@bitkyc08/opencodex 2.28.0 → 2.29.0

package/src/integrations/mutation-flight.ts

@@ -0,0 +1,71 @@
+import type { IntegrationClientId } from "./registry";
+
+const INTEGRATION_MUTATION_JOIN_MS = 120_000;
+export const INTEGRATION_MUTATION_TERMINAL_MS = 10 * 60_000;
+
+interface IntegrationMutationFlight {
+  key: string;
+  startedAt: number;
+  promise: Promise<unknown>;
+}
+
+export class IntegrationMutationBusyError extends Error {
+  constructor(readonly clientId: IntegrationClientId) {
+    super("integration_mutation_busy");
+  }
+}
+
+const integrationMutationFlights = new Map<IntegrationClientId, IntegrationMutationFlight>();
+let integrationMutationRunTestHook: ((operation: () => Promise<unknown>) => Promise<unknown>) | null = null;
+
+/**
+ * One in-process flight per client, shared by explicit HTTP mutations and
+ * implicit catalog refreshes. Equal operations join; different semantics are
+ * busy instead of, for example, letting an explicit apply join a refresh-only
+ * no-op for an absent block.
+ */
+export function runIntegrationMutationFlight<T>(
+  clientId: IntegrationClientId,
+  key: string,
+  now: () => number,
+  operation: () => Promise<T>,
+): Promise<T> {
+  const startedAt = now();
+  const current = integrationMutationFlights.get(clientId);
+  if (current) {
+    const age = startedAt - current.startedAt;
+    if (current.key === key && age < INTEGRATION_MUTATION_JOIN_MS) {
+      return current.promise as Promise<T>;
+    }
+    if (age <= INTEGRATION_MUTATION_TERMINAL_MS) {
+      return Promise.reject(new IntegrationMutationBusyError(clientId));
+    }
+    if (integrationMutationFlights.get(clientId) === current) {
+      integrationMutationFlights.delete(clientId);
+    }
+  }
+
+  const flight: IntegrationMutationFlight = {
+    key,
+    startedAt,
+    promise: Promise.resolve(),
+  };
+  const run = async (): Promise<unknown> => operation();
+  flight.promise = (integrationMutationRunTestHook
+    ? integrationMutationRunTestHook(run)
+    : run()
+  ).finally(() => {
+    if (integrationMutationFlights.get(clientId) === flight) {
+      integrationMutationFlights.delete(clientId);
+    }
+  });
+  integrationMutationFlights.set(clientId, flight);
+  return flight.promise as Promise<T>;
+}
+
+export function setIntegrationMutationFlightTestHook(
+  run: ((operation: () => Promise<unknown>) => Promise<unknown>) | null,
+): void {
+  integrationMutationRunTestHook = run;
+  integrationMutationFlights.clear();
+}

package/src/integrations/owned-refresh.ts

