@bitkyc08/opencodex 2.6.17 → 2.6.18

package/src/router.ts

@@ -8,17 +8,26 @@ interface RouteResult {
   modelId: string;
 }
 
-const MODEL_PROVIDER_PATTERNS: Record<string, string[]> = {
-  anthropic: [
+const MODEL_PROVIDER_PATTERNS: Array<{ providerNames: string[]; prefixes: string[] }> = [
+  {
+    providerNames: ["anthropic"],
+    prefixes: [
     "claude-", "claude-sonnet-", "claude-opus-", "claude-haiku-",
-  ],
-  chatgpt: [
+    ],
+  },
+  {
+    providerNames: ["openai", "chatgpt", "openai-apikey"],
+    prefixes: [
     "gpt-", "o1-", "o3-", "o4-",
-  ],
-  groq: [
+    ],
+  },
+  {
+    providerNames: ["groq"],
+    prefixes: [
     "llama-", "mixtral-", "gemma-",
-  ],
-};
+    ],
+  },
+];
 
 // Merge registry-default effort maps under user values so persisted built-in provider configs
 // that predate reasoningEffortMap/modelReasoningEffortMap still get correct wire translations
@@ -151,6 +160,9 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
     }
   }
 
+  const patternRoute = routeByKnownModelPattern(config, modelId);
+  if (patternRoute) return patternRoute;
+
   for (const [provName, prov] of activeProviderEntries(config)) {
     if (prov.models && Array.isArray(prov.models) && (prov.models as string[]).includes(modelId)) {
       return {
@@ -161,10 +173,24 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
     }
   }
 
-  for (const [patternKey, prefixes] of Object.entries(MODEL_PROVIDER_PATTERNS)) {
+  if (hasOwnProvider(config.providers, config.defaultProvider)) {
+    const defaultProv = config.providers[config.defaultProvider];
+    if (defaultProv.disabled === true) throw new Error(`Default provider is disabled: ${config.defaultProvider}`);
+    return {
+      providerName: config.defaultProvider,
+      provider: routedProviderConfig(config.defaultProvider, defaultProv),
+      modelId,
+    };
+  }
+
+  throw new Error(`No provider configured for model: ${modelId}`);
+}
+
+function routeByKnownModelPattern(config: OcxConfig, modelId: string): RouteResult | undefined {
+  for (const { providerNames, prefixes } of MODEL_PROVIDER_PATTERNS) {
     if (prefixes.some(prefix => modelId.startsWith(prefix))) {
-      const matchingProvider = activeProviderEntries(config).find(
-        ([name]) => name === patternKey || name.startsWith(patternKey)
+      const matchingProvider = Object.entries(config.providers).find(
+        ([name]) => providerNames.some(providerName => name === providerName || name.startsWith(`${providerName}-`))
       );
       if (matchingProvider) {
         const [provName, prov] = matchingProvider;
@@ -176,16 +202,5 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
       }
     }
   }
-
-  if (hasOwnProvider(config.providers, config.defaultProvider)) {
-    const defaultProv = config.providers[config.defaultProvider];
-    if (defaultProv.disabled === true) throw new Error(`Default provider is disabled: ${config.defaultProvider}`);
-    return {
-      providerName: config.defaultProvider,
-      provider: routedProviderConfig(config.defaultProvider, defaultProv),
-      modelId,
-    };
-  }
-
-  throw new Error(`No provider configured for model: ${modelId}`);
+  return undefined;
 }

package/src/server/adapter-resolve.ts

@@ -1,5 +1,6 @@
 import { createAnthropicAdapter } from "../adapters/anthropic";
 import { createAzureAdapter } from "../adapters/azure";
+import { createCursorAdapter } from "../adapters/cursor";
 import { createGoogleAdapter } from "../adapters/google";
 import { createKiroAdapter } from "../adapters/kiro";
 import { createOpenAIChatAdapter } from "../adapters/openai-chat";
@@ -37,6 +38,8 @@ export function resolveAdapter(providerConfig: OcxProviderConfig) {
     case "azure":
     case "azure-openai":
       return createAzureAdapter(providerConfig);
+    case "cursor":
+      return createCursorAdapter(providerConfig);
     default:
       throw new Error(`Unknown adapter: ${providerConfig.adapter}`);
   }

package/src/server.ts

@@ -15,6 +15,7 @@ import type { Server, ServerWebSocket } from "bun";
 import {
   DEFAULT_SUBAGENT_MODELS,
   codexAutoStartEnabled,
+  applyProxyEnv,
   getConfigPath,
   hasOwnProvider,
   isValidProviderName,
@@ -25,6 +26,7 @@ import {
   websocketsEnabled,
 } from "./config";
 import { parseRequest } from "./responses/parser";
+import { expandPreviousResponseInput, previousResponseConversationId, rememberResponseState } from "./responses/state";
 import { routeModel } from "./router";
 import { namespacedToolName } from "./types";
 import {
@@ -39,7 +41,8 @@ import { describeImagesInPlace, planVisionSidecar } from "./vision";
 import { removeCredential } from "./oauth/store";
 import { enrichProviderFromCatalog, listKeyLoginProviders } from "./oauth/key-providers";
 import { deriveProviderPresets } from "./providers/derive";
-import type { AdapterEvent, OcxConfig, OcxProviderConfig } from "./types";
+import { createAdapterEventQueue } from "./adapters/run-turn-queue";
+import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig } from "./types";
 import type { OcxUsage } from "./types";
 import { DEFAULT_PROVIDER_CONTEXT_CAP, globalContextCapValue, providerContextCap, providerContextCaps, setAllProviderContextCaps, setGlobalContextCapValue, setProviderContextCap } from "./provider-context-cap";
 import {
@@ -190,6 +193,22 @@ const VERSION = (() => {
 
 // Adapter resolution + wire-protocol override extracted to ./server/adapter-resolve.
 
+function buildToolBridgeMaps(parsed: OcxParsedRequest): {
+  toolNsMap: Map<string, { namespace: string; name: string }>;
+  freeformToolNames: Set<string>;
+  toolSearchToolNames: Set<string>;
+} {
+  const toolNsMap = new Map<string, { namespace: string; name: string }>();
+  const freeformToolNames = new Set<string>();
+  const toolSearchToolNames = new Set<string>();
+  for (const t of parsed.context.tools ?? []) {
+    if (t.namespace) toolNsMap.set(namespacedToolName(t.namespace, t.name), { namespace: t.namespace, name: t.name });
+    if (t.freeform) freeformToolNames.add(t.name);
+    if (t.toolSearch) toolSearchToolNames.add(t.name);
+  }
+  return { toolNsMap, freeformToolNames, toolSearchToolNames };
+}
+
 function sidecarOutcomeRecorder(config: OcxConfig, authCtx: CodexAuthContext): ((outcome: CodexUpstreamOutcome) => void) | undefined {
   return authCtx.kind === "pool" || authCtx.kind === "main-pool"
     ? outcome => recordCodexUpstreamOutcome(config, authCtx.accountId, outcome)
@@ -239,10 +258,12 @@ async function handleResponses(
   } catch {
     return formatErrorResponse(400, "invalid_request_error", "Invalid JSON body");
   }
+  body = expandPreviousResponseInput(body);
 
   let parsed;
   try {
     parsed = parseRequest(body);
+    parsed._cursorConversationId = previousResponseConversationId(parsed.previousResponseId);
   } catch (err) {
     return formatErrorResponse(400, "invalid_request_error", err instanceof Error ? err.message : String(err));
   }
@@ -455,6 +476,62 @@ async function handleResponses(
     });
   }
 
+  if (adapter.runTurn) {
+    const runTurnAbort = new AbortController();
+    linkAbortSignal(runTurnAbort, options.abortSignal);
+    const queue = createAdapterEventQueue();
+    const runTurn = async (): Promise<void> => {
+      try {
+        await adapter.runTurn?.(
+          parsed,
+          { headers: selectedForwardHeaders, abortSignal: runTurnAbort.signal },
+          queue.push,
+        );
+      } catch (err) {
+        queue.push({
+          type: "error",
+          message: err instanceof Error ? err.message : String(err),
+        });
+      } finally {
+        queue.close();
+      }
+    };
+
+    const { toolNsMap, freeformToolNames, toolSearchToolNames } = buildToolBridgeMaps(parsed);
+    if (parsed.stream) {
+      void runTurn();
+      const sseStream = bridgeToResponsesSSE(
+        queue.stream(), parsed.modelId, toolNsMap, freeformToolNames, toolSearchToolNames,
+        () => {
+          runTurnAbort.abort();
+          queue.close();
+        }, 2_000,
+        {
+          ...(options.forceEmptyResponseId ? { responseId: "" } : {}),
+          stallTimeoutSec: config.stallTimeoutSec,
+          hideThinkingSummary: parsed.options.hideThinkingSummary,
+          onCompletedResponse: response => rememberResponseState(parsed._rawBody, response, parsed._cursorConversationId),
+        },
+      );
+      const bridgeTurnAc = new AbortController();
+      const trackedSse = trackStreamLifetime(sseStream, bridgeTurnAc);
+      return new Response(trackedSse, {
+        headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" },
+      });
+    }
+
+    await runTurn();
+    const events = await queue.collect();
+    const json = buildResponseJSON(events, parsed.modelId, {
+      hideThinkingSummary: parsed.options.hideThinkingSummary,
+      toolNsMap,
+      freeformToolNames,
+      toolSearchToolNames,
+    });
+    rememberResponseState(parsed._rawBody, json, parsed._cursorConversationId);
+    return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } });
+  }
+
   // Web-search sidecar: Codex enabled web_search but this is a routed (non-OpenAI) model that can't
   // run it server-side. Expose web_search as a function tool and run searches via the gpt-mini sidecar
   // through the ChatGPT passthrough, looping until the model answers. Otherwise take the normal path.
@@ -506,14 +583,7 @@ async function handleResponses(
 
   if (parsed.stream) {
     const eventStream = adapter.parseStream(upstreamResponse);
-    const toolNsMap = new Map<string, { namespace: string; name: string }>();
-    const freeformToolNames = new Set<string>();
-    const toolSearchToolNames = new Set<string>();
-    for (const t of parsed.context.tools ?? []) {
-      if (t.namespace) toolNsMap.set(namespacedToolName(t.namespace, t.name), { namespace: t.namespace, name: t.name });
-      if (t.freeform) freeformToolNames.add(t.name);
-      if (t.toolSearch) toolSearchToolNames.add(t.name);
-    }
+    const { toolNsMap, freeformToolNames, toolSearchToolNames } = buildToolBridgeMaps(parsed);
     const sseStream = bridgeToResponsesSSE(
       eventStream, parsed.modelId, toolNsMap, freeformToolNames, toolSearchToolNames,
       () => upstream.abort(), 2_000,
@@ -521,6 +591,7 @@ async function handleResponses(
         ...(options.forceEmptyResponseId ? { responseId: "" } : {}),
         stallTimeoutSec: config.stallTimeoutSec,
         hideThinkingSummary: parsed.options.hideThinkingSummary,
+        onCompletedResponse: response => rememberResponseState(parsed._rawBody, response, parsed._cursorConversationId),
       },
     );
     const bridgeTurnAc = new AbortController();
@@ -537,20 +608,14 @@ async function handleResponses(
     } finally {
       cleanupUpstreamAbort();
     }
-    const toolNsMap = new Map<string, { namespace: string; name: string }>();
-    const freeformToolNames = new Set<string>();
-    const toolSearchToolNames = new Set<string>();
-    for (const t of parsed.context.tools ?? []) {
-      if (t.namespace) toolNsMap.set(namespacedToolName(t.namespace, t.name), { namespace: t.namespace, name: t.name });
-      if (t.freeform) freeformToolNames.add(t.name);
-      if (t.toolSearch) toolSearchToolNames.add(t.name);
-    }
+    const { toolNsMap, freeformToolNames, toolSearchToolNames } = buildToolBridgeMaps(parsed);
     const json = buildResponseJSON(events, parsed.modelId, {
       hideThinkingSummary: parsed.options.hideThinkingSummary,
       toolNsMap,
       freeformToolNames,
       toolSearchToolNames,
     });
+    rememberResponseState(parsed._rawBody, json, parsed._cursorConversationId);
     return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } });
   }
 
@@ -1542,6 +1607,51 @@ async function handleManagementAPI(req: Request, url: URL, config: OcxConfig): P
     return jsonResponse({ ok: true, codexAutoStart: codexAutoStartEnabled(config) });
   }
 
+  if (url.pathname === "/api/sync" && req.method === "POST") {
+    const { syncModelsToCodex } = await import("./codex-sync");
+    const result = await syncModelsToCodex(undefined, config, null);
+    return jsonResponse({
+      ...result,
+      staleAppServerHint: "If Codex App still shows an older model list, restart its long-lived app-server process after sync.",
+    }, result.ok ? 200 : 500);
+  }
+
+  if (url.pathname === "/api/update/check" && req.method === "GET") {
+    const { checkForUpdate, normalizeUpdateChannel } = await import("./update-job");
+    const rawTag = url.searchParams.get("tag");
+    if (rawTag && rawTag !== "latest" && rawTag !== "preview") {
+      return jsonResponse({ error: "tag must be latest or preview" }, 400);
+    }
+    return jsonResponse(checkForUpdate(normalizeUpdateChannel(rawTag)));
+  }
+
+  if (url.pathname === "/api/update/run" && req.method === "POST") {
+    const { normalizeUpdateChannel, startUpdateJob, UpdateJobError } = await import("./update-job");
+    let body: { tag?: unknown; restart?: unknown };
+    try { body = await req.json(); } catch { return jsonResponse({ error: "invalid JSON body" }, 400); }
+    if (body.tag !== undefined && body.tag !== "latest" && body.tag !== "preview") {
+      return jsonResponse({ error: "tag must be latest or preview" }, 400);
+    }
+    if (body.restart !== undefined && typeof body.restart !== "boolean") {
+      return jsonResponse({ error: "restart boolean is required" }, 400);
+    }
+    try {
+      return jsonResponse({ ok: true, job: startUpdateJob(normalizeUpdateChannel(body.tag as string | undefined), body.restart !== false) });
+    } catch (err) {
+      if (err instanceof UpdateJobError) {
+        return jsonResponse({ error: err.message, code: err.code }, err.status);
+      }
+      return jsonResponse({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  }
+
+  if (url.pathname === "/api/update/status" && req.method === "GET") {
+    const { readUpdateJob } = await import("./update-job");
+    const job = readUpdateJob(url.searchParams.get("jobId"));
+    if (!job) return jsonResponse({ error: "update job not found" }, 404);
+    return jsonResponse({ ok: true, job });
+  }
+
   if (url.pathname === "/api/sidecar-settings" && req.method === "GET") {
     const ws = config.webSearchSidecar ?? {};
     const vs = config.visionSidecar ?? {};
@@ -1869,6 +1979,7 @@ async function fetchAllModels(config: OcxConfig): Promise<CatalogModel[]> {
 
 export function startServer(port?: number) {
   const config = loadConfig();
+  applyProxyEnv(config);
   assertServerAuthConfig(config);
   // Refresh OAuth provider presets (models/noReasoningModels) from the registry so a proxy update
   // adding/dropping models reaches existing configs on start — not just fresh installs.
@@ -1942,7 +2053,8 @@ export function startServer(port?: number) {
       }
 
       if (url.pathname === "/healthz" && req.method === "GET") {
-        return jsonResponse({ status: "ok", version: VERSION, uptime: process.uptime() }, 200, req, config);
+        // service/pid/port let CLI liveness reject foreign 200s and verify pid identity.
+        return jsonResponse({ status: "ok", service: "opencodex", version: VERSION, uptime: process.uptime(), pid: process.pid, port: listenPort }, 200, req, config);
       }
 
       if (url.pathname.startsWith("/api/")) {

package/src/service.ts

@@ -9,12 +9,13 @@ import { execFileSync, execSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { getConfigDir, readPid, removePid } from "./config";
+import { expandUserPath, getConfigDir, readPid, removePid, removeRuntimePort } from "./config";
 import { loadConfig } from "./config";
 import { restoreNativeCodex } from "./codex-inject";
 import { durableBunPath, durableBunRuntime } from "./bun-runtime";
-import { isProcessAlive, killProxy } from "./process-control";
+import { isProcessAlive, stopProxy } from "./process-control";
 import { serviceApiTokenFilePath } from "./service-secrets";
+import { windowsEnvIndirectBatchPathList, windowsEnvIndirectBatchValue } from "./win-paths";
 
 const LABEL = "com.opencodex.proxy";
 const TASK = "opencodex-proxy";
@@ -62,11 +63,15 @@ function serviceStatePaths(): string[] {
 }
 
 function currentCodexHome(): string {
-  return resolve(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
+  const raw = process.env.CODEX_HOME?.trim();
+  return raw ? resolve(expandUserPath(raw)) : join(homedir(), ".codex");
 }
 
 function currentOpenCodexHome(): string {
-  return resolve(process.env.OPENCODEX_HOME?.trim() || getConfigDir());
+  // getConfigDir() already resolves OPENCODEX_HOME with ~ expansion; keep the
+  // install-state comparison on the same normalization or `~/...` values falsely
+  // fail the environment-match check depending on cwd.
+  return getConfigDir();
 }
 
 function normalizePathForCompare(path: string): string {
@@ -78,13 +83,19 @@ interface ServiceInstallState {
   version: 1;
   codexHome: string;
   opencodexHome: string;
+  /** Baked at install; lets status flag paths gone stale after npm prefix/nvm moves. */
+  bunPath?: string;
+  cliPath?: string;
 }
 
 function writeServiceInstallState(): void {
+  const { bun, cli } = cliEntry();
   const state: ServiceInstallState = {
     version: 1,
     codexHome: currentCodexHome(),
     opencodexHome: currentOpenCodexHome(),
+    bunPath: bun,
+    cliPath: cli,
   };
   for (const path of serviceStatePaths()) {
     const dir = dirname(path);
@@ -252,9 +263,15 @@ function windowsBatchValue(value: string): string {
     .replace(/[\r\n]/g, "");
 }
 
-function windowsBatchSet(name: string, value: string | undefined): string | null {
+type WindowsBatchValueKind = "raw" | "path" | "pathList";
+
+function windowsBatchSet(name: string, value: string | undefined, kind: WindowsBatchValueKind = "raw"): string | null {
   if (!value) return null;
-  return `set "${name}=${windowsBatchValue(value)}"`;
+  const rendered =
+    kind === "path" ? windowsEnvIndirectBatchValue(value, windowsBatchValue)
+    : kind === "pathList" ? windowsEnvIndirectBatchPathList(value, windowsBatchValue)
+    : windowsBatchValue(value);
+  return `set "${name}=${rendered}"`;
 }
 
 function taskXmlString(value: string): string {
@@ -273,14 +290,17 @@ export function buildWindowsServiceScript(entry = cliEntry()): string {
   const lines = [
     "@echo off",
     "setlocal",
+    // The wrapper runs in its own hidden console, so switching that console to UTF-8 is
+    // safe (no leak into user shells) and lets cmd parse any UTF-8 remnants correctly.
+    "chcp 65001 >nul",
     windowsBatchSet("OCX_SERVICE", "1"),
-    windowsBatchSet("PATH", path),
-    windowsBatchSet("CODEX_HOME", process.env.CODEX_HOME?.trim()),
-    windowsBatchSet("OPENCODEX_HOME", process.env.OPENCODEX_HOME?.trim()),
-    windowsBatchSet("OCX_API_TOKEN_FILE", serviceApiTokenFilePath()),
-    windowsBatchSet("OCX_SERVICE_LOG", serviceLogPath()),
-    windowsBatchSet("OCX_BUN", bun),
-    windowsBatchSet("OCX_CLI", cli),
+    windowsBatchSet("PATH", path, "pathList"),
+    windowsBatchSet("CODEX_HOME", process.env.CODEX_HOME?.trim(), "path"),
+    windowsBatchSet("OPENCODEX_HOME", process.env.OPENCODEX_HOME?.trim(), "path"),
+    windowsBatchSet("OCX_API_TOKEN_FILE", serviceApiTokenFilePath(), "path"),
+    windowsBatchSet("OCX_SERVICE_LOG", serviceLogPath(), "path"),
+    windowsBatchSet("OCX_BUN", bun, "path"),
+    windowsBatchSet("OCX_CLI", cli, "path"),
     'if exist "%OCX_API_TOKEN_FILE%" (',
     '  set /p OPENCODEX_API_AUTH_TOKEN=<"%OCX_API_TOKEN_FILE%"',
     ")",
@@ -295,7 +315,9 @@ export function buildWindowsServiceScript(entry = cliEntry()): string {
     '"%OCX_BUN%" "%OCX_CLI%" start >>"%OCX_SERVICE_LOG%" 2>&1',
     "if %ERRORLEVEL% NEQ 0 (",
     '  >>"%OCX_SERVICE_LOG%" echo [%DATE% %TIME%] child exited with code %ERRORLEVEL%; restarting in 5s',
-    "  timeout /t 5 /nobreak >nul",
+    // `timeout` needs console stdin and dies with "Input redirection is not supported"
+    // under Task Scheduler, turning the 5s cooldown into a hot restart loop; ping doesn't.
+    "  ping -n 6 127.0.0.1 >nul",
     "  goto loop",
     ")",
     "endlocal",
@@ -374,13 +396,32 @@ function uninstallLaunchd(): void {
 }
 
 // ── Windows (Task Scheduler) ──
+/**
+ * In-place service-asset write that tolerates the transient EBUSY/EPERM/EACCES Windows
+ * throws while the just-ended task's cmd.exe (or an AV scanner) still holds the file.
+ */
+function writeServiceAssetWithRetry(path: string, content: string, encoding: "utf8" | "utf16le"): void {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      writeFileSync(path, content, encoding);
+      return;
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (attempt >= 2 || (code !== "EBUSY" && code !== "EPERM" && code !== "EACCES")) throw err;
+      Bun.sleepSync(150);
+    }
+  }
+}
+
 function installWindows(): void {
   if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true });
   writeServiceApiTokenFile();
-  const script = windowsServiceScriptPath();
-  writeFileSync(script, buildWindowsServiceScript(), "utf8");
-  writeFileSync(windowsTaskXmlPath(), `\uFEFF${buildWindowsTaskXml(script)}`, "utf16le");
+  // End a running task BEFORE rewriting the assets it is executing — cmd.exe reading the
+  // script mid-rewrite runs a torn batch file, and its open handle can fail the write.
   try { stopWindows(); } catch { /* not running */ }
+  const script = windowsServiceScriptPath();
+  writeServiceAssetWithRetry(script, buildWindowsServiceScript(), "utf8");
+  writeServiceAssetWithRetry(windowsTaskXmlPath(), `\uFEFF${buildWindowsTaskXml(script)}`, "utf16le");
   schtasks(buildWindowsSchtasksCreateArgs(script));
   schtasks(["/run", "/tn", TASK]);
   writeServiceInstallState();
@@ -394,8 +435,22 @@ function uninstallWindows(): void {
   if (existsSync(windowsTaskXmlPath())) unlinkSync(windowsTaskXmlPath());
 }
 
+/**
+ * Warn when the paths baked into installed service assets no longer exist (npm prefix
+ * moved, nvm switch, reinstall) — the service manager would restart-loop on a dead path
+ * while `schtasks`/`launchctl` still report "installed".
+ */
+export function bakedServicePathsDiagnostic(): string | null {
+  const state = readServiceInstallState();
+  if (!state?.bunPath || !state?.cliPath) return null;
+  const missing = [state.bunPath, state.cliPath].filter(path => !existsSync(path));
+  if (missing.length === 0) return null;
+  return `STALE baked paths (missing: ${missing.join(", ")}) — run 'ocx service install' to re-bake`;
+}
+
 function serviceDiagnosticsSummary(): string {
-  return `logs: ${serviceLogPath()}`;
+  const stale = bakedServicePathsDiagnostic();
+  return stale ? `${stale}; logs: ${serviceLogPath()}` : `logs: ${serviceLogPath()}`;
 }
 
 // ── Linux (systemd user unit) ──
@@ -489,21 +544,23 @@ function platformOps(): ServiceOps | null {
 
 type TrackedProxyCleanupResult = "none" | "stale" | "stopped";
 
-function stopTrackedProxyIfRunning(): TrackedProxyCleanupResult {
+async function stopTrackedProxyIfRunning(): Promise<TrackedProxyCleanupResult> {
   const pid = readPid();
   if (!pid) return "none";
   if (!isProcessAlive(pid)) {
     removePid(pid);
+    removeRuntimePort(pid);
     return "stale";
   }
-  killProxy(pid);
+  await stopProxy(pid);
   removePid(pid);
+  removeRuntimePort(pid);
   return "stopped";
 }
 
-function stopTrackedProxyForServiceCommand(): TrackedProxyCleanupResult {
+async function stopTrackedProxyForServiceCommand(): Promise<TrackedProxyCleanupResult> {
   try {
-    return stopTrackedProxyIfRunning();
+    return await stopTrackedProxyIfRunning();
   } catch (err) {
     console.error(`⚠️  Failed to stop proxy: ${err instanceof Error ? err.message : String(err)}`);
     return "none";
@@ -531,6 +588,13 @@ export function stopServiceIfInstalled(): boolean {
   return false;
 }
 
+/** Delete install-state files; stale state would make `ocx update` "reinstall" a service that no longer exists. */
+function removeServiceInstallState(): void {
+  for (const path of serviceStatePaths()) {
+    try { if (existsSync(path)) unlinkSync(path); } catch { /* best-effort */ }
+  }
+}
+
 /**
  * Best-effort service removal for full uninstall. Unlike `ocx service uninstall`, this is quiet
  * when no service exists and never exits the process just because the platform has no service
@@ -540,16 +604,16 @@ export function uninstallServiceIfInstalled(): boolean {
   assertServiceEnvironmentMatchesInstall();
   if (process.platform === "darwin") {
     if (existsSync(plistPath())) {
-      try { uninstallLaunchd(); return true; } catch { return false; }
+      try { uninstallLaunchd(); removeServiceInstallState(); return true; } catch { return false; }
     }
   } else if (process.platform === "win32") {
     try {
       const q = schtasks(["/query", "/tn", TASK]);
-      if (q.includes(TASK)) { uninstallWindows(); return true; }
+      if (q.includes(TASK)) { uninstallWindows(); removeServiceInstallState(); return true; }
     } catch { /* task not found */ }
   } else if (process.platform === "linux" && existsSync(unitPath())) {
-    try { uninstallSystemd(); return true; } catch {
-      try { unlinkSync(unitPath()); return true; } catch { return false; }
+    try { uninstallSystemd(); removeServiceInstallState(); return true; } catch {
+      try { unlinkSync(unitPath()); removeServiceInstallState(); return true; } catch { return false; }
     }
   }
   return false;
@@ -581,7 +645,7 @@ export function serviceStatusSummary(): string {
   return `unsupported on ${process.platform}`;
 }
 
-export function serviceCommand(sub?: string): void {
+export async function serviceCommand(sub?: string): Promise<void> {
   const ops = platformOps();
   if (!ops) {
     console.error("ocx service supports macOS (launchd), Windows (Task Scheduler), and Linux (systemd).");
@@ -602,7 +666,7 @@ export function serviceCommand(sub?: string): void {
     case "stop":
       assertServiceEnvironmentMatchesInstall();
       ops.stop();
-      stopTrackedProxyForServiceCommand();
+      await stopTrackedProxyForServiceCommand();
       restoreNativeCodex();
       console.log("✅ service stopped + native Codex restored.");
       break;
@@ -616,12 +680,10 @@ export function serviceCommand(sub?: string): void {
     case "remove":
       assertServiceEnvironmentMatchesInstall();
       ops.stop();
-      stopTrackedProxyForServiceCommand();
+      await stopTrackedProxyForServiceCommand();
       ops.uninstall();
       restoreNativeCodex();
-      for (const path of serviceStatePaths()) {
-        try { if (existsSync(path)) unlinkSync(path); } catch { /* best-effort */ }
-      }
+      removeServiceInstallState();
       try { if (existsSync(serviceApiTokenFilePath())) unlinkSync(serviceApiTokenFilePath()); } catch { /* best-effort */ }
       console.log("✅ service uninstalled + native Codex restored.");
       break;

package/src/types.ts

@@ -5,6 +5,8 @@ export interface OcxParsedRequest {
   stream: boolean;
   options: OcxRequestOptions;
   _rawBody?: unknown;
+  /** Provider-private stable Cursor conversation id resolved from the Responses previous_response_id chain. */
+  _cursorConversationId?: string;
   /**
    * 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
@@ -166,6 +168,7 @@ export interface OcxRequestOptions {
   topP?: number;
   stopSequences?: string[];
   toolChoice?: OcxToolChoice;
+  parallelToolCalls?: boolean;
   reasoning?: string;
   hideThinkingSummary?: boolean;
   serviceTier?: string;
@@ -192,7 +195,9 @@ export type AdapterEvent =
   | { 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 }
-  | { type: "error"; message: string };
+  // `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 };
 
 /**
  * A web source backing a search answer. Surfaced on the search-end event and rendered by the bridge
@@ -232,6 +237,12 @@ export interface OcxConfig {
   contextCapValue?: number;
   /** Bind hostname. Default "127.0.0.1" (loopback only). Set "0.0.0.0" to expose on all interfaces. */
   hostname?: string;
+  /**
+   * Outbound HTTP(S) proxy URL for provider requests (e.g. "http://user:pass@proxy:8080", or
+   * "${HTTPS_PROXY}"-style env reference). Mirrored into HTTP_PROXY/HTTPS_PROXY at startup when
+   * those are unset — Bun's fetch honors them for all outbound calls; localhost is excluded.
+   */
+  proxy?: string;
   /** Upstream stall timeout (seconds). After this many seconds of no upstream data, emits response.incomplete. Default 90. Min 1. */
   stallTimeoutSec?: number;
   /** Connect timeout (ms) for upstream fetch — covers DNS, TCP, TLS, and response header. Default 30000. */
@@ -359,6 +370,18 @@ export interface OcxProviderConfig {
   project?: string;
   /** Vertex AI location, e.g. "us-central1" or "global" (or GOOGLE_CLOUD_LOCATION env). */
   location?: string;
+  /**
+   * Cursor adapter only: MCP servers opencodex starts/connects and exposes to the Cursor agent
+   * as callable tools. Each entry is spawned (stdio `command`) or connected (`url`) lazily per
+   * stream; their tools are advertised to the Cursor server and executed against the live server.
+   */
+  mcpServers?: Record<string, import("./adapters/cursor/mcp-config").CursorMcpServerConfig>;
+  /**
+   * Cursor adapter only: opt-in external executor for computer-use / record-screen. opencodex is
+   * headless and cannot control a screen itself; provide commands here only when running on a host
+   * that can. With no executor, these tools honestly report "not supported".
+   */
+  desktopExecutor?: import("./adapters/cursor/native-exec-desktop").DesktopExecutorConfig;
 }
 
 export interface CodexAccount {