feat: Anthropic Messages API support for CLI

Add dual-protocol LLM client that auto-detects and speaks both OpenAI
Chat Completions and Anthropic Messages API. Enables MiniMax Anthropic
mode and native Claude API support.

- llm_anthropic.go: streaming SSE parser, message/tool conversion,
  non-streaming for compaction
- Protocol auto-detection from URL (/anthropic) or LLM_PROTOCOL env var
- 20 unit tests + 4 live integration tests against MiniMax Anthropic
- Boot screen and /session show active protocol
- MiniMax context window (204K) and cost estimates added

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: halfaipg

boot.go

@@ -191,9 +191,14 @@ func buildBootSteps(cfg *Config) []bootStep {
 	if home != "" && strings.HasPrefix(workDisplay, home) {
 		workDisplay = "~" + workDisplay[len(home):]
 	}
+	proto := detectProtocol(cfg.BaseURL)
+	protoLabel := "chat completions"
+	if proto == ProtocolAnthropic {
+		protoLabel = "messages api"
+	}
 	return []bootStep{
 		{label: "config", value: "loaded"},
-		{label: "provider", value: cfg.Model},
+		{label: "provider", value: fmt.Sprintf("%s (%s)", cfg.Model, protoLabel)},
 		{label: "workspace", value: fmt.Sprintf("%s (%d files)", workDisplay, fileCount)},
 		{label: "terminal", value: TerminalName()},
 		{label: "status", value: "ready"},

commands.go

@@ -115,6 +115,16 @@ func init() {
 			var sb strings.Builder
 			sb.WriteString(styleMuted.Render("  Session info:") + "\n")
 			sb.WriteString(styleDim.Render("  Model:    ") + styleMuted.Render(m.config.Model) + "\n")
+			// Protocol (API format)
+			proto := ProtocolOpenAI
+			if m.agent != nil {
+				proto = m.agent.client.Protocol
+			}
+			protoLabel := "Chat Completions (OpenAI)"
+			if proto == ProtocolAnthropic {
+				protoLabel = "Messages API (Anthropic)"
+			}
+			sb.WriteString(styleDim.Render("  Protocol: ") + styleMuted.Render(protoLabel) + "\n")
 			// Token counts with cost estimate
 			tokenLine := fmt.Sprintf("%d (%d in + %d out)", totalTokens, m.tokens.PromptTokens, m.tokens.CompletionTokens)
 			cost := estimateCost(m.config.Model, m.tokens.PromptTokens, m.tokens.CompletionTokens)
@@ -451,6 +461,9 @@ func estimateCost(model string, promptTokens, completionTokens int) string {
 		"claude-sonnet": {3.00, 15.0},
 		"claude-opus":   {15.0, 75.0},
 		"claude-haiku":  {0.25, 1.25},
+		"minimax-m2.5":  {1.00, 5.00},
+		"minimax-m2.1":  {0.50, 2.50},
+		"minimax-m2":    {0.50, 2.50},
 		"glm-4":         {0.14, 0.14},
 		"glm-4.7":       {0.14, 0.14},
 	}

compact.go

@@ -37,6 +37,7 @@ var defaultContextWindows = map[string]int{
 	"o3":             200000,
 	"o4-mini":        200000,
 	"claude":         200000,
+	"minimax":        204800,
 	"glm":            128000,
 	"gemini":         1000000,
 	"deepseek":       128000,
@@ -227,8 +228,16 @@ func compactHistory(client *LLMClient, messages []ChatMessage) ([]ChatMessage, b
 	return compacted, true
 }
 
-// nonStreamingChat makes a non-streaming Chat Completions call.
+// nonStreamingChat makes a non-streaming LLM call, dispatching by protocol.
 func nonStreamingChat(client *LLMClient, messages []ChatMessage) (string, error) {
+	if client.Protocol == ProtocolAnthropic {
+		return nonStreamingChatAnthropic(client, messages)
+	}
+	return nonStreamingChatOpenAI(client, messages)
+}
+
+// nonStreamingChatOpenAI makes a non-streaming OpenAI Chat Completions call.
+func nonStreamingChatOpenAI(client *LLMClient, messages []ChatMessage) (string, error) {
 	body := map[string]interface{}{
 		"model":    client.Model,
 		"messages": messages,

llm.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"os"
 	"strings"
 	"time"
 )
@@ -108,11 +109,18 @@ type StreamEvent struct {
 //  LLM Client
 // ──────────────────────────────────────────────────────────────
 
+// Protocol constants for API format detection
+const (
+	ProtocolOpenAI    = "openai"
+	ProtocolAnthropic = "anthropic"
+)
+
 type LLMClient struct {
-	APIKey  string
-	BaseURL string
-	Model   string
-	client  *http.Client
+	APIKey   string
+	BaseURL  string
+	Model    string
+	Protocol string // "openai" or "anthropic"
+	client   *http.Client
 }
 
 func NewLLMClient(apiKey, baseURL, model string) *LLMClient {
@@ -126,18 +134,50 @@ func newLLMClientWithTimeout(apiKey, baseURL, model string, timeout time.Duratio
 	if model == "" {
 		model = "gpt-4o"
 	}
+	baseURL = strings.TrimSuffix(baseURL, "/")
+	protocol := detectProtocol(baseURL)
+
 	return &LLMClient{
-		APIKey:  apiKey,
-		BaseURL: strings.TrimSuffix(baseURL, "/"),
-		Model:   model,
-		client:  &http.Client{Timeout: timeout},
+		APIKey:   apiKey,
+		BaseURL:  baseURL,
+		Model:    model,
+		Protocol: protocol,
+		client:   &http.Client{Timeout: timeout},
 	}
 }
 
-// StreamChat sends a streaming Chat Completions request and pushes
-// parsed events into the provided channel. Caller should read from ch
-// until it is closed.
+// detectProtocol determines the API protocol from the base URL and env vars.
+func detectProtocol(baseURL string) string {
+	// Explicit env var override
+	if p := os.Getenv("LLM_PROTOCOL"); p != "" {
+		switch strings.ToLower(p) {
+		case "anthropic", "claude", "messages":
+			return ProtocolAnthropic
+		default:
+			return ProtocolOpenAI
+		}
+	}
+	// Auto-detect from URL
+	urlLower := strings.ToLower(baseURL)
+	if strings.Contains(urlLower, "/anthropic") || strings.Contains(urlLower, "anthropic.com") {
+		return ProtocolAnthropic
+	}
+	return ProtocolOpenAI
+}
+
+// StreamChat sends a streaming LLM request and pushes parsed events
+// into the provided channel. Dispatches to the appropriate protocol
+// implementation based on c.Protocol.
 func (c *LLMClient) StreamChat(ctx context.Context, messages []ChatMessage, tools []ToolDef, ch chan<- StreamEvent) {
+	if c.Protocol == ProtocolAnthropic {
+		c.streamChatAnthropic(ctx, messages, tools, ch)
+		return
+	}
+	c.streamChatOpenAI(ctx, messages, tools, ch)
+}
+
+// streamChatOpenAI sends a streaming OpenAI Chat Completions request.
+func (c *LLMClient) streamChatOpenAI(ctx context.Context, messages []ChatMessage, tools []ToolDef, ch chan<- StreamEvent) {
 	defer close(ch)
 
 	body := map[string]interface{}{