main.go

package main

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

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

// Tool definitions describe the functions Claude can call.
// The JSON schema tells Claude what parameters each function expects.
var tools = []anthropic.ToolParam{
	{
		Name:        "get_weather",
		Description: anthropic.String("Get the current weather for a given city"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"city": map[string]interface{}{
					"type":        "string",
					"description": "The city to get weather for",
				},
				"unit": map[string]interface{}{
					"type":        "string",
					"enum":        []string{"celsius", "fahrenheit"},
					"description": "Temperature unit",
				},
			},
			Required: []string{"city"},
		},
	},
	{
		Name:        "calculate",
		Description: anthropic.String("Perform a basic arithmetic calculation"),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]interface{}{
				"expression": map[string]interface{}{
					"type":        "string",
					"description": "A math expression like '2 + 2' or '10 * 5'",
				},
			},
			Required: []string{"expression"},
		},
	},
}

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

	// Run the tool-use loop
	runToolLoop(ctx, client, "What's the weather in London and Dublin? Also, what is 42 * 17?")
}

// runToolLoop implements the full tool-use cycle:
// 1. Send messages + tool definitions to Claude
// 2. If Claude returns tool_use blocks, execute the requested tools
// 3. Append results and call Claude again
// 4. Repeat until Claude returns a final text response (stop_reason == "end_turn")
func runToolLoop(ctx context.Context, client *anthropic.Client, userMsg string) {
	history := []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(userMsg)),
	}

	for {
		resp, err := client.Messages.New(ctx, anthropic.MessageNewParams{
			Model:     anthropic.ModelClaudeOpus4_7,
			MaxTokens: 1024,
			Tools:     tools,
			Messages:  history,
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "API error: %v\n", err)
			os.Exit(1)
		}

		// Append Claude's response to history
		history = append(history, anthropic.NewAssistantMessage(resp.Content...))

		// If Claude is done (no more tool calls), print the final answer
		if resp.StopReason == "end_turn" {
			for _, block := range resp.Content {
				switch b := block.AsAny().(type) {
				case anthropic.TextBlock:
					fmt.Println(b.Text)
				}
			}
			break
		}

		// Claude wants to use tools — collect all tool_use blocks and execute them
		if resp.StopReason == "tool_use" {
			var toolResults []anthropic.ToolResultBlockParam

			for _, block := range resp.Content {
				switch b := block.AsAny().(type) {
				case anthropic.ToolUseBlock:
					fmt.Printf("[Tool call] %s(%s)\n", b.Name, string(b.Input))
					result := executeTool(b.Name, b.Input)
					fmt.Printf("[Tool result] %s\n", result)

					toolResults = append(toolResults, anthropic.ToolResultBlockParam{
						ToolUseID: b.ID,
						Content: []anthropic.ToolResultBlockParamContentUnion{
							{OfRequestTextBlock: &anthropic.TextBlockParam{Text: result}},
						},
					})
				}
			}

			// Feed all tool results back to Claude in a single user turn
			history = append(history, anthropic.NewUserMessage(
				func() []anthropic.ContentBlockParamUnion {
					blocks := make([]anthropic.ContentBlockParamUnion, len(toolResults))
					for i, tr := range toolResults {
						blocks[i] = anthropic.ContentBlockParamUnion{OfToolResult: &tr}
					}
					return blocks
				}()...,
			))
		}
	}
}

// executeTool routes a tool call to the appropriate Go function.
func executeTool(name string, input json.RawMessage) string {
	switch name {
	case "get_weather":
		var params struct {
			City string `json:"city"`
			Unit string `json:"unit"`
		}
		json.Unmarshal(input, &params)
		unit := params.Unit
		if unit == "" {
			unit = "celsius"
		}
		// Stub implementation — replace with a real weather API call
		return fmt.Sprintf(`{"city":"%s","temperature":18,"unit":"%s","condition":"partly cloudy"}`, params.City, unit)

	case "calculate":
		var params struct {
			Expression string `json:"expression"`
		}
		json.Unmarshal(input, &params)
		// Stub — in a real app you'd evaluate the expression safely
		return fmt.Sprintf(`{"expression":"%s","result":"(calculated)"}`, params.Expression)

	default:
		return fmt.Sprintf(`{"error":"unknown tool %q"}`, name)
	}
}