anthropic.go

package goai

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

func init() {
	register("anthropic", newAnthropicProvider)
}

// anthropicProvider implements Provider for Anthropic Claude models
type anthropicProvider struct {
	apiKey      string
	modelID     string
	apiEndpoint string
}

// newAnthropicProvider creates a new Anthropic provider
func newAnthropicProvider(model string, opts Options) (Provider, error) {
	if opts.APIKey == "" {
		return nil, fmt.Errorf("%w: anthropic", ErrNoAPIKey)
	}
	
	endpoint := opts.Endpoint
	if endpoint == "" {
		endpoint = "https://api.anthropic.com/v1/messages"
	}
	
	return &anthropicProvider{
		apiKey:      opts.APIKey,
		modelID:     model,
		apiEndpoint: endpoint,
	}, nil
}

// chat sends a prompt to Anthropic and returns the response
func (p *anthropicProvider) chat(ctx context.Context, prompt string, opts Options) (*Response, error) {
	start := time.Now()
	
	requestBody := map[string]interface{}{
		"model": p.modelID,
		"messages": []map[string]string{
			{"role": "user", "content": prompt},
		},
		"max_tokens": opts.MaxTokens,
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		return nil, &Error{
			Provider: "anthropic",
			Message:  fmt.Sprintf("failed to marshal request: %v", err),
			Err:      err,
		}
	}
	
	req, err := http.NewRequestWithContext(ctx, "POST", p.apiEndpoint, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, &Error{
			Provider: "anthropic",
			Message:  fmt.Sprintf("failed to create request: %v", err),
			Err:      err,
		}
	}
	
	req.Header.Set("x-api-key", p.apiKey)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("anthropic-version", "2023-06-01")
	
	client := &http.Client{Timeout: opts.Timeout}
	resp, err := client.Do(req)
	if err != nil {
		return nil, &Error{
			Provider: "anthropic",
			Message:  fmt.Sprintf("request failed: %v", err),
			Err:      err,
		}
	}
	defer resp.Body.Close()
	
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, &Error{
			Provider: "anthropic",
			Message:  fmt.Sprintf("failed to read response: %v", err),
			Err:      err,
		}
	}
	
	if resp.StatusCode != http.StatusOK {
		return nil, &Error{
			Provider:   "anthropic",
			StatusCode: resp.StatusCode,
			Message:    string(body),
		}
	}
	
	var apiResponse struct {
		Content []struct {
			Text string `json:"text"`
		} `json:"content"`
		Usage struct {
			InputTokens  int `json:"input_tokens"`
			OutputTokens int `json:"output_tokens"`
		} `json:"usage"`
	}
	
	if err := json.Unmarshal(body, &apiResponse); err != nil {
		return nil, &Error{
			Provider: "anthropic",
			Message:  fmt.Sprintf("failed to parse response: %v", err),
			Err:      err,
		}
	}
	
	if len(apiResponse.Content) == 0 {
		return nil, &Error{
			Provider: "anthropic",
			Message:  "no response from Anthropic",
			Err:      ErrNoResponse,
		}
	}
	
	return &Response{
		Content:    apiResponse.Content[0].Text,
		TokensUsed: apiResponse.Usage.InputTokens + apiResponse.Usage.OutputTokens,
		LatencyMs:  time.Since(start).Milliseconds(),
		Model:      p.modelID,
		Provider:   "anthropic",
		Metadata:   map[string]interface{}{"model": p.modelID},
	}, nil
}

// name returns the provider name
func (p *anthropicProvider) name() string {
	return "anthropic"
}

// model returns the model identifier
func (p *anthropicProvider) model() string {
	return p.modelID
}