feat(llm): support OpenAI Codex endpoints

README.md

@@ -126,6 +126,15 @@ export OCR_LLM_MODEL=claude-opus-4-6
 export OCR_USE_ANTHROPIC=true
 ```
 
+For OpenAI Codex / GPT-5 reasoning models, use the Responses endpoint:
+
+```bash
+ocr config set llm.url https://api.openai.com/v1/responses
+ocr config set llm.auth_token "$OPENAI_API_KEY"
+ocr config set llm.model gpt-5.1-codex-max
+ocr config set llm.use_anthropic false
+```
+
 Config is stored in `~/.opencodereview/config.json`.
 
 It is also compatible with Claude Code environment variables (`ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_MODEL`) and parses `~/.zshrc` / `~/.bashrc` for those exports.
@@ -331,9 +340,9 @@ Config file: `~/.opencodereview/config.json`
 
 | Key | Type | Example |
 |-----|------|---------|
-| `llm.url` | string | `https://api.openai.com/v1/chat/completions` |
+| `llm.url` | string | `https://api.openai.com/v1/responses` or `https://api.openai.com/v1/chat/completions` |
 | `llm.auth_token` | string | `sk-xxxxxxx` |
-| `llm.model` | string | `claude-opus-4-6` |
+| `llm.model` | string | `gpt-5.1-codex-max` or `claude-opus-4-6` |
 | `llm.use_anthropic` | boolean | `true` \| `false` |
 | `language` | string | `English` \| `Chinese` (default: Chinese) |
 | `telemetry.enabled` | boolean | `true` \| `false` |
@@ -352,6 +361,8 @@ Environment variables take precedence over the config file.
 | `OCR_LLM_MODEL` | Model name |
 | `OCR_USE_ANTHROPIC` | `true` = Anthropic, `false` = OpenAI |
 
+`OCR_LLM_AUTH_TOKEN` and `OCR_LLM_USE_ANTHROPIC` are also accepted for compatibility with the CI examples.
+
 
 ## Telemetry
 

cmd/opencodereview/flags.go

@@ -247,9 +247,10 @@ Usage:
   ocr config set <key> <value>
 
 Examples:
-  ocr config set llm.url https://xx/v1/openai/chat/completions
+  ocr config set llm.url https://api.openai.com/v1/responses
   ocr config set llm.auth_token xxxxxxxxxx
-  ocr config set llm.model claude-opus-4-6
+  ocr config set llm.model gpt-5.1-codex-max
+  ocr config set llm.use_anthropic false
   ocr config set llm.extra_body '{"thinking":{"type":"disabled"}}'
   ocr config set language English
   ocr config set telemetry.enabled true

internal/llm/client.go

@@ -1,5 +1,6 @@
 // Package llm provides LLM client interfaces supporting multiple protocols.
