Hello, model: one call, from an empty folder

package main
 
import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
	"time"
)
 
const (
	defaultBaseURL = "https://api.anthropic.com"
	model          = "claude-haiku-4-5-20251001"
)
 
// What we send.
type request struct {
	Model     string    `json:"model"`
	MaxTokens int       `json:"max_tokens"`
	Messages  []message `json:"messages"`
}
 
type message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}
 
// What comes back.
type response struct {
	Content    []block `json:"content"`
	StopReason string  `json:"stop_reason"`
	Usage      usage   `json:"usage"`
}
 
type block struct {
	Type string `json:"type"`
	Text string `json:"text"`
}
 
type usage struct {
	InputTokens  int `json:"input_tokens"`
	OutputTokens int `json:"output_tokens"`
}

func main() {
	apiKey := os.Getenv("ANTHROPIC_API_KEY")
	if apiKey == "" {
		fmt.Fprintln(os.Stderr, "set ANTHROPIC_API_KEY")
		os.Exit(1)
	}
	if len(os.Args) < 2 {
		fmt.Fprintln(os.Stderr, `usage: hello "your question"`)
		os.Exit(1)
	}
 
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
 
	res, err := ask(ctx, defaultBaseURL, apiKey, strings.Join(os.Args[1:], " "))
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
 
	for _, b := range res.Content {
		if b.Type == "text" {
			fmt.Println(b.Text)
		}
	}
	fmt.Fprintf(os.Stderr, "\n[stop: %s · in: %d tokens · out: %d tokens]\n",
		res.StopReason, res.Usage.InputTokens, res.Usage.OutputTokens)
}

package main
 
import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
)
 
// fakeAnthropic stands in for api.anthropic.com. It records what it was sent
// and replies with whatever status and body the test asks for.
func fakeAnthropic(t *testing.T, status int, reply string) (*httptest.Server, *http.Request, *[]byte) {
	t.Helper()
	var gotReq http.Request
	var gotBody []byte
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotReq = *r
		gotBody, _ = io.ReadAll(r.Body)
		w.Header().Set("content-type", "application/json")
		w.WriteHeader(status)
		io.WriteString(w, reply)
	}))
	t.Cleanup(srv.Close)
	return srv, &gotReq, &gotBody
}
 
const okReply = `{
  "id": "msg_01", "type": "message", "role": "assistant",
  "content": [{"type": "text", "text": "Hello, Ilango."}],
  "model": "claude-haiku-4-5-20251001",
  "stop_reason": "end_turn", "stop_sequence": null,
  "usage": {"input_tokens": 12, "output_tokens": 6}
}`
 
func TestAskSendsAWellFormedRequest(t *testing.T) {
	srv, req, body := fakeAnthropic(t, 200, okReply)
 
	if _, err := ask(context.Background(), srv.URL, "test-key", "Say hello"); err != nil {
		t.Fatalf("ask: %v", err)
	}
 
	if req.Method != "POST" || req.URL.Path != "/v1/messages" {
		t.Errorf("got %s %s, want POST /v1/messages", req.Method, req.URL.Path)
	}
	if got := req.Header.Get("x-api-key"); got != "test-key" {
		t.Errorf("x-api-key = %q", got)
	}
	if got := req.Header.Get("anthropic-version"); got != "2023-06-01" {
		t.Errorf("anthropic-version = %q", got)
	}
 
	var sent struct {
		Model     string `json:"model"`
		MaxTokens int    `json:"max_tokens"`
		Messages  []struct {
			Role    string `json:"role"`
			Content string `json:"content"`
		} `json:"messages"`
	}
	if err := json.Unmarshal(*body, &sent); err != nil {
		t.Fatalf("request body is not JSON: %v\n%s", err, *body)
	}
	if sent.Model == "" || sent.MaxTokens <= 0 {
		t.Errorf("model and max_tokens are required, got %q and %d", sent.Model, sent.MaxTokens)
	}
	if len(sent.Messages) != 1 || sent.Messages[0].Role != "user" || sent.Messages[0].Content != "Say hello" {
		t.Errorf("messages = %+v, want one user message with the prompt", sent.Messages)
	}
}
 
func TestAskDecodesTheReply(t *testing.T) {
	srv, _, _ := fakeAnthropic(t, 200, okReply)
 
	res, err := ask(context.Background(), srv.URL, "test-key", "Say hello")
	if err != nil {
		t.Fatalf("ask: %v", err)
	}
	if len(res.Content) != 1 || res.Content[0].Type != "text" || res.Content[0].Text != "Hello, Ilango." {
		t.Errorf("content = %+v", res.Content)
	}
	if res.StopReason != "end_turn" {
		t.Errorf("stop reason = %q", res.StopReason)
	}
	if res.Usage.InputTokens != 12 || res.Usage.OutputTokens != 6 {
		t.Errorf("usage = %+v", res.Usage)
	}
}
 
func TestAskTurnsAnAPIErrorIntoAGoError(t *testing.T) {
	srv, _, _ := fakeAnthropic(t, 401,
		`{"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}`)
 
	_, err := ask(context.Background(), srv.URL, "bad-key", "Say hello")
	if err == nil {
		t.Fatal("want an error for a 401, got nil")
	}
	if !strings.Contains(err.Error(), "invalid x-api-key") {
		t.Errorf("error should carry the API's message, got: %v", err)
	}
}
 
func TestAskStopsWhenTheContextIsCancelled(t *testing.T) {
	srv, _, _ := fakeAnthropic(t, 200, okReply)
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
 
	if _, err := ask(ctx, srv.URL, "test-key", "Say hello"); err == nil {
		t.Fatal("want an error from a cancelled context, got nil")
	}
}