feat(codex): add planner-reviewer agent mode

internal/runtime/executor/codex_agent_pipeline.go

@@ -0,0 +1,488 @@
+package executor
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	cliproxyauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
+	cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/executor"
+	sdktranslator "github.com/router-for-me/CLIProxyAPI/v6/sdk/translator"
+	"github.com/tidwall/gjson"
+	"github.com/tidwall/sjson"
+)
+
+type codexAgentMode string
+
+const (
+	codexAgentModeNone            codexAgentMode = ""
+	codexAgentModePlannerReviewer codexAgentMode = "planner-reviewer"
+)
+
+type codexAgentConfig struct {
+	Mode codexAgentMode
+}
+
+func (c codexAgentConfig) Enabled() bool { return c.Mode != codexAgentModeNone }
+
+type codexCompletedPassResult struct {
+	Completed []byte
+	Request   []byte
+	Headers   http.Header
+	Usage     usageDetail
+	UsageOK   bool
+}
+
+func parseCodexAgentConfig(bodies ...[]byte) codexAgentConfig {
+	for _, body := range bodies {
+		if len(body) == 0 || !gjson.ValidBytes(body) {
+			continue
+		}
+		for _, path := range []string{"_cliproxy.agent_mode", "agent_mode"} {
+			raw := strings.TrimSpace(gjson.GetBytes(body, path).String())
+			if raw == "" {
+				continue
+			}
+			switch normalizeCodexAgentMode(raw) {
+			case codexAgentModePlannerReviewer:
+				return codexAgentConfig{Mode: codexAgentModePlannerReviewer}
+			}
+		}
+	}
+	return codexAgentConfig{}
+}
+
+func normalizeCodexAgentMode(v string) codexAgentMode {
+	s := strings.ToLower(strings.TrimSpace(v))
+	s = strings.ReplaceAll(s, "_", "-")
+	switch s {
+	case "planner-reviewer", "plannerreviewer":
+		return codexAgentModePlannerReviewer
+	default:
+		return codexAgentModeNone
+	}
+}
+
+func codexAgentModeSupportedForStreaming(body []byte) bool {
+	cfg := parseCodexAgentConfig(body)
+	return !cfg.Enabled()
+}
+
+func codexAgentCompatibilityIssue(body []byte) string {
+	if len(body) == 0 || !gjson.ValidBytes(body) {
+		return "request body is not valid JSON"
+	}
+	if tools := gjson.GetBytes(body, "tools"); tools.Exists() {
+		if !tools.IsArray() || len(tools.Array()) > 0 {
+			return "tool-enabled requests are not supported"
+		}
+	}
+	if gjson.GetBytes(body, "text.format").Exists() {
+		return "structured text.format responses are not supported"
+	}
+	if gjson.GetBytes(body, "response_format").Exists() {
+		return "structured response_format responses are not supported"
+	}
+	return ""
+}
+
+func codexExtractTaskText(body []byte) (string, bool) {
+	if len(body) == 0 || !gjson.ValidBytes(body) {
+		return "", false
+	}
+	root := gjson.ParseBytes(body)
+	var segments []string
+	unsupported := false
+
+	if inst := strings.TrimSpace(root.Get("instructions").String()); inst != "" {
+		segments = append(segments, "Instructions:\n"+inst)
+	}
+
+	input := root.Get("input")
+	if !input.Exists() {
+		return strings.TrimSpace(strings.Join(segments, "\n\n")), !unsupported
+	}
+
+	if input.IsArray() {
+		for _, item := range input.Array() {
+			itemType := strings.TrimSpace(item.Get("type").String())
+			switch itemType {
+			case "message":
+				role := strings.TrimSpace(item.Get("role").String())
+				if role == "" {
+					role = "user"
+				}
+				texts, okText := codexCollectMessageContentText(item.Get("content"))
+				if !okText {
+					unsupported = true
+				}
+				if len(texts) > 0 {
+					segments = append(segments, strings.ToUpper(role)+":\n"+strings.Join(texts, "\n"))
+				}
+			case "function_call":
+				name := strings.TrimSpace(item.Get("name").String())
+				args := strings.TrimSpace(item.Get("arguments").String())
+				if name != "" || args != "" {
+					segments = append(segments, "FUNCTION_CALL:\nname="+name+"\nargs="+args)
+				}
+			case "function_call_output":
+				out := strings.TrimSpace(item.Get("output").String())
+				if out != "" {
+					segments = append(segments, "FUNCTION_OUTPUT:\n"+out)
+				}
+			default:
+				if txt := strings.TrimSpace(item.Get("text").String()); txt != "" {
+					segments = append(segments, txt)
+				} else if itemType != "" {
+					unsupported = true
+				}
+			}
+		}
+	}
+
+	return strings.TrimSpace(strings.Join(segments, "\n\n")), !unsupported
+}
+
+func codexCollectMessageContentText(content gjson.Result) ([]string, bool) {
+	var parts []string
+	if !content.Exists() {
+		return parts, true
+	}
+	if content.IsArray() {
+		unsupported := false
+		for _, part := range content.Array() {
+			partType := strings.TrimSpace(part.Get("type").String())
+			switch partType {
+			case "input_text", "output_text", "text":
+				if txt := strings.TrimSpace(part.Get("text").String()); txt != "" {
+					parts = append(parts, txt)
+				}
+			case "":
+				if txt := strings.TrimSpace(part.String()); txt != "" {
+					parts = append(parts, txt)
+				}
+			default:
+				unsupported = true
+			}
+		}
+		return parts, !unsupported
+	}
+	if txt := strings.TrimSpace(content.String()); txt != "" {
+		return []string{txt}, true
+	}
+	return parts, true
+}
+
+func codexExtractCompletedMessageAndReasoning(payload []byte) (message string, reasoning string) {
+	root := gjson.ParseBytes(payload)
+	if root.Get("type").String() != "response.completed" {
+		return "", ""
+	}
+	output := root.Get("response.output")
+	if !output.Exists() || !output.IsArray() {
+		return "", ""
+	}
+	var msgParts []string
+	var reasoningParts []string
+	for _, item := range output.Array() {
+		switch item.Get("type").String() {
+		case "message":
+			content := item.Get("content")
+			if content.IsArray() {
+				for _, part := range content.Array() {
+					if part.Get("type").String() == "output_text" {
+						if txt := strings.TrimSpace(part.Get("text").String()); txt != "" {
+							msgParts = append(msgParts, txt)
+						}
+					}
+				}
+			}
+		case "reasoning":
+			if summary := item.Get("summary"); summary.IsArray() {
+				for _, part := range summary.Array() {
+					if txt := strings.TrimSpace(part.Get("text").String()); txt != "" {
+						reasoningParts = append(reasoningParts, txt)
+					}
+				}
+			}
+			if len(reasoningParts) == 0 {
+				if txt := strings.TrimSpace(item.Get("content").String()); txt != "" {
+					reasoningParts = append(reasoningParts, txt)
+				}
+			}
+		}
+	}
+	return strings.TrimSpace(strings.Join(msgParts, "\n")), strings.TrimSpace(strings.Join(reasoningParts, "\n"))
+}
+
+func codexAgentTruncate(s string, max int) string {
+	if max <= 0 {
+		max = 12000
+	}
+	s = strings.TrimSpace(s)
+	if len(s) <= max {
+		return s
+	}
+	const suffix = "\n\n[truncated by server-side agent pipeline]"
+	if max <= len(suffix)+16 {
+		return s[:max]
+	}
+	return s[:max-len(suffix)] + suffix
+}
+
+func codexBuildAgentPassBody(baseBody []byte, phase string, originalTask string, plannerOutput string, reviewerOutput string) ([]byte, error) {
+	if len(baseBody) == 0 || !gjson.ValidBytes(baseBody) {
+		return nil, fmt.Errorf("codex agent pipeline: invalid base request body")
+	}
+	out := bytes.Clone(baseBody)
+
+	// Remove client/local controls and features incompatible with internal review passes.
+	for _, path := range []string{
+		"_cliproxy",
+		"agent_mode",
+		"tools",
+		"tool_choice",
+		"parallel_tool_calls",
+		"text.format",
+		"response_format",
+		"previous_response_id",
+		"prompt_cache_key",
+	} {
+		out, _ = sjson.DeleteBytes(out, path)
+	}
+	out, _ = sjson.SetBytes(out, "stream", true)
+
+	instructions := codexAgentPhaseInstructions(phase)
+	out, _ = sjson.SetBytes(out, "instructions", instructions)
+
+	prompt := codexAgentPhasePrompt(phase, originalTask, plannerOutput, reviewerOutput)
+	inputJSON := fmt.Sprintf(`[{"type":"message","role":"user","content":[{"type":"input_text","text":%q}]}]`, prompt)
+	out, _ = sjson.SetRawBytes(out, "input", []byte(inputJSON))
+
+	return out, nil
+}
+
+func codexAgentPhaseInstructions(phase string) string {
+	var base string
+	switch phase {
+	case "planner":
+		base = "You are an internal planning agent. Produce a strong plan and draft direction. Do not mention hidden reasoning. Be explicit and structured. Output planning artifacts only, not the final user answer."
+	case "reviewer":
+		base = "You are an internal reviewer agent. Critique the plan/draft rigorously, identify gaps and edge cases, and propose fixes. Do not produce the final user answer."
+	case "final":
+		base = "You are the final responder. Use the plan and review to produce the best final answer for the user. Do not mention the internal planner/reviewer workflow unless the user explicitly asks."
+	default:
+		base = "You are an internal agent pass."
+	}
+
+	sections := []string{base, codexDeepEngineeringStandardsPrompt()}
+	if phase == "final" {
+		sections = append(sections, codexNormalResponseFormatPrompt())
+	}
+	return strings.TrimSpace(strings.Join(sections, "\n\n"))
+}
+
+func codexAgentPhasePrompt(phase string, originalTask string, plannerOutput string, reviewerOutput string) string {
+	task := codexAgentTruncate(originalTask, 16000)
+	planner := codexAgentTruncate(plannerOutput, 12000)
+	reviewer := codexAgentTruncate(reviewerOutput, 12000)
+
+	switch phase {
+	case "planner":
+		return strings.TrimSpace(`Original user request and context:
+` + task + `
+
+Produce:
+1. A solution plan
+2. Key technical risks and edge cases
+3. A draft answer/implementation direction
+
+Prefer depth over brevity, but keep it actionable.`)
+	case "reviewer":
+		return strings.TrimSpace(`Original user request and context:
+` + task + `
+
+Planner output:
+` + planner + `
+
+Review the planner output critically. Identify incorrect assumptions, missing edge cases, scalability/performance concerns, accessibility concerns (if UI), and maintainability risks.
+
+Produce:
+1. Findings (ordered by severity)
+2. Suggested corrections
+3. What the final answer must include`)
+	case "final":
+		return strings.TrimSpace(`Original user request and context:
+` + task + `
+
+Planner output:
+` + planner + `
+
+Reviewer output:
+` + reviewer + `
+
+Produce the final answer for the user. Incorporate valid reviewer feedback. Keep it technically rigorous and directly useful.`)
+	default:
+		return task
+	}
+}
+
+func addUsageDetails(a usageDetail, b usageDetail) usageDetail {
+	return usageDetail{
+		InputTokens:     a.InputTokens + b.InputTokens,
+		OutputTokens:    a.OutputTokens + b.OutputTokens,
+		ReasoningTokens: a.ReasoningTokens + b.ReasoningTokens,
+		CachedTokens:    a.CachedTokens + b.CachedTokens,
+		TotalTokens:     a.TotalTokens + b.TotalTokens,
+	}
+}
+
+func findCodexCompletedEventFromSSEData(data []byte) ([]byte, bool) {
+	lines := bytes.Split(data, []byte("\n"))
+	for _, line := range lines {
+		if payload, ok := codexCompletedEventPayload(line); ok {
+			return payload, true
+		}
+	}
+	return nil, false
+}
+
+func (e *CodexExecutorRefactored) executeCodexCompletedHTTPPass(ctx context.Context, auth *cliproxyauth.Auth, apiKey string, url string, from sdktranslator.Format, req cliproxyexecutor.Request, body []byte, usePromptCache bool) (codexCompletedPassResult, error) {
+	result := codexCompletedPassResult{Request: bytes.Clone(body)}
+
+	var httpReq *http.Request
+	var err error
+	if usePromptCache {
+		httpReq, err = e.cacheHelper(ctx, from, url, req, body)
+	} else {
+		httpReq, err = http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	}
+	if err != nil {
+		return result, err
+	}
+
+	provider := NewCodexProvider(e.cfg)
+	provider.ApplyHeaders(httpReq, auth, apiKey, true)
+
+	var authID, authLabel, authType, authValue string
+	if auth != nil {
+		authID = auth.ID
+		authLabel = auth.Label
+		authType, authValue = auth.AccountInfo()
+	}
+	recordAPIRequest(ctx, e.cfg, upstreamRequestLog{
+		URL:       url,
+		Method:    http.MethodPost,
+		Headers:   httpReq.Header.Clone(),
+		Body:      body,
+		Provider:  e.Identifier(),
+		AuthID:    authID,
+		AuthLabel: authLabel,
+		AuthType:  authType,
+		AuthValue: authValue,
+	})
+
+	httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
+	httpResp, err := httpClient.Do(httpReq)
+	if err != nil {
+		recordAPIResponseError(ctx, e.cfg, err)
+		return result, err
+	}
+	defer httpResp.Body.Close()
+
+	result.Headers = httpResp.Header.Clone()
+	recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, result.Headers.Clone())
+	if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
+		b, _ := io.ReadAll(httpResp.Body)
+		appendAPIResponseChunk(ctx, e.cfg, b)
+		logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
+		return result, statusErr{code: httpResp.StatusCode, msg: string(b)}
+	}
+
+	data, err := io.ReadAll(httpResp.Body)
+	if err != nil {
+		recordAPIResponseError(ctx, e.cfg, err)
+		return result, err
+	}
+	appendAPIResponseChunk(ctx, e.cfg, data)
+
+	completed, ok := findCodexCompletedEventFromSSEData(data)
+	if !ok {
+		return result, statusErr{code: 408, msg: "stream error: stream disconnected before completion: stream closed before response.completed"}
+	}
+	result.Completed = completed
+	if detail, okUsage := parseCodexUsage(completed); okUsage {
+		result.Usage = detail
+		result.UsageOK = true
+	}
+	return result, nil
+}
+
+func (e *CodexExecutorRefactored) executeCodexPlannerReviewerPipeline(ctx context.Context, auth *cliproxyauth.Auth, apiKey string, baseURL string, from sdktranslator.Format, req cliproxyexecutor.Request, normalizedBody []byte) (codexCompletedPassResult, error) {
+	if issue := codexAgentCompatibilityIssue(normalizedBody); issue != "" {
+		return codexCompletedPassResult{}, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode planner-reviewer unsupported: " + issue}
+	}
+
+	taskText, taskSupported := codexExtractTaskText(normalizedBody)
+	if !taskSupported {
+		return codexCompletedPassResult{}, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode planner-reviewer unsupported: request contains unsupported non-text input parts"}
+	}
+	if strings.TrimSpace(taskText) == "" {
+		return codexCompletedPassResult{}, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode planner-reviewer unsupported: unable to extract textual task content"}
+	}
+
+	url := strings.TrimSuffix(baseURL, "/") + "/responses"
+
+	plannerBody, err := codexBuildAgentPassBody(normalizedBody, "planner", taskText, "", "")
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	plannerRes, err := e.executeCodexCompletedHTTPPass(ctx, auth, apiKey, url, from, req, plannerBody, false)
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	plannerText, plannerReasoning := codexExtractCompletedMessageAndReasoning(plannerRes.Completed)
+	if plannerReasoning != "" && plannerText != "" {
+		plannerText = plannerText + "\n\nReviewer note from planner reasoning summary:\n" + plannerReasoning
+	} else if plannerText == "" {
+		plannerText = plannerReasoning
+	}
+	if strings.TrimSpace(plannerText) == "" {
+		return codexCompletedPassResult{}, statusErr{code: http.StatusBadGateway, msg: "codex agent_mode planner-reviewer failed: planner pass returned no text"}
+	}
+
+	reviewerBody, err := codexBuildAgentPassBody(normalizedBody, "reviewer", taskText, plannerText, "")
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	reviewerRes, err := e.executeCodexCompletedHTTPPass(ctx, auth, apiKey, url, from, req, reviewerBody, false)
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	reviewerText, reviewerReasoning := codexExtractCompletedMessageAndReasoning(reviewerRes.Completed)
+	if reviewerReasoning != "" && reviewerText != "" {
+		reviewerText = reviewerText + "\n\nReviewer reasoning summary:\n" + reviewerReasoning
+	} else if reviewerText == "" {
+		reviewerText = reviewerReasoning
+	}
+	if strings.TrimSpace(reviewerText) == "" {
+		return codexCompletedPassResult{}, statusErr{code: http.StatusBadGateway, msg: "codex agent_mode planner-reviewer failed: reviewer pass returned no text"}
+	}
+
+	finalBody, err := codexBuildAgentPassBody(normalizedBody, "final", taskText, plannerText, reviewerText)
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	finalRes, err := e.executeCodexCompletedHTTPPass(ctx, auth, apiKey, url, from, req, finalBody, false)
+	if err != nil {
+		return codexCompletedPassResult{}, err
+	}
+	finalRes.Request = finalBody
+	finalRes.Usage = addUsageDetails(finalRes.Usage, plannerRes.Usage)
+	finalRes.Usage = addUsageDetails(finalRes.Usage, reviewerRes.Usage)
+	finalRes.UsageOK = finalRes.UsageOK || plannerRes.UsageOK || reviewerRes.UsageOK
+	return finalRes, nil
+}

