Add generic LLM provider interface and agent-side tool queue

Signed-off-by: Marek Safarik <msafarik@redhat.com>

Author: Marek Safarik

cmd/client/main.go

@@ -36,12 +36,6 @@ func main() {
 		log.Printf("Warning: .env file not loaded: %v", err)
 	}
 
-	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
-	if apiKey == "" {
-		log.Println("ANTHROPIC_API_KEY environment variable not set")
-		return
-	}
-
 	serverPath := os.Getenv("MCP_SERVER_PATH")
 	if serverPath == "" {
 		serverPath = defaultServerPath
@@ -52,16 +46,22 @@ func main() {
 		port = defaultPort
 	}
 
+	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
+	if apiKey == "" {
+		log.Println("ANTHROPIC_API_KEY environment variable not set")
+		return
+	}
+
 	if _, err := os.Stat(serverPath); os.IsNotExist(err) { // #nosec G703 -- serverPath from env/default, not user input
 		log.Printf("Warning: MCP server not found at %s", serverPath)
 		log.Printf("Build the server first: go build -o bin/server cmd/server/main.go")
 		return
 	}
 
+	provider := agent.NewClaudeProvider(apiKey)
 	agentInstance := agent.NewAgent(agent.Config{
-		APIKey:     apiKey,
 		ServerPath: serverPath,
-	})
+	}, provider)
 
 	if err := agentInstance.Connect(ctx); err != nil {
 		log.Printf("Failed to connect to MCP server: %v", err)

internal/agent/agent.go

@@ -44,10 +44,10 @@ type Agent struct {
 	mcpCmd     *exec.Cmd
 	tools      []*mcp.Tool
 	messages   []Message
+	toolQueue  []ToolRequest
 }
 
 func NewAgent(cfg Config, provider LLMProvider) *Agent {
-	// Apply defaults
 	if cfg.Model == "" {
 		cfg.Model = DefaultModel
 	}
@@ -107,7 +107,7 @@ func (a *Agent) Close() {
 }
 
 func (a *Agent) SendMessage(ctx context.Context, userMessage string, onMessage func(Message)) error {
-	a.messages = append(a.messages, Message{Role: RoleUser, Content: []Content{{Type: ContentTypeText, Text: userMessage}}})
+	a.messages = append(a.messages, Message{Role: RoleUser, Text: userMessage})
 	return a.callLLM(ctx, onMessage)
 }
 
@@ -119,29 +119,27 @@ func (a *Agent) callLLM(ctx context.Context, onMessage func(Message)) error {
 		Messages:     a.messages,
 		Tools:        a.tools,
 	})
-
 	if err != nil {
 		return err
 	}
-	for _, textBlock := range response.TextBlocks {
-		a.messages = append(a.messages, Message{Role: RoleAssistant, Content: []Content{{Type: ContentTypeText, Text: textBlock}}})
-		onMessage(Message{Role: RoleAssistant, Content: []Content{{Type: ContentTypeText, Text: textBlock}}})
-	}
-	for _, toolUse := range response.ToolUses {
-		msg := Message{
-			Role: RoleTool,
-			Content: []Content{
-				{
-					Type:      ContentTypeToolUse,
-					ToolID:    toolUse.ID,
-					ToolName:  toolUse.Name,
-					ToolInput: toolUse.Arguments,
-				},
-			},
-		}
 
-		a.messages = append(a.messages, msg)
-		onMessage(msg)
+	msg := Message{
+		Role:      RoleAssistant,
+		Text:      strings.Join(response.TextBlocks, "\n"),
+		ToolCalls: response.ToolUses,
+	}
+	a.messages = append(a.messages, msg)
+
+	if msg.Text != "" {
+		onMessage(Message{Role: RoleAssistant, Text: msg.Text})
+	}
+
+	a.toolQueue = make([]ToolRequest, len(response.ToolUses))
+	copy(a.toolQueue, response.ToolUses)
+
+	if len(a.toolQueue) > 0 {
+		tc := a.toolQueue[0]
+		onMessage(Message{Role: RoleAssistant, ToolCalls: []ToolRequest{tc}})
 	}
 
 	return nil
@@ -166,20 +164,45 @@ func (a *Agent) ExecuteTool(ctx context.Context, toolRequest *ToolRequest, onMes
 	default:
 		resultText = extractTextContent(result.Content)
 	}
+
 	msg := Message{
 		Role: RoleTool,
-		Content: []Content{
-			{
-				Type:    ContentTypeToolResult,
-				Text:    resultText,
-				IsError: isError,
-			},
+		ToolResult: &ToolResult{
+			ToolID:  toolRequest.ID,
+			Output:  resultText,
+			IsError: isError,
 		},
 	}
 	a.messages = append(a.messages, msg)
 	onMessage(msg)
 
-	return nil
+	return a.advanceToolQueue(ctx, onMessage)
+}
+
+func (a *Agent) ToolDeny(ctx context.Context, tool *ToolRequest, onMessage func(Message)) error {
+	a.messages = append(a.messages, Message{
+		Role: RoleTool,
+		ToolResult: &ToolResult{
+			ToolID: tool.ID,
+			Output: "Tool execution denied by user.",
+		},
+	})
+
+	return a.advanceToolQueue(ctx, onMessage)
+}
+
+func (a *Agent) advanceToolQueue(ctx context.Context, onMessage func(Message)) error {
+	if len(a.toolQueue) > 0 {
+		a.toolQueue = a.toolQueue[1:]
+	}
+
+	if len(a.toolQueue) > 0 {
+		tc := a.toolQueue[0]
+		onMessage(Message{Role: RoleAssistant, ToolCalls: []ToolRequest{tc}})
+		return nil
+	}
+
+	return a.callLLM(ctx, onMessage)
 }
 
 func extractTextContent(content []mcp.Content) string {
@@ -194,19 +217,7 @@ func extractTextContent(content []mcp.Content) string {
 	return resultText.String()
 }
 
-func (a *Agent) ToolDeny(ctx context.Context, tool *ToolRequest, onMessage func(Message)) error {
-	a.messages = append(a.messages, Message{
-		Role: RoleTool,
-		Content: []Content{
-			{
-				Type: ContentTypeToolResult,
-				Text: "Tool execution denied by user.",
-			},
-		},
-	})
-	return a.callLLM(ctx, onMessage)
-}
-
 func (a *Agent) Reset() {
 	a.messages = []Message{}
+	a.toolQueue = nil
 }

internal/agent/provider_claude.go

@@ -1,11 +1,91 @@
 package agent
 
 import (
+	"context"
+	"fmt"
+
 	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
-func convertMCPToolToClaudeTool(tool *mcp.Tool) anthropic.ToolUnionParam {
+type ClaudeProvider struct {
+	client anthropic.Client
+}
+
+func NewClaudeProvider(apiKey string) *ClaudeProvider {
+	return &ClaudeProvider{
+		client: anthropic.NewClient(option.WithAPIKey(apiKey)),
+	}
+}
+
+func (p *ClaudeProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error) {
+	messages := convertMessagesToClaude(opts.Messages)
+	tools := convertToolsToClaude(opts.Tools)
+
+	response, err := p.client.Messages.New(ctx, anthropic.MessageNewParams{
+		Model:     anthropic.Model(opts.Model),
+		MaxTokens: opts.MaxTokens,
+		System:    []anthropic.TextBlockParam{{Type: "text", Text: opts.SystemPrompt}},
+		Messages:  messages,
+		Tools:     tools,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("claude API error: %w", err)
+	}
+
+	return parseClaudeResponse(response), nil
+}
+
+func convertMessagesToClaude(messages []Message) []anthropic.MessageParam {
+	result := make([]anthropic.MessageParam, 0, len(messages))
+
+	i := 0
+	for i < len(messages) {
+		msg := messages[i]
+
+		switch msg.Role {
+		case RoleUser:
+			result = append(result, anthropic.NewUserMessage(anthropic.NewTextBlock(msg.Text)))
+			i++
+
+		case RoleAssistant:
+			var blocks []anthropic.ContentBlockParamUnion
+			if msg.Text != "" {
+				blocks = append(blocks, anthropic.NewTextBlock(msg.Text))
+			}
+			for _, tc := range msg.ToolCalls {
+				blocks = append(blocks, anthropic.NewToolUseBlock(tc.ID, tc.Arguments, tc.Name))
+			}
+			result = append(result, anthropic.NewAssistantMessage(blocks...))
+			i++
+
+		case RoleTool:
+			var blocks []anthropic.ContentBlockParamUnion
+			for i < len(messages) && messages[i].Role == RoleTool && messages[i].ToolResult != nil {
+				tr := messages[i].ToolResult
+				blocks = append(blocks, anthropic.NewToolResultBlock(tr.ToolID, tr.Output, tr.IsError))
+				i++
+			}
+			result = append(result, anthropic.NewUserMessage(blocks...))
+
+		default:
+			i++
+		}
+	}
+
+	return result
+}
+
+func convertToolsToClaude(tools []*mcp.Tool) []anthropic.ToolUnionParam {
+	result := make([]anthropic.ToolUnionParam, 0, len(tools))
+	for _, tool := range tools {
+		result = append(result, convertMCPToolToClaude(tool))
+	}
+	return result
+}
+
+func convertMCPToolToClaude(tool *mcp.Tool) anthropic.ToolUnionParam {
 	inputSchemaMap, ok := tool.InputSchema.(map[string]any)
 	if !ok || inputSchemaMap == nil {
 		inputSchemaMap = map[string]any{}
@@ -40,55 +120,21 @@ func convertMCPToolToClaudeTool(tool *mcp.Tool) anthropic.ToolUnionParam {
 	return toolParam
 }
 
-// func (a *Agent) callClaude(ctx context.Context, onMessage func(Message)) error {
-// 	response, err := a.anthropicClient.Messages.New(ctx, anthropic.MessageNewParams{
-// 		Model:     a.config.Model,
-// 		MaxTokens: a.config.MaxTokens,
-// 		System:    []anthropic.TextBlockParam{{Type: "text", Text: a.config.SystemPrompt}},
-// 		Messages:  a.messages,
-// 		Tools:     a.tools,
-// 	})
-// 	if err != nil {
-// 		return fmt.Errorf("claude API error: %w", err)
-// 	}
-
-// 	assistantContent, toolRequests := a.processResponse(response, onMessage)
-
-// 	a.messages = append(a.messages, anthropic.NewAssistantMessage(assistantContent...))
-
-// 	for _, toolRequest := range toolRequests {
-// 		onMessage(Message{
-// 			Role:    "tool_request",
-// 			Content: toolRequest.Name,
-// 			ToolID:  toolRequest.ID,
-// 			Tool:    toolRequest,
-// 		})
-// 	}
-// 	return nil
-// }
-
-func (a *Agent) processResponse(response *anthropic.Message, onMessage func(Message)) (
-	[]anthropic.ContentBlockParamUnion,
-	[]*ToolRequest,
-) {
-	var assistantContent []anthropic.ContentBlockParamUnion
-	var toolRequests []*ToolRequest
+func parseClaudeResponse(response *anthropic.Message) *LLMResponse {
+	result := &LLMResponse{}
 
 	for _, block := range response.Content {
 		switch content := block.AsAny().(type) {
 		case anthropic.TextBlock:
-			onMessage(Message{Role: "assistant", Content: content.Text})
-			assistantContent = append(assistantContent, anthropic.NewTextBlock(content.Text))
-
+			result.TextBlocks = append(result.TextBlocks, content.Text)
 		case anthropic.ToolUseBlock:
-			assistantContent = append(assistantContent, anthropic.NewToolUseBlock(content.ID, content.Input, content.Name))
-			toolRequests = append(toolRequests, &ToolRequest{
+			result.ToolUses = append(result.ToolUses, ToolRequest{
 				ID:        content.ID,
 				Name:      content.Name,
 				Arguments: content.Input,
 			})
 		}
 	}
 
-	return assistantContent, toolRequests
+	return result
 }

internal/agent/types.go

@@ -8,32 +8,21 @@ const (
 	RoleTool      Role = "tool"
 )
 
-type ContentType string
-
-const (
-	ContentTypeText       ContentType = "text"
-	ContentTypeToolUse    ContentType = "tool_use"
-	ContentTypeToolResult ContentType = "tool_result"
-)
-
 type Message struct {
-	Role    Role      `json:"role"`
-	Content []Content `json:"content"`
-}
-
-type Content struct {
-	Type ContentType `json:"type"`
-	Text string      `json:"text,omitempty"`
-
-	ToolID    string `json:"tool_id,omitempty"`
-	ToolName  string `json:"tool_name,omitempty"`
-	ToolInput any    `json:"tool_input,omitempty"`
-
-	IsError bool `json:"is_error,omitempty"`
+	Role       Role
+	Text       string
+	ToolCalls  []ToolRequest
+	ToolResult *ToolResult
 }
 
 type ToolRequest struct {
 	ID        string
 	Name      string
 	Arguments any
 }
+
+type ToolResult struct {
+	ToolID  string
+	Output  string
+	IsError bool
+}