@@ -0,0 +1,74 @@
+/**
+ * Refresh a file integration only when OpenCodex already owns its block.
+ *
+ * This is the safe bridge between an implicit operation such as `ocx sync`
+ * and the explicit integration writer. An implicit sync may update a block
+ * the user previously enabled, but it must never claim an unowned block,
+ * recreate one the user removed, or overwrite edits made after our write.
+ */
+import type { ExportModel } from "../clients/config-export";
+import type { OcxConfig } from "../types";
+import type { IntegrationIO } from "./config-io";
+import type { IntegrationClientId } from "./registry";
+import { runIntegrationMutationFlight } from "./mutation-flight";
+import { createIntegrationStateStore, type IntegrationStateStore } from "./store";
+import {
+  refreshIntegrationCoordinated,
+  type CoordinatedIntegrationOptions,
+} from "./writer";
+
+export interface OwnedIntegrationRefreshInput {
+  clientId: IntegrationClientId;
+  /** Lazy in `ocx sync`, so an unowned client does not even load the catalog. */
+  models: readonly ExportModel[] | (() => Promise<readonly ExportModel[]>);
+  config: OcxConfig;
+  port: number;
+  env?: NodeJS.ProcessEnv;
+  home?: string;
+  store?: IntegrationStateStore;
+  io?: IntegrationIO;
+}
+
+export interface OwnedIntegrationRefreshOutcome {
+  readonly client: IntegrationClientId;
+  readonly ok: boolean;
+  readonly changed?: boolean;
+  readonly reason?: string;
+}
+
+/**
+ * Returns `null` when the client has never been connected by OpenCodex.
+ * Callers use that distinction to report "left alone" rather than "skipped".
+ */
+export async function refreshOwnedIntegration(
+  input: OwnedIntegrationRefreshInput,
+  options?: CoordinatedIntegrationOptions,
+): Promise<OwnedIntegrationRefreshOutcome | null> {
+  const store = input.store ?? createIntegrationStateStore();
+
+  // The ownership record is the user's durable opt-in. Do this check before
+  // reading or classifying the target so an implicit sync can never turn an
+  // unowned provider block into one of ours.
+  const record = store.readRecords()[input.clientId];
+  if (!record || record.clientId !== input.clientId) return null;
+
+  const { models: suppliedModels, ...rest } = input;
+  const models = typeof suppliedModels === "function"
+    ? await suppliedModels()
+    : suppliedModels;
+  const bound = { ...rest, models, store };
+  const result = await runIntegrationMutationFlight(
+    input.clientId,
+    "refresh",
+    input.io?.now ?? Date.now,
+    () => refreshIntegrationCoordinated(bound, options),
+  );
+  return result.ok
+    ? {
+        client: input.clientId,
+        ok: true,
+        changed: result.changed,
+        ...(result.state === "absent" ? { reason: result.message } : {}),
+      }
+    : { client: input.clientId, ok: false, reason: result.message };
+}

package/src/integrations/registry.ts

@@ -27,6 +27,10 @@ import {
   opencodeGlobalConfigPath,
   openclawConfigPath,
   openclawHomeDir,
+  piAgentDir,
+  piConfigPath,
+  primeAgentDir,
+  primeConfigPath,
   zcodeConfigPath,
   zcodeHomeDir,
   type ExportClientId,
@@ -77,8 +81,18 @@ export const INTEGRATION_CLIENTS: Record<IntegrationClientId, IntegrationClientS
   },
   pi: {
     id: "pi",
-    configPath: (_env = process.env, home = homedir()) => join(home, ".pi", "agent", "models.json"),
-    detectDir: (_env = process.env, home = homedir()) => join(home, ".pi"),
+    configPath: (env = process.env, home = homedir()) => piConfigPath(env, home),
+    /*
+     * Deliberately not `piAgentDir` unconditionally. Without an override the
+     * install signal stays `~/.pi`, which is what it has always been: narrowing
+     * it to `~/.pi/agent` would flip a user who has the former without the
+     * latter from installed to absent, and this change is about honoring the
+     * override, not about redefining detection. With an override there is no
+     * parent worth testing — the variable names the agent directory itself — so
+     * that directory becomes the signal.
+     */
+    detectDir: (env = process.env, home = homedir()) =>
+      env.PI_CODING_AGENT_DIR?.trim() ? piAgentDir(env, home) : join(home, ".pi"),
   },
   omp: {
     id: "omp",
@@ -120,12 +134,21 @@ export const INTEGRATION_CLIENTS: Record<IntegrationClientId, IntegrationClientS
     id: "mcode",
     configPath: (env = process.env, home = homedir()) => mcodeConfigPath(env, home),
     detectDir: (env = process.env, home = homedir()) => mcodeHomeDir(env, home),
+    writerLock: { suffix: ".lock" },
   },
   zcode: {
     id: "zcode",
     configPath: (env = process.env, home = homedir()) => zcodeConfigPath(env, home),
     detectDir: (env = process.env, home = homedir()) => zcodeHomeDir(env, home),
   },
+  prime: {
+    id: "prime",
+    configPath: (env = process.env, home = homedir()) => primeConfigPath(env, home),
+    // The agent directory, not its parent: `PRIME_AGENT_CODING_AGENT_DIR` names
+    // that directory directly, so there is no parent to test when the override
+    // is set. Same choice as OMP, whose detect signal is `ompAgentDir`.
+    detectDir: (env = process.env, home = homedir()) => primeAgentDir(env, home),
+  },
 };
 
 export const INTEGRATION_CLIENT_IDS: readonly IntegrationClientId[] =

package/src/integrations/writer.ts

