fix: provider consolidation and remaining audit fixes

Unify Provider, TokenStreamer, and StreamProvider into a single Provider
interface with Complete + CompleteStream + Name. Remove dead StreamProvider
interface, StreamEvent/StreamConfig types, SSEDecoder, and Stream() methods
from all providers. Agent now calls CompleteStream directly.

Also: delete leftover basic/cli binaries, add .gitignore, expand BashTool
dangerous patterns (21 total), add symlink-safe path protection, and
implement weighted token estimation heuristic.

Author: Patel230

.gitignore

@@ -0,0 +1,28 @@
+# Compiled binaries
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+basic
+cli
+
+# Test binary
+*.test
+
+# Output of go coverage
+*.out
+
+# Go workspace
+go.work
+go.work.sum
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

agent.go

@@ -19,7 +19,7 @@ import (
 // ErrUnknownTool is returned when a tool call references a tool that is not registered.
 var ErrUnknownTool = errors.New("unknown tool")
 
-const maxAgentIterations = 20
+const defaultMaxAgentIterations = 20
 
 // ToolCall represents a tool invocation.
 type ToolCall struct {
@@ -74,6 +74,9 @@ type Agent struct {
 	Skills        []Skill
 	Messages      []Message
 
+	// MaxIterations overrides the default iteration limit when set to > 0.
+	MaxIterations int
+
 	// Context compaction config.
 	contextConfig ContextConfig
 
@@ -361,7 +364,12 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string, emitF
 
 	opts := a.completionOpts()
 
-	for i := 0; i < maxAgentIterations; i++ {
+	maxIter := defaultMaxAgentIterations
+	if a.MaxIterations > 0 {
+		maxIter = a.MaxIterations
+	}
+
+	for i := 0; i < maxIter; i++ {
 		a.logger.Info("agent iteration", "step", i+1)
 		emit(Event{Type: string(EventTurnStart), Content: fmt.Sprintf("turn %d", i+1)})
 
@@ -376,17 +384,11 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string, emitF
 			response string
 			err      error
 		)
-		if ts, ok := a.provider.(TokenStreamer); ok {
-			response, err = RetryWithResult(ctx, DefaultRetryConfig, func() (string, error) {
-				return ts.CompleteStream(ctx, messages, opts, func(token string) {
-					emit(Event{Type: string(EventTokenUpdate), Content: token})
-				})
+		response, err = RetryWithResult(ctx, DefaultRetryConfig, func() (string, error) {
+			return a.provider.CompleteStream(ctx, messages, opts, func(token string) {
+				emit(Event{Type: string(EventTokenUpdate), Content: token})
 			})
-		} else {
-			response, err = RetryWithResult(ctx, DefaultRetryConfig, func() (string, error) {
-				return a.provider.Complete(ctx, messages, opts)
-			})
-		}
+		})
 		if err != nil {
 			emit(Event{Type: string(EventError), Content: err.Error(), IsError: true})
 			return "", fmt.Errorf("provider error at step %d: %w", i+1, err)
@@ -419,7 +421,7 @@ func (a *Agent) Run(ctx context.Context, systemPrompt, userMessage string, emitF
 		emit(Event{Type: string(EventTurnEnd), Content: ""})
 	}
 
-	return "", fmt.Errorf("agent exceeded max iterations (%d)", maxAgentIterations)
+	return "", fmt.Errorf("agent exceeded max iterations (%d)", maxIter)
 }
 
 func (a *Agent) emit(e Event) {
@@ -846,7 +848,12 @@ func (a *Agent) PromptMessages(ctx context.Context, messages []Message) chan Eve
 
 		opts := a.completionOpts()
 
-		for i := 0; i < maxAgentIterations; i++ {
+		maxIter := defaultMaxAgentIterations
+		if a.MaxIterations > 0 {
+			maxIter = a.MaxIterations
+		}
+
+		for i := 0; i < maxIter; i++ {
 			// Check for cancellation before each turn.
 			select {
 			case <-loopCtx.Done():
@@ -868,17 +875,11 @@ func (a *Agent) PromptMessages(ctx context.Context, messages []Message) chan Eve
 				response string
 				turnErr  error
 			)
-			if ts, ok := a.provider.(TokenStreamer); ok {
-				response, turnErr = RetryWithResult(loopCtx, DefaultRetryConfig, func() (string, error) {
-					return ts.CompleteStream(loopCtx, fullMessages, opts, func(token string) {
-						emitFn(Event{Type: string(EventTokenUpdate), Content: token})
-					})
+			response, turnErr = RetryWithResult(loopCtx, DefaultRetryConfig, func() (string, error) {
+				return a.provider.CompleteStream(loopCtx, fullMessages, opts, func(token string) {
+					emitFn(Event{Type: string(EventTokenUpdate), Content: token})
 				})
-			} else {
-				response, turnErr = RetryWithResult(loopCtx, DefaultRetryConfig, func() (string, error) {
-					return a.provider.Complete(loopCtx, fullMessages, opts)
-				})
-			}
+			})
 			if turnErr != nil {
 				emitFn(Event{Type: string(EventError), Content: turnErr.Error(), IsError: true})
 				break

agent_test.go

@@ -310,12 +310,12 @@ func TestAgentHooks_BeforeTurnReceivesMessages(t *testing.T) {
 }
 
 // ---------------------------------------------------------------------------
-// TokenStreamer tests
+// Streaming tests
 // ---------------------------------------------------------------------------
 
-// TestAgentTokenStreamer_EventsEmitted verifies that EventTokenUpdate events
-// are emitted when the provider implements TokenStreamer.
-func TestAgentTokenStreamer_EventsEmitted(t *testing.T) {
+// TestAgentStreaming_EventsEmitted verifies that EventTokenUpdate events
+// are emitted during streaming completions.
+func TestAgentStreaming_EventsEmitted(t *testing.T) {
 	p := iteragent.NewMockStream("hello world")
 	a := iteragent.New(p, nil, testLogger())
 
@@ -338,9 +338,9 @@ func TestAgentTokenStreamer_EventsEmitted(t *testing.T) {
 	}
 }
 
-// TestAgentTokenStreamer_RunReturnsFullResponse verifies Run() returns the
+// TestAgentStreaming_RunReturnsFullResponse verifies Run() returns the
 // complete response even when token streaming is active.
-func TestAgentTokenStreamer_RunReturnsFullResponse(t *testing.T) {
+func TestAgentStreaming_RunReturnsFullResponse(t *testing.T) {
 	p := iteragent.NewMockStream("the quick brown fox")
 	a := iteragent.New(p, nil, testLogger())
 
@@ -353,10 +353,10 @@ func TestAgentTokenStreamer_RunReturnsFullResponse(t *testing.T) {
 	}
 }
 
-// TestAgentTokenStreamer_WithTools verifies streaming still works when a tool
+// TestAgentStreaming_WithTools verifies streaming still works when a tool
 // 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) {
+func TestAgentStreaming_WithTools(t *testing.T) {
 	toolCall := iteragent.ToolCall{Tool: "noop", Args: map[string]string{}}
 	noopTool := iteragent.Tool{
 		Name: "noop",
@@ -388,21 +388,6 @@ func TestAgentTokenStreamer_WithTools(t *testing.T) {
 	}
 }
 
-// TestAgentTokenStreamer_NonStreamingProviderNoTokenEvents verifies that a
-// plain Provider (no TokenStreamer) emits NO EventTokenUpdate events.
-func TestAgentTokenStreamer_NonStreamingProviderNoTokenEvents(t *testing.T) {
-	p := iteragent.NewMock("plain response") // does not implement TokenStreamer
-	a := iteragent.New(p, nil, testLogger())
-
-	events := a.Prompt(context.Background(), "hello")
-	for e := range events {
-		if iteragent.EventType(e.Type) == iteragent.EventTokenUpdate {
-			t.Errorf("unexpected EventTokenUpdate from non-streaming provider: %q", e.Content)
-		}
-	}
-	a.Finish()
-}
-
 // TestAgentClose verifies that Close() is safe to call on an agent with no MCP
 // servers and does not block or panic.
 func TestAgentClose(t *testing.T) {
@@ -545,7 +530,7 @@ func TestPromptMessages_Hooks_OnToolStartEnd(t *testing.T) {
 }
 
 // TestPromptMessages_Hooks_TokenUpdate verifies EventTokenUpdate events are emitted
-// via PromptMessages when the provider implements TokenStreamer.
+// via PromptMessages during streaming completions.
 func TestPromptMessages_Hooks_TokenUpdate(t *testing.T) {
 	const want = "streamed via prompt messages"
 	p := iteragent.NewMockStream(want)
@@ -572,7 +557,7 @@ func TestPromptMessages_Hooks_TokenUpdate(t *testing.T) {
 }
 
 // TestSubAgentStreaming verifies that SubAgent.Run delegates to the embedded Agent,
-// which means TokenStreamer and EventTokenUpdate both flow through correctly after the refactor.
+// which means streaming and EventTokenUpdate both flow through correctly.
 func TestSubAgentStreaming(t *testing.T) {
 	const want = "subagent streamed answer"
 	p := iteragent.NewMockStream(want)
@@ -657,6 +642,9 @@ func (p *blockingProvider) Complete(ctx context.Context, messages []iteragent.Me
 	<-ctx.Done()
 	return "", ctx.Err()
 }
+func (p *blockingProvider) CompleteStream(ctx context.Context, messages []iteragent.Message, opts iteragent.CompletionOptions, onToken func(string)) (string, error) {
+	return p.Complete(ctx, messages, opts)
+}
 
 // ---------------------------------------------------------------------------
 // MCP integration tests

anthropic.go

@@ -23,7 +23,7 @@ type anthropicProvider struct {
 }
 
 // NewAnthropic returns a native Anthropic provider.
-// The returned provider implements both Provider and TokenStreamer.
+// The returned provider implements Provider with streaming support.
 func NewAnthropic(cfg AnthropicConfig) Provider {
 	return &anthropicProvider{
 		cfg:    cfg,
@@ -102,7 +102,7 @@ func (p *anthropicProvider) buildAnthropicBody(messages []Message, opt Completio
 	return json.Marshal(reqMap)
 }
 
-// CompleteStream implements TokenStreamer. It uses SSE to deliver tokens
+// CompleteStream implements Provider. It uses SSE to deliver tokens
 // incrementally via onToken as they arrive from the Anthropic API.
 func (p *anthropicProvider) CompleteStream(ctx context.Context, messages []Message, opt CompletionOptions, onToken func(string)) (string, error) {
 	body, err := p.buildAnthropicBody(messages, opt, true)

azure.go

@@ -106,7 +106,7 @@ func (p *AzureOpenAIProvider) Complete(ctx context.Context, messages []Message,
 	return response.Choices[0].Message.Content, nil
 }
 
-// CompleteStream implements TokenStreamer for Azure OpenAI using the SSE streaming endpoint.
+// CompleteStream implements Provider for Azure OpenAI using the SSE streaming endpoint.
 func (p *AzureOpenAIProvider) CompleteStream(ctx context.Context, messages []Message, opt CompletionOptions, onToken func(string)) (string, error) {
 	apiVersion := p.config.APIVersion
 	if apiVersion == "" {
@@ -161,121 +161,3 @@ func messagesToAzureFormat(messages []Message) []map[string]interface{} {
 	return result
 }
 
-func (p *AzureOpenAIProvider) Stream(ctx context.Context, config StreamConfig, messages []Message, onEvent func(StreamEvent)) (Message, error) {
-	apiVersion := p.config.APIVersion
-	if apiVersion == "" {
-		apiVersion = "2024-02-15-preview"
-	}
-
-	url := fmt.Sprintf("%s/openai/deployments/%s/chat/completions?api-version=%s",
-		p.config.Endpoint, p.config.Deployment, apiVersion)
-
-	body := map[string]interface{}{
-		"messages": messagesToAzureFormat(messages),
-		"stream":   true,
-	}
-
-	if config.MaxTokens > 0 {
-		body["max_tokens"] = config.MaxTokens
-	}
-	if config.Temperature > 0 {
-		body["temperature"] = config.Temperature
-	}
-
-	jsonBody, err := json.Marshal(body)
-	if err != nil {
-		return Message{}, fmt.Errorf("marshal request: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBody))
-	if err != nil {
-		return Message{}, fmt.Errorf("create request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("api-key", p.config.APIKey)
-
-	resp, err := p.client.Do(req)
-	if err != nil {
-		return Message{}, fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		respBody, _ := io.ReadAll(resp.Body) // best-effort for error message
-		return Message{}, fmt.Errorf("Azure OpenAI error (%d): %s", resp.StatusCode, string(respBody))
-	}
-
-	var content strings.Builder
-	decoder := NewSSEDecoder(resp.Body)
-
-	for {
-		event, err := decoder.Decode()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			break
-		}
-
-		if event.Type == "content" || event.Type == "content_block" {
-			content.WriteString(event.Content)
-			onEvent(event)
-		}
-	}
-
-	return Message{
-		Role:    "assistant",
-		Content: content.String(),
-	}, nil
-}
-
-type SSEDecoder struct {
-	reader io.Reader
-	buf    []byte
-}
-
-func NewSSEDecoder(reader io.Reader) *SSEDecoder {
-	return &SSEDecoder{reader: reader, buf: make([]byte, 1024)}
-}
-
-func (d *SSEDecoder) Decode() (StreamEvent, error) {
-	var line string
-	for {
-		n, err := d.reader.Read(d.buf)
-		if n == 0 || err != nil {
-			return StreamEvent{}, err
-		}
-		line = string(d.buf[:n])
-		if strings.HasPrefix(line, "data:") {
-			break
-		}
-	}
-
-	line = strings.TrimSpace(strings.TrimPrefix(line, "data:"))
-	if line == "[DONE]" {
-		return StreamEvent{}, io.EOF
-	}
-
-	var delta struct {
-		Choices []struct {
-			Delta struct {
-				Content string `json:"content"`
-			} `json:"delta"`
-		} `json:"choices"`
-	}
-
-	if err := json.Unmarshal([]byte(line), &delta); err != nil {
-		return StreamEvent{}, err
-	}
-
-	content := ""
-	if len(delta.Choices) > 0 {
-		content = delta.Choices[0].Delta.Content
-	}
-
-	return StreamEvent{
-		Type:    StreamEventContent,
-		Content: content,
-	}, nil
-}

azure_test.go

@@ -286,27 +286,3 @@ func TestAzureComplete_ContextCancelled(t *testing.T) {
 	}
 }
 
-// ---------------------------------------------------------------------------
-// SSEDecoder
-// ---------------------------------------------------------------------------
-
-func TestSSEDecoder_ContentEvent(t *testing.T) {
-	data := "data: {\"choices\":[{\"delta\":{\"content\":\"hello\"}}]}\n"
-	decoder := iteragent.NewSSEDecoder(strings.NewReader(data))
-	event, err := decoder.Decode()
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if event.Content != "hello" {
-		t.Errorf("expected content 'hello', got %q", event.Content)
-	}
-}
-
-func TestSSEDecoder_DoneSignal(t *testing.T) {
-	import_io := "data: [DONE]\n"
-	decoder := iteragent.NewSSEDecoder(strings.NewReader(import_io))
-	_, err := decoder.Decode()
-	if err == nil {
-		t.Error("expected EOF for [DONE] signal")
-	}
-}