internal/runtime/executor/codex_agent_pipeline_test.go

@@ -0,0 +1,130 @@
+package executor
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/tidwall/gjson"
+)
+
+func TestParseCodexAgentConfig(t *testing.T) {
+	tests := []struct {
+		name string
+		body []byte
+		want codexAgentMode
+	}{
+		{
+			name: "cliproxy nested",
+			body: []byte(`{"_cliproxy":{"agent_mode":"planner-reviewer"}}`),
+			want: codexAgentModePlannerReviewer,
+		},
+		{
+			name: "top-level alias underscore",
+			body: []byte(`{"agent_mode":"planner_reviewer"}`),
+			want: codexAgentModePlannerReviewer,
+		},
+		{
+			name: "unknown mode",
+			body: []byte(`{"_cliproxy":{"agent_mode":"foo"}}`),
+			want: codexAgentModeNone,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseCodexAgentConfig(tt.body)
+			if got.Mode != tt.want {
+				t.Fatalf("mode = %q, want %q", got.Mode, tt.want)
+			}
+		})
+	}
+}
+
+func TestCodexAgentCompatibilityIssue(t *testing.T) {
+	if issue := codexAgentCompatibilityIssue([]byte(`{"tools":[{"name":"x"}]}`)); !strings.Contains(issue, "tool") {
+		t.Fatalf("expected tool compatibility issue, got %q", issue)
+	}
+	if issue := codexAgentCompatibilityIssue([]byte(`{"text":{"format":{"type":"json_schema"}}}`)); !strings.Contains(issue, "structured") {
+		t.Fatalf("expected structured compatibility issue, got %q", issue)
+	}
+	if issue := codexAgentCompatibilityIssue([]byte(`{"input":[]}`)); issue != "" {
+		t.Fatalf("unexpected issue for simple text request: %q", issue)
+	}
+}
+
+func TestCodexBuildAgentPassBody(t *testing.T) {
+	base := []byte(`{
+		"model":"gpt-5",
+		"stream":true,
+		"reasoning":{"effort":"high"},
+		"tools":[{"type":"function","name":"x"}],
+		"_cliproxy":{"agent_mode":"planner-reviewer"},
+		"input":[{"type":"message","role":"user","content":[{"type":"input_text","text":"hi"}]}]
+	}`)
+
+	out, err := codexBuildAgentPassBody(base, "planner", "original task", "", "")
+	if err != nil {
+		t.Fatalf("codexBuildAgentPassBody error: %v", err)
+	}
+
+	if got := gjson.GetBytes(out, "tools"); got.Exists() {
+		t.Fatalf("expected tools to be stripped, got %s", got.Raw)
+	}
+	if got := gjson.GetBytes(out, "_cliproxy"); got.Exists() {
+		t.Fatalf("expected _cliproxy to be stripped, got %s", got.Raw)
+	}
+	if !gjson.GetBytes(out, "stream").Bool() {
+		t.Fatalf("expected stream=true in internal pass body")
+	}
+	if got := gjson.GetBytes(out, "reasoning.effort").String(); got != "high" {
+		t.Fatalf("reasoning.effort = %q, want %q", got, "high")
+	}
+	prompt := gjson.GetBytes(out, "input.0.content.0.text").String()
+	if !strings.Contains(prompt, "original task") {
+		t.Fatalf("expected planner prompt to include original task, got %q", prompt)
+	}
+	instructions := gjson.GetBytes(out, "instructions").String()
+	if !strings.Contains(strings.ToLower(instructions), "planning agent") {
+		t.Fatalf("expected planner instructions, got %q", instructions)
+	}
+}
+
+func TestCodexExtractCompletedMessageAndReasoning(t *testing.T) {
+	payload := []byte(`{
+		"type":"response.completed",
+		"response":{
+			"output":[
+				{"type":"reasoning","summary":[{"type":"summary_text","text":"check edge cases"}]},
+				{"type":"message","content":[{"type":"output_text","text":"final answer"}]}
+			]
+		}
+	}`)
+	msg, reasoning := codexExtractCompletedMessageAndReasoning(payload)
+	if msg != "final answer" {
+		t.Fatalf("message = %q, want %q", msg, "final answer")
+	}
+	if reasoning != "check edge cases" {
+		t.Fatalf("reasoning = %q, want %q", reasoning, "check edge cases")
+	}
+}
+
+func TestCodexAgentPhaseInstructions_IncludeDeepEngineeringStandards(t *testing.T) {
+	planner := codexAgentPhaseInstructions("planner")
+	if !strings.Contains(planner, "internal planning agent") {
+		t.Fatalf("planner instructions missing role text: %q", planner)
+	}
+	if !strings.Contains(planner, "Override Brevity") || !strings.Contains(planner, "Library & Framework Discipline") {
+		t.Fatalf("planner instructions missing shared engineering standards: %q", planner)
+	}
+	if strings.Contains(planner, "Response format (normal mode)") {
+		t.Fatalf("planner instructions should not include final response format block: %q", planner)
+	}
+
+	final := codexAgentPhaseInstructions("final")
+	if !strings.Contains(final, "final responder") {
+		t.Fatalf("final instructions missing role text: %q", final)
+	}
+	if !strings.Contains(final, "Response format (normal mode)") {
+		t.Fatalf("final instructions missing response format block: %q", final)
+	}
+}

