main.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

// Agent wraps Claude with a set of tools and handles the reasoning loop automatically.
type Agent struct {
	client  *anthropic.Client
	tools   []anthropic.ToolParam
	history []anthropic.MessageParam
	system  []anthropic.TextBlockParam
}

// NewAgent creates an agent with a system prompt and a set of tools.
func NewAgent(client *anthropic.Client, systemPrompt string, tools []anthropic.ToolParam) *Agent {
	return &Agent{
		client: client,
		tools:  tools,
		system: []anthropic.TextBlockParam{
			anthropic.NewTextBlockParam(systemPrompt),
		},
	}
}

// Run sends a user message and continues the tool-use loop until Claude returns end_turn.
func (a *Agent) Run(ctx context.Context, userMsg string) (string, error) {
	a.history = append(a.history, anthropic.NewUserMessage(anthropic.NewTextBlock(userMsg)))

	for {
		resp, err := a.client.Messages.New(ctx, anthropic.MessageNewParams{
			Model:     anthropic.ModelClaudeOpus4_7,
			MaxTokens: 2048,
			System:    a.system,
			Tools:     a.tools,
			Messages:  a.history,
		})
		if err != nil {
			return "", err
		}

		a.history = append(a.history, anthropic.NewAssistantMessage(resp.Content...))

		if resp.StopReason == "end_turn" {
			var sb strings.Builder
			for _, block := range resp.Content {
				switch b := block.AsAny().(type) {
				case anthropic.TextBlock:
					sb.WriteString(b.Text)
				}
			}
			return sb.String(), nil
		}

		if resp.StopReason == "tool_use" {
			var toolResults []anthropic.ToolResultBlockParam
			for _, block := range resp.Content {
				switch b := block.AsAny().(type) {
				case anthropic.ToolUseBlock:
					fmt.Printf("  → calling %s\n", b.Name)
					result := dispatchTool(b.Name, b.Input)
					toolResults = append(toolResults, anthropic.ToolResultBlockParam{
						ToolUseID: b.ID,
						Content: []anthropic.ToolResultBlockParamContentUnion{
							{OfRequestTextBlock: &anthropic.TextBlockParam{Text: result}},
						},
					})
				}
			}

			blocks := make([]anthropic.ContentBlockParamUnion, len(toolResults))
			for i, tr := range toolResults {
				blocks[i] = anthropic.ContentBlockParamUnion{OfToolResult: &tr}
			}
			a.history = append(a.history, anthropic.NewUserMessage(blocks...))
		}
	}
}

// Tool registry
var availableTools = []anthropic.ToolParam{
	{
		Name:        "search_web",
		Description: anthropic.String("Search the web for current information on a topic"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"query": map[string]interface{}{"type": "string", "description": "Search query"},
			},
			Required: []string{"query"},
		},
	},
	{
		Name:        "read_file",
		Description: anthropic.String("Read the contents of a local file"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"path": map[string]interface{}{"type": "string", "description": "File path to read"},
			},
			Required: []string{"path"},
		},
	},
	{
		Name:        "write_file",
		Description: anthropic.String("Write content to a local file"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"path":    map[string]interface{}{"type": "string", "description": "File path to write"},
				"content": map[string]interface{}{"type": "string", "description": "Content to write"},
			},
			Required: []string{"path", "content"},
		},
	},
	{
		Name:        "run_command",
		Description: anthropic.String("Run a shell command and return its output"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"command": map[string]interface{}{"type": "string", "description": "Shell command to run"},
			},
			Required: []string{"command"},
		},
	},
}

func dispatchTool(name string, input json.RawMessage) string {
	switch name {
	case "search_web":
		var p struct{ Query string `json:"query"` }
		json.Unmarshal(input, &p)
		return fmt.Sprintf(`{"results":["Result 1 for '%s'","Result 2 for '%s'"]}`, p.Query, p.Query)
	case "read_file":
		var p struct{ Path string `json:"path"` }
		json.Unmarshal(input, &p)
		return fmt.Sprintf(`{"content":"(stub) contents of %s"}`, p.Path)
	case "write_file":
		var p struct {
			Path    string `json:"path"`
			Content string `json:"content"`
		}
		json.Unmarshal(input, &p)
		return fmt.Sprintf(`{"success":true,"path":"%s"}`, p.Path)
	case "run_command":
		var p struct{ Command string `json:"command"` }
		json.Unmarshal(input, &p)
		return fmt.Sprintf(`{"output":"(stub) ran: %s"}`, p.Command)
	default:
		return fmt.Sprintf(`{"error":"unknown tool %q"}`, name)
	}
}

func main() {
	client := anthropic.NewClient(option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")))
	ctx := context.Background()

	agent := NewAgent(
		client,
		"You are a research assistant. Use your tools to gather information, then write a concise summary. Think step by step.",
		availableTools,
	)

	task := "Research the latest Go release, find any release notes in ./NOTES.md, and write a summary to ./SUMMARY.md"
	fmt.Printf("Task: %s\n\n", task)

	result, err := agent.Run(ctx, task)
	if err != nil {
		fmt.Fprintf(os.Stderr, "agent error: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("\nFinal answer:\n%s\n", result)
}