@@ -240,7 +240,7 @@ function preflight(input: IntegrationWriteInput) {
   return { failed: undefined, store, io, clientId, spec, exportSpec, configPath, before, parsed, contribution, record, classified } as const;
 }
 
-export function applyIntegration(input: IntegrationWriteInput): WriteOutcome {
+function applyOrRefreshIntegration(input: IntegrationWriteInput, allowAbsent: boolean): WriteOutcome {
   const pre = preflight(input);
   if (pre.failed) return pre.failed;
   const { store, io, clientId, spec, exportSpec, configPath, before, parsed, contribution, record, classified } = pre;
@@ -271,6 +271,21 @@ export function applyIntegration(input: IntegrationWriteInput): WriteOutcome {
         ? `${configPath} holds a value where opencodex would have to write a section, so applying would replace it`
         : `${configPath} cannot be changed safely`);
   }
+  /*
+   * An implicit catalog sync is refresh-only. Keeping this decision inside the
+   * writer's one preflight closes the read-then-apply race where a user could
+   * remove the managed block after a caller classified it as stale and a
+   * normal apply would silently recreate it.
+   */
+  if (classified.state === "absent" && !allowAbsent) {
+    return {
+      ok: true,
+      changed: false,
+      state: "absent",
+      clientId,
+      message: "managed block is absent; refresh did not reconnect it",
+    };
+  }
   if (classified.state === "current") {
     return { ok: true, changed: false, state: "current", clientId, message: "already applied" };
   }
@@ -352,6 +367,15 @@ export function applyIntegration(input: IntegrationWriteInput): WriteOutcome {
   });
 }
 