internal/runtime/executor/codex_executor_refactored.go

@@ -75,6 +75,9 @@ func (e *CodexExecutorRefactored) HttpRequest(ctx context.Context, auth *cliprox
 
 // Execute performs a non-streaming request to the Codex API.
 func (e *CodexExecutorRefactored) Execute(ctx context.Context, auth *cliproxyauth.Auth, req cliproxyexecutor.Request, opts cliproxyexecutor.Options) (resp cliproxyexecutor.Response, err error) {
+	if cfg := parseCodexAgentConfig(req.Payload); cfg.Enabled() && opts.Alt == "responses/compact" {
+		return cliproxyexecutor.Response{}, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode is not supported for /responses/compact"}
+	}
 	if opts.Alt == "responses/compact" {
 		return e.executeCompact(ctx, auth, req, opts)
 	}
@@ -111,84 +114,35 @@ func (e *CodexExecutorRefactored) executeViaStream(ctx context.Context, auth *cl
 
 	requestedModel := payloadRequestedModel(opts, req.Model)
 	body = applyPayloadConfigWithRoot(e.cfg, baseModel, to.String(), "", body, originalTranslated, requestedModel)
+	agentCfg := parseCodexAgentConfig(body, req.Payload)
 	body, err = normalizeCodexRequestBody(body, baseModel, true)
 	if err != nil {
 		return resp, err
 	}
 
-	url := strings.TrimSuffix(baseURL, "/") + "/responses"
-	httpReq, err := e.cacheHelper(ctx, from, url, req, body)
-	if err != nil {
-		return resp, err
-	}
-
-	provider := NewCodexProvider(e.cfg)
-	provider.ApplyHeaders(httpReq, auth, apiKey, true)
-
-	var authID, authLabel, authType, authValue string
-	if auth != nil {
-		authID = auth.ID
-		authLabel = auth.Label
-		authType, authValue = auth.AccountInfo()
+	var pass codexCompletedPassResult
+	switch agentCfg.Mode {
+	case codexAgentModePlannerReviewer:
+		pass, err = e.executeCodexPlannerReviewerPipeline(ctx, auth, apiKey, baseURL, from, req, body)
+	default:
+		url := strings.TrimSuffix(baseURL, "/") + "/responses"
+		pass, err = e.executeCodexCompletedHTTPPass(ctx, auth, apiKey, url, from, req, body, true)
 	}
-	recordAPIRequest(ctx, e.cfg, upstreamRequestLog{
-		URL:       url,
-		Method:    http.MethodPost,
-		Headers:   httpReq.Header.Clone(),
-		Body:      body,
-		Provider:  e.Identifier(),
-		AuthID:    authID,
-		AuthLabel: authLabel,
-		AuthType:  authType,
-		AuthValue: authValue,
-	})
-
-	httpClient := newProxyAwareHTTPClient(ctx, e.cfg, auth, 0)
-	httpResp, err := httpClient.Do(httpReq)
 	if err != nil {
-		recordAPIResponseError(ctx, e.cfg, err)
 		return resp, err
 	}
-	defer httpResp.Body.Close()
-
-	recordAPIResponseMetadata(ctx, e.cfg, httpResp.StatusCode, httpResp.Header.Clone())
-	if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
-		b, _ := io.ReadAll(httpResp.Body)
-		appendAPIResponseChunk(ctx, e.cfg, b)
-		logWithRequestID(ctx).Debugf("request error, error status: %d, error message: %s", httpResp.StatusCode, summarizeErrorBody(httpResp.Header.Get("Content-Type"), b))
-		return resp, statusErr{code: httpResp.StatusCode, msg: string(b)}
+	if pass.UsageOK {
+		reporter.publish(ctx, pass.Usage)
 	}
 
-	data, err := io.ReadAll(httpResp.Body)
-	if err != nil {
-		recordAPIResponseError(ctx, e.cfg, err)
-		return resp, err
+	reqBodyForTranslation := body
+	if len(pass.Request) > 0 {
+		reqBodyForTranslation = pass.Request
 	}
-	appendAPIResponseChunk(ctx, e.cfg, data)
-
-	// Parse stream to find response.completed event
-	lines := bytes.Split(data, []byte("\n"))
-	for _, line := range lines {
-		if !bytes.HasPrefix(line, dataTag) {
-			continue
-		}
-
-		line = bytes.TrimSpace(line[5:])
-		if gjson.GetBytes(line, "type").String() != "response.completed" {
-			continue
-		}
-
-		if detail, ok := parseCodexUsage(line); ok {
-			reporter.publish(ctx, detail)
-		}
-
-		var param any
-		out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, originalPayload, body, line, &param)
-		resp = cliproxyexecutor.Response{Payload: []byte(out), Headers: httpResp.Header.Clone()}
-		return resp, nil
-	}
-
-	return resp, statusErr{code: 408, msg: "stream error: stream disconnected before completion: stream closed before response.completed"}
+	var param any
+	out := sdktranslator.TranslateNonStream(ctx, to, from, req.Model, originalPayload, reqBodyForTranslation, pass.Completed, &param)
+	resp = cliproxyexecutor.Response{Payload: []byte(out), Headers: pass.Headers}
+	return resp, nil
 }
 
 // executeCompact handles the /responses/compact endpoint
@@ -288,6 +242,9 @@ func (e *CodexExecutorRefactored) ExecuteStream(ctx context.Context, auth *clipr
 	if opts.Alt == "responses/compact" {
 		return nil, statusErr{code: http.StatusBadRequest, msg: "streaming not supported for /responses/compact"}
 	}
+	if cfg := parseCodexAgentConfig(req.Payload); cfg.Enabled() {
+		return nil, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode is not supported for streaming requests"}
+	}
 
 	return e.base.ExecuteStream(ctx, auth, req, opts)
 }

internal/runtime/executor/codex_provider.go

@@ -140,6 +140,9 @@ func normalizeCodexRequestBody(body []byte, model string, stream bool) ([]byte,
 		}
 	}
 	body, _ = sjson.DeleteBytes(body, "reasoning_effort")
+	body = applyCodexReasoningProfile(body)
+	body, _ = sjson.DeleteBytes(body, "_cliproxy")
+	body, _ = sjson.DeleteBytes(body, "agent_mode")
 
 	// Delete Codex-specific fields that shouldn't be sent
 	body, _ = sjson.DeleteBytes(body, "previous_response_id")
@@ -179,3 +182,123 @@ func codexCompletedEventPayload(data []byte) ([]byte, bool) {
 	}
 	return payload, true
 }
+
+// applyCodexReasoningProfile injects a structured analysis scaffold into `instructions`
+// when callers request a local reasoning profile and reasoning is enabled.
+//
+// Local control fields (removed before upstream request):
+//   - `_cliproxy.reasoning_profile`: "deep", "deep_engineering"
+//   - `_cliproxy.reasoning_prompt`: custom instruction text to append
+//   - `_cliproxy.force_reasoning_profile`: bool (inject even if reasoning is disabled)
+//
+// This intentionally requests a visible rationale/analysis structure rather than hidden chain-of-thought.
+func applyCodexReasoningProfile(body []byte) []byte {
+	if len(body) == 0 || !gjson.ValidBytes(body) {
+		return body
+	}
+
+	profile := strings.TrimSpace(gjson.GetBytes(body, "_cliproxy.reasoning_profile").String())
+	custom := strings.TrimSpace(gjson.GetBytes(body, "_cliproxy.reasoning_prompt").String())
+	force := gjson.GetBytes(body, "_cliproxy.force_reasoning_profile").Bool()
+
+	if profile == "" && custom == "" {
+		return body
+	}
+	if !force && !codexReasoningEnabled(body) {
+		body, _ = sjson.DeleteBytes(body, "_cliproxy")
+		return body
+	}
+
+	snippet := buildCodexReasoningProfilePrompt(profile, custom)
+	if strings.TrimSpace(snippet) == "" {
+		body, _ = sjson.DeleteBytes(body, "_cliproxy")
+		return body
+	}
+
+	currentInstructions := strings.TrimSpace(gjson.GetBytes(body, "instructions").String())
+	if currentInstructions == "" {
+		body, _ = sjson.SetBytes(body, "instructions", snippet)
+	} else {
+		body, _ = sjson.SetBytes(body, "instructions", currentInstructions+"\n\n"+snippet)
+	}
+
+	body, _ = sjson.DeleteBytes(body, "_cliproxy")
+	return body
+}
+
+func codexReasoningEnabled(body []byte) bool {
+	for _, path := range []string{"reasoning.effort", "reasoning_effort"} {
+		if effort := gjson.GetBytes(body, path); effort.Exists() {
+			v := strings.ToLower(strings.TrimSpace(effort.String()))
+			if v != "" && v != "none" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func buildCodexReasoningProfilePrompt(profile, custom string) string {
+	var sections []string
+	switch strings.ToLower(strings.TrimSpace(profile)) {
+	case "", "none", "off", "disabled":
+		// no preset
+	case "deep", "deep_engineering", "engineering":
+		sections = append(sections, `Response profile:
+- Prefer thoroughness over brevity.
+- Use multi-lens analysis (user intent/cognitive load, technical tradeoffs/performance, accessibility, scalability/maintenance).
+- Avoid shallow conclusions; justify decisions concretely.
+- Provide a visible rationale summary instead of hidden internal reasoning.
+- Structure the answer into:
+  1. Architectural/Design Rationale
+  2. Edge Cases and Failure Prevention
+  3. Production-Ready Implementation`)
+		sections = append(sections, codexDeepEngineeringStandardsPrompt())
+		sections = append(sections, codexNormalResponseFormatPrompt())
+	default:
+		// Unknown preset names are ignored; custom text can still be applied.
+	}
+	if strings.TrimSpace(custom) != "" {
+		sections = append(sections, custom)
+	}
+	return strings.TrimSpace(strings.Join(sections, "\n\n"))
+}
+
+func codexDeepEngineeringStandardsPrompt() string {
+	return strings.TrimSpace(`Engineering depth policy:
+- Override Brevity: Immediately suspend the "Zero Fluff" rule when rigor is required.
+- Maximum Depth: Engage in exhaustive, deep-level reasoning before writing a single line when implementation is requested.
+- Prohibition: Never use surface-level logic. If the reasoning feels easy, dig deeper until the logic is irrefutable.
+
+Multi-Dimensional Analysis (apply when relevant):
+- Architectural: Separation of concerns, modularity, dependency direction, coupling.
+- Performance: Time/space complexity, memory layout, I/O costs, concurrency pitfalls, hot-path optimization.
+- Reliability: Error handling strategy, edge cases, failure modes, defensive programming.
+- Scalability: Will the design hold at 10x load/scope, and what is the long-term maintenance burden.
+- Security: Input validation, injection vectors, privilege boundaries, secrets management.
+- Ecosystem Fit: Prefer solutions native to the language/framework/community.
+
+Coding standards (all languages):
+- Library & Framework Discipline (critical): If a library/framework/engine is active in the project, use it. Do not rebuild utilities the ecosystem already provides, and do not introduce redundant overlapping dependencies. Exception: wrappers/extensions are fine when the underlying primitive stays project-native.
+- Language-specific awareness:
+  - Python: Type hints, pathlib over os.path, f-strings, dataclasses/Pydantic when appropriate, async for I/O-bound work.
+  - Lua: Respect table-driven design, metatables over class emulation unless already used, 1-based indexing, and target runtime differences.
+  - JavaScript/TypeScript: Strict TypeScript where possible, framework conventions (React/Vue/Svelte), ESM over CJS.
+  - Systems (Rust/Go/C/C++): Ownership/lifetime clarity, avoid unnecessary hot-path allocations, respect the language concurrency model.
+  - Shell/Bash: Prefer POSIX when portability matters, use set -euo pipefail, quote variables.
+  - SQL: Always parameterize queries unless a documented exception exists.
+- Universal standards:
+  - Error Handling: Never swallow errors silently; use the idiomatic error model.
+  - Naming: Descriptive and consistent, following language/project conventions.
+  - Structure: Logical module organization; no god files; avoid oversized functions.
+  - Comments: Explain why, not what.`)
+}
+
+func codexNormalResponseFormatPrompt() string {
+	return strings.TrimSpace(`Response format (normal mode):
+1. Rationale: 1-2 sentences on the approach and why.
+2. The Code: production-ready code using project-native libraries/frameworks.
+3. Edge Cases: what can fail and how the implementation defends against it.
+
+When describing reasoning, provide a visible rationale summary. Do not expose hidden chain-of-thought.`)
+}

internal/runtime/executor/codex_provider_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 
 	"github.com/gin-gonic/gin"
@@ -54,6 +55,92 @@ func TestNormalizeCodexRequestBody_MapsReasoningEffortAlias(t *testing.T) {
 	}
 }
 
+func TestNormalizeCodexRequestBody_AutoInjectsReasoningProfile(t *testing.T) {
+	input := []byte(`{
+		"reasoning_effort":"high",
+		"instructions":"Base instructions",
+		"_cliproxy":{"reasoning_profile":"deep_engineering"}
+	}`)
+
+	got, err := normalizeCodexRequestBody(input, "gpt-5", true)
+	if err != nil {
+		t.Fatalf("normalizeCodexRequestBody returned error: %v", err)
+	}
+
+	instructions := gjson.GetBytes(got, "instructions").String()
+	if instructions == "" {
+		t.Fatal("instructions should not be empty")
+	}
+	if instructions == "Base instructions" {
+		t.Fatalf("expected reasoning profile to append instructions")
+	}
+	if !containsAll(instructions, "Base instructions", "Architectural/Design Rationale", "Edge Cases and Failure Prevention", "Production-Ready Implementation") {
+		t.Fatalf("instructions missing expected scaffold: %q", instructions)
+	}
+	if !containsAll(instructions, "Override Brevity", "Library & Framework Discipline", "Response format (normal mode)") {
+		t.Fatalf("instructions missing deep engineering standards block: %q", instructions)
+	}
+	if gjson.GetBytes(got, "_cliproxy").Exists() {
+		t.Fatalf("expected local _cliproxy controls to be stripped")
+	}
+}
+
+func TestNormalizeCodexRequestBody_DoesNotInjectReasoningProfileWhenThinkingDisabled(t *testing.T) {
+	input := []byte(`{
+		"reasoning_effort":"none",
+		"instructions":"Base instructions",
+		"_cliproxy":{"reasoning_profile":"deep_engineering"}
+	}`)
+
+	got, err := normalizeCodexRequestBody(input, "gpt-5", true)
+	if err != nil {
+		t.Fatalf("normalizeCodexRequestBody returned error: %v", err)
+	}
+
+	if instructions := gjson.GetBytes(got, "instructions").String(); instructions != "Base instructions" {
+		t.Fatalf("instructions = %q, want %q", instructions, "Base instructions")
+	}
+	if gjson.GetBytes(got, "_cliproxy").Exists() {
+		t.Fatalf("expected local _cliproxy controls to be stripped")
+	}
+}
+
+func TestNormalizeCodexRequestBody_IncludesCustomReasoningPrompt(t *testing.T) {
+	input := []byte(`{
+		"reasoning":{"effort":"medium"},
+		"_cliproxy":{"reasoning_prompt":"Use strict WCAG AAA and include an edge-case checklist."}
+	}`)
+
+	got, err := normalizeCodexRequestBody(input, "gpt-5", true)
+	if err != nil {
+		t.Fatalf("normalizeCodexRequestBody returned error: %v", err)
+	}
+
+	instructions := gjson.GetBytes(got, "instructions").String()
+	if !containsAll(instructions, "strict WCAG AAA", "edge-case checklist") {
+		t.Fatalf("custom reasoning prompt not injected: %q", instructions)
+	}
+}
+
+func TestNormalizeCodexRequestBody_StripsAgentModeControls(t *testing.T) {
+	input := []byte(`{
+		"agent_mode":"planner-reviewer",
+		"_cliproxy":{"agent_mode":"planner-reviewer"},
+		"instructions":"hello"
+	}`)
+
+	got, err := normalizeCodexRequestBody(input, "gpt-5", true)
+	if err != nil {
+		t.Fatalf("normalizeCodexRequestBody returned error: %v", err)
+	}
+	if gjson.GetBytes(got, "agent_mode").Exists() {
+		t.Fatalf("expected agent_mode to be stripped")
+	}
+	if gjson.GetBytes(got, "_cliproxy").Exists() {
+		t.Fatalf("expected _cliproxy to be stripped")
+	}
+}
+
 func TestCodexProviderApplyHeaders_ForwardsCodexHintHeaders(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 	rec := httptest.NewRecorder()
@@ -121,9 +208,25 @@ func TestCodexCompletedEventPayload(t *testing.T) {
 	}
 }
 
+func TestBuildCodexReasoningProfilePrompt_DeepEngineeringIncludesLanguageStandards(t *testing.T) {
+	got := buildCodexReasoningProfilePrompt("deep_engineering", "")
+	if !containsAll(got, "Language-specific awareness", "Shell/Bash", "SQL: Always parameterize queries") {
+		t.Fatalf("deep engineering prompt missing language-specific standards: %q", got)
+	}
+}
+
 func contextWithGinForTest(c *gin.Context) context.Context {
 	if c == nil {
 		return context.Background()
 	}
 	return context.WithValue(context.Background(), "gin", c)
 }
+
+func containsAll(s string, subs ...string) bool {
+	for _, sub := range subs {
+		if !strings.Contains(s, sub) {
+			return false
+		}
+	}
+	return true
+}

internal/runtime/executor/codex_websockets_executor_refactored.go

@@ -317,6 +317,11 @@ func (e *CodexWebsocketsExecutorRefactored) Execute(ctx context.Context, auth *c
 
 	requestedModel := payloadRequestedModel(opts, req.Model)
 	body = applyPayloadConfigWithRoot(e.cfg, baseModel, to.String(), "", body, originalTranslated, requestedModel)
+	if cfg := parseCodexAgentConfig(body, req.Payload); cfg.Enabled() {
+		logWithRequestID(ctx).Debugf("codex websockets executor: agent_mode=%s requested; falling back to HTTP codex executor for non-stream execution", cfg.Mode)
+		return e.CodexExecutor.Execute(ctx, auth, req, opts)
+	}
+	body = applyCodexReasoningProfile(body)
 	body, _ = sjson.SetBytes(body, "model", baseModel)
 	body, _ = sjson.SetBytes(body, "stream", true)
 	body, _ = sjson.DeleteBytes(body, "previous_response_id")
@@ -445,6 +450,9 @@ func (e *CodexWebsocketsExecutorRefactored) ExecuteStream(ctx context.Context, a
 	if opts.Alt == "responses/compact" {
 		return nil, statusErr{code: http.StatusBadRequest, msg: "streaming not supported for /responses/compact"}
 	}
+	if cfg := parseCodexAgentConfig(req.Payload); cfg.Enabled() {
+		return nil, statusErr{code: http.StatusBadRequest, msg: "codex agent_mode is not supported for streaming requests"}
+	}
 
 	baseModel := thinking.ParseSuffix(req.Model).ModelName
 	apiKey, baseURL := codexCreds(auth)
@@ -466,6 +474,7 @@ func (e *CodexWebsocketsExecutorRefactored) ExecuteStream(ctx context.Context, a
 
 	requestedModel := payloadRequestedModel(opts, req.Model)
 	body = applyPayloadConfigWithRoot(e.cfg, baseModel, to.String(), "", body, body, requestedModel)
+	body = applyCodexReasoningProfile(body)
 
 	body, preflight, err := e.prepareCodexWebsocketPreflight(ctx, auth, req, from, apiKey, baseURL, body)
 	if err != nil {