feat: native tools, LLM compaction, thinking streamer, model fallback, retry jitter

- Native tool calling for Anthropic (tool_use), OpenAI (function_calling),
  Gemini (function declarations) — all with multi-round loops
- NativeToolExecutor with parallel/sequential execution
- JSON schema generator (ToolSchema, NativeToolDefinition, parseToolDescription)
- ThinkingStreamer interface + Anthropic implementation (CompleteStreamWithThinking)
- LLMCompactionStrategy — uses provider to summarize old turns, falls back to tiered
- Azure provider wired into NewProvider switch
- Tool.Execute / ToolCall.Args upgraded: map[string]string → map[string]interface{}
  ArgStr() helper added; 25+ call sites updated
- CompletionOptions.Model for per-call model override across all providers
- WithFallbackModel + isFallbackError for automatic model fallback on not-found errors
- Retry jitter: ±25% randomness on backoff to prevent thundering herd
- Event channel buffer 256 → 1024 for parallel tool burst headroom
- Tool output cap: 200-line head+tail truncation via capToolOutput()
- Message-level prompt caching (cache_control on penultimate message)
- Stuck-loop detection: abort if same tool call repeats 3×
- Additional tests: native tools, multi-turn, context window, stuck-loop

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Patel230

agent.go

@@ -35,14 +35,14 @@ func TestAgentSimpleResponse(t *testing.T) {
 func TestAgentToolCall(t *testing.T) {
 	toolCall := iteragent.ToolCall{
 		Tool: "echo",
-		Args: map[string]string{"msg": "ping"},
+		Args: map[string]interface{}{"msg": "ping"},
 	}
 
 	called := false
 	echoTool := iteragent.Tool{
 		Name:        "echo",
 		Description: "Echo the msg argument",
-		Execute: func(ctx context.Context, args map[string]string) (string, error) {
+		Execute: func(ctx context.Context, args map[string]interface{}) (string, error) {
 			called = true
 			return "pong", nil
 		},
@@ -130,6 +130,57 @@ func TestParseToolCallsNone(t *testing.T) {
 	}
 }
 
+// TestParseToolCallsMalformedJSON verifies that truncated/malformed tool blocks
+// are recovered where possible and silently dropped when unrecoverable.
+func TestParseToolCallsMalformedJSON(t *testing.T) {
+	cases := []struct {
+		name    string
+		input   string
+		wantN   int
+		wantTool string
+	}{
+		{
+			name:     "truncated after tool value",
+			input:    "```tool\n{\"tool\":\"bash\",\"args\":{\"command\":\"ls\"\n```",
+			wantN:    1,
+			wantTool: "bash",
+		},
+		{
+			name:     "missing outer closing brace",
+			input:    "```tool\n{\"tool\":\"read_file\",\"args\":{\"path\":\"/tmp/x\"}\n```",
+			wantN:    1,
+			wantTool: "read_file",
+		},
+		{
+			name:  "completely invalid JSON",
+			input: "```tool\nnot json at all\n```",
+			wantN: 0,
+		},
+		{
+			name:  "empty block",
+			input: "```tool\n\n```",
+			wantN: 0,
+		},
+		{
+			name:     "trailing garbage after closing brace",
+			input:    "```tool\n{\"tool\":\"bash\",\"args\":{\"command\":\"ls\"}} extra stuff\n```",
+			wantN:    1,
+			wantTool: "bash",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			calls := iteragent.ParseToolCalls(tc.input)
+			if len(calls) != tc.wantN {
+				t.Fatalf("want %d calls, got %d", tc.wantN, len(calls))
+			}
+			if tc.wantN > 0 && calls[0].Tool != tc.wantTool {
+				t.Errorf("want tool=%q, got %q", tc.wantTool, calls[0].Tool)
+			}
+		})
+	}
+}
+
 // TestToolDescriptions verifies that tool descriptions are formatted.
 func TestToolDescriptions(t *testing.T) {
 	tools := []iteragent.Tool{
@@ -226,13 +277,13 @@ func TestAgentHooks_BeforeAfterTurn(t *testing.T) {
 func TestAgentHooks_OnToolStartEnd(t *testing.T) {
 	toolCall := iteragent.ToolCall{
 		Tool: "greet",
-		Args: map[string]string{"name": "world"},
+		Args: map[string]interface{}{"name": "world"},
 	}
 	greetTool := iteragent.Tool{
 		Name:        "greet",
 		Description: "Greet someone",
-		Execute: func(ctx context.Context, args map[string]string) (string, error) {
-			return "hello " + args["name"], nil
+		Execute: func(ctx context.Context, args map[string]interface{}) (string, error) {
+			return "hello " + iteragent.ArgStr(args, "name"), nil
 		},
 	}
 
@@ -243,10 +294,10 @@ func TestAgentHooks_OnToolStartEnd(t *testing.T) {
 	var endResults []string
 	var endErrors []error
 	a.WithHooks(iteragent.AgentHooks{
-		OnToolStart: func(toolName string, args map[string]string) {
+		OnToolStart: func(toolName string, args map[string]interface{}) {
 			startTools = append(startTools, toolName)
-			if args["name"] != "world" {
-				t.Errorf("OnToolStart: args[name]=%q, want %q", args["name"], "world")
+			if iteragent.ArgStr(args, "name") != "world" {
+				t.Errorf("OnToolStart: args[name]=%q, want %q", iteragent.ArgStr(args, "name"), "world")
 			}
 		},
 		OnToolEnd: func(toolName string, result string, err error) {
@@ -357,10 +408,10 @@ func TestAgentTokenStreamer_RunReturnsFullResponse(t *testing.T) {
 // call precedes the final response. The mock streams every turn, so we verify
 // that EventTokenUpdate events were emitted and the final answer is correct.
 func TestAgentTokenStreamer_WithTools(t *testing.T) {
-	toolCall := iteragent.ToolCall{Tool: "noop", Args: map[string]string{}}
+	toolCall := iteragent.ToolCall{Tool: "noop", Args: map[string]interface{}{}}
 	noopTool := iteragent.Tool{
 		Name: "noop",
-		Execute: func(ctx context.Context, args map[string]string) (string, error) {
+		Execute: func(ctx context.Context, args map[string]interface{}) (string, error) {
 			return "done", nil
 		},
 	}
@@ -421,13 +472,13 @@ func TestAgentClose(t *testing.T) {
 // when the parallel execution strategy is used.
 func TestAgentHooks_Parallel(t *testing.T) {
 	calls := []iteragent.ToolCall{
-		{Tool: "t1", Args: map[string]string{}},
-		{Tool: "t2", Args: map[string]string{}},
+		{Tool: "t1", Args: map[string]interface{}{}},
+		{Tool: "t2", Args: map[string]interface{}{}},
 	}
 	makeTool := func(name string) iteragent.Tool {
 		return iteragent.Tool{
 			Name: name,
-			Execute: func(ctx context.Context, args map[string]string) (string, error) {
+			Execute: func(ctx context.Context, args map[string]interface{}) (string, error) {
 				return name + "-result", nil
 			},
 		}
@@ -441,7 +492,7 @@ func TestAgentHooks_Parallel(t *testing.T) {
 	var started, ended []string
 
 	a.WithHooks(iteragent.AgentHooks{
-		OnToolStart: func(toolName string, args map[string]string) {
+		OnToolStart: func(toolName string, args map[string]interface{}) {
 			mu.Lock()
 			started = append(started, toolName)
 			mu.Unlock()
@@ -507,10 +558,10 @@ func TestPromptMessages_Hooks_BeforeAfterTurn(t *testing.T) {
 // TestPromptMessages_Hooks_OnToolStartEnd verifies OnToolStart and OnToolEnd fire
 // around each tool execution during PromptMessages().
 func TestPromptMessages_Hooks_OnToolStartEnd(t *testing.T) {
-	toolCall := iteragent.ToolCall{Tool: "ping", Args: map[string]string{}}
+	toolCall := iteragent.ToolCall{Tool: "ping", Args: map[string]interface{}{}}
 	pingTool := iteragent.Tool{
 		Name: "ping",
-		Execute: func(ctx context.Context, args map[string]string) (string, error) {
+		Execute: func(ctx context.Context, args map[string]interface{}) (string, error) {
 			return "pong", nil
 		},
 	}
@@ -519,7 +570,7 @@ func TestPromptMessages_Hooks_OnToolStartEnd(t *testing.T) {
 
 	var startTools, endTools []string
 	a.WithHooks(iteragent.AgentHooks{
-		OnToolStart: func(toolName string, args map[string]string) {
+		OnToolStart: func(toolName string, args map[string]interface{}) {
 			startTools = append(startTools, toolName)
 		},
 		OnToolEnd: func(toolName string, result string, err error) {
@@ -778,7 +829,7 @@ func TestAgentWithMcpServerHttp_ToolCallable(t *testing.T) {
 	ctx := context.Background()
 	// Agent will call mcp_echo on turn 1, then return "done" on turn 2.
 	p := iteragent.NewMockWithTools("done", []iteragent.ToolCall{
-		{Tool: "mcp_echo", Args: map[string]string{}},
+		{Tool: "mcp_echo", Args: map[string]interface{}{}},
 	})
 	a, err := iteragent.New(p, nil, testLogger()).
 		WithMcpServerHttp(ctx, srv.URL)

agent_test.go

@@ -35,6 +35,22 @@ func (p *anthropicProvider) Name() string {
 	return fmt.Sprintf("anthropic(%s)", p.cfg.Model)
 }
 
+// ContextWindow returns the context window for the configured Anthropic model.
+func (p *anthropicProvider) ContextWindow() int {
+	return anthropicContextWindow(p.cfg.Model)
+}
+
+func anthropicContextWindow(model string) int {
+	// All current Claude models support 200k context.
+	// Older claude-instant / claude-2 are 100k.
+	switch {
+	case strings.HasPrefix(model, "claude-instant"), strings.HasPrefix(model, "claude-2"):
+		return 100_000
+	default:
+		return 200_000
+	}
+}
+
 type anthropicResponse struct {
 	Content []struct {
 		Text string `json:"text"`
@@ -75,8 +91,12 @@ func (p *anthropicProvider) buildAnthropicBody(messages []Message, opt Completio
 	if opt.MaxTokens > 0 {
 		maxTokens = opt.MaxTokens
 	}
+	model := p.cfg.Model
+	if opt.Model != "" {
+		model = opt.Model
+	}
 	reqMap := map[string]interface{}{
-		"model":      p.cfg.Model,
+		"model":      model,
 		"max_tokens": maxTokens,
 		"messages":   filtered,
 	}
@@ -93,6 +113,35 @@ func (p *anthropicProvider) buildAnthropicBody(messages []Message, opt Completio
 			reqMap["system"] = system
 		}
 	}
+
+	// Message-level caching: add cache_control to the penultimate message to
+	// cache the conversation history before the current user turn.
+	msgCacheEnabled := opt.CacheConfig != nil && opt.CacheConfig.Enabled && opt.CacheConfig.CacheMessages
+	if msgCacheEnabled && len(filtered) >= 2 {
+		type contentBlock struct {
+			Type         string            `json:"type"`
+			Text         string            `json:"text"`
+			CacheControl map[string]string `json:"cache_control,omitempty"`
+		}
+		type cachedMsg struct {
+			Role    string         `json:"role"`
+			Content []contentBlock `json:"content"`
+		}
+		msgs := make([]interface{}, len(filtered))
+		for i, m := range filtered {
+			if i == len(filtered)-2 {
+				msgs[i] = cachedMsg{
+					Role: m.Role,
+					Content: []contentBlock{
+						{Type: "text", Text: m.Content, CacheControl: map[string]string{"type": "ephemeral"}},
+					},
+				}
+			} else {
+				msgs[i] = map[string]interface{}{"role": m.Role, "content": m.Content}
+			}
+		}
+		reqMap["messages"] = msgs
+	}
 	if opt.ThinkingLevel != ThinkingLevelOff && opt.ThinkingLevel != "" {
 		budget := thinkingBudget(opt.ThinkingLevel)
 		reqMap["thinking"] = map[string]interface{}{
@@ -138,6 +187,48 @@ func (p *anthropicProvider) CompleteStream(ctx context.Context, messages []Messa
 	return result, nil
 }
 
+// CompleteStreamWithThinking implements ThinkingStreamer. It delivers both
+// text tokens (via onToken) and thinking tokens (via onThinking) as they
+// arrive. Returns the full concatenated text response.
+func (p *anthropicProvider) CompleteStreamWithThinking(ctx context.Context, messages []Message, opt CompletionOptions, onToken func(string), onThinking func(string)) (string, error) {
+	body, err := p.buildAnthropicBody(messages, opt, true)
+	if err != nil {
+		return "", fmt.Errorf("marshal request: %w", err)
+	}
+
+	headers := map[string]string{
+		"x-api-key":         p.cfg.APIKey,
+		"anthropic-version": "2023-06-01",
+	}
+	if opt.CacheConfig != nil && opt.CacheConfig.Enabled {
+		headers["anthropic-beta"] = "prompt-caching-2024-07-31"
+	}
+
+	var full strings.Builder
+	sseClient := NewSSEClient()
+	err = sseClient.Stream(ctx, "https://api.anthropic.com/v1/messages", headers, body, func(e SSEEvent) {
+		if token, ok := ParseAnthropicSSE(e.Data); ok && token != "" {
+			full.WriteString(token)
+			if onToken != nil {
+				onToken(token)
+			}
+		}
+		if thinking, ok := ParseAnthropicSSEThinking(e.Data); ok && thinking != "" {
+			if onThinking != nil {
+				onThinking(thinking)
+			}
+		}
+	})
+	if err != nil {
+		return "", fmt.Errorf("anthropic stream: %w", err)
+	}
+	result := full.String()
+	if result == "" {
+		return "", fmt.Errorf("empty streaming response from anthropic")
+	}
+	return result, nil
+}
+
 func (p *anthropicProvider) Complete(ctx context.Context, messages []Message, opts ...CompletionOptions) (string, error) {
 	var opt CompletionOptions
 	if len(opts) > 0 {