-// Supported protocols: Anthropic Messages API, OpenAI Chat Completions API.
+// Supported protocols: Anthropic Messages API, OpenAI Chat Completions API,
+// and OpenAI Responses API.
 package llm
 
 import (
@@ -197,7 +198,8 @@ type ClientConfig struct {
 // --- Factory ---
 
 // NewLLMClient creates the appropriate client based on the resolved endpoint protocol.
-// protocol: "anthropic" -> AnthropicClient, anything else -> OpenAIClient.
+// protocol: "anthropic" -> AnthropicClient; OpenAI /responses URLs -> OpenAIResponsesClient;
+// anything else -> OpenAIClient.
 func NewLLMClient(ep ResolvedEndpoint) LLMClient {
 	cfg := ClientConfig{
 		URL:       ep.URL,
@@ -208,6 +210,9 @@ func NewLLMClient(ep ResolvedEndpoint) LLMClient {
 	if ep.Protocol == "anthropic" {
 		return NewAnthropicClient(cfg)
 	}
+	if isResponsesEndpoint(ep.URL) {
+		return NewOpenAIResponsesClient(cfg)
+	}
 	return NewOpenAIClient(cfg)
 }
 
@@ -270,7 +275,11 @@ func CountTokensForModel(text string, modelName string) int {
 func encodingForModel(modelName string) string {
 	lower := strings.ToLower(modelName)
 	switch {
-	case strings.Contains(lower, "o1") || strings.Contains(lower, "o3") || strings.Contains(lower, "o4"):
+	case strings.Contains(lower, "gpt-5") ||
+		strings.Contains(lower, "codex") ||
+		strings.Contains(lower, "o1") ||
+		strings.Contains(lower, "o3") ||
+		strings.Contains(lower, "o4"):
 		return "o200k_base"
 	default:
 		return "cl100k_base"
@@ -307,6 +316,19 @@ func NewClient(cfg ClientConfig) *OpenAIClient {
 	return NewOpenAIClient(cfg)
 }
 
+func isResponsesEndpoint(rawURL string) bool {
+	return strings.HasSuffix(strings.TrimRight(rawURL, "/"), "/responses")
+}
+
+func useMaxCompletionTokens(model string) bool {
+	lower := strings.ToLower(model)
+	return strings.Contains(lower, "gpt-5") ||
+		strings.Contains(lower, "codex") ||
+		strings.Contains(lower, "o1") ||
+		strings.Contains(lower, "o3") ||
+		strings.Contains(lower, "o4")
+}
+
 // ChatRequest represents the payload for a chat completion call.
 type ChatRequest struct {
 	Model       string    `json:"model"`
@@ -370,15 +392,10 @@ func (c *OpenAIClient) StreamCompletionWithCtx(ctx context.Context, req ChatRequ
 	}
 
 	return c.withRetryCtx(ctx, func() error {
-		body := make(map[string]any)
-		b, _ := json.Marshal(req)
-		json.Unmarshal(b, &body)
-		body["model"] = model
-		for k, v := range c.cfg.ExtraBody {
-			body[k] = v
+		payload, err := c.buildRequestPayload(model, req)
+		if err != nil {
+			return fmt.Errorf("marshal request body: %w", err)
 		}
-
-		payload, _ := json.Marshal(body)
 		httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, c.cfg.URL, bytes.NewReader(payload))
 		if err != nil {
 			return fmt.Errorf("create request: %w", err)
@@ -431,8 +448,7 @@ func (c *OpenAIClient) doRequestCtx(ctx context.Context, model string, req ChatR
 	if model == "" {
 		model = c.cfg.Model
 	}
-	req.Model = model
-	payload, err := mergeExtraBody(req, c.cfg.ExtraBody)
+	payload, err := c.buildRequestPayload(model, req)
 	if err != nil {
 		return nil, fmt.Errorf("marshal request body: %w", err)
 	}
@@ -478,6 +494,26 @@ func (c *OpenAIClient) doRequestCtx(ctx context.Context, model string, req ChatR
 	}, nil
 }
 
+func (c *OpenAIClient) buildRequestPayload(model string, req ChatRequest) ([]byte, error) {
+	req.Model = model
+	b, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+	var body map[string]any
+	if err := json.Unmarshal(b, &body); err != nil {
+		return nil, err
+	}
+	if req.MaxTokens > 0 && useMaxCompletionTokens(model) {
+		delete(body, "max_tokens")
+		body["max_completion_tokens"] = req.MaxTokens
+	}
+	for k, v := range c.cfg.ExtraBody {
+		body[k] = v
+	}
+	return json.Marshal(body)
+}
+
 // --- AnthropicClient ---
 
 const anthropicVersion = "2023-06-01"

internal/llm/client_test.go

@@ -1,6 +1,9 @@
 package llm
 
 import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 )
 
@@ -47,6 +50,205 @@ func TestNewOpenAIClient_URLNormalization(t *testing.T) {
 	}
 }
 
+func TestNewOpenAIResponsesClient_URLNormalization(t *testing.T) {
+	tests := []struct {
+		name     string
+		inputURL string
+		wantURL  string
+	}{
+		{
+			name:     "base URL without trailing slash",
+			inputURL: "https://api.example.com/v1",
+			wantURL:  "https://api.example.com/v1/responses",
+		},
+		{
+			name:     "base URL with trailing slash",
+			inputURL: "https://api.example.com/v1/",
+			wantURL:  "https://api.example.com/v1/responses",
+		},
+		{
+			name:     "full URL already has responses",
+			inputURL: "https://api.example.com/v1/responses",
+			wantURL:  "https://api.example.com/v1/responses",
+		},
+		{
+			name:     "full URL with trailing slash",
+			inputURL: "https://api.example.com/v1/responses/",
+			wantURL:  "https://api.example.com/v1/responses/",
+		},
+		{
+			name:     "bare host",
+			inputURL: "https://api.example.com",
+			wantURL:  "https://api.example.com/responses",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := NewOpenAIResponsesClient(ClientConfig{URL: tt.inputURL})
+			if client.cfg.URL != tt.wantURL {
+				t.Errorf("got URL %q, want %q", client.cfg.URL, tt.wantURL)
+			}
+		})
+	}
+}
+
+func TestNewLLMClient_SelectsResponsesClient(t *testing.T) {
+	client := NewLLMClient(ResolvedEndpoint{
+		URL:      "https://api.openai.com/v1/responses",
+		Token:    "test-token",
+		Model:    "gpt-5.1-codex-max",
+		Protocol: "openai",
+	})
+	if _, ok := client.(*OpenAIResponsesClient); !ok {
+		t.Fatalf("expected *OpenAIResponsesClient, got %T", client)
+	}
+}
+
+func TestOpenAIClient_UsesMaxCompletionTokensForCodexModels(t *testing.T) {
+	var got map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"id":"chatcmpl_1","model":"gpt-5.1-codex-max","choices":[{"message":{"role":"assistant","content":"ok"},"finish_reason":"stop"}]}`))
+	}))
+	defer server.Close()
+
+	client := NewOpenAIClient(ClientConfig{URL: server.URL, APIKey: "test-token", Model: "gpt-5.1-codex-max"})
+	_, err := client.Completions(ChatRequest{
+		Messages:  []Message{NewTextMessage("user", "hi")},
+		MaxTokens: 42,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if _, ok := got["max_tokens"]; ok {
+		t.Fatalf("request included max_tokens: %#v", got)
+	}
+	if got["max_completion_tokens"] != float64(42) {
+		t.Fatalf("max_completion_tokens = %#v, want 42", got["max_completion_tokens"])
+	}
+}
+
+func TestOpenAIClient_KeepsMaxTokensForLegacyModels(t *testing.T) {
+	var got map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"id":"chatcmpl_1","model":"gpt-4o","choices":[{"message":{"role":"assistant","content":"ok"},"finish_reason":"stop"}]}`))
+	}))
+	defer server.Close()
+
+	client := NewOpenAIClient(ClientConfig{URL: server.URL, APIKey: "test-token", Model: "gpt-4o"})
+	_, err := client.Completions(ChatRequest{
+		Messages:  []Message{NewTextMessage("user", "hi")},
+		MaxTokens: 42,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if _, ok := got["max_completion_tokens"]; ok {
+		t.Fatalf("request included max_completion_tokens: %#v", got)
+	}
+	if got["max_tokens"] != float64(42) {
+		t.Fatalf("max_tokens = %#v, want 42", got["max_tokens"])
+	}
+}
+
+func TestOpenAIResponsesClient_RequestAndResponseMapping(t *testing.T) {
+	var got map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/responses" {
+			t.Fatalf("path = %q, want /v1/responses", r.URL.Path)
+		}
+		if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{
+			"id":"resp_1",
+			"model":"gpt-5.1-codex-max",
+			"output":[
+				{"type":"message","role":"assistant","content":[{"type":"output_text","text":"Need more context"}]},
+				{"type":"function_call","call_id":"call_1","name":"code_search","arguments":"{\"query\":\"foo\"}"}
+			],
+			"usage":{"input_tokens":10,"output_tokens":5,"total_tokens":15}
+		}`))
+	}))
+	defer server.Close()
+
+	client := NewOpenAIResponsesClient(ClientConfig{
+		URL:    server.URL + "/v1",
+		APIKey: "test-token",
+		Model:  "gpt-5.1-codex-max",
+	})
+	resp, err := client.Completions(ChatRequest{
+		Messages: []Message{
+			NewTextMessage("system", "review code"),
+			NewTextMessage("user", "diff"),
+			NewToolCallMessage("", []ToolCall{{
+				ID:   "call_prev",
+				Type: "function",
+				Function: FunctionCall{
+					Name:      "code_search",
+					Arguments: `{"query":"bar"}`,
+				},
+			}}),
+			NewToolResultMessage("call_prev", "result"),
+		},
+		Tools: []ToolDef{{
+			Type: "function",
+			Function: FunctionDef{
+				Name:        "code_search",
+				Description: "Search code",
+				Parameters:  map[string]any{"type": "object"},
+			},
+		}},
+		MaxTokens: 99,
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if got["max_output_tokens"] != float64(99) {
+		t.Fatalf("max_output_tokens = %#v, want 99", got["max_output_tokens"])
+	}
+	input := got["input"].([]any)
+	if input[0].(map[string]any)["role"] != "system" {
+		t.Fatalf("first input item = %#v", input[0])
+	}
+	if input[2].(map[string]any)["type"] != "function_call" {
+		t.Fatalf("third input item = %#v", input[2])
+	}
+	if input[3].(map[string]any)["type"] != "function_call_output" {
+		t.Fatalf("fourth input item = %#v", input[3])
+	}
+	tools := got["tools"].([]any)
+	if tools[0].(map[string]any)["strict"] != false {
+		t.Fatalf("tool strict = %#v, want false", tools[0].(map[string]any)["strict"])
+	}
+
+	if resp.Content() != "Need more context" {
+		t.Fatalf("content = %q", resp.Content())
+	}
+	calls := resp.ToolCalls()
+	if len(calls) != 1 || calls[0].ID != "call_1" || calls[0].Function.Name != "code_search" {
+		t.Fatalf("tool calls = %#v", calls)
+	}
+	if resp.Usage == nil || resp.Usage.TotalTokens != 15 {
+		t.Fatalf("usage = %#v", resp.Usage)
+	}
+}
+
 func TestNewAnthropicClient_URLNormalization(t *testing.T) {
 	tests := []struct {
 		name     string