@bitkyc08/opencodex 2.6.17 → 2.6.18

package/src/oauth/key-providers.ts

@@ -1,5 +1,5 @@
 import type { OcxProviderConfig } from "../types";
-import { deriveKeyLoginMap } from "../providers/derive";
+import { deriveKeyLoginMap, enrichProviderFromRegistry } from "../providers/derive";
 
 /**
  * API-key "login" providers: not OAuth — the flow opens the provider's dashboard so the user can
@@ -14,6 +14,7 @@ export interface KeyLoginProvider {
   /** Where the user creates/copies the API key. */
   dashboardUrl: string;
   models?: string[];
+  liveModels?: boolean;
   defaultModel?: string;
   contextWindow?: number;
   modelContextWindows?: Record<string, number>;
@@ -35,45 +36,19 @@ export interface KeyLoginProvider {
   autoToolChoiceOnlyModels?: string[];
   preserveReasoningContentModels?: string[];
   escapeBuiltinToolNames?: boolean;
+  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
 }
 
 export const KEY_LOGIN_PROVIDERS: Record<string, KeyLoginProvider> = deriveKeyLoginMap();
 
 /**
- * Copy a key-login catalog entry's seed/classification (`models`, `noVisionModels`,
- * `noReasoningModels`, `defaultModel`) onto a provider config being created, for any field the caller
- * didn't already supply. Lets the vision/reasoning classification actually reach the saved config
- * (the GUI/API only send adapter/baseUrl/apiKey/defaultModel). No-op for non-catalog provider names.
+ * Copy a registry entry's seed/classification (`models`, `liveModels`, `noVisionModels`,
+ * `noReasoningModels`, `defaultModel`) onto a provider config being created, for any field the
+ * caller didn't already supply. Lets the vision/reasoning classification actually reach the saved
+ * config (the GUI/API only send adapter/baseUrl/apiKey/defaultModel). No-op for unknown names.
  */
 export function enrichProviderFromCatalog(name: string, prov: OcxProviderConfig): void {
-  const e = KEY_LOGIN_PROVIDERS[name];
-  if (!e) return;
-  if (!prov.models && e.models) prov.models = [...e.models];
-  if (!prov.defaultModel && e.defaultModel) prov.defaultModel = e.defaultModel;
-  if (prov.contextWindow === undefined && e.contextWindow !== undefined) prov.contextWindow = e.contextWindow;
-  if (!prov.modelContextWindows && e.modelContextWindows) prov.modelContextWindows = { ...e.modelContextWindows };
-  if (!prov.modelInputModalities && e.modelInputModalities) prov.modelInputModalities = cloneRecordOfArrays(e.modelInputModalities);
-  if (!prov.reasoningEfforts && e.reasoningEfforts) prov.reasoningEfforts = [...e.reasoningEfforts];
-  if (!prov.modelReasoningEfforts && e.modelReasoningEfforts) prov.modelReasoningEfforts = cloneRecordOfArrays(e.modelReasoningEfforts);
-  if (!prov.reasoningEffortMap && e.reasoningEffortMap) prov.reasoningEffortMap = { ...e.reasoningEffortMap };
-  if (!prov.modelReasoningEffortMap && e.modelReasoningEffortMap) prov.modelReasoningEffortMap = cloneNestedRecord(e.modelReasoningEffortMap);
-  if (!prov.noVisionModels && e.noVisionModels) prov.noVisionModels = [...e.noVisionModels];
-  if (!prov.noReasoningModels && e.noReasoningModels) prov.noReasoningModels = [...e.noReasoningModels];
-  if (!prov.noTemperatureModels && e.noTemperatureModels) prov.noTemperatureModels = [...e.noTemperatureModels];
-  if (!prov.noTopPModels && e.noTopPModels) prov.noTopPModels = [...e.noTopPModels];
-  if (!prov.noPenaltyModels && e.noPenaltyModels) prov.noPenaltyModels = [...e.noPenaltyModels];
-  if (!prov.autoToolChoiceOnlyModels && e.autoToolChoiceOnlyModels) prov.autoToolChoiceOnlyModels = [...e.autoToolChoiceOnlyModels];
-  if (!prov.preserveReasoningContentModels && e.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...e.preserveReasoningContentModels];
-  if (prov.escapeBuiltinToolNames === undefined && e.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = e.escapeBuiltinToolNames;
-}
-
-
-function cloneRecordOfArrays(input: Record<string, string[]>): Record<string, string[]> {
-  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, [...value]]));
-}
-
-function cloneNestedRecord(input: Record<string, Record<string, string>>): Record<string, Record<string, string>> {
-  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, { ...value }]));
+  enrichProviderFromRegistry(name, prov);
 }
 
 export function isKeyLoginProvider(name: string): boolean {
@@ -108,6 +83,18 @@ export async function validateApiKey(provider: KeyLoginProvider, key: string): P
       return "unknown";
     }
 