+export function applyIntegration(input: IntegrationWriteInput): WriteOutcome {
+  return applyOrRefreshIntegration(input, true);
+}
+
+/** Refresh an owned stale block, but never create or reconnect an absent one. */
+export function refreshIntegration(input: IntegrationWriteInput): WriteOutcome {
+  return applyOrRefreshIntegration(input, false);
+}
+
 export function disableIntegration(input: IntegrationWriteInput): WriteOutcome {
   const pre = preflight(input);
   if (pre.failed) return pre.failed;
@@ -627,6 +651,13 @@ export function applyIntegrationCoordinated(
   return coordinatedWrite(input, applyIntegration, options);
 }
 
+export function refreshIntegrationCoordinated(
+  input: IntegrationWriteInput,
+  options?: CoordinatedIntegrationOptions,
+): Promise<WriteOutcome> {
+  return coordinatedWrite(input, refreshIntegration, options);
+}
+
 export function disableIntegrationCoordinated(
   input: IntegrationWriteInput,
   options?: CoordinatedIntegrationOptions,

package/src/lab/public/signature.ts

@@ -52,6 +52,22 @@ function publisherForPrivateKey(privateKeyPem: string): PublicPublisherV1 {
   };
 }
 
+/**
+ * The bounded errno-shaped code from a failed ACL harden, or null when the cause
+ * carries none.
+ *
+ * Only the code is allowed into the message. `hardenSecretPath` already sanitizes
+ * its own diagnostic prose, but this error is what reaches a CI log, so what
+ * crosses that boundary is re-checked here rather than trusted: an errno code has
+ * no separator, no lowercase and a bounded length, and therefore cannot carry the
+ * key pathname or the username component inside it.
+ */
+function aclFailureCode(error: unknown): string | null {
+  if (!(error instanceof Error) || !("code" in error)) return null;
+  const code = (error as NodeJS.ErrnoException).code;
+  return typeof code === "string" && /^[A-Z][A-Z0-9_]{1,30}$/.test(code) ? code : null;
+}
+
 function requirePublisherKeyAcl(path: string, timeoutMemoKey = path): void {
   privateRegularFileSize(path, PRIVATE_KEY_FILE_OPTIONS);
   let hardened: { ok: boolean };
@@ -63,9 +79,17 @@ function requirePublisherKeyAcl(path: string, timeoutMemoKey = path): void {
     hardened = { ok: false };
   }
   if (!hardened.ok) {
+    // Name the cause in the message, not only on `cause`. Every harden failure
+    // reaches a CI log as this one string, and the three that occur there need
+    // different fixes: ETIMEDOUT is the budget, EACLIDENTITY is the effective-SID
+    // lookup, EICACLS is icacls refusing the path. A message identical across all
+    // three cannot be acted on without a Windows box to re-run it under (#2152).
+    const code = aclFailureCode(hardeningError);
     const failure = new PublicEvidenceValidationError(
       "public_publisher_key_unsafe",
-      "public publisher key ACL hardening did not complete",
+      code
+        ? `public publisher key ACL hardening did not complete (${code})`
+        : "public publisher key ACL hardening did not complete",
     );
     if (hardeningError !== undefined) {
       (failure as Error & { cause?: unknown }).cause = hardeningError;

package/src/lab/subject/behavior-fingerprint.ts

@@ -12,7 +12,7 @@ const CLOSED_KEYS = new Set([
   "reasoning.supported", "reasoning.efforts", "reasoning.defaultEffort", "reasoning.effortMap", "reasoning.wireFormat",
   "reasoning.summaryMode", "reasoning.replayMode", "reasoning.splitMode", "reasoning.toggleMode", "reasoning.budgetMode",
   "tools.choiceRestrictions", "tools.parallel", "tools.hostedPreference", "tools.customFreeform", "tools.builtinNameEscaping",
-  "cache.forwarding", "cache.retention", "anthropic.eofPolicy",
+  "cache.forwarding", "cache.retention", "anthropic.eofPolicy", "openai-chat.eofPolicy",
   "google.mode", "google.projectFingerprint", "google.locationFingerprint",
   "openrouter.order", "openrouter.only", "openrouter.allowFallbacks",
   "sidecars.vision", "sidecars.webSearch",

package/src/lib/redact.ts

@@ -1,6 +1,6 @@
 export const REDACTED_SECRET = "[REDACTED]";
 
-const SENSITIVE_KEY_PATTERN = /^(?:authorization|proxy-authorization|cookie|set-cookie|set-cookie2|api[-_]?key|x-api-key|x-goog-api-key|x-amz-security-token|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|client[-_]?secret|password|profile[-_]?arn)$/i;
+const SENSITIVE_KEY_PATTERN = /^(?:authorization|proxy-authorization|cookie|set-cookie|set-cookie2|api[-_]?key|x-api-key|x-goog-api-key|x-amz-security-token|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|client[-_]?secret|password|profile[-_]?arn|exa[-_]?api[-_]?key)$/i;
 
 /**
  * Colon-labelled credential headers echoed back inside an error body
@@ -33,7 +33,7 @@ const SENSITIVE_KEY_PATTERN = /^(?:authorization|proxy-authorization|cookie|set-
 // Every letter position also accepts \u0001, the placeholder the fold emits for
 // an unresolved HTML named reference: `authorⅈzation` is the label with one
 // character we cannot name, and that is still the label.
-const CREDENTIAL_HEADER_LABEL_RAW = "x-api-key|x-goog-api-key|x-amz-security-token|api[_-]?key|apiKey|access[_-]?token|accessToken|refresh[_-]?token|refreshToken|id[_-]?token|client[_-]?secret|clientSecret|authorization|proxy-authorization|cookie|set-cookie|password|secret|token";
+const CREDENTIAL_HEADER_LABEL_RAW = "x-api-key|x-goog-api-key|x-amz-security-token|api[_-]?key|apiKey|exa[_-]?api[_-]?key|exaApiKey|access[_-]?token|accessToken|refresh[_-]?token|refreshToken|id[_-]?token|client[_-]?secret|clientSecret|authorization|proxy-authorization|cookie|set-cookie|password|secret|token";
 
 const CREDENTIAL_HEADER_LABEL = CREDENTIAL_HEADER_LABEL_RAW
   .replace(/(?<![\[\\])([A-Za-z])(?![\]\-])/g, "[$1\u0001]");

package/src/oauth/log.ts

@@ -1,5 +1,6 @@
 // src/oauth/log.ts
 import { maskAccountId } from "../lib/privacy";
+import { redactSecretString } from "../lib/redact";
 
 /** Normalize camelCase / snake_case / kebab-case field names before secret checks. */
 function normalizeFieldKey(key: string): string {
@@ -20,6 +21,7 @@ const FORBIDDEN_NORMALIZED = new Set([
   "id_token",
   "client_secret",
   "oauth_code",
+  "code_verifier",
   "clientsecret",
 ]);
 
@@ -44,5 +46,5 @@ export function logOAuthEvent(
     if (value === undefined) continue;
     parts.push(`${key}=${String(value)}`);
   }
-  console.info(parts.join(" "));
+  console.info(redactSecretString(parts.join(" ")));
 }

package/src/providers/derive.ts

@@ -47,6 +47,7 @@ export interface DerivedKeyLoginProvider {
   thinkingToggleModels?: string[];
   thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
+  openaiChatEofTolerance?: boolean;
   googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
   project?: string;
   location?: string;
@@ -247,6 +248,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.parallelToolCalls !== undefined ? { parallelToolCalls: entry.parallelToolCalls } : {}),
     ...(entry.promptCacheKey !== undefined ? { promptCacheKey: entry.promptCacheKey } : {}),
     ...(entry.chatServiceTier !== undefined ? { chatServiceTier: entry.chatServiceTier } : {}),
+    ...(entry.openaiChatEofTolerance !== undefined ? { openaiChatEofTolerance: entry.openaiChatEofTolerance } : {}),
     ...(entry.responsesPath !== undefined ? { responsesPath: entry.responsesPath } : {}),
     ...(entry.statelessResponses !== undefined ? { statelessResponses: entry.statelessResponses } : {}),
     ...(entry.requiresAdjacentResponsesToolResults !== undefined
@@ -306,6 +308,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
       ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
       ...(entry.escapeBuiltinToolNames !== undefined ? { escapeBuiltinToolNames: entry.escapeBuiltinToolNames } : {}),
+      ...(entry.openaiChatEofTolerance !== undefined ? { openaiChatEofTolerance: entry.openaiChatEofTolerance } : {}),
       ...(entry.googleMode ? { googleMode: entry.googleMode } : {}),
       ...(entry.project ? { project: entry.project } : {}),
       ...(entry.location ? { location: entry.location } : {}),
@@ -461,6 +464,9 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.parallelToolCalls === undefined && seed.parallelToolCalls !== undefined) prov.parallelToolCalls = seed.parallelToolCalls;
   if (prov.promptCacheKey === undefined && seed.promptCacheKey !== undefined) prov.promptCacheKey = seed.promptCacheKey;
   if (prov.chatServiceTier === undefined && seed.chatServiceTier !== undefined) prov.chatServiceTier = seed.chatServiceTier;
+  if (prov.openaiChatEofTolerance === undefined && seed.openaiChatEofTolerance !== undefined) {
+    prov.openaiChatEofTolerance = seed.openaiChatEofTolerance;
+  }
   // Fill-only: a hand-edited path must survive, and a config saved before the registry
   // learned this route still gets backfilled.
   if (prov.responsesPath === undefined && seed.responsesPath !== undefined) prov.responsesPath = seed.responsesPath;
@@ -474,6 +480,9 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
     prov.fastWire = cloneFastWire(entry.fastWire);
   }
   if (prov.supportsServiceTier === undefined && entry.supportsServiceTier !== undefined) prov.supportsServiceTier = entry.supportsServiceTier;
+  if (prov.supportsOpenAiWebSearchToolFields === undefined && entry.supportsOpenAiWebSearchToolFields !== undefined) {
+    prov.supportsOpenAiWebSearchToolFields = entry.supportsOpenAiWebSearchToolFields;
+  }
   if (prov.preserveResponsesReasoningContent === undefined && entry.preserveResponsesReasoningContent !== undefined) prov.preserveResponsesReasoningContent = entry.preserveResponsesReasoningContent;
   applyReasoningSummaryDefaults(prov, entry.modelSupportsReasoningSummaries);
   applyServiceTierModelDefaults(prov, serviceTierModelDefaultsFor(entry, prov));

package/src/providers/fastwire.ts

@@ -143,34 +143,40 @@ function resolvePolicyAdapter(
   inbound: InboundWire,
 ): { adapter: string; hardPinned: boolean; forwardCallerServiceTier?: boolean } {
   // Hard pins and configured overrides deliberately use the same exact-key semantics as
-  // resolveWireProtocolOverride(). Registry defaults alone normalize ids at their boundary.
+  // resolveWireProtocolOverride(). Registry route policy normalizes ids at its boundary.
   const hardPin = Object.hasOwn(authority.hardPins, modelId)
     ? authority.hardPins[modelId]
     : undefined;
   if (typeof hardPin === "string") return { adapter: hardPin, hardPinned: true };
   if (authority.modelWireOverrideAllowed) {
+    const registryDefault = MODEL_ADAPTER_OVERRIDE_ALLOWED.has(authority.providerAdapter)
+      ? registryDefaultForModel(
+          authority.registryWireDefaults,
+          modelId,
+          inbound,
+          authority.providerAuthMode,
+        )
+      : undefined;
     const configured = Object.hasOwn(authority.modelAdapters, modelId)
       ? authority.modelAdapters[modelId]
       : undefined;
     if (typeof configured === "string" && MODEL_ADAPTER_OVERRIDE_ALLOWED.has(configured)) {
-      return { adapter: configured, hardPinned: false };
+      return {
+        adapter: configured,
+        hardPinned: false,
+        ...(registryDefault?.forwardCallerServiceTier === false
+          ? { forwardCallerServiceTier: false }
+          : {}),
+      };
     }
-    if (MODEL_ADAPTER_OVERRIDE_ALLOWED.has(authority.providerAdapter)) {
-      const registryDefault = registryDefaultForModel(
-        authority.registryWireDefaults,
-        modelId,
-        inbound,
-        authority.providerAuthMode,
-      );
-      if (registryDefault !== undefined) {
-        return {
-          adapter: registryDefault.adapter,
-          hardPinned: false,
-          ...(registryDefault.forwardCallerServiceTier !== undefined
-            ? { forwardCallerServiceTier: registryDefault.forwardCallerServiceTier }
-            : {}),
-        };
-      }
+    if (registryDefault !== undefined) {
+      return {
+        adapter: registryDefault.adapter,
+        hardPinned: false,
+        ...(registryDefault.forwardCallerServiceTier !== undefined
+          ? { forwardCallerServiceTier: registryDefault.forwardCallerServiceTier }
+          : {}),
+      };
     }
   }
   return { adapter: authority.providerAdapter, hardPinned: false };

package/src/providers/openai-tiers.ts

@@ -1,5 +1,6 @@
 import type { CodexAccountMode, OcxConfig, OcxProviderConfig, ProviderCostOverlay } from "../types";
 import { OPENAI_PROVIDER_TIER_VERSION } from "../types";
+import { openaiResponsesUrl } from "../adapters/openai-responses-url";
 import { MAX_COST4_RATE } from "../usage/expected-prices";
 
 export const OPENAI_CODEX_PROVIDER_ID = "openai";
@@ -36,7 +37,35 @@ export function isCanonicalOpenAiForwardProvider(provider: OcxProviderConfig): b
     && normalizedBaseUrl(provider.baseUrl) === CODEX_FORWARD_BASE_URL;
 }
 
-const OPENAI_API_BASE_URL = "https://api.openai.com/v1";
+const OPENAI_API_ORIGIN = "https://api.openai.com";
+const OPENAI_API_BASE_URL = `${OPENAI_API_ORIGIN}/v1`;
+const OPENAI_API_RESPONSES_URL = `${OPENAI_API_BASE_URL}/responses`;
+
+/**
+ * The Responses endpoint the adapter would actually POST key-auth traffic to, normalized.
+ *
+ * Mirrors the adapter's own construction (`src/adapters/openai-responses.ts`): a configured
+ * `responsesPath` is appended to the base verbatim, and only the default branch runs the
+ * `/v1/responses` suffix normalization. Classifying on the base URL alone would call
+ * `baseUrl: "https://api.openai.com"` with `responsesPath: "/other"` official even though that
+ * request never reaches the official Responses endpoint.
+ */
+function resolvedResponsesEndpoint(provider: OcxProviderConfig): string | undefined {
+  try {
+    const raw = provider.responsesPath === undefined
+      ? openaiResponsesUrl(provider.baseUrl)
+      : `${provider.baseUrl.replace(/\/$/, "")}${provider.responsesPath}`;
+    return normalizedBaseUrl(raw);
+  } catch {
+    return undefined;
+  }
+}
+
+function isOfficialOpenAiResponsesDestination(provider: OcxProviderConfig): boolean {
+  // Exact normalized URL keeps lookalike/suffix hosts out of this set: `api.openai.com.evil.test`
+  // resolves to its own origin, never to the official one.
+  return resolvedResponsesEndpoint(provider) === OPENAI_API_RESPONSES_URL;
+}
 
 /**
  * Whether this provider can serve `POST /responses/compact`. The canonical ChatGPT
@@ -54,6 +83,36 @@ export function supportsNativeResponsesCompactEndpoint(
     && normalizedBaseUrl(provider.baseUrl) === OPENAI_API_BASE_URL;
 }
 
+/**
+ * Whether this destination is an OpenAI-operated Responses backend — the canonical ChatGPT Codex
+ * surface or the official OpenAI API.
+ *
+ * Deliberately not keyed on `authMode === "forward"`: a noncanonical forward provider does not
+ * receive the caller's credentials (see the forward-header gate in the Responses adapter), so
+ * forward auth says nothing about which backend is on the other end.
+ */
+export function isOpenAiOperatedResponsesDestination(provider: OcxProviderConfig): boolean {
+  if (isCanonicalOpenAiForwardProvider(provider)) return true;
+  return provider.adapter === "openai-responses"
+    && isOfficialOpenAiResponsesDestination(provider);
+}
+
+/**
+ * Whether this destination can decode a native (non-`ocx1:`) compaction blob.
+ *
+ * Only the backend that minted a blob can decode it. `authMode: "forward"` alone is not a signal:
+ * the adapter forwards caller credentials only to the canonical ChatGPT Codex surface, while a
+ * noncanonical forward provider receives no caller credentials and may point at any backend.
+ *
+ * Relay only to an OpenAI-operated destination or a destination whose operator explicitly opts in.
+ * Keyed by destination rather than provider id: a blob's issuer is the URL that produced it, not the
+ * local config key a replay travels under.
+ */
+export function destinationDecodesNativeCompactionBlob(provider: OcxProviderConfig): boolean {
+  return isOpenAiOperatedResponsesDestination(provider)
+    || provider.decodesNativeCompactionBlobs === true;
+}
+
 export interface OpenAiTierMigrationProjection {
   config: OcxConfig;
   changed: boolean;

package/src/providers/registry.ts

@@ -222,6 +222,8 @@ export interface ProviderRegistryEntry {
    * (and the canonical openai seed comparison keeps its exact key set).
    */
   supportsServiceTier?: boolean;
+  /** Registry default for OpenAI extended hosted web_search field support. */
+  supportsOpenAiWebSearchToolFields?: boolean;
   /** Registry default for exact model service-tier capability; explicit config keys win. */
   modelSupportsServiceTier?: Record<string, boolean>;
   /**
@@ -266,6 +268,8 @@ export interface ProviderRegistryEntry {
    * `supportsServiceTier`, which governs the Responses wire.
    */
   chatServiceTier?: boolean;
+  /** OpenAI Chat EOF policy for gateways that omit terminal frames after complete tool calls. */
+  openaiChatEofTolerance?: boolean;
   autoToolChoiceOnlyModels?: string[];
   preserveReasoningContentModels?: string[];
   requiresReasoningPlaceholderModels?: string[];
@@ -291,7 +295,7 @@ export type ProviderConfigSeed = Pick<
   | "modelMaxInputTokens" | "defaultMaxOutputTokens" | "modelMaxOutputTokens"
   | "reasoningEfforts" | "modelReasoningEfforts" | "modelDefaultReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap" | "reasoningWireFormat"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
-  | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "requiresReasoningPlaceholderModels" | "reasoningSplitModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "escapeBuiltinToolNames"
+  | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "requiresReasoningPlaceholderModels" | "reasoningSplitModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "escapeBuiltinToolNames" | "openaiChatEofTolerance"
   | "googleMode" | "project" | "location" | "headers"
 >;
 
@@ -1006,6 +1010,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     featured: true,
     oauthId: "xai",
     jawcodeBundle: "xai",
+    supportsOpenAiWebSearchToolFields: false,
     note: "Log in with your Grok account",
     // Parallel tool calls: officially supported and default-on per docs.x.ai function-calling
     // (verified 260709, devlog/_plan/260709_parallel_tool_calls). Streamed calls arrive whole
@@ -1023,19 +1028,18 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     // grok-4.5; the reasoning ladder does not — 4.6 adds the documented xhigh rung.
     models: ["grok-4.6", "grok-4.5", "grok-4.3", "grok-4.20-0309-reasoning", "grok-4.20-0309-non-reasoning", "grok-build-0.1", "grok-composer-2.5-fast"],
     defaultModel: "grok-4.5",
-    // The current Grok CLI catalog declares both subscription models as native Responses
-    // backends. Keep API-key and translated Chat/Anthropic callers on their existing wire;
-    // Codex Responses traffic can relay xAI's SSE as it arrives instead of waiting for the
-    // Chat Completions compatibility stream to flush at the end of a reasoning turn.
+    // Keep Codex Responses callers on the compatibility Chat wire until xAI can replay
+    // opaque reasoning continuation and compaction state across later turns. The scoped
+    // declaration also keeps caller-owned service tiers off the OAuth subscription route.
     modelWireDefaults: {
       "grok-4.6": {
-        wire: "openai-responses",
+        wire: "openai-chat",
         inbound: ["responses"],
         authModes: ["oauth"],
         forwardCallerServiceTier: false,
       },
       "grok-4.5": {
-        wire: "openai-responses",
+        wire: "openai-chat",
         inbound: ["responses"],
         authModes: ["oauth"],
         forwardCallerServiceTier: false,
@@ -1276,6 +1280,9 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     id: "opencode-go", label: "opencode go", adapter: "openai-chat", baseUrl: "https://opencode.ai/zen/go/v1",
     authKind: "key", featured: true, dashboardUrl: "https://opencode.ai/auth", defaultModel: "kimi-k2.7-code",
     jawcodeBundle: "opencode-go", note: "GLM, DeepSeek, Kimi, Qwen, MiMo…",
+    // Zen Go can close a Chat stream after a fully assembled function call without sending
+    // finish_reason or [DONE] (#2260). The adapter still rejects incomplete argument JSON.
+    openaiChatEofTolerance: true,
     /* [Decision Log]
     - 목적과 의도: Route GPT 5.6 Luna to the Responses endpoint that OpenCode Go documents for that exact model.
     - 기존 구현 및 제약 조건: The provider is mixed-wire but its provider-wide `openai-chat` adapter sent Luna to `/chat/completions`; explicit user `modelAdapters` entries must remain authoritative.

package/src/providers/xai-responses-opt-in.ts

@@ -0,0 +1,15 @@
+import type { OcxProviderConfig } from "../types";
+
+export const XAI_RESPONSES_OPT_IN_MODELS = ["grok-4.6", "grok-4.5"] as const;
+
+export type XaiResponsesOptInState = boolean | "mixed";
+
+/** Derived dashboard/API state for the two modelAdapters entries owned by the xAI opt-in. */
+export function xaiResponsesOptInState(provider: OcxProviderConfig): XaiResponsesOptInState {
+  const enabled = XAI_RESPONSES_OPT_IN_MODELS.map(
+    model => provider.modelAdapters?.[model] === "openai-responses",
+  );
+  if (enabled.every(Boolean)) return true;
+  if (enabled.some(Boolean)) return "mixed";
+  return false;
+}

package/src/responses/compaction.ts

@@ -33,6 +33,24 @@ export const SUMMARY_PREFIX = "Another language model started to solve this prob
 
 export const OPAQUE_COMPACTION_NOTE = "[earlier conversation was compacted; the summary is stored in a format this model cannot read]";
 
+/**
+ * Item types in the compact wire family. Each carries an `encrypted_content` blob the client
+ * replays verbatim on every later turn, and the minting backend verifies it is unmodified.
+ *
+ * Keep this the only enumeration: a copy that listed just `compaction` let the response-side
+ * field backfill synthesize ids into the other two, which the client then replayed as "modified
+ * from the compact response".
+ */
+const COMPACTION_ITEM_TYPES: ReadonlySet<string> = new Set([
+  "compaction",
+  "compaction_summary",
+  "context_compaction",
+]);
+
+export function isCompactionItemType(type: unknown): boolean {
+  return typeof type === "string" && COMPACTION_ITEM_TYPES.has(type);
+}
+
 export function encodeCompactionSummary(summary: string): string {
   return OCX_COMPACTION_PREFIX + Buffer.from(summary, "utf-8").toString("base64");
 }