Claude Provider

import (
    "context"
    "fmt"

    "oss.nandlabs.io/golly/genai"
    "oss.nandlabs.io/golly/genai/impl"
)

provider := impl.NewClaudeProvider("sk-ant-...", nil)
defer provider.Close()

msg := genai.NewTextMessage(genai.RoleUser, "Hello, what can you do?")
resp, err := provider.Generate(context.Background(), "claude-sonnet-4-20250514", msg, nil)
if err != nil {
    panic(err)
}
for _, c := range resp.Candidates {
    for _, p := range c.Message.Parts {
        if p.Text != nil {
            fmt.Println(p.Text.Text)
        }
    }
}

// Uses x-api-key header auth (Anthropic's standard mechanism)
provider := impl.NewClaudeProvider("sk-ant-...", nil)

import (
    "oss.nandlabs.io/golly/clients"
    "oss.nandlabs.io/golly/genai/impl"
    "oss.nandlabs.io/golly/rest"
)

provider := impl.NewClaudeProviderWithConfig(&impl.ClaudeProviderConfig{
    Auth:       clients.NewAPIKeyAuth("x-api-key", "sk-ant-..."),
    APIVersion: "2023-06-01",
    BaseURL:    "https://api.anthropic.com",
    Models:     []string{"claude-sonnet-4-20250514", "claude-haiku-4-20250414", "claude-opus-4-20250514"},
    Description: "Production Claude",
    Version:     "2.0.0",
    ExtraHeaders: map[string]string{
        "anthropic-beta": "prompt-caching-2024-07-31",
    },
}, &rest.ClientOpts{
    // Optional: configure retry, circuit breaker, timeouts, etc.
})

// Convenience — wraps key as x-api-key header automatically
provider := impl.NewClaudeProvider("sk-ant-...", nil)

// Equivalent explicit config
provider = impl.NewClaudeProviderWithConfig(&impl.ClaudeProviderConfig{
    Auth: clients.NewAPIKeyAuth("x-api-key", "sk-ant-..."),
}, nil)

type SecretManagerAuth struct {
    client     *secretmanager.Client
    secretName string
}

func (s *SecretManagerAuth) Type() clients.AuthType { return clients.AuthTypeAPIKey }
func (s *SecretManagerAuth) User() (string, error)  { return "", nil }
func (s *SecretManagerAuth) Pass() (string, error)  { return "", nil }
func (s *SecretManagerAuth) Token() (string, error) {
    result, err := s.client.AccessSecretVersion(ctx, &secretmanagerpb.AccessSecretVersionRequest{
        Name: s.secretName,
    })
    if err != nil {
        return "", err
    }
    return string(result.Payload.Data), nil
}

provider := impl.NewClaudeProviderWithConfig(&impl.ClaudeProviderConfig{
    Auth: &SecretManagerAuth{
        client:     smClient,
        secretName: "projects/my-proj/secrets/claude-key/versions/latest",
    },
}, nil)

msg := genai.NewTextMessage(genai.RoleUser, "Explain quantum entanglement.")
opts := genai.NewOptionsBuilder().
    SetMaxTokens(1024).
    SetTemperature(0.5).
    Build()

resp, err := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, opts)

opts := genai.NewOptionsBuilder().
    SetMaxTokens(2048).
    Build()
opts.Set(genai.OptionSystemInstructions,
    "You are an expert Go programmer. Always provide idiomatic Go code with error handling.")

msg := genai.NewTextMessage(genai.RoleUser, "How do I implement a worker pool?")
resp, err := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, opts)

msg := genai.NewTextMessage(genai.RoleUser, "Write a detailed analysis of Go's concurrency model.")
opts := genai.NewOptionsBuilder().SetMaxTokens(2048).Build()

respCh, errCh := provider.GenerateStream(ctx, "claude-sonnet-4-20250514", msg, opts)
for resp := range respCh {
    for _, c := range resp.Candidates {
        for _, p := range c.Message.Parts {
            if p.Text != nil {
                fmt.Print(p.Text.Text) // prints token by token
            }
        }
    }
}
if err := <-errCh; err != nil {
    // handle streaming error
}

// Image from bytes (supported)
msg := genai.NewTextMessage(genai.RoleUser, "What's in this image?")
genai.AddBinPart(msg, "photo", jpegBytes, "image/jpeg")

resp, err := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, nil)

resp, _ := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, opts)
for _, c := range resp.Candidates {
    for _, p := range c.Message.Parts {
        if p.FuncCall != nil {
            fmt.Printf("Tool call: %s(%v)\n", p.FuncCall.FunctionName, p.FuncCall.Arguments)
        }
    }
}

resp, _ := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, opts)

// Claude returns a single candidate (no multi-candidate support)
candidate := resp.Candidates[0]
candidate.FinishReason // genai.FinishReasonEndTurn, FinishReasonLength, FinishReasonStop, FinishReasonToolCall
candidate.Message      // *genai.Message with Parts (text, tool_use)

// Token usage metadata
resp.Meta.InputTokens   // prompt tokens
resp.Meta.OutputTokens  // completion tokens
resp.Meta.TotalTokens   // input + output
resp.Meta.CachedTokens  // cache_read_input_tokens (if prompt caching is enabled)

resp, err := provider.Generate(ctx, "claude-sonnet-4-20250514", msg, opts)
if err != nil {
    // Error format: "claude API error [error_type]: error message"
    log.Fatal(err)
}

// Prompt caching
provider := impl.NewClaudeProviderWithConfig(&impl.ClaudeProviderConfig{
    Auth: clients.NewAPIKeyAuth("x-api-key", "sk-ant-..."),
    ExtraHeaders: map[string]string{
        "anthropic-beta": "prompt-caching-2024-07-31",
    },
}, nil)

// Multiple beta features (comma-separated)
provider = impl.NewClaudeProviderWithConfig(&impl.ClaudeProviderConfig{
    Auth: clients.NewAPIKeyAuth("x-api-key", "sk-ant-..."),
    ExtraHeaders: map[string]string{
        "anthropic-beta": "prompt-caching-2024-07-31,max-tokens-3-5-sonnet-2024-07-15",
    },
}, nil)