+    if (provider.adapter === "google" && (provider.googleMode ?? "ai-studio") === "ai-studio") {
+      // Generative Language API rejects Bearer-wrapped API keys; probe models.list with the
+      // documented x-goog-api-key header instead (pageSize=1 — validation only needs a 200).
+      const res = await fetch(`${provider.baseUrl}/v1beta/models?pageSize=1`, {
+        headers: { "x-goog-api-key": key },
+        signal: AbortSignal.timeout(8000),
+      });
+      if (res.ok) return true;
+      if (res.status === 400 || res.status === 401 || res.status === 403) return false;
+      return "unknown";
+    }
+
     const res = await fetch(`${provider.baseUrl}/models`, {
       headers: { Authorization: `Bearer ${key}` },
       signal: AbortSignal.timeout(8000),

package/src/oauth/login-cli.ts

@@ -1,6 +1,7 @@
 import * as readline from "node:readline";
 import { openUrl } from "../open-url";
-import { loadConfig, readPid, saveConfig } from "../config";
+import { loadConfig, saveConfig } from "../config";
+import { findLiveProxy, probeHostname } from "../proxy-liveness";
 import { OAUTH_PROVIDERS, runLogin } from "./index";
 import { KEY_LOGIN_PROVIDERS, isKeyLoginProvider, validateApiKey, type KeyLoginProvider } from "./key-providers";
 import type { OcxProviderConfig } from "../types";
@@ -14,10 +15,12 @@ export function runningProxyUpdateHeaders(): Headers {
 
 /** Push the new provider into a running proxy's live config so it routes without a restart. */
 async function notifyRunningProxy(name: string, provider: unknown): Promise<void> {
-  if (!readPid()) return;
-  const cfg = loadConfig();
+  // Identity-checked runtime-port lookup: reaches a fallback-port proxy and avoids
+  // posting credentials-adjacent config to whatever else answers on config.port.
+  const live = await findLiveProxy();
+  if (!live) return;
   try {
-    await fetch(`http://localhost:${cfg.port}/api/providers`, {
+    await fetch(`http://${probeHostname(live.hostname)}:${live.port}/api/providers`, {
       method: "POST",
       headers: runningProxyUpdateHeaders(),
       body: JSON.stringify({ name, provider }),

package/src/open-url.ts

@@ -17,5 +17,9 @@ export function openUrl(url: string): void {
   const args = process.platform === "win32"
     ? ["url.dll,FileProtocolHandler", url]
     : [url];
-  spawn(cmd, args, { detached: true, stdio: "ignore", shell: false }).unref();
+  const child = spawn(cmd, args, { detached: true, stdio: "ignore", shell: false });
+  // Headless hosts (no xdg-open) emit ENOENT as an async 'error' event; without a
+  // listener that is an uncaught exception that kills the whole proxy/login flow.
+  child.on("error", () => {});
+  child.unref();
 }

package/src/ports.ts

@@ -1,5 +1,18 @@
 import { createServer } from "node:net";
 
+/**
+ * True when an error means "this port/address is already bound" — the only bind failure
+ * that is safe to answer with a retry on another port. Bun/Node surface it as
+ * `code: "EADDRINUSE"` or an EADDRINUSE / "address in use" message depending on the API.
+ */
+export function isAddrInUse(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  const { code, message } = err as { code?: unknown; message?: unknown };
+  if (code === "EADDRINUSE") return true;
+  const text = typeof message === "string" ? message.toLowerCase() : "";
+  return text.includes("eaddrinuse") || text.includes("in use");
+}
+
 export async function isPortAvailable(port: number, hostname = "127.0.0.1"): Promise<boolean> {
   return await new Promise(resolve => {
     const server = createServer();

package/src/process-control.ts

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { loadConfig, readRuntimePort } from "./config";
 
 export function isProcessAlive(pid: number): boolean {
   try {
@@ -19,6 +20,81 @@ export function waitForExit(pid: number, timeoutMs: number): boolean {
   return !isProcessAlive(pid);
 }
 
+/** Injectable seams so the graceful-stop flow is unit-testable without a live proxy. */
+export interface GracefulStopIo {
+  fetchFn?: typeof fetch;
+  readRuntime?: (pid: number) => { port: number; hostname?: string } | null;
+  waitExit?: (pid: number, timeoutMs: number) => boolean;
+  env?: Record<string, string | undefined>;
+  exitTimeoutMs?: number;
+}
+
+/**
+ * Host to POST /api/stop against: follow the recorded bind hostname when it names a
+ * concrete address (a proxy bound to ::1 or a LAN IP is unreachable on 127.0.0.1);
+ * loopback aliases and wildcard binds all answer on IPv4 loopback.
+ */
+export function gracefulStopHost(hostname: string | undefined): string {
+  const trimmed = (hostname ?? "").trim();
+  const lower = trimmed.toLowerCase();
+  if (!trimmed || lower === "localhost" || trimmed === "127.0.0.1" || trimmed === "0.0.0.0" || trimmed === "::" || trimmed === "[::]") {
+    return "127.0.0.1";
+  }
+  if (lower === "::1" || lower === "[::1]") return "[::1]";
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed;
+  return trimmed.includes(":") ? `[${trimmed}]` : trimmed;
+}
+
+/**
+ * Ask a running proxy to stop itself via the management API (`POST /api/stop`), which
+ * drains in-flight turns, restores native Codex, and cleans its pid/runtime files.
+ * This is the only way to get a GRACEFUL stop on Windows, where the POSIX
+ * SIGTERM-then-SIGKILL ladder does not exist and `taskkill /F` gives the proxy no
+ * chance to run its shutdown handlers. Returns false when the proxy can't be reached
+ * or doesn't exit in time — callers fall back to {@link killProxy}.
+ */
+export async function stopProxyGracefully(pid: number, io: GracefulStopIo = {}): Promise<boolean> {
+  const readRuntime = io.readRuntime ?? readRuntimePort;
+  const runtime = readRuntime(pid);
+  if (!runtime?.port) return false;
+  const env = io.env ?? process.env;
+  const headers: Record<string, string> = {};
+  // Non-loopback binds require management auth; loopback ignores the extra header.
+  const token = env.OPENCODEX_API_AUTH_TOKEN?.trim();
+  if (token) headers["x-opencodex-api-key"] = token;
+  const fetchFn = io.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`http://${gracefulStopHost(runtime.hostname)}:${runtime.port}/api/stop`, {
+      method: "POST",
+      headers,
+      signal: AbortSignal.timeout(2000),
+    });
+    if (!res.ok) return false;
+  } catch {
+    return false;
+  }
+  const waitExit = io.waitExit ?? waitForExit;
+  // Honor the server's own drain window: /api/stop answers 200 first, then drains for
+  // config.shutdownTimeoutMs. Waiting less than that hard-kills mid-drain.
+  const exitTimeoutMs = io.exitTimeoutMs ?? drainDeadlineMs();
+  return waitExit(pid, exitTimeoutMs);
+}
+
+function drainDeadlineMs(): number {
+  try {
+    return (loadConfig().shutdownTimeoutMs ?? 5000) + 3000;
+  } catch {
+    return 8000;
+  }
+}
+
+/** Graceful-first stop: management-API drain, then the platform kill ladder. */
+export async function stopProxy(pid: number): Promise<void> {
+  if (!isProcessAlive(pid)) return;
+  if (await stopProxyGracefully(pid)) return;
+  killProxy(pid);
+}
+
 export function killProxy(pid: number): void {
   if (!isProcessAlive(pid)) return;
   if (process.platform === "win32") {

package/src/provider-label.ts

@@ -1,12 +1,17 @@
 import { CODEX_ACCOUNT_LOG_LABEL_RE } from "./codex-account-label";
 
+function canonicalUsageProviderLabel(provider: string): string {
+  return provider === "chatgpt" ? "openai" : provider;
+}
+
 export function baseProviderLabel(provider: string): string {
   const cut = provider.lastIndexOf("-");
-  if (cut <= 0) return provider;
+  if (cut <= 0) return canonicalUsageProviderLabel(provider);
   const suffix = provider.slice(cut + 1);
   // `-main` is the legacy log label for the main Codex account (MAIN_CODEX_ACCOUNT_ID). New entries
-  // log under the base provider name, but historical `<provider>-main` entries must still collapse so
-  // the usage table aggregates the main account into a single row instead of a stray split.
-  if (suffix === "main") return provider.slice(0, cut);
-  return CODEX_ACCOUNT_LOG_LABEL_RE.test(suffix) ? provider.slice(0, cut) : provider;
+  // log under the base provider name, but historical `<provider>-main` entries must still collapse.
+  // ChatGPT auth-pool and OpenAI passthrough are the same Codex/OpenAI usage surface, so display
+  // summaries normalize them to one `openai` row after recognized main/pool suffixes are removed.
+  if (suffix === "main") return canonicalUsageProviderLabel(provider.slice(0, cut));
+  return CODEX_ACCOUNT_LOG_LABEL_RE.test(suffix) ? canonicalUsageProviderLabel(provider.slice(0, cut)) : provider;
 }

package/src/providers/derive.ts

@@ -7,6 +7,7 @@ export interface DerivedKeyLoginProvider {
   adapter: string;
   dashboardUrl: string;
   models?: string[];
+  liveModels?: boolean;
   defaultModel?: string;
   contextWindow?: number;
   modelContextWindows?: Record<string, number>;
@@ -41,7 +42,7 @@ export interface DerivedProviderPreset {
   adapter: string;
   baseUrl: string;
   defaultModel?: string;
-  auth: "oauth" | "forward" | "key";
+  auth: "oauth" | "forward" | "key" | "local";
   oauthProvider?: string;
   dashboardUrl?: string;
   note?: string;
@@ -66,6 +67,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     authMode: entry.authKind === "local" ? undefined : entry.authKind,
     ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
     ...(entry.models ? { models: [...entry.models] } : {}),
+    ...(entry.liveModels !== undefined ? { liveModels: entry.liveModels } : {}),
     ...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
     ...(entry.modelContextWindows ? { modelContextWindows: { ...entry.modelContextWindows } } : {}),
     ...(entry.modelInputModalities ? { modelInputModalities: cloneRecordOfArrays(entry.modelInputModalities) } : {}),
@@ -98,6 +100,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       adapter: entry.adapter,
       dashboardUrl: entry.dashboardUrl,
       ...(entry.models ? { models: [...entry.models] } : {}),
+      ...(entry.liveModels !== undefined ? { liveModels: entry.liveModels } : {}),
       ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
       ...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
       ...(entry.modelContextWindows ? { modelContextWindows: { ...entry.modelContextWindows } } : {}),
@@ -149,11 +152,35 @@ export function deriveOAuthIds(): string[] {
 
 export function deriveProviderPresets(): DerivedProviderPreset[] {
   const presets = PROVIDER_REGISTRY
-    .filter(entry => entry.featured || entry.authKind === "key")
+    .filter(entry => entry.featured || entry.authKind === "key" || entry.dashboardPreset)
     .map(entryToPreset);
   return [...dedupePresets(presets), customPreset()];
 }
 
+export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig): void {
+  const entry = PROVIDER_REGISTRY.find(row => row.id === name);
+  if (!entry) return;
+  const seed = providerConfigSeed(entry);
+  if (!prov.defaultModel && seed.defaultModel) prov.defaultModel = seed.defaultModel;
+  if (!prov.models && seed.models) prov.models = [...seed.models];
+  if (prov.liveModels === undefined && seed.liveModels !== undefined) prov.liveModels = seed.liveModels;
+  if (prov.contextWindow === undefined && seed.contextWindow !== undefined) prov.contextWindow = seed.contextWindow;
+  if (!prov.modelContextWindows && seed.modelContextWindows) prov.modelContextWindows = { ...seed.modelContextWindows };
+  if (!prov.modelInputModalities && seed.modelInputModalities) prov.modelInputModalities = cloneRecordOfArrays(seed.modelInputModalities);
+  if (!prov.reasoningEfforts && seed.reasoningEfforts) prov.reasoningEfforts = [...seed.reasoningEfforts];
+  if (!prov.modelReasoningEfforts && seed.modelReasoningEfforts) prov.modelReasoningEfforts = cloneRecordOfArrays(seed.modelReasoningEfforts);
+  if (!prov.reasoningEffortMap && seed.reasoningEffortMap) prov.reasoningEffortMap = { ...seed.reasoningEffortMap };
+  if (!prov.modelReasoningEffortMap && seed.modelReasoningEffortMap) prov.modelReasoningEffortMap = cloneNestedRecord(seed.modelReasoningEffortMap);
+  if (!prov.noVisionModels && seed.noVisionModels) prov.noVisionModels = [...seed.noVisionModels];
+  if (!prov.noReasoningModels && seed.noReasoningModels) prov.noReasoningModels = [...seed.noReasoningModels];
+  if (!prov.noTemperatureModels && seed.noTemperatureModels) prov.noTemperatureModels = [...seed.noTemperatureModels];
+  if (!prov.noTopPModels && seed.noTopPModels) prov.noTopPModels = [...seed.noTopPModels];
+  if (!prov.noPenaltyModels && seed.noPenaltyModels) prov.noPenaltyModels = [...seed.noPenaltyModels];
+  if (!prov.autoToolChoiceOnlyModels && seed.autoToolChoiceOnlyModels) prov.autoToolChoiceOnlyModels = [...seed.autoToolChoiceOnlyModels];
+  if (!prov.preserveReasoningContentModels && seed.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...seed.preserveReasoningContentModels];
+  if (prov.escapeBuiltinToolNames === undefined && seed.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = seed.escapeBuiltinToolNames;
+}
+
 export function deriveFeaturedProviderIds(): string[] {
   return PROVIDER_REGISTRY.filter(entry => entry.featured).map(entry => entry.id);
 }
@@ -181,7 +208,7 @@ function entryToPreset(entry: ProviderRegistryEntry): DerivedProviderPreset {
     label: entry.label,
     adapter: entry.adapter,
     baseUrl: entry.baseUrl,
-    auth: entry.authKind === "forward" ? "forward" : entry.authKind === "oauth" ? "oauth" : "key",
+    auth: entry.authKind === "forward" ? "forward" : entry.authKind === "oauth" ? "oauth" : entry.authKind === "local" ? "local" : "key",
     ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
     ...(entry.authKind === "oauth" ? { oauthProvider: entry.oauthId ?? entry.id } : {}),
     ...(entry.dashboardUrl ? { dashboardUrl: entry.dashboardUrl } : {}),

package/src/providers/registry.ts

@@ -1,6 +1,13 @@
 import type { OcxProviderConfig } from "../types";
 import { KIRO_MODELS, KIRO_MODEL_CONTEXT_WINDOWS, KIRO_MODEL_REASONING_EFFORTS } from "./kiro-models";
 import { ANTIGRAVITY_MODELS, ANTIGRAVITY_MODEL_CONTEXT_WINDOWS } from "./antigravity-models";
+import {
+  CURSOR_STATIC_MODELS,
+  cursorModelContextWindows,
+  cursorModelIds,
+  cursorModelInputModalities,
+  cursorModelReasoningEfforts,
+} from "../adapters/cursor/discovery";
 
 export type ProviderAuthKind = "forward" | "oauth" | "key" | "local";
 export type MetadataModelIdNormalize = "case-insensitive";
@@ -12,10 +19,12 @@ export interface ProviderRegistryEntry {
   baseUrl: string;
   authKind: ProviderAuthKind;
   featured?: boolean;
+  dashboardPreset?: boolean;
   note?: string;
   dashboardUrl?: string;
   defaultModel?: string;
   models?: string[];
+  liveModels?: boolean;
   contextWindow?: number;
   modelContextWindows?: Record<string, number>;
   modelInputModalities?: Record<string, string[]>;
@@ -43,7 +52,7 @@ export interface ProviderRegistryEntry {
 export type ProviderConfigSeed = Pick<
   OcxProviderConfig,
   "adapter" | "baseUrl" | "authMode" | "defaultModel" | "models"
-  | "contextWindow" | "modelContextWindows" | "modelInputModalities"
+  | "liveModels" | "contextWindow" | "modelContextWindows" | "modelInputModalities"
   | "reasoningEfforts" | "modelReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
   | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "escapeBuiltinToolNames"
@@ -115,6 +124,22 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     featured: true,
     note: "Uses your codex login — no API key",
   },
+  {
+    id: "cursor",
+    label: "Cursor (experimental, live native exec)",
+    adapter: "cursor",
+    baseUrl: "https://api2.cursor.sh",
+    authKind: "oauth",
+    featured: false,
+    dashboardPreset: true,
+    note: "Experimental Cursor bridge. Live transport, live model discovery, and native read/write/delete/shell execution are enabled after a standalone PKCE browser login via 'ocx login cursor'.",
+    models: cursorModelIds(CURSOR_STATIC_MODELS),
+    liveModels: true,
+    defaultModel: "auto",
+    modelContextWindows: cursorModelContextWindows(CURSOR_STATIC_MODELS),
+    modelInputModalities: cursorModelInputModalities(CURSOR_STATIC_MODELS),
+    modelReasoningEfforts: cursorModelReasoningEfforts(CURSOR_STATIC_MODELS),
+  },
   {
     id: "xai",
     label: "xAI Grok",
@@ -355,3 +380,16 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
 export function getProviderRegistryEntry(id: string): ProviderRegistryEntry | undefined {
   return PROVIDER_REGISTRY.find(entry => entry.id === id);
 }
+
+/**
+ * Effective Google wire mode for a provider: config value, else registry backfill (a saved
+ * key-login config may omit `googleMode` — mirrors the router's backfill), else "ai-studio"
+ * (the Generative Language API default). Null for non-google adapters.
+ */
+export function effectiveGoogleMode(
+  providerId: string,
+  prov: { adapter?: string; googleMode?: "ai-studio" | "vertex" | "cloud-code-assist" },
+): "ai-studio" | "vertex" | "cloud-code-assist" | null {
+  if (prov.adapter !== "google") return null;
+  return prov.googleMode ?? getProviderRegistryEntry(providerId)?.googleMode ?? "ai-studio";
+}

package/src/proxy-liveness.ts

@@ -0,0 +1,122 @@
+/**
+ * Runtime-state-first proxy liveness with identity checking.
+ *
+ * Historically `ensure`/`start` probed only `config.port` and accepted ANY 2xx /healthz:
+ * a proxy that started on a fallback port was invisible (duplicate starts, Codex synced
+ * back to a dead port), and a foreign app answering 200 on the configured port counted
+ * as "our proxy". Liveness now (1) prefers the pid + runtime-port record and (2) requires
+ * the /healthz body to identify as opencodex.
+ *
+ * Lives outside cli.ts (which dispatches argv at module top level) so tests can import it.
+ */
+import { loadConfig, readPid, readRuntimePort } from "./config";
+
+export interface HealthzIdentity {
+  service?: unknown;
+  status?: unknown;
+  version?: unknown;
+  uptime?: unknown;
+  pid?: unknown;
+}
+
+export interface LivenessIo {
+  fetchFn?: typeof fetch;
+  readPidFn?: () => number | null;
+  readRuntimeFn?: (pid?: number) => { pid?: number; port: number; hostname?: string } | null;
+  configFn?: () => { port?: number; hostname?: string };
+  timeoutMs?: number;
+}
+
+export interface LiveProxy {
+  pid: number | null;
+  port: number;
+  /** Raw bind hostname the probe succeeded against; compose URLs via `probeHostname`. */
+  hostname?: string;
+}
+
+/**
+ * Host to probe for a given bind hostname: wildcards answer on IPv4 loopback, and raw
+ * IPv6 addresses must be bracketed or the composed URL is invalid.
+ */
+export function probeHostname(hostname: string | undefined): string {
+  const trimmed = (hostname ?? "").trim();
+  if (!trimmed || trimmed === "0.0.0.0" || trimmed === "::" || trimmed === "[::]") return "127.0.0.1";
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed;
+  return trimmed.includes(":") ? `[${trimmed}]` : trimmed;
+}
+
+/**
+ * True when a /healthz body identifies an opencodex proxy. Accepts the explicit
+ * `service: "opencodex"` marker, plus the legacy `{status, version, uptime}` trio so a
+ * still-running pre-identity proxy (e.g. right after `ocx update`) is not mistaken for a
+ * foreign server and shadow-started over.
+ */
+export function isOpencodexHealthz(body: HealthzIdentity | null): boolean {
+  if (!body) return false;
+  if (body.service === "opencodex") return true;
+  if (body.service !== undefined) return false;
+  return body.status === "ok" && typeof body.version === "string" && typeof body.uptime === "number";
+}
+
+/** Identity-checked /healthz probe; null when unreachable, non-OK, or not our proxy. */
+export async function proxyIdentityAt(
+  port: number,
+  opts: { hostname?: string; expectedPid?: number } = {},
+  io: LivenessIo = {},
+): Promise<{ pid: number | null } | null> {
+  const fetchFn = io.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`http://${probeHostname(opts.hostname)}:${port}/healthz`, {
+      signal: AbortSignal.timeout(io.timeoutMs ?? 750),
+    });
+    if (!res.ok) return null;
+    const body = (await res.json().catch(() => null)) as HealthzIdentity | null;
+    if (!isOpencodexHealthz(body)) return null;
+    const pid = typeof body?.pid === "number" ? body.pid : null;
+    if (opts.expectedPid !== undefined && pid !== null && pid !== opts.expectedPid) return null;
+    return { pid };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Locate the live proxy: pid file → runtime-port record → identity probe. Falls back to
+ * the configured port ONLY when no runtime record answers, so a fallback-port proxy is
+ * found and a foreign listener on the configured port is rejected.
+ */
+export async function findLiveProxy(io: LivenessIo = {}): Promise<LiveProxy | null> {
+  const readPidFn = io.readPidFn ?? readPid;
+  const readRuntimeFn = io.readRuntimeFn ?? readRuntimePort;
+  const configFn = io.configFn ?? loadConfig;
+
+  const pid = readPidFn();
+  let probedPort: number | null = null;
+  if (pid) {
+    const runtime = readRuntimeFn(pid);
+    if (runtime?.port) {
+      probedPort = runtime.port;
+      const identity = await proxyIdentityAt(runtime.port, { hostname: runtime.hostname, expectedPid: pid }, io);
+      if (identity) return { pid, port: runtime.port, hostname: runtime.hostname };
+    }
+  }
+
+  // Orphan recovery: the pid file can be lost/corrupt while the proxy is alive (crash of a
+  // sibling command, manual deletion). The runtime record still says where it listens —
+  // identity-probe it so ensure/update/stop see the live proxy instead of shadowing it.
+  const record = readRuntimeFn();
+  if (record?.port && record.port !== probedPort) {
+    const expectedPid = typeof record.pid === "number" ? record.pid : undefined;
+    const identity = await proxyIdentityAt(record.port, { hostname: record.hostname, expectedPid }, io);
+    // Only the healthz-reported pid is authoritative here. The record's pid may be stale
+    // (its process dead, the port reused by a pidless legacy proxy) — synthesizing it
+    // would hand destructive callers (stopProxy → kill fallback) a reusable pid.
+    if (identity) return { pid: identity.pid ?? null, port: record.port, hostname: record.hostname };
+  }
+
+  const config = configFn();
+  const port = config.port ?? 10100;
+  const identity = await proxyIdentityAt(port, { hostname: config.hostname }, io);
+  if (identity) return { pid: identity.pid ?? pid ?? null, port, hostname: config.hostname };
+  return null;
+}

package/src/responses/parser.ts

@@ -388,6 +388,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
   }
   const tc = mapToolChoice(data.tool_choice);
   if (tc !== undefined) options.toolChoice = tc;
+  if (data.parallel_tool_calls !== undefined) options.parallelToolCalls = data.parallel_tool_calls;
   if (data.reasoning?.effort && REASONING_EFFORTS.has(data.reasoning.effort)) {
     options.reasoning = data.reasoning.effort;
   }

package/src/responses/state.ts

@@ -0,0 +1,83 @@
+const MAX_STORED_RESPONSES = 1_000;
+const RESPONSE_TTL_MS = 60 * 60 * 1_000;
+
+interface StoredResponseState {
+  createdAt: number;
+  items: unknown[];
+  conversationId?: string;
+  cursorCheckpointUsable?: boolean;
+}
+
+const states = new Map<string, StoredResponseState>();
+
+function now(): number {
+  return Date.now();
+}
+
+function inputItems(input: unknown): unknown[] {
+  if (input === undefined) return [];
+  if (Array.isArray(input)) return input;
+  if (typeof input === "string") return [{ role: "user", content: input }];
+  return [input];
+}
+
+function pruneResponses(at = now()): void {
+  for (const [id, state] of states) {
+    if (at - state.createdAt > RESPONSE_TTL_MS) states.delete(id);
+  }
+  while (states.size > MAX_STORED_RESPONSES) {
+    const oldest = states.keys().next().value;
+    if (!oldest) break;
+    states.delete(oldest);
+  }
+}
+
+export function expandPreviousResponseInput(body: unknown): unknown {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return body;
+  const request = body as Record<string, unknown>;
+  const previousId = typeof request.previous_response_id === "string" ? request.previous_response_id : undefined;
+  if (!previousId) return body;
+  pruneResponses();
+  const previous = states.get(previousId);
+  if (!previous) return body;
+  return {
+    ...request,
+    input: [...previous.items, ...inputItems(request.input)],
+  };
+}
+
+export function previousResponseConversationId(responseId: string | undefined): string | undefined {
+  if (!responseId) return undefined;
+  pruneResponses();
+  return states.get(responseId)?.conversationId;
+}
+
+export function rememberResponseState(
+  requestBody: unknown,
+  response: { id?: unknown; output?: unknown; status?: unknown },
+  conversationId?: string,
+): void {
+  if (!requestBody || typeof requestBody !== "object" || Array.isArray(requestBody)) return;
+  const request = requestBody as Record<string, unknown>;
+  if (request.store === false) return;
+  if (typeof response.id !== "string" || !Array.isArray(response.output)) return;
+  if (response.status !== undefined && response.status !== "completed") return;
+  states.set(response.id, {
+    createdAt: now(),
+    items: [...inputItems(request.input), ...response.output],
+    // Always preserve the Cursor conversation id so the next tool-result turn can continue the SAME
+    // Cursor conversation (multi-turn continuation). Separately track whether Cursor's own
+    // checkpoint/cache is safe to reuse: a turn that ended with a pending client tool call produced an
+    // incomplete agent turn on the Cursor side (we suspended without a real mcpResult), so its
+    // checkpoint must not be reused — but the conversation id string itself is still valid.
+    ...(conversationId ? { conversationId } : {}),
+    cursorCheckpointUsable: !response.output.some(item => {
+      return !!item && typeof item === "object" && (item as { type?: unknown }).type === "function_call";
+    }),
+  });
+  pruneResponses();
+}
+
+export function clearResponseStateForTests(): void {
+  states.clear();
+}