@bitkyc08/opencodex 2.7.33 → 2.7.34

package/src/types.ts

@@ -9,6 +9,8 @@ export interface OcxParsedRequest {
   _previousResponseInputExpanded?: boolean;
   /** Provider-private stable Cursor conversation id resolved from the Responses previous_response_id chain. */
   _cursorConversationId?: string;
+  /** Provider-private continuation metadata resolved from the Responses previous_response_id chain. */
+  _providerContinuation?: OcxProviderContinuationState;
   /**
    * The hosted `{type:"web_search", ...}` tool config, stashed when Codex enables web search. Routed
    * (non-OpenAI) providers can't run it server-side, so the proxy re-exposes it as a function tool and
@@ -28,6 +30,12 @@ export interface OcxParsedRequest {
    * (see src/responses/compaction.ts).
    */
   _compactionRequest?: boolean;
+  /**
+   * True when the current request newly introduced a stored compaction summary/marker. Historical
+   * markers restored by previous_response_id expansion were already acknowledged and do not reset
+   * provider-private continuation caches again on every later turn.
+   */
+  _contextCompactionBoundary?: boolean;
 }
 
 export interface OcxContext {
@@ -51,6 +59,8 @@ export interface OcxUserMessage {
 export interface OcxAssistantMessage {
   role: "assistant";
   content: OcxAssistantContentPart[];
+  /** Responses message phase, preserved when replaying translated provider output. */
+  phase?: OcxMessagePhase;
   model?: string;
   timestamp: number;
 }
@@ -69,6 +79,8 @@ export interface OcxToolResultMessage {
   toolNamespace?: string;
   /** Text, or content parts when a tool (e.g. Codex view_image) returns an image in its output. */
   content: string | OcxContentPart[];
+  /** True when the Responses result contained opaque encrypted output Kiro cannot translate. */
+  containsEncryptedContent?: boolean;
   isError: boolean;
   timestamp: number;
 }
@@ -191,9 +203,26 @@ export interface OcxRequestOptions {
   promptCacheKey?: string;
 }
 
+export type OcxMessagePhase = "commentary" | "final_answer";
+
+/**
+ * Provider-private state that must follow a locally expanded `previous_response_id` chain.
+ * Kept out of public Responses output and persisted only in the bounded local continuation cache.
+ */
+export interface OcxProviderContinuationState {
+  cursor?: {
+    conversationId?: string;
+    checkpointUsable?: boolean;
+  };
+  kiro?: {
+    conversationId?: string;
+  };
+  [provider: string]: Record<string, unknown> | undefined;
+}
+
 export type AdapterEvent =
   | { type: "heartbeat" }
-  | { type: "text_delta"; text: string }
+  | { type: "text_delta"; text: string; phase?: OcxMessagePhase }
   | { type: "thinking_delta"; thinking: string }
   // Anthropic extended-thinking round-trip: signature_delta for the current thinking block, and
   // opaque redacted_thinking blocks. Both must be replayed verbatim or tool-use turns 400.
@@ -211,10 +240,35 @@ export type AdapterEvent =
   // the SAME output index, so the activity animates instead of flashing completed instantly.
   | { type: "web_search_call_begin"; id: string }
   | { type: "web_search_call_end"; id: string; queries: string[]; status?: "completed" | "failed"; sources?: OcxUrlCitation[] }
-  | { type: "done"; usage?: OcxUsage; stopReason?: string }
+  | {
+      type: "done";
+      usage?: OcxUsage;
+      stopReason?: string;
+      endTurn?: boolean;
+      providerState?: OcxProviderContinuationState;
+    }
+  | {
+      type: "incomplete";
+      reason: string;
+      message?: string;
+      usage?: OcxUsage;
+      retryable?: boolean;
+      endTurn?: boolean;
+      providerState?: OcxProviderContinuationState;
+    }
   // `usage` carries best-effort partial consumption when a turn dies before a clean done
   // (e.g. cursor upstream 502 mid-stream), so failed requests can log real token counts.
-  | { type: "error"; message: string; usage?: OcxUsage };
+  | {
+      type: "error";
+      message: string;
+      usage?: OcxUsage;
+      /** Authoritative upstream/proxy status when known; avoids message-based classification. */
+      status?: number;
+      /** Responses error type and code when the adapter has a structured provider failure. */
+      errorType?: string;
+      code?: string;
+      retryable?: boolean;
+    };
 
 /**
  * A web source backing a search answer. Surfaced on the search-end event and rendered by the bridge
@@ -399,6 +453,11 @@ export interface OcxConfig {
    * the resolved sub-agent roster block ("" when nothing resolves).
    */
   injectionPrompt?: string;
+  /**
+   * Proxy-authored multi-agent developer guidance. Undefined/true = enabled for
+   * backward compatibility; false suppresses both v1 and v2 guidance injection.
+   */
+  multiAgentGuidanceEnabled?: boolean;
   /**
    * Global hard ceiling for the reasoning effort of EVERY proxied turn (main agent AND
    * sub-agents). Ladder value "low".."max"; incoming efforts ranking above it are rewritten
@@ -520,6 +579,12 @@ export interface OcxComboConfig {
   stickyLimit?: number;
   /** Used when the client omits reasoning.effort. null/omitted leaves the target default unchanged. */
   defaultEffort?: OcxComboDefaultEffort | null;
+  /**
+   * Optional public model name replacing the default `combo/<id>` slug. Bare names
+   * without "/" are allowed (e.g. "deepseek-v4-flash") so the combo can answer to a
+   * mandated model id; exact-match requests route here before any provider resolution.
+   */
+  alias?: string;
 }
 
 /**
@@ -614,9 +679,24 @@ export interface OpenRouterProviderRouting {
   allowFallbacks?: boolean;
 }
 
+export interface ResponsesItemIdRepairConfig {
+  /** Exact `message` item ids that the proxy should rewrite to request-local canonical ids. */
+  message?: string[];
+  /** Exact `reasoning` item ids that the proxy should rewrite to request-local canonical ids. */
+  reasoning?: string[];
+  /** Backfill missing `output_item.done` / terminal snapshot ids from the matching output_index. */
+  repairMissingTerminalIds?: boolean;
+}
+
 export interface OcxProviderConfig {
   adapter: string;
   baseUrl: string;
+  /**
+   * Optional relative resource path for key-auth openai-responses requests. Must start with `/`
+   * and must not include a URL scheme, query string, or fragment. When omitted, the adapter keeps
+   * the legacy `/v1/responses` construction.
+   */
+  responsesPath?: string;
   /**
    * Explicit opt-in for non-registry private-network destinations such as localhost, RFC1918,
    * link-local, or unique-local upstreams. Metadata endpoints remain blocked.
@@ -661,6 +741,13 @@ export interface OcxProviderConfig {
   modelInputModalities?: Record<string, string[]>;
   /** Model-specific max input token limits. Values cap auto_compact_token_limit. */
   modelMaxInputTokens?: Record<string, number>;
+  /**
+   * Provider-wide fallback for chat-completions `max_tokens` when the caller omits
+   * Responses `max_output_tokens`. Adapters still let an explicit request win.
+   */
+  defaultMaxOutputTokens?: number;
+  /** Model-specific fallback output token budgets. Exact/model-pattern entries beat the provider default. */
+  modelMaxOutputTokens?: Record<string, number>;
   headers?: Record<string, string>;
   /** Default provider-routing preferences for models sent through the canonical OpenRouter API. */
   openRouterRouting?: OpenRouterProviderRouting;
@@ -731,6 +818,12 @@ export interface OcxProviderConfig {
    * fields. Default off; only enable for providers that document this parameter.
    */
   promptCacheKey?: boolean;
+  /**
+   * Provider-local passthrough SSE repair for broken openai-responses gateways that reuse exact
+   * placeholder message/reasoning ids or omit the terminal id after a stable added event.
+   * Disabled by default; function_call ids and call_id pairing are never rewritten.
+   */
+  responsesItemIdRepair?: ResponsesItemIdRepairConfig;
   /** Model ids whose tool_choice only accepts `auto` or `none`; forced/named choices are downgraded. */
   autoToolChoiceOnlyModels?: string[];
   /** Model ids that expect prior assistant `reasoning_content` to be preserved in chat history. */
@@ -778,23 +871,23 @@ export interface OcxProviderConfig {
   desktopExecutor?: import("./adapters/cursor/native-exec-desktop").DesktopExecutorConfig;
   /**
    * Cursor adapter only: unsafe opt-in escape hatch for Cursor server-driven built-in local
-   * read/write/delete/ls/grep/shell/fetch execution. Defaults to false so remote Cursor messages
-   * cannot bypass Codex approval/sandbox semantics. Explicit MCP and desktop executors remain
-   * controlled by their own opt-in config.
+   * read/write/delete/ls/grep/shell/fetch execution. Prefer `nativeLocalExec: "on"` for new
+   * configs; this legacy boolean remains a server-local explicit opt-in for existing operators.
+   * Defaults to false so remote Cursor messages cannot bypass Codex approval/sandbox semantics.
+   * Explicit MCP and desktop executors remain controlled by their own opt-in config.
    */
   unsafeAllowNativeLocalExec?: boolean;
   /**
    * Cursor adapter only: native local exec policy mode (exec-policy.ts).
-   * "codex-sandbox" (default) allows server-driven local exec only when the
-   * request's instructions/developer text declares the Codex danger-full-access
-   * sandbox (approves the normal full-access flow, denies undeclared requests);
-   * "off" rejects all server-driven local exec; "on" always allows (same as legacy
-   * unsafeAllowNativeLocalExec:true). NOTE: the declaration is CALLER-CONTROLLED prose —
-   * the proxy cannot verify it. Enable "codex-sandbox" only where every client
-   * that can reach the data plane is trusted: the default loopback bind admits
-   * ANY process on this host without auth (including other local users on
-   * multi-user machines), and isAllowedRequestOrigin blocks non-loopback
-   * browser origins by default but not loopback-origin or origin-less callers.
+   * "off" (default) rejects server-driven local exec; "on" always allows it for this
+   * provider and should be used only for a trusted local experiment on a host where every
+   * data-plane caller is trusted. "codex-sandbox" is accepted for backwards compatibility
+   * but is fail-closed like "off": Responses instructions/system/developer text is
+   * caller-controlled prose, and opencodex has no trustworthy per-request attestation that it
+   * reflects a real Codex sandbox state. The default loopback bind admits ANY local process
+   * without auth (including other local users on multi-user machines), and
+   * isAllowedRequestOrigin blocks non-loopback browser origins by default but not
+   * loopback-origin or origin-less callers.
    */
   nativeLocalExec?: "off" | "codex-sandbox" | "on";
 }

package/src/update/job.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { atomicWriteFile, getConfigDir, loadConfig, readPid, readRuntimePort } from "../config";
 import { killProxy } from "../lib/process-control";
 import { waitForPortAvailable } from "../server/ports";
+import { proxyIdentityAt } from "../server/proxy-liveness";
 import { isServiceInstalled } from "../service";
 import {
   type Channel,
@@ -24,6 +25,8 @@ const RELEASE_NOTES_URL = "https://github.com/lidge-jun/opencodex/releases/lates
 const UPDATE_JOB_FILENAME = "update-job.json";
 const UPDATE_TIMEOUT_MS = 180_000;
 const RESTART_TIMEOUT_MS = 60_000;
+const RESTART_HEALTH_TIMEOUT_MS = 15_000;
+const RESTART_STABILITY_WINDOW_MS = 15_000;
 
 export type UpdateJobStatus = "running" | "restarting" | "succeeded" | "failed";
 
@@ -291,6 +294,9 @@ export interface RestartIo {
   waitForPort?: typeof waitForPortAvailable;
   spawnStart?: (job: UpdateJobState, installer: Installer, port?: number) => void;
   serviceInstalledFn?: () => boolean;
+  probeProxy?: (port: number, hostname?: string) => Promise<boolean>;
+  sleepMs?: (ms: number) => Promise<void>;
+  now?: () => number;
   /** Service-mode install/reinstall command (defaults to spawnSync via runLoggedCommand). */
   runService?: (
     job: UpdateJobState,
@@ -377,6 +383,79 @@ export function restartAfterUpdateForTests(
   return restartAfterUpdate(job, captured, io);
 }
 
+function restartFailureHint(port: number): string {
+  return `Update installed, but the restarted proxy did not stay healthy on port ${port}. `
+    + "Try 'ocx start'. If the update log shows bun postinstall or EPERM warnings, "
+    + "reinstall with 'npm install -g --allow-scripts=bun @bitkyc08/opencodex'.";
+}
+
+/**
+ * Confirm that the detached/service restart really came back and stayed up. The GUI worker
+ * used to mark success immediately after spawning the new process, which hid Windows cases
+ * where npm left the bundled Bun runtime half-updated and the restarted proxy died seconds
+ * later. A healthy /healthz must appear, then remain healthy for one short stability window.
+ */
+async function confirmRestartedProxy(
+  job: UpdateJobState,
+  captured: { port: number; hostname: string },
+  io: RestartIo = {},
+): Promise<boolean> {
+  /* [Decision Log]
+  - 목적과 의도: GUI update job이 detached restart 요청만 보고 성공 처리하지 않도록, 실제 프록시 복귀 여부를 확인한다.
+  - 기존 구현 및 제약 조건: update-job.json은 spawn/service reinstall 직후 `succeeded`로 끝났고, Windows npm/Bun 교체 실패처럼 몇 초 후 죽는 재시작을 잡지 못했다.
+  - 검토한 주요 대안: (1) 포트 점유만 확인 — 외부 프로세스/죽기 직전 프로세스를 성공으로 오인할 수 있다. (2) 무기한 /healthz 폴링 — UX가 느려지고 worker 종료 시점이 불명확하다. (3) 짧은 healthy 등장 + 안정성 창 확인 — 실제 복귀를 확인하면서도 대기 시간을 제한할 수 있다.
+  - 선택한 방식: identity-aware /healthz probe가 일정 시간 안에 나타나고, 추가 안정성 창 동안 유지되는지 확인한다.
+  - 다른 대안 대신 이 방식을 선택한 이유: GUI는 "업데이트가 설치됐지만 재시작은 실패"를 분리해 알려줘야 하며, 이 방식이 가장 적은 오탐으로 그 경계를 만든다.
+  - 장점, 단점 및 영향: 장점은 silent restart failure가 update-job 상태로 드러난다는 점이다. 단점은 성공 판정이 최대 30초 늦어질 수 있다는 점이며, 대신 실제 복귀를 더 정확히 반영한다.
+  */
+  const probe = io.probeProxy ?? (async (port: number, hostname?: string) => (
+    !!(await proxyIdentityAt(port, { hostname }))
+  ));
+  const sleep = io.sleepMs ?? (async (ms: number) => {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  });
+  const now = io.now ?? (() => Date.now());
+  const port = captured.port;
+  const hostname = captured.hostname;
+  const startDeadline = now() + RESTART_HEALTH_TIMEOUT_MS;
+
+  while (now() < startDeadline) {
+    if (await probe(port, hostname)) {
+      updateJob(job, {}, `Proxy reported healthy on ${hostname}:${port}; confirming it stays up...`);
+      const stableUntil = now() + RESTART_STABILITY_WINDOW_MS;
+      while (now() < stableUntil) {
+        if (!(await probe(port, hostname))) {
+          updateJob(job, {
+            status: "failed",
+            restarted: false,
+            error: `proxy restart became unhealthy on ${hostname}:${port}`,
+          }, restartFailureHint(port));
+          return false;
+        }
+        await sleep(500);
+      }
+      updateJob(job, {}, `Proxy stayed healthy for ${Math.trunc(RESTART_STABILITY_WINDOW_MS / 1000)}s after restart.`);
+      return true;
+    }
+    await sleep(250);
+  }
+
+  updateJob(job, {
+    status: "failed",
+    restarted: false,
+    error: `proxy restart never became healthy on ${hostname}:${port}`,
+  }, restartFailureHint(port));
+  return false;
+}
+
+export function confirmRestartAfterUpdateForTests(
+  job: UpdateJobState,
+  captured: { port: number; hostname: string },
+  io: RestartIo,
+): Promise<boolean> {
+  return confirmRestartedProxy(job, captured, io);
+}
+
 export async function runGuiUpdateWorker(jobId: string, channel: Channel, restart: boolean): Promise<void> {
   let job = readUpdateJob(jobId);
   const check = checkForUpdate(channel);
@@ -457,7 +536,8 @@ export async function runGuiUpdateWorker(jobId: string, channel: Channel, restar
     if (restart) {
       job = updateJob(job, { status: "restarting" }, "Update installed. Restarting proxy...");
       await restartAfterUpdate(job, captured);
-      updateJob(job, { status: "succeeded", restarted: true }, "Restart requested.");
+      if (!(await confirmRestartedProxy(job, captured))) return;
+      updateJob(job, { status: "succeeded", restarted: true }, "Restart requested and proxy is healthy.");
       return;
     }
 

package/src/vision/describe.ts

@@ -1,6 +1,7 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
 import { signalWithTimeout, cancelBodyOnAbort } from "../lib/abort";
+import { redactSecretString } from "../lib/redact";
 import { sidecarEnter } from "../lib/sidecar-tracker";
 import { fetchWithResetRetry } from "../lib/upstream-retry";
 import { parseSidecarSSE } from "../web-search/parse";
@@ -99,7 +100,7 @@ export async function describeImage(
     if (!res.ok) {
       const t = await res.text().catch(() => "");
       console.warn(`[vision] sidecar HTTP ${res.status} (${Date.now() - t0}ms)`);
-      return { text: "", error: `vision sidecar HTTP ${res.status}: ${t.slice(0, 200)}` };
+      return { text: "", error: `vision sidecar HTTP ${res.status}: ${redactSecretString(t.slice(0, 200))}` };
     }
     const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
     let parsed;

package/src/web-search/executor.ts

@@ -1,6 +1,7 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
 import { signalWithTimeout, cancelBodyOnAbort } from "../lib/abort";
+import { redactSecretString } from "../lib/redact";
 import { sidecarEnter } from "../lib/sidecar-tracker";
 import { fetchWithResetRetry } from "../lib/upstream-retry";
 import { parseSidecarSSE, type WebSearchResult } from "./parse";
@@ -84,7 +85,7 @@ export async function runWebSearch(
     if (!res.ok) {
       const t = await res.text().catch(() => "");
       console.warn(`[web-search] sidecar HTTP ${res.status} for query "${query.slice(0, 80)}" (${Date.now() - t0}ms)`);
-      return { text: "", sources: [], error: `sidecar HTTP ${res.status}: ${t.slice(0, 200)}` };
+      return { text: "", sources: [], error: `sidecar HTTP ${res.status}: ${redactSecretString(t.slice(0, 200))}` };
     }
     const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
     try {

package/src/web-search/loop.ts

@@ -364,6 +364,13 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         inactivityTimeoutMs: routedModelStallTimeoutMs,
       })) {
         if (event.type === "heartbeat") yield event;
+        // Kiro's explicit-completion protocol marks ordinary assistant text as commentary while
+        // it performs a bounded final-answer retry. That text is safe to surface immediately and
+        // is exactly what the native Kiro transport streams. Keeping it in the search scanner made
+        // Codex show only `Working` until both Kiro attempts had finished (often 30-40 seconds).
+        // Tool events remain buffered below, so the decision to invoke the hosted sidecar is still
+        // atomic and no search call can escape before its stream has validated successfully.
+        else if (event.type === "text_delta" && event.phase === "commentary") yield event;
         else events.push(event);
       }
     } catch (error) {
@@ -373,7 +380,8 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       throw new LoopError(502, `Provider stream error: ${error instanceof Error ? error.message : String(error)}`);
     }
 
-    const terminalIndexes = events.flatMap((event, index) => event.type === "done" || event.type === "error" ? [index] : []);
+    const terminalIndexes = events.flatMap((event, index) =>
+      event.type === "done" || event.type === "incomplete" || event.type === "error" ? [index] : []);
     if (terminalIndexes.length !== 1 || terminalIndexes[0] !== events.length - 1) {
       throw new LoopError(502, `Web-search adapter stream protocol error: expected one final terminal event, received ${terminalIndexes.length}`);
     }

package/src/web-search/progress-stream.ts

@@ -241,7 +241,7 @@ export async function* parseStreamWithProgress(
   resetInactivity();
 
   const parserPump = (async (): Promise<void> => {
-    let heldDone: Extract<AdapterEvent, { type: "done" }> | undefined;
+    let heldTerminal: Extract<AdapterEvent, { type: "done" | "incomplete" }> | undefined;
     try {
       iterator = parseStream(tappedResponse);
       if (settled) {
@@ -250,11 +250,11 @@ export async function* parseStreamWithProgress(
       }
       while (true) {
         let result: IteratorResult<AdapterEvent>;
-        if (heldDone) {
+        if (heldTerminal) {
           let drainTimer: ReturnType<typeof setTimeout> | undefined;
           const drainTimeout = new Promise<never>((_, reject) => {
             drainTimer = setTimeout(() => reject(new WebSearchStreamProtocolError(
-              `adapter did not return within ${postTerminalDrainTimeoutMs}ms after done`,
+              `adapter did not return within ${postTerminalDrainTimeoutMs}ms after ${heldTerminal?.type ?? "terminal event"}`,
             )), postTerminalDrainTimeoutMs);
           });
           const stoppedDuringDrain = stopped.then(reason => { throw reason; });
@@ -268,8 +268,8 @@ export async function* parseStreamWithProgress(
         }
 
         if (result.done) {
-          if (!heldDone) throw new WebSearchStreamProtocolError("adapter returned without a done event");
-          await handoff.deliver(heldDone);
+          if (!heldTerminal) throw new WebSearchStreamProtocolError("adapter returned without a terminal event");
+          await handoff.deliver(heldTerminal);
           if (!settled) {
             settled = true;
             clearInactivity();
@@ -281,17 +281,19 @@ export async function* parseStreamWithProgress(
         }
 
         const event = result.value;
-        if (heldDone) {
+        if (heldTerminal) {
           throw new WebSearchStreamProtocolError(
-            event.type === "done" ? "adapter yielded more than one done event" : "adapter yielded an event after done",
+            event.type === "done" || event.type === "incomplete"
+              ? "adapter yielded more than one terminal event"
+              : "adapter yielded an event after its terminal event",
           );
         }
         if (event.type === "error") {
           fail(new Error(event.message));
           return;
         }
-        if (event.type === "done") {
-          heldDone = event;
+        if (event.type === "done" || event.type === "incomplete") {
+          heldTerminal = event;
           continue;
         }
         await handoff.deliver(event);
@@ -300,7 +302,7 @@ export async function* parseStreamWithProgress(
       fail(error instanceof WebSearchStreamProtocolError
         ? error
         : new WebSearchStreamProtocolError(
-          `adapter threw${heldDone ? " after done" : ""}: ${error instanceof Error ? error.message : String(error)}`,
+          `adapter threw${heldTerminal ? " after its terminal event" : ""}: ${error instanceof Error ? error.message : String(error)}`,
         ));
     }
   })();