@bitkyc08/opencodex 2.24.2 → 2.25.0

package/src/responses/truncated-stop-reason.ts

@@ -0,0 +1,60 @@
+/**
+ * Whether a `done` event's `stopReason` means the turn was cut short rather than finishing, and
+ * which Responses `incomplete_details.reason` it maps to.
+ *
+ * `stopReason` is an open-ended string and adapters do not agree on a vocabulary: openai-chat and
+ * google normalize to `max_tokens`/`content_filter`, Command Code forwards the raw provider or AI
+ * SDK value (`length`, `content-filter`, `error`), and Anthropic forwards `stop_reason` verbatim
+ * (`refusal`, `model_context_window_exceeded`, ...). A guard that matched only the two canonical
+ * strings let those turns read as completed — and, on a compaction turn, install a half-written
+ * summary as replacement history (#422).
+ *
+ * Classifying here keeps that decision independent of which adapter produced the event, and keeps
+ * suppression and terminal status in agreement: a turn whose compaction item is withheld must not
+ * also report success, or codex-rs receives a completed response with zero compaction items and
+ * fatals.
+ *
+ * Unknown reasons are deliberately NOT truncated. This must never turn a healthy turn into a
+ * failure, and an unrecognized value is far more likely an ordinary stop.
+ */
+type TruncationKind = "max_output_tokens" | "content_filter";
+
+const TRUNCATED_STOP_REASONS = new Map<string, TruncationKind>([
+  // canonical (openai-chat, google)
+  ["max_tokens", "max_output_tokens"],
+  ["content_filter", "content_filter"],
+  // raw OpenAI / Command Code (AI SDK) finish reasons
+  ["length", "max_output_tokens"],
+  ["content-filter", "content_filter"],
+  // raw Anthropic stop reasons
+  ["max_output_tokens", "max_output_tokens"],
+  ["model_context_window_exceeded", "max_output_tokens"],
+  ["refusal", "content_filter"],
+  // Anthropic documents `pause_turn` as a long-running turn that the client is expected to
+  // CONTINUE. Whatever was produced so far is by definition unfinished, so it must not be
+  // installed as replacement history.
+  ["pause_turn", "max_output_tokens"],
+  // raw Gemini / Vertex finish reasons
+  ["malformed_function_call", "content_filter"],
+  ["malformed_response", "content_filter"],
+  ["unexpected_tool_call", "content_filter"],
+  ["safety", "content_filter"],
+  ["recitation", "content_filter"],
+  ["blocklist", "content_filter"],
+  ["prohibited_content", "content_filter"],
+  ["spii", "content_filter"],
+  ["image_safety", "content_filter"],
+  ["language", "content_filter"],
+  // Kiro
+  ["model_context_window_exceeded_exception", "max_output_tokens"],
+]);
+
+/** The `incomplete_details.reason` a truncated stop maps to, or undefined for a normal stop. */
+export function truncationReasonFor(stopReason: string | undefined): TruncationKind | undefined {
+  if (stopReason === undefined) return undefined;
+  return TRUNCATED_STOP_REASONS.get(stopReason.trim().toLowerCase());
+}
+
+export function isTruncatedStopReason(stopReason: string | undefined): boolean {
+  return truncationReasonFor(stopReason) !== undefined;
+}

package/src/router.ts

@@ -12,7 +12,7 @@ import { hasOwnProvider, resolveEnvValue } from "./config";
 import { assertProviderDestinationAllowed } from "./lib/destination-policy";
 import { redactSecretString, redactUrlForLog } from "./lib/redact";
 import { PROVIDER_REGISTRY, providerCodexAccountMode } from "./providers/registry";
