@bitkyc08/opencodex 2.7.33 → 2.7.34

package/src/adapters/openai-chat.ts

@@ -1,7 +1,7 @@
 import type { ProviderAdapter } from "./base";
 import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxThinkingContent, OcxToolCall, OcxUsage } from "../types";
 import { isAllowedToolChoice, modelInList, namespacedToolName, resolveToolChoiceWireName, toolAllowedByChoice } from "../types";
-import { mapReasoningEffort } from "../reasoning-effort";
+import { mapReasoningEffort, modelRecordValue } from "../reasoning-effort";
 import { redactSecretString } from "../lib/redact";
 import { contentPartsToText } from "./image";
 import { neutralizeIdentity } from "./identity";
@@ -460,9 +460,15 @@ function usageFromOpenAIChat(usage: Record<string, unknown> | undefined): OcxUsa
   };
 }
 
-function thinkingBudgetForEffort(parsed: OcxParsedRequest, reasoningEffort: string): number | undefined {
+function resolveMaxTokens(provider: OcxProviderConfig, parsed: OcxParsedRequest): number | undefined {
+  return parsed.options.maxOutputTokens
+    ?? modelRecordValue(provider.modelMaxOutputTokens, parsed.modelId)
+    ?? provider.defaultMaxOutputTokens;
+}
+
+function thinkingBudgetForEffort(parsed: OcxParsedRequest, reasoningEffort: string, maxOutputTokens?: number): number | undefined {
   if (parsed.options.reasoning === "minimal") return 0;
-  const maxBudget = parsed.options.maxOutputTokens ?? 32768;
+  const maxBudget = maxOutputTokens ?? 32768;
   const fractions: Record<string, number> = {
     low: 0.20,
     medium: 0.50,
@@ -495,6 +501,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         messages,
         stream: parsed.stream,
       };
+      const maxTokens = resolveMaxTokens(provider, parsed);
       const openRouterRouting = resolveOpenRouterRouting(provider, parsed.modelId);
       if (openRouterRouting) body.provider = openRouterProviderPayload(openRouterRouting);
       if (tools) body.tools = tools;
@@ -503,7 +510,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
           ? (toolChoice === "none" ? "none" : "auto")
           : toolChoice;
       }
-      if (parsed.options.maxOutputTokens !== undefined) body.max_tokens = parsed.options.maxOutputTokens;
+      if (maxTokens !== undefined) body.max_tokens = maxTokens;
       if (parsed.options.temperature !== undefined && !modelInList(provider.noTemperatureModels, parsed.modelId)) {
         body.temperature = parsed.options.temperature;
       }
@@ -514,7 +521,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       const reasoningEffort = mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning);
       if (reasoningEffort !== undefined) {
         if (modelInList(provider.thinkingBudgetModels, parsed.modelId)) {
-          const budget = thinkingBudgetForEffort(parsed, reasoningEffort);
+          const budget = thinkingBudgetForEffort(parsed, reasoningEffort, maxTokens);
           if (budget !== undefined) body.thinking_budget = budget;
         } else if (modelInList(provider.thinkingToggleModels, parsed.modelId)) {
           // Vendor thinking-toggle wire (MiMo v2.x, GLM 5/5.1): the mapped value is the toggle

package/src/adapters/openai-responses.ts

@@ -440,8 +440,13 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
           headers["chatgpt-account-id"] = override.chatgptAccountId;
         }
       } else {
-        const base = provider.baseUrl.replace(/\/v1\/?$/, "");
-        url = `${base}/v1/responses`;
+        if (provider.responsesPath === undefined) {
+          const base = provider.baseUrl.replace(/\/v1\/?$/, "");
+          url = `${base}/v1/responses`;
+        } else {
+          const base = provider.baseUrl.replace(/\/$/, "");
+          url = `${base}${provider.responsesPath}`;
+        }
         if (provider.apiKey) headers["Authorization"] = `Bearer ${provider.apiKey}`;
         if (provider.headers) Object.assign(headers, provider.headers);
       }

package/src/bridge.ts

@@ -1,4 +1,4 @@
-import type { AdapterEvent, OcxUsage } from "./types";
+import type { AdapterEvent, OcxMessagePhase, OcxProviderContinuationState, OcxUsage } from "./types";
 import { adapterFailureFromMessage, classifyError, type OcxErrorPayload } from "./lib/errors";
 import { encodeCompactionSummary } from "./responses/compaction";
 import { encodeReasoningEnvelope, type ReasoningEnvelope } from "./responses/reasoning-envelope";
@@ -43,6 +43,18 @@ function responseError(status: number, type: string, message: string): OcxErrorP
   return classifyError(status, type, message);
 }
 
+function adapterFailureFromEvent(event: Extract<AdapterEvent, { type: "error" }>): { httpStatus: number; error: OcxErrorPayload } {
+  if (event.status === undefined && event.errorType === undefined && event.code === undefined) {
+    return adapterFailureFromMessage(event.message);
+  }
+  const fallback = adapterFailureFromMessage(event.message);
+  const httpStatus = event.status ?? fallback.httpStatus;
+  const error = classifyError(httpStatus, event.errorType ?? fallback.error.type, event.message);
+  if (event.errorType !== undefined) error.type = event.errorType;
+  if (event.code !== undefined) error.code = event.code;
+  return { httpStatus, error };
+}
+
 export { adapterFailureFromMessage } from "./lib/errors";
 
 /**
@@ -85,7 +97,7 @@ export function bridgeToResponsesSSE(
     /** One-shot: first non-empty text/thinking/raw-reasoning delta observed (WP4 TTFT). */
     onFirstOutput?: () => void;
     onTerminal?: (status: ResponsesTerminalStatus) => void;
-    onCompletedResponse?: (response: Record<string, unknown>) => void;
+    onCompletedResponse?: (response: Record<string, unknown>, providerState?: OcxProviderContinuationState) => void;
   },
 ): ReadableStream<Uint8Array> {
   // Freeform/custom tools (apply_patch) carry their body in `input`; the model is given a
@@ -173,9 +185,10 @@ export function bridgeToResponsesSSE(
       let outputIndex = 0;
       const finishedItems: OutputItem[] = [];
 
-      const responseSnapshot = (status: string, output: OutputItem[]) => ({
+      const responseSnapshot = (status: string, output: OutputItem[], endTurn?: boolean) => ({
         id: responseId, object: "response", created_at: createdAt,
         status, model: modelId, output, usage: null,
+        ...(endTurn !== undefined ? { end_turn: endTurn } : {}),
       });
 
       emit("response.created", { response: responseSnapshot("in_progress", []) });
@@ -213,7 +226,7 @@ export function bridgeToResponsesSSE(
         try { controller.enqueue(heartbeatFrame); } catch { closed = true; }
       }, heartbeatMs);
 
-      let currentMsg: { itemId: string; outputIndex: number; text: string } | null = null;
+      let currentMsg: { itemId: string; outputIndex: number; text: string; phase?: OcxMessagePhase } | null = null;
       let currentReasoning: { itemId: string; outputIndex: number; text: string } | null = null;
       let currentRawReasoning: { itemId: string; outputIndex: number; text: string } | null = null;
       // Anthropic extended-thinking round-trip state: the signature signs the CURRENT thinking
@@ -299,6 +312,7 @@ export function bridgeToResponsesSSE(
         const item = {
           type: "message", id: currentMsg.itemId, status: "completed", role: "assistant",
           content: [{ type: "output_text", text: currentMsg.text, annotations }],
+          ...(currentMsg.phase ? { phase: currentMsg.phase } : {}),
         };
         emit("response.output_item.done", { output_index: currentMsg.outputIndex, item });
         finishedItems.push(item as OutputItem);
@@ -441,7 +455,7 @@ export function bridgeToResponsesSSE(
           // its compaction UI renders nothing mid-turn, so nothing is lost visually.
           if (options?.compaction) {
             if (event.type === "text_delta") { compactionText += event.text; continue; }
-            if (event.type !== "done" && event.type !== "error") continue;
+            if (event.type !== "done" && event.type !== "incomplete" && event.type !== "error") continue;
           }
           switch (event.type) {
             case "text_delta": {
@@ -449,18 +463,20 @@ export function bridgeToResponsesSSE(
               if (currentRawReasoning) closeCurrentRawReasoning();
               flushHiddenRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
+              if (currentMsg && currentMsg.phase !== event.phase) closeCurrentMessage();
               if (!currentMsg) {
                 const itemId = `msg_${uuid()}`;
                 const item = {
                   type: "message", id: itemId, status: "in_progress", role: "assistant",
                   content: [] as { type: string; text: string; annotations: never[] }[],
+                  ...(event.phase ? { phase: event.phase } : {}),
                 };
                 emit("response.output_item.added", { output_index: outputIndex, item });
                 emit("response.content_part.added", {
                   item_id: itemId, output_index: outputIndex, content_index: 0,
                   part: { type: "output_text", text: "", annotations: [] },
                 });
-                currentMsg = { itemId, outputIndex, text: "" };
+                currentMsg = { itemId, outputIndex, text: "", ...(event.phase ? { phase: event.phase } : {}) };
               }
               currentMsg.text += event.text;
               emit("response.output_text.delta", {
@@ -634,17 +650,49 @@ export function bridgeToResponsesSSE(
                 finishedItems.push(item as OutputItem);
                 outputIndex++;
               }
-              const truncated = event.stopReason === "max_tokens";
-              const response = {
-                ...responseSnapshot(truncated ? "incomplete" : "completed", finishedItems),
-                usage: responsesUsage(event.usage),
-                ...(truncated ? { incomplete_details: { reason: "max_output_tokens" } } : {}),
-              };
-              options?.onCompletedResponse?.(response);
-              emit(truncated ? "response.incomplete" : "response.completed", {
-                response,
+              if (event.stopReason === "max_tokens") {
+                // Upstream hit its output token cap. Surface as incomplete so the client can
+                // distinguish a truncated turn from a genuinely finished one (issue #246).
+                const response = {
+                  ...responseSnapshot("incomplete", finishedItems, event.endTurn),
+                  usage: responsesUsage(event.usage),
+                  incomplete_details: { reason: "max_output_tokens" },
+                };
+                // Still cache the partial output so previous_response_id replay works.
+                options?.onCompletedResponse?.(response, event.providerState);
+                emit("response.incomplete", { response });
+                reportTerminal("incomplete");
+              } else {
+                const response = { ...responseSnapshot("completed", finishedItems, event.endTurn), usage: responsesUsage(event.usage) };
+                options?.onCompletedResponse?.(response, event.providerState);
+                emit("response.completed", {
+                  response,
+                });
+                reportTerminal("completed");
+              }
+              terminated = true;
+              break;
+            }
+            case "incomplete": {
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
+              flushHiddenRawReasoning();
+              if (currentToolCall) closeCurrentToolCall();
+              if (currentWebSearch) closeCurrentWebSearch("failed", []);
+              flushHiddenReasoningEnvelope();
+              emit("response.incomplete", {
+                response: {
+                  ...responseSnapshot("incomplete", finishedItems, event.endTurn),
+                  usage: responsesUsage(event.usage),
+                  incomplete_details: {
+                    reason: event.reason,
+                    ...(event.message ? { message: event.message } : {}),
+                    ...(event.retryable !== undefined ? { retryable: event.retryable } : {}),
+                  },
+                },
               });
-              reportTerminal(truncated ? "incomplete" : "completed");
+              reportTerminal("incomplete");
               terminated = true;
               break;
             }
@@ -655,7 +703,7 @@ export function bridgeToResponsesSSE(
               flushHiddenRawReasoning();
               if (currentToolCall) closeCurrentToolCall();
               if (currentWebSearch) closeCurrentWebSearch("failed", []);
-              const failure = adapterFailureFromMessage(event.message);
+              const failure = adapterFailureFromEvent(event);
               emit("response.failed", {
                 response: {
                   ...responseSnapshot("failed", finishedItems),
@@ -664,6 +712,7 @@ export function bridgeToResponsesSSE(
                   ...(event.usage ? { usage: responsesUsage(event.usage) } : {}),
                   error: failure.error,
                   last_error: failure.error,
+                  ...(event.retryable !== undefined ? { retryable: event.retryable } : {}),
                 },
               });
               reportTerminal("failed");
@@ -736,16 +785,20 @@ export function buildResponseJSON(
     toolSearchToolNames?: Set<string>;
     /** Remote compaction v2 turn — append one synthetic compaction output item (see bridgeToResponsesSSE). */
     compaction?: boolean;
+    onProviderState?: (state: OcxProviderContinuationState) => void;
   },
 ): Record<string, unknown> {
   const responseId = `resp_${uuid()}`;
   const output: OutputItem[] = [];
   let usage: OcxUsage | undefined;
-  let errorMessage: string | undefined;
+  let errorEvent: Extract<AdapterEvent, { type: "error" }> | undefined;
+  let incompleteEvent: Extract<AdapterEvent, { type: "incomplete" }> | undefined;
+  let endTurn: boolean | undefined;
   let stopReason: string | undefined;
   let compactionText = "";
 
   let currentText = "";
+  let currentTextPhase: OcxMessagePhase | undefined;
   let currentSummaryReasoning = "";
   let currentRawReasoning = "";
   // Anthropic extended-thinking round-trip (batch): see bridgeToResponsesSSE counterpart.
@@ -774,8 +827,10 @@ export function buildResponseJSON(
     output.push({
       type: "message", id: `msg_${uuid()}`, role: "assistant", status: "completed",
       content: [{ type: "output_text", text: currentText, annotations }],
+      ...(currentTextPhase ? { phase: currentTextPhase } : {}),
     });
     currentText = "";
+    currentTextPhase = undefined;
   };
   const flushSummaryReasoning = () => {
     if (!currentSummaryReasoning && !batchSignature && batchRedacted.length === 0) return;
@@ -847,13 +902,17 @@ export function buildResponseJSON(
   for (const e of events) {
     switch (e.type) {
       case "text_delta":
+        if (currentText && currentTextPhase !== e.phase) flushText();
         if (currentSummaryReasoning) flushSummaryReasoning();
         if (currentRawReasoning) flushRawReasoning();
         if (currentToolCallId) flushToolCall();
         // Compaction turns keep the summary out of normal message output (replay dedup — see
         // bridgeToResponsesSSE); it ships only inside the synthetic compaction item below.
         if (options?.compaction) compactionText += e.text;
-        else currentText += e.text;
+        else {
+          currentTextPhase = e.phase;
+          currentText += e.text;
+        }
         break;
       case "thinking_delta":
         if (currentText) flushText();
@@ -913,11 +972,19 @@ export function buildResponseJSON(
         }
         break;
       case "error":
-        errorMessage = e.message;
+        errorEvent = e;
+        usage = e.usage ?? usage;
+        break;
+      case "incomplete":
+        incompleteEvent = e;
+        endTurn = e.endTurn;
+        if (e.providerState) options?.onProviderState?.(e.providerState);
         break;
       case "done":
         usage = e.usage;
-        stopReason = e.stopReason;
+        endTurn = e.endTurn;
+        if (e.providerState) options?.onProviderState?.(e.providerState);
+        if (e.stopReason === "max_tokens") stopReason = "max_tokens";
         break;
     }
   }
@@ -925,18 +992,34 @@ export function buildResponseJSON(
   flushSummaryReasoning();
   flushRawReasoning();
   flushToolCall();
-  if (options?.compaction && !errorMessage) {
+  if (options?.compaction && !errorEvent) {
     output.push({ type: "compaction", id: `cmp_${uuid()}`, encrypted_content: encodeCompactionSummary(compactionText) });
   }
 
+  const failure = errorEvent ? adapterFailureFromEvent(errorEvent) : undefined;
+  const status = errorEvent
+    ? "failed"
+    : incompleteEvent || stopReason === "max_tokens"
+      ? "incomplete"
+      : "completed";
   return {
     id: responseId, object: "response",
     created_at: Math.floor(Date.now() / 1000),
-    status: errorMessage ? "failed" : stopReason === "max_tokens" ? "incomplete" : "completed",
+    status,
     model: modelId, output,
-    ...(errorMessage ? { error: { message: errorMessage } } : {}),
-    ...(!errorMessage && stopReason === "max_tokens" ? { incomplete_details: { reason: "max_output_tokens" } } : {}),
-    usage: responsesUsage(usage),
+    ...(endTurn !== undefined ? { end_turn: endTurn } : {}),
+    ...(failure ? { error: failure.error, last_error: failure.error } : {}),
+    ...(errorEvent?.retryable !== undefined ? { retryable: errorEvent.retryable } : {}),
+    ...(incompleteEvent ? {
+      incomplete_details: {
+        reason: incompleteEvent.reason,
+        ...(incompleteEvent.message ? { message: incompleteEvent.message } : {}),
+        ...(incompleteEvent.retryable !== undefined ? { retryable: incompleteEvent.retryable } : {}),
+      },
+    } : stopReason === "max_tokens" ? {
+      incomplete_details: { reason: "max_output_tokens" },
+    } : {}),
+    usage: responsesUsage(incompleteEvent?.usage ?? usage),
   };
 }
 

package/src/claude/outbound.ts

@@ -314,16 +314,26 @@ export function responsesSseToAnthropicSse(
           }
           case "response.completed": {
             const response = isRec(data.response) ? data.response : {};
+            if (response.end_turn === false && !sawToolUse) {
+              fail(529, "upstream turn ended without a final answer", true);
+              break;
+            }
             finish(sawToolUse ? "tool_use" : "end_turn", response.usage);
             break;
           }
           case "response.incomplete": {
             const response = isRec(data.response) ? data.response : {};
             const details = isRec(response.incomplete_details) ? response.incomplete_details : {};
-            const reason = details.reason === "max_output_tokens" ? "max_tokens"
-              : details.reason === "content_filter" ? "refusal"
-              : sawToolUse ? "tool_use" : "end_turn";
-            finish(reason, response.usage);
+            if (details.reason === "max_output_tokens") {
+              finish("max_tokens", response.usage);
+            } else if (details.reason === "content_filter") {
+              finish("refusal", response.usage);
+            } else {
+              const message = typeof details.message === "string" && details.message.trim()
+                ? details.message
+                : `upstream response was incomplete${typeof details.reason === "string" ? ` (${details.reason})` : ""}`;
+              fail(529, message, true);
+            }
             break;
           }
           case "response.failed": {
@@ -454,8 +464,21 @@ export function responsesJsonToAnthropicMessage(json: unknown, model: string): R
   }
 
   const details = isRec(body.incomplete_details) ? body.incomplete_details : {};
+  if (body.status === "incomplete"
+    && details.reason !== "max_output_tokens"
+    && details.reason !== "content_filter") {
+    const message = typeof details.message === "string" && details.message.trim()
+      ? details.message
+      : `upstream response was incomplete${typeof details.reason === "string" ? ` (${details.reason})` : ""}`;
+    return anthropicErrorBody(529, message, "overloaded_error");
+  }
+  if (body.status === "completed" && body.end_turn === false && !sawToolUse) {
+    return anthropicErrorBody(529, "upstream turn ended without a final answer", "overloaded_error");
+  }
   const stopReason = body.status === "incomplete" && details.reason === "max_output_tokens"
     ? "max_tokens"
+    : body.status === "incomplete" && details.reason === "content_filter"
+      ? "refusal"
     : sawToolUse ? "tool_use" : "end_turn";
 
   return {

package/src/cli/index.ts

@@ -106,7 +106,7 @@ async function chooseListenPort(requestedPort?: number): Promise<number> {
       preferRetryIntervalMs: 50,
       allowEphemeralFallback: !hardPin,
     });
-    if (selected !== preferred) {
+    if (preferred > 0 && selected !== preferred) {
       console.log(`⚠️  Port ${preferred} is busy; starting opencodex on ${selected}.`);
     }
     if (shouldPersistSelectedPort(config.port, selected, preferred)) {