fix: harden providers, tools, and remove duplicate nvidia shim

Cap HTTP response reads at 10MB, replace grep-based search with bounded
filepath walk, consolidate NVIDIA onto OpenAICompat, and add compat stubs
for downstream iterate APIs.

Author: Patel230

.golangci.yml

@@ -27,7 +27,7 @@ linters-settings:
 
   errcheck:
     # Ignore common intentional unchecked errors.
-    ignore: fmt:.*,io/fs:PathError
+    exclude-functions: fmt:.*,io/fs:PathError
 
 issues:
   exclude-rules:

anthropic.go

@@ -167,7 +167,7 @@ func (p *anthropicProvider) Complete(ctx context.Context, messages []Message, op
 	}
 	defer resp.Body.Close()
 
-	raw, err := io.ReadAll(resp.Body)
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
 	if err != nil {
 		return "", fmt.Errorf("read response: %w", err)
 	}

anthropic_test.go

@@ -2,7 +2,6 @@ package iteragent_test
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
@@ -12,36 +11,6 @@ import (
 	iteragent "github.com/GrayCodeAI/iteragent"
 )
 
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-
-// anthropicServer creates a test server that responds like the Anthropic API.
-func anthropicServer(t *testing.T, handler http.HandlerFunc) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(handler)
-}
-
-// patchAnthropicURL swaps the hardcoded Anthropic URL — we test via Complete
-// using a mock provider that records the request body, since we cannot patch
-// the URL directly. Instead we test NewAnthropic then swap out the http.Client
-// by exercising exported behaviour end-to-end.
-//
-// The real Complete calls https://api.anthropic.com. For unit tests we instead:
-//  1. Test Name() directly (no network)
-//  2. Test request body construction by calling Complete against a local server
-//     via a custom http.Client set on the provider.
-//
-// Since anthropicProvider is unexported, we exercise Complete indirectly via
-// an Agent backed by a mock provider that returns a fixed body. The actual
-// HTTP layer is tested via the SSE tests and the OpenAPI adapter tests.
-//
-// Here we test the parts we CAN reach without reflection or unexported access:
-//   - Name() shape
-//   - thinkingBudget logic (via exported ThinkingLevel constants)
-//   - NewAnthropic constructor returns non-nil Provider
-//   - Complete on a testServer-backed provider using the internal testable path
-
 // ---------------------------------------------------------------------------
 // NewAnthropic
 // ---------------------------------------------------------------------------
@@ -80,30 +49,6 @@ func TestNewAnthropic_DifferentModels(t *testing.T) {
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Complete — via httptest (using Agent with the mock HTTP layer)
-// ---------------------------------------------------------------------------
-
-// anthropicJSONResponse builds a valid Anthropic /v1/messages response body.
-func anthropicJSONResponse(text string) []byte {
-	resp := map[string]interface{}{
-		"content": []map[string]interface{}{
-			{"type": "text", "text": text},
-		},
-	}
-	b, _ := json.Marshal(resp)
-	return b
-}
-
-// anthropicErrorResponse builds an Anthropic error response body.
-func anthropicErrorResponse(msg string) []byte {
-	resp := map[string]interface{}{
-		"error": map[string]string{"message": msg},
-	}
-	b, _ := json.Marshal(resp)
-	return b
-}
-
 // TestAnthropicComplete_* tests use the Agent+Mock pattern because the
 // anthropicProvider is unexported. The real provider path is verified via
 // direct httptest servers in CompleteStream tests below (which use the SSEClient

azure.go

@@ -78,7 +78,7 @@ func (p *AzureOpenAIProvider) Complete(ctx context.Context, messages []Message,
 	}
 	defer resp.Body.Close()
 
-	respBody, err := io.ReadAll(resp.Body)
+	respBody, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
 	if err != nil {
 		return "", fmt.Errorf("read response: %w", err)
 	}
@@ -160,4 +160,3 @@ func messagesToAzureFormat(messages []Message) []map[string]interface{} {
 	}
 	return result
 }
-

azure_test.go

@@ -285,4 +285,3 @@ func TestAzureComplete_ContextCancelled(t *testing.T) {
 		t.Fatal("expected error from cancelled context")
 	}
 }
-

bedrock.go

@@ -93,7 +93,7 @@ func (p *BedrockProvider) Complete(ctx context.Context, messages []Message, opts
 	}
 	defer resp.Body.Close()
 
-	respBody, err := io.ReadAll(resp.Body)
+	respBody, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
 	if err != nil {
 		return "", fmt.Errorf("read response: %w", err)
 	}
@@ -138,7 +138,6 @@ func (p *BedrockProvider) CompleteStream(ctx context.Context, messages []Message
 	return result, nil
 }
 
-
 func (p *BedrockProvider) signRequest(req *http.Request, payload string) {
 	now := time.Now().UTC()
 	date := now.Format("20060102T150405Z")

compat.go

@@ -0,0 +1,57 @@
+package iteragent
+
+// Compatibility stubs for iterate. These interfaces and functions existed in
+// earlier iteragent versions and are still referenced by downstream consumers.
+
+// TokenStreamer is implemented by providers that support token-level streaming.
+type TokenStreamer interface {
+	CompleteStreamTokens(ctx interface{}, messages []Message, opts CompletionOptions) (<-chan string, error)
+}
+
+// ThinkingStreamer is implemented by providers that expose thinking/reasoning tokens.
+type ThinkingStreamer interface {
+	CompleteWithThinking(ctx interface{}, messages []Message, opts CompletionOptions) (string, string, error)
+}
+
+// NativeToolCaller is implemented by providers that support native tool calling.
+type NativeToolCaller interface {
+	CompleteWithTools(ctx interface{}, messages []Message, tools []ToolDefinition, opts CompletionOptions) (string, []ToolCall, error)
+}
+
+// ProviderContextWindow returns the context window size in tokens for the
+// given provider, or 0 if unknown.
+func ProviderContextWindow(p Provider) int {
+	// No providers currently expose their context window size.
+	return 0
+}
+
+// WithLLMCompaction enables LLM-assisted compaction at the given token threshold.
+func (a *Agent) WithLLMCompaction(tokens int) *Agent {
+	// LLM compaction is not supported in this version.
+	return a
+}
+
+// SetPinnedMessages sets messages that should be preserved during compaction.
+func (a *Agent) SetPinnedMessages(msgs []Message) {
+	// Pinned messages are not supported in this version.
+}
+
+// LLMCompactionStrategy uses an LLM to compact conversation history.
+type LLMCompactionStrategy struct {
+	Provider   Provider
+	KeepRecent int
+}
+
+// Compact reduces the message list to fit within maxTokens using LLM summarisation.
+func (s *LLMCompactionStrategy) Compact(messages []Message, maxTokens int) []Message {
+	// LLM compaction is not supported; fall back to simple truncation.
+	if len(messages) > s.KeepRecent {
+		return messages[len(messages)-s.KeepRecent:]
+	}
+	return messages
+}
+
+// ArgStr extracts a string value from a map[string]string args map.
+func ArgStr(args map[string]string, key string) string {
+	return args[key]
+}

context_test.go

@@ -28,7 +28,7 @@ func TestEstimateTokens(t *testing.T) {
 
 func TestEstimateTotalTokens(t *testing.T) {
 	msgs := []iteragent.Message{
-		{Role: "user", Content: "abcd"},     // 1 token + 4 overhead = 5
+		{Role: "user", Content: "abcd"},      // 1 token + 4 overhead = 5
 		{Role: "assistant", Content: "abcd"}, // 1 token + 4 overhead = 5
 	}
 	got := iteragent.EstimateTotalTokens(msgs)
@@ -130,7 +130,7 @@ func TestCompactMessagesTiered_Level3_KeepsFirstAndLast(t *testing.T) {
 	}
 
 	cfg := iteragent.ContextConfig{
-		MaxTokens:          10,  // extremely low → all levels triggered
+		MaxTokens:          10, // extremely low → all levels triggered
 		KeepRecent:         3,
 		KeepFirst:          2,
 		ToolOutputMaxLines: 5,
@@ -369,7 +369,7 @@ func TestCompactMessagesTiered_AssistantSummary(t *testing.T) {
 	}
 
 	cfg := iteragent.ContextConfig{
-		MaxTokens:          80,  // enough to trigger level 2 but not drop everything
+		MaxTokens:          80, // enough to trigger level 2 but not drop everything
 		KeepRecent:         2,
 		KeepFirst:          1,
 		ToolOutputMaxLines: 50,

gemini.go

@@ -166,7 +166,7 @@ func (p *geminiProvider) Complete(ctx context.Context, messages []Message, opts
 	}
 	defer resp.Body.Close()
 
-	raw, err := io.ReadAll(resp.Body)
+	raw, err := io.ReadAll(io.LimitReader(resp.Body, 10*1024*1024))
 	if err != nil {
 		return "", fmt.Errorf("read response: %w", err)
 	}

go.sum

@@ -1,2 +0,0 @@
-# This go.sum file was generated to ensure reproducible builds.
-# This module has no external dependencies.