-import { applyDirectReasoningEffortContracts } from "./providers/derive";
+import { applyDirectReasoningEffortContracts, hasLegacyClinePassReasoningEfforts } from "./providers/derive";
 import {
   providerMatchesRegistryTransportWithStaticGuards,
   providerSupportsLiveModelDiscovery,
@@ -286,14 +286,6 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
   const modelReasoningEffortMap = mergeNestedRecord(registryEntry.modelReasoningEffortMap, provider.modelReasoningEffortMap);
   const modelReasoningEfforts = mergeStringArrayRecord(registryEntry.modelReasoningEfforts, provider.modelReasoningEfforts);
   const modelDefaultReasoningEfforts = mergeRecordFill(registryEntry.modelDefaultReasoningEfforts, provider.modelDefaultReasoningEfforts);
-  // Key-login used to persist this exact low-only ClinePass capability seed. Once the gateway's
-  // wider input ladder was live-verified, leaving that generated row untouched would keep old
-  // installs clamped forever. This branch is reached only after canonical transport matching, so
-  // same-named custom destinations and every other explicit ladder still retain user precedence.
-  const repairLegacyClinePassReasoningEfforts = providerName === "cline-pass"
-    && provider.reasoningWireFormat === "gateway-object"
-    && provider.reasoningEfforts?.length === 1
-    && provider.reasoningEfforts[0] === "low";
   const modelContextWindows = providerName === OPENAI_API_PROVIDER_ID
     ? mergePositiveNumberCaps(registryEntry.modelContextWindows, provider.modelContextWindows)
     : mergeRecordFill(registryEntry.modelContextWindows, provider.modelContextWindows);
@@ -374,7 +366,7 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
     ...(provider.project === undefined && registryEntry.project !== undefined ? { project: registryEntry.project } : {}),
     ...(provider.location === undefined && registryEntry.location !== undefined ? { location: registryEntry.location } : {}),
     ...(provider.contextWindow === undefined && registryEntry.contextWindow !== undefined ? { contextWindow: registryEntry.contextWindow } : {}),
-    ...((provider.reasoningEfforts === undefined || repairLegacyClinePassReasoningEfforts)
+    ...((provider.reasoningEfforts === undefined || hasLegacyClinePassReasoningEfforts(providerName, provider))
       && registryEntry.reasoningEfforts !== undefined
       ? { reasoningEfforts: [...registryEntry.reasoningEfforts] }
       : {}),

package/src/server/management/provider-routes.ts

@@ -33,6 +33,7 @@ import { replaceProviderAccountSet } from "../../oauth/store";
 import { providerDestinationResolvedError } from "../../lib/destination-policy";
 import { reconcileLiveStateStores } from "../../lib/state-store-registrations";
 import { ProviderOutboundPolicyError, providerOutboundGet, providerOutboundPost, providerRedirectError } from "../../lib/provider-outbound";
+import { fetchCursorUsableModels } from "../../adapters/cursor/live-models";
 import { parseAntigravityAvailableModels } from "../../providers/antigravity-models";
 import { enrichProviderFromCatalog, listKeyLoginProviders } from "../../oauth/key-providers";
 import { deriveProviderPresets } from "../../providers/derive";
@@ -732,6 +733,27 @@ export async function handleProviderRoutes(ctx: ManagementContext): Promise<Resp
     if (prov.authMode === "oauth" && !apiKey) {
       return jsonResponse({ ok: false, latencyMs: 0, error: "static catalog only — upstream not verified (not logged in)" });
     }
+    if (prov.adapter === "cursor") {
+      const started = Date.now();
+      const live = await fetchCursorUsableModels({
+        apiKey: apiKey ?? "",
+        baseUrl: prov.baseUrl,
+      });
+      const latencyMs = Date.now() - started;
+      if (!live.ok) {
+        return jsonResponse({
+          ok: false,
+          latencyMs,
+          error: `cursor discovery ${live.error}${live.detail ? `: ${live.detail}` : ""}`,
+        });
+      }
+      return jsonResponse({
+        ok: true,
+        latencyMs,
+        models: live.models.length,
+        message: `Connected. ${live.models.length} models.`,
+      });
+    }
     const project = prov.project ?? snapshot?.projectId;
     if (antigravity && !project) {
       return jsonResponse({ ok: false, latencyMs: 0, error: "Antigravity project unavailable — re-run `ocx login google-antigravity`" });

package/src/server/request-log.ts

@@ -1004,10 +1004,14 @@ function finalizedUsage(
   const usageFallback = !finalUsage && estimate !== undefined
     ? { inputTokens: estimate, outputTokens: 0, estimated: true }
     : undefined;
-  const loggedUsage = finalUsage && estimate !== undefined
+  const combinedInputTokens = finalUsage && estimate !== undefined
+    ? Math.max(finalUsage.inputTokens, estimate)
+    : undefined;
+  const loggedUsage = finalUsage && combinedInputTokens !== undefined
     ? {
         ...finalUsage,
-        inputTokens: Math.max(finalUsage.inputTokens, estimate),
+        inputTokens: combinedInputTokens,
+        totalTokens: combinedInputTokens + finalUsage.outputTokens,
         estimated: true,
       }
     : finalUsage
@@ -1017,7 +1021,11 @@ function finalizedUsage(
       // ESTIMATE via capEstimateAtContextWindow, and Math.max preserves a real
       // provider-reported count, so it needs no further reduction.
       ? (finalUsage.estimated && contextWindow !== undefined && finalUsage.inputTokens > contextWindow
-          ? { ...finalUsage, inputTokens: contextWindow }
+          ? {
+              ...finalUsage,
+              inputTokens: contextWindow,
+              totalTokens: contextWindow + finalUsage.outputTokens,
+            }
           : finalUsage)
       : usageFallback;
   const totalTokens = usageTotalTokens(loggedUsage);

package/src/server/responses/core.ts

@@ -14,6 +14,7 @@ import {
   bindReasoningReplayScope,
   reasoningReplayCodexCredentialIdentity,
   reasoningReplayDestinationIdentity,
+  durableReplayDestinationIdentity,
   reasoningReplayKeyCredentialIdentity,
   reasoningReplayOAuthCredentialIdentity,
 } from "../../responses/reasoning-replay-cache";
@@ -336,6 +337,7 @@ function bindRouteReasoningReplayScope(args: {
       ? {
           providerName,
           providerDestinationIdentity,
+          providerDestinationDurableIdentity: durableReplayDestinationIdentity(provider.baseUrl),
           adapterName,
           modelId: parsed.modelId,
           credentialIdentity,

package/src/types.ts

@@ -5,6 +5,11 @@ export interface OcxReasoningReplayIdentity {
   providerName: string;
   /** Opaque process-local digest of the exact upstream destination. */
   providerDestinationIdentity: string;
+  /**
+   * The same destination, digested WITHOUT the process-local random key, so it can key a
+   * durable store. Absent when no base URL was resolvable.
+   */
+  providerDestinationDurableIdentity?: string;
   adapterName: string;
   modelId: string;
   /** Opaque process-local credential identity; never a raw token or API key. */
@@ -1392,8 +1397,15 @@ export interface OcxProviderConfig {
    * HTTP/2 streaming responses (issue #1668). "http1.1" / "h1" forces HTTP/1.1,
    * "http2" / "h2" forces HTTP/2. Absent or "auto" keeps Bun's default negotiation
    * (current behavior unchanged). Only meaningful for https: base URLs.
-   */
+  */
   upstreamHttpVersion?: UpstreamHttpVersion;
+  /**
+   * Google only. When `false`, the AI Studio (direct) path sends Gemini Flash ids
+   * unchanged to the wire instead of applying the `-tiered` suffix (`gemini-3.7-flash`
+   * -> `gemini-3.7-flash-tiered`). Set this to `false` when the configured upstream still
+   * serves the bare ids. Absent (default) keeps the rename.
+   */
+  directGeminiWireRenames?: boolean;
   /** Keep provider settings on disk but exclude it from routing and model/catalog listings. */
   disabled?: boolean;
   /**