cartethyia 2.7.0 → 2.7.1

package/src/providers/integrations/buddy/codebuddy/cn-provider.ts

@@ -16,19 +16,18 @@ import { providerBaseUrl } from "../../../provider-metadata";
 import {
   codebuddyAdapterConfig,
 } from "./shared";
+import { CODEBUDDY_CN_RAW } from "./cn-catalog";
 import { CODEBUDDY_SYSTEM_PROMPT } from "./provider";
 import {
   BUDDY_CN_IMAGE_MODEL_ID_SET,
   makeBuddyCnImageModels,
   makeBuddyModel,
-  type BuddyRawEntry,
 } from "../buddy-catalog-shared";
 import { BUDDY_CN_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-discovery-shared";
 import {
   buddyPrePayloadCommon,
-  coalesceConsecutiveUserMessages,
-  dropEmptyBuddyMessages,
-  ensureBuddyLeadingSystem,
+  finalizeBuddyMessages,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -93,42 +92,18 @@ export function codeBuddyCnPrePayload(
   if (Array.isArray(payload["messages"])) {
     const messages = payload["messages"] as Array<Record<string, unknown>>;
     neutralizeCnMessages(messages);
-    coalesceConsecutiveUserMessages(messages);
-    dropEmptyBuddyMessages(messages);
-    ensureBuddyLeadingSystem(messages, CODEBUDDY_CN_NEUTRAL_PROMPT);
+    finalizeBuddyMessages(messages, { leadPrompt: CODEBUDDY_CN_NEUTRAL_PROMPT });
   }
   ensurePayloadModel(payload, candidate, "CodeBuddy CN");
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }
 
 // Model catalog — CodeBuddy CN console and CLI catalog.
 // Exported because `buddyModelOutputLimit` searches every buddy raw table, and
 // a CN-only id would otherwise never get an output limit.
-export const CODEBUDDY_CN_RAW: readonly BuddyRawEntry[] = [
-  ["glm-5.1", "GLM 5.1", true, true, 200_000, 48_000],
-  ["glm-5.2", "GLM 5.2", true, true, 1_000_000, 64_000],
-  ["glm-5.3", "GLM 5.3", true, true, 1_000_000, 64_000],
-  ["glm-5.3-flash", "GLM 5.3 Flash", true, true, 1_000_000, 131_072],
-  ["glm-5v-turbo", "GLM 5v Turbo", true, true, 200_000, 64_000],
-  ["minimax-m3", "MiniMax M3", true, true, 512_000, 64_000],
-  // 1M context, reasoning always on (upstream states both); vision inherited
-  // from the M3 row, which is the same family.
-  ["minimax-m3.1-flash", "MiniMax M3.1 Flash", true, true, 1_000_000, 128_000],
-  ["mimo-v2.6-pro", "MiMo V2.6 Pro", true, true, 1_000_000, 128_000],
-  ["kimi-k2.8-preview", "Kimi K2.8 Preview", true, true, 1_000_000, 64_000],
-  ["kimi-k3.1-pro", "Kimi K3.1 Pro", true, true, 1_000_000, 32_000],
-  ["hy3", "Hy3", true, true, 192_000, 64_000],
-  ["hy4-preview", "Hy4 Preview", true, true, 960_000, 64_000],
-  ["space-bunny", "Space Bunny", true, true, 1_000_000, 128_000],
-  ["step-5-preview", "Step 5 Preview", true, true, 1_000_000, 64_000],
-  ["deepseek-v4-pro", "DeepSeek V4 Pro", true, true, 1_000_000, 128_000],
-  ["deepseek-v4.1-flash", "DeepSeek V4.1 Flash", true, true, 1_000_000, 128_000],
-  // Live on the CN roster but absent here, so a request for it resolved to
-  // nothing. Limits as published by /v3/config.
-  ["kimi-k3-1", "Kimi K3-1", true, true, 1_000_000, 32_000],
-  ["minimax-m2.7", "MiniMax M2.7", true, true, 200_000, 48_000],
-];
+export { CODEBUDDY_CN_RAW };
 /**
  * CN's image-generation rows (`hunyuan-image-alpha`).
  *

package/src/providers/integrations/buddy/codebuddy/provider.ts

@@ -30,6 +30,7 @@ import { BUDDY_INTL_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-disc
 import {
   applyBuddySystemPrompt,
   buddyPrePayloadCommon,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -86,6 +87,7 @@ function codeBuddyIntlPrePayload(
     applyBuddySystemPrompt(messages as Array<Record<string, unknown>>, CODEBUDDY_SYSTEM_PROMPT);
   }
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }
 

package/src/providers/integrations/buddy/codebuddy/shared.ts

@@ -3,9 +3,10 @@ import type { CanonicalRequest } from "../../../../protocol/canonical-model";
 import type { ProviderDispatchContext, ProviderDispatchTarget, ProviderId } from "../../../provider-contracts";
 import { resolveInboundSessionId } from "../../../operations/session-resolution";
 import { buddyConversationHeaders } from "../buddy-conversation-headers";
-import { buddyEnterprise, buddyUserId, resolveBuddyIdentity } from "../buddy-identity";
+import { buddyEnterprise, buddyUserId, resolveBuddyDeviceBinding, resolveBuddyIdentity } from "../buddy-identity";
 import { buildCodeBuddyUserAgent, getCodeBuddyCnVersion, getCodeBuddyVersion } from "../../../operations/client-versions";
-import { readBuddyDeviceToken } from "../workbuddy/shared";
+import { buddyDeviceTokenHeaders } from "../workbuddy/shared";
+import { CODEBUDDY_TURING_CONFIG } from "../turing-device-token";
 import { buddyCliHeaders, buddyCliTraceHeaders } from "../buddy-cli-headers";
 
 /** Client identity variant behind the per-request CodeBuddy headers. */
@@ -34,7 +35,6 @@ export async function codebuddyHeaders(
 ): Promise<Record<string, string>> {
   const identity = variant === "IDE" ? "IDE" : "CLI";
   const ua = buildCodeBuddyUserAgent(identity);
-  const deviceToken = readBuddyDeviceToken(context);
   const conversationId = resolveInboundSessionId(context, request);
   const conversation = buddyConversationHeaders({
     ...(conversationId === undefined ? {} : { conversationId }),
@@ -88,7 +88,22 @@ export async function codebuddyHeaders(
     // turn-level aggregation key, and a chat request without it is refused for a
     // missing conversation id.
     ...conversation,
-    ...(deviceToken === undefined ? {} : { "X-Device-Token": deviceToken }),
+    // Per-account device binding (qimei36) — distinct device per account.
+    ...(() => {
+      const binding = resolveBuddyDeviceBinding(context);
+      return binding === undefined ? {} : { "X-Device-Id-List": JSON.stringify({ qimei36: binding }) };
+    })(),
+    // The desktop client sends the device-token pair on both realms. SDK
+    // token when configured, captured token otherwise, or the official failure
+    // placeholder. CodeBuddy uses its own SDK payload profile (same SDK,
+    // distinct product identity). (CLI branch above already returned without
+    // device headers.)
+    ...(await buddyDeviceTokenHeaders({
+      realm: identity === "IDE" ? "intl" : "cn",
+      context,
+      cliIdentity,
+      turingConfig: CODEBUDDY_TURING_CONFIG,
+    })),
   };
 }
 

package/src/providers/integrations/buddy/turing-device-token.ts

@@ -0,0 +1,262 @@
+/**
+ * TuringShield device-token integration for the buddy providers.
+ *
+ * WorkBuddy/CodeBuddy desktop clients derive `X-Device-Token` from Tencent's
+ * TuringShield SDK (native addon + DLL, channel 400111). The upstream risk
+ * control expects that header on chat traffic, and the official desktop app
+ * always presents either a real token or an `X-Device-Token-Error` — never
+ * neither.
+ *
+ * The SDK is a proprietary native binary shipped inside this repository under
+ * `vendor/turing-sdk/` (extracted from the WorkBuddy desktop app, channel
+ * 400111). `CARTETHYIA_TURING_SDK_PATH` remains as an optional override for
+ * deployments that bring their own copy. When neither is present the service
+ * falls back to the same "sdk_not_initialized" failure state the desktop app
+ * emits when the SDK cannot run.
+ *
+ * Loading and calling the SDK is safe: `configure()` is local-only, and
+ * `fetchDeviceToken()` performs the SDK's normal network exchange with the
+ * Turing endpoint (the same call the desktop client makes). On platforms
+ * without native support (non-win32/darwin) the service degrades to the
+ * fallback.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { log } from "../../../observability/logger";
+import { resolvePackagePath } from "../../../config/package-paths";
+
+/** Channel assigned to the WorkBuddy desktop product (see cli/product.json). */
+export const TURING_CHANNEL_ID = 400111;
+
+/** Per-provider SDK configuration (payload identity sent to Turing). */
+export interface TuringSdkConfig {
+  readonly channelId: number;
+  readonly productName: string;
+  readonly productVersion: string;
+}
+
+/** Canonical config for the WorkBuddy profile. */
+export const WORKBUDDY_TURING_CONFIG: TuringSdkConfig = {
+  channelId: TURING_CHANNEL_ID,
+  productName: "WorkBuddy AI",
+  productVersion: "5.8.4",
+};
+
+/** Canonical config for the CodeBuddy profile (same SDK, distinct payload). */
+export const CODEBUDDY_TURING_CONFIG: TuringSdkConfig = {
+  channelId: TURING_CHANNEL_ID,
+  productName: "CodeBuddy",
+  productVersion: "4.12.1",
+};
+
+/** Mirror the desktop client's service defaults (main-bootstrap.js). */
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+const DEFAULT_REFRESH_INTERVAL_MS = 5 * 60_000;
+const DEFAULT_RETRY_BASE_DELAY_MS = 30_000;
+const DEFAULT_RETRY_MAX_DELAY_MS = 5 * 60_000;
+const MAX_BACKOFF_LEVEL = 20;
+
+/**
+ * Resolve the directory holding the Turing SDK native files, or null.
+ *
+ * Priority: `CARTETHYIA_TURING_SDK_PATH` override → bundled copy in
+ * `vendor/turing-sdk/build/Release/` under the package root (works both in
+ * source and in the compiled binary, where `CARTETHYIA_PACKAGE_ROOT` points at
+ * `/app`).
+ */
+export function resolveTuringSdkRoot(): string | null {
+  const env = process.env["CARTETHYIA_TURING_SDK_PATH"];
+  if (env !== undefined && env.trim().length > 0) return env.trim();
+  // Bundled SDK (committed in vendor/).
+  const bundled = resolvePackagePath("vendor", "turing-sdk", "build", "Release");
+  if (existsSync(path.join(bundled, "turing_sdk.node"))) return bundled;
+  return null;
+}
+
+/** Pure header decision, matching the desktop app's `token || error` contract. */
+export function turingHeadersForRequest(args: {
+  token?: string;
+  error?: string;
+  cliIdentity?: boolean;
+}): Record<string, string> {
+  if (args.cliIdentity) return {};
+  const token = args.token?.trim();
+  if (token !== undefined && token.length > 0) return { "x-device-token": token };
+  const error = args.error?.trim();
+  if (error !== undefined && error.length > 0) return { "x-device-token-error": error };
+  return { "x-device-token-error": "sdk_not_initialized" };
+}
+
+/** Stable identifier for logs (never the token itself). */
+function logDeviceFingerprint(): string {
+  const parts = [process.platform, process.arch, process.env["COMPUTERNAME"] ?? process.env["HOSTNAME"] ?? ""];
+  return createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+}
+
+export class TuringDeviceTokenService {
+  private binding: { configure(...a: unknown[]): unknown; fetchDeviceToken(o: unknown): unknown } | null = null;
+  private loadAttempted = false;
+  private configured = false;
+
+  private cachedToken: string | undefined;
+  private cachedError: string | undefined;
+  private cachedAt = 0;
+  private consecutiveFailures = 0;
+  private nextRetryAt = 0;
+  private inflight: Promise<string> | undefined;
+
+  constructor(private readonly config: TuringSdkConfig = WORKBUDDY_TURING_CONFIG) {}
+
+  private ensureLoaded(): boolean {
+    if (this.loadAttempted) return this.configured;
+    this.loadAttempted = true;
+    const root = resolveTuringSdkRoot();
+    if (root === null) {
+      log.warn("[turing-sdk] no SDK root (env unset & vendor missing); device token fallback active");
+      return false;
+    }
+    const nodePath = path.join(root, "turing_sdk.node");
+    if (!existsSync(nodePath)) {
+      log.warn("[turing-sdk] turing_sdk.node not found at " + nodePath);
+      return false;
+    }
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const loaded: unknown = require(nodePath);
+      if (loaded === null || typeof loaded !== "object" || typeof (loaded as Record<string, unknown>)["configure"] !== "function") {
+        log.warn("[turing-sdk] native addon loaded but exposes no configure()");
+        return false;
+      }
+      const binding = loaded as NonNullable<TuringDeviceTokenService["binding"]>;
+      binding.configure(this.config.channelId, this.config.productName, this.config.productVersion);
+      this.binding = binding;
+      this.configured = true;
+      log.info(
+        "[turing-sdk] native SDK configured (channel " + this.config.channelId +
+        ", product " + this.config.productName + " " + this.config.productVersion +
+        ", " + logDeviceFingerprint() + ")",
+      );
+    } catch (error) {
+      log.warn("[turing-sdk] failed to load/configure native SDK: " + (error instanceof Error ? error.message : String(error)));
+      this.binding = null;
+    }
+    return this.configured;
+  }
+
+  /** Returns a real token when the SDK can produce one; undefined otherwise. */
+  async fetchDeviceToken(): Promise<string | undefined> {
+    if (!this.ensureLoaded()) return undefined;
+    const now = Date.now();
+    if (this.inflight) return this.inflight;
+    const task = this.performFetch().finally(() => {
+      this.inflight = undefined;
+    });
+    this.inflight = task;
+    try {
+      const token = await task;
+      this.cachedToken = token;
+      this.cachedError = undefined;
+      this.cachedAt = now;
+      this.consecutiveFailures = 0;
+      this.nextRetryAt = 0;
+      return token;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.cachedError = message.replace(/[^\x20-\x7E]/g, "").slice(0, 64);
+      this.consecutiveFailures += 1;
+      const level = Math.min(Math.max(0, this.consecutiveFailures - 1), MAX_BACKOFF_LEVEL);
+      const delay = Math.min(DEFAULT_RETRY_BASE_DELAY_MS * 2 ** level, DEFAULT_RETRY_MAX_DELAY_MS);
+      this.nextRetryAt = Date.now() + delay;
+      return undefined;
+    }
+  }
+
+  private async performFetch(): Promise<string> {
+    const binding = this.binding;
+    if (!binding) throw new Error("sdk_not_initialized");
+    const timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+    const promise = binding.fetchDeviceToken({
+      usingCachedMessage: true,
+      includesOutdatedMessage: false,
+      includesDeviceInfo: true,
+      timeoutMs,
+    });
+    const token = await this.withTimeout(Promise.resolve(promise) as Promise<string>, timeoutMs);
+    const text = typeof token === "string" ? token : String(token ?? "");
+    if (text.trim().length === 0) throw new Error("Turing SDK returned an empty device token");
+    return text.trim();
+  }
+
+  private async withTimeout(promise: Promise<string>, ms: number): Promise<string> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<string>((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Turing SDK device token request timed out after " + ms + "ms")), ms);
+          timer.unref?.();
+        }),
+      ]);
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+    }
+  }
+
+  /**
+   * Headers for one buddy request. Ensures a cached token exists (refreshing
+   * in the background when stale), then returns the desktop `token || error`
+   * contract.
+   */
+  async headersForRequest(cliIdentity?: boolean, requested?: TuringSdkConfig): Promise<Record<string, string>> {
+    // The Turing SDK rejects a channelId change after initialization. Keep the
+    // first config that actually configures the binding; later conflicting
+    // requests are warned once and keep serving the active token.
+    if (requested !== undefined) {
+      const activeOrMine = this.configured ? this.config : requested;
+      if (this.configured && (requested.channelId !== this.config.channelId || requested.productName !== this.config.productName)) {
+        log.warn("[turing-sdk] ignoring conflicting SDK config (channel " + requested.channelId + ", " + requested.productName + "); active is channel " + this.config.channelId + ", " + this.config.productName);
+      } else {
+        void activeOrMine;
+      }
+    }
+    let token: string | undefined = this.cachedToken;
+    let error: string | undefined = this.cachedError;
+    const now = Date.now();
+    if (token === undefined) {
+      if (now < this.nextRetryAt) {
+        // Keep whatever we had; still within backoff.
+      } else {
+        token = await this.fetchDeviceToken();
+        if (token === undefined) error = this.cachedError;
+      }
+    } else if (now - this.cachedAt >= DEFAULT_REFRESH_INTERVAL_MS) {
+      // Stale: refresh opportunistically but keep serving the cached token.
+      void this.fetchDeviceToken();
+    }
+    return turingHeadersForRequest({
+      ...(token === undefined ? {} : { token }),
+      ...(error === undefined ? {} : { error }),
+      ...(cliIdentity === undefined ? {} : { cliIdentity }),
+    });
+  }
+}
+
+/**
+ * Process-wide services keyed by their SDK config (channel/product). Each
+ * provider identity gets its own service so its payload (productName,
+ * productVersion) is used when the SDK is first configured. The underlying
+ * native addon is shared, but configure() runs per instance.
+ */
+const servicesByConfig = new Map<string, TuringDeviceTokenService>();
+export function getTuringDeviceTokenService(
+  config: TuringSdkConfig = WORKBUDDY_TURING_CONFIG,
+): TuringDeviceTokenService {
+  const key = `${config.channelId}:${config.productName}`;
+  let service = servicesByConfig.get(key);
+  if (service === undefined) {
+    service = new TuringDeviceTokenService(config);
+    servicesByConfig.set(key, service);
+  }
+  return service;
+}

package/src/providers/integrations/buddy/workbuddy/provider.ts

@@ -34,6 +34,7 @@ import { BUDDY_INTL_MODELS_PATH, fetchBuddyDirectoryModels } from "../buddy-disc
 import {
   applyBuddySystemPrompt,
   buddyPrePayloadCommon,
+  injectBuddyParallelToolCalls,
   normalizeBuddyToolNames,
 } from "../buddy-chat-shared";
 
@@ -141,6 +142,7 @@ export function workbuddyPrePayload(
     restoreHistoricalToolDefinitions(payload, normalizedMessages);
   }
   normalizeBuddyToolNames(payload);
+  injectBuddyParallelToolCalls(payload, request);
   void request;
 }
 

package/src/providers/integrations/buddy/workbuddy/shared.ts

@@ -8,12 +8,18 @@ import type { ProviderDispatchContext, ProviderDispatchTarget, ProviderId } from
 import { resolveInboundSessionId } from "../../../operations/session-resolution";
 import { buddyConversationHeaders } from "../buddy-conversation-headers";
 import { buddyCliHeaders, buddyCliTraceHeaders } from "../buddy-cli-headers";
-import { buddyEnterprise, buddyUserId, resolveBuddyIdentity } from "../buddy-identity";
+import { buddyEnterprise, buddyUserId, resolveBuddyDeviceBinding, resolveBuddyIdentity } from "../buddy-identity";
 import {
   buildWorkBuddyUserAgent,
   getWorkBuddyClientVersion,
   getWorkBuddyCliVersion,
 } from "../../../operations/client-versions";
+import {
+  getTuringDeviceTokenService,
+  resolveTuringSdkRoot,
+  type TuringSdkConfig,
+  WORKBUDDY_TURING_CONFIG,
+} from "../turing-device-token";
 
 /**
  * WorkBuddy serves chat from a versioned path on a base URL that carries no
@@ -140,8 +146,17 @@ export async function workbuddyHeaders(
     headers["x-machine-id"] = deriveAccountStableId(accountId, "machine");
     headers["x-session-id"] = deriveAccountStableId(accountId, "session");
   }
-  const deviceToken = readBuddyDeviceToken(context);
-  if (deviceToken !== undefined) headers["x-device-token"] = deviceToken;
+  // Per-account device binding: distinct device identity per account (see
+  // resolveBuddyDeviceBinding). Sent as the desktop's X-Device-Id-List.
+  const binding = resolveBuddyDeviceBinding(context);
+  if (binding !== undefined) {
+    headers["x-device-id-list"] = JSON.stringify({ qimei36: binding });
+  }
+  Object.assign(headers, await buddyDeviceTokenHeaders({
+    realm: domain.endsWith(".cn") ? "cn" : "intl",
+    context,
+    cliIdentity,
+  }));
   return headers;
 }
 
@@ -165,6 +180,44 @@ export function readBuddyDeviceToken(context?: ProviderDispatchContext): string
   return readDeviceTokenFile();
 }
 
+/**
+ * The reference `X-Device-Token` pair, per the official desktop app.
+ *
+ * The desktop client (WorkBuddyAI, channel 400111) always presents one of the
+ * two on chat traffic — a real token from the TuringShield SDK, or an
+ * `X-Device-Token-Error` when the SDK cannot produce one. It never omits both,
+ * and it sends the header on every realm (Intl and CN alike). The SDK is a
+ * proprietary native addon; when it is not configured we fall back to a
+ * captured token (auth_state / `CARTETHYIA_DEVICE_TOKEN_FILE`) and only then
+ * to the official failure state.
+ *
+ * - `CARTETHYIA_TURING_SDK_PATH` → real token via `TuringDeviceTokenService`.
+ * - Legacy token (auth_state/file) → used when the SDK is unavailable.
+ * - CLI identity never carries a device token (the CLI has no device).
+ */
+export async function buddyDeviceTokenHeaders(args: {
+  realm: "intl" | "cn";
+  context: ProviderDispatchContext | undefined;
+  cliIdentity: boolean | undefined;
+  turingConfig?: TuringSdkConfig;
+}): Promise<Record<string, string>> {
+  const { context, cliIdentity, turingConfig } = args;
+  void args.realm; // the desktop client sends the token on both realms
+  if (resolveBuddyIdentity(context, cliIdentity) === "cli") return {};
+  // Native SDK first (real token), when configured.
+  if (resolveTuringSdkRoot() !== null) {
+    const sdkHeaders = await getTuringDeviceTokenService(turingConfig ?? WORKBUDDY_TURING_CONFIG).headersForRequest(false);
+    if (sdkHeaders["x-device-token"] !== undefined) return sdkHeaders;
+    // SDK configured but could not produce a token: mirror its failure state,
+    // like the desktop client does — do not fall back to a stale file token.
+    return sdkHeaders;
+  }
+  // No SDK on this deployment: a captured token is better than nothing.
+  const token = readBuddyDeviceToken(context);
+  if (token !== undefined) return { "x-device-token": token };
+  return { "x-device-token-error": "sdk_not_initialized" };
+}
+
 function readDeviceTokenFile(): string | undefined {
   const now = Date.now();
   if (deviceTokenFileCache !== undefined && now - deviceTokenFileCache.readAt < DEVICE_TOKEN_FILE_TTL_MS) {

package/src/providers/integrations/claude/claude.ts

@@ -49,7 +49,7 @@ import { getClaudeCliVersion, adoptClaudeCliVersion, getClaudeSdkVersion } from
 import { adoptRequiredVersion } from "../../operations/client-version-resolver";
 import { getOrCreateInstallId } from "../shared/install-id";
 import { canonicalToClaudeMessagesPayload } from "../../../protocol/request/messages";
-import { applyParamQuirks } from "../../../transport/translation/quirks";
+import { applyParamQuirks } from "../../../protocol/translation/quirks";
 import { CLAUDE_BILLING_HEADER_PREFIX, endpointUrl } from "../../../protocol/codecs";
 import { sendClaudeMessagesRequest } from "../../../protocol/upstream/send-claude-messages";
 import {

package/src/providers/integrations/cloudflareai/cloudflareai.ts

@@ -25,7 +25,7 @@ import type { CanonicalEvent, CanonicalRequest } from "../../../protocol/canonic
 import { GatewayError } from "../../../protocol/gateway-error";
 import { buildClaudeMessagesRequest, filterClaudeCustomHeaders } from "../shared/claude-messages";
 import { sendClaudeMessagesRequest } from "../../../protocol/upstream/send-claude-messages";
-import { applyParamQuirks } from "../../../transport/translation/quirks";
+import { applyParamQuirks } from "../../../protocol/translation/quirks";
 import { decodeCloudflareAiGatewayCredential } from "../../../security/credential-codec";
 
 export const CLOUDFLAREAI_PROVIDER_ID = "cloudflareai" as const;

package/src/providers/integrations/codex/codex-errors.ts

@@ -7,11 +7,11 @@
 import { GatewayError } from "../../../protocol/gateway-error";
 import {
   classifyUpstreamError,
-  parseRetryAfter,
   extractUpstreamMessage,
   upstreamErrorIdentifier,
   upstreamRequestId,
 } from "../../../transport/failure-policy";
+import { parseRetryAfter } from "../../../protocol/upstream-parsing";
 import { tryParseJsonObject } from "../../../protocol/codecs";
 
 function toNumberOrUndefined(value: string | null): number | undefined {

package/src/providers/integrations/codex/codex.ts

@@ -33,9 +33,9 @@ import { isRecord, joinUrl } from "../../../protocol/codecs";
 import { postUpstreamJson } from "../../../protocol/upstream/post-json";
 import {
   MIN_RETRY_BUDGET_MS,
-  parseUpstreamBackoff,
   sleep as defaultSleep,
 } from "../../../transport/failure-policy";
+import { parseUpstreamBackoff } from "../../../protocol/upstream-parsing";
 
 /**
  * Sleep used by the 429 capacity-wait loop, overridable in tests.

package/src/providers/integrations/factory/factory.ts

@@ -49,7 +49,7 @@ import { createUpstreamDeadlineLifecycle, abortGatewayError } from "../../operat
 import { mapUpstreamHttpError } from "../../../transport/failure-policy";
 import { buildClaudeMessagesRequest, filterClaudeCustomHeaders } from "../shared/claude-messages";
 import { sendClaudeMessagesRequest } from "../../../protocol/upstream/send-claude-messages";
-import { applyParamQuirks } from "../../../transport/translation/quirks";
+import { applyParamQuirks } from "../../../protocol/translation/quirks";
 import { createApiKeyAdapter } from "../../configured-provider";
 import type { ApiKeyProviderSpec } from "../../configured-provider";
 import { decodeFactoryDroidCredential } from "../../../security/credential-codec";

package/src/providers/integrations/github/github.ts

@@ -25,7 +25,7 @@ import { postUpstreamJson } from "../../../protocol/upstream/post-json";
 import { providerBaseUrl } from "../../provider-metadata";
 import { getOrCreateInstallId } from "../shared/install-id";
 import { resolveRedisClient } from "../../../persistence/redis";
-import { applyParamQuirks } from "../../../transport/translation/quirks";
+import { applyParamQuirks } from "../../../protocol/translation/quirks";
 import { resolveInboundSessionId } from "../../operations/session-resolution";
 import {
   GITHUB_REQUEST_HEADERS,

package/src/providers/integrations/grok/grok.ts

@@ -20,7 +20,7 @@ import { providerBaseUrl } from "../../provider-metadata";
 import { boundedUpstreamArray, boundedUpstreamNumber, sanitizeUpstreamLabel } from "../../provider-sanitize";
 import { isRecord } from "../../../protocol/codecs";
 import { modelsDevCatalog } from "../../discovery/models-dev-catalog";
-import type { ReasoningEffortLevel } from "../../../transport/translation/thinking";
+import type { ReasoningEffortLevel } from "../../../protocol/translation/thinking";
 import type { FetchLike } from "../../quota/quota-contracts";
 import { resolveInboundSessionId, resolvePromptCacheKey } from "../../operations/session-resolution";
 import {

package/src/providers/integrations/inception/provider.ts

@@ -0,0 +1,91 @@
+import type { ApiKeyProviderSpec } from "../../configured-provider";
+import { fetchOpenAICompatibleModels } from "../../discovery/openai-model-discovery";
+import { defineModel, type ModelDefinition } from "../../provider-model-definition";
+
+const INCEPTION_PROVIDER_ID = "inception" as const;
+
+/**
+ * Inception Labs (Mercury) — bearer-authenticated OpenAI-compatible chat.
+ *
+ * The upstream is a plain `POST /v1/chat/completions` service (SSE streaming,
+ * tool calling, structured outputs, `reasoning_effort`). Base URL comes from
+ * `BUNDLED_PROVIDER_METADATA`; the chat path is declared below the `/v1`
+ * root, exactly like every other version-rooted OpenAI-compatible provider.
+ */
+export const INCEPTION_SPEC: ApiKeyProviderSpec = {
+  provider_id: INCEPTION_PROVIDER_ID,
+  endpoint_paths_by_wire_family: {},
+};
+
+/**
+ * Offline floor: the Mercury chat model this provider serves, pinned to the
+ * free-tier allowance (100M free tokens at signup).
+ *
+ * The roster intentionally carries only `mercury-3` — the operator's choice.
+ * Mercury Voice is enterprise-gated, Mercury Decide is a native decisions
+ * endpoint, and Mercury Edit 2 is FIM/edit; none of them is a chat model, and
+ * a chat wire would not serve them.
+ *
+ * `freeTier` is the catalog flag the console groups on; `free: true` zeroes
+ * the cost the way every other free-allowance provider models its rows — the
+ * allowance does not bill, so the row must not show a price. Limits are
+ * mercury-3's own chat-completions numbers: 1M context, 131072 max output,
+ * reasoning (instant/low/medium/high), tool calling.
+ */
+export const INCEPTION_MODELS: readonly ModelDefinition[] = [
+  defineModel({
+    id: "mercury-3",
+    wireFamily: "chat",
+    endpoint: "/chat/completions",
+    ctx: 1_000_000,
+    out: 131_072,
+    reasoning: true,
+    toolCall: true,
+    free: true,
+    freeTier: true,
+  }),
+];
+
+/**
+ * Live `/v1/models` listing, pinned to the free tier.
+ *
+ * The listing requires the API key (matches the chat endpoint's bearer), so
+ * the credential is forwarded when present; an unauthenticated fetch fails
+ * cleanly and the static roster stays authoritative.
+ *
+ * Every fetched row is stamped `freeTier` and zero-priced, the same rule the
+ * static roster declares: this provider is pinned to its free allowance, so a
+ * model upstream adds must not land in the billed tail.
+ *
+ * A fetched id that the static roster already knows keeps the roster row
+ * whole, not the listing's fields: upstream publishes `max_output_length` and
+ * no `reasoning`/`tool_call` keys, so the shared OpenAI-compatible reader
+ * would otherwise overwrite mercury-3's advertised 131072 output and reasoning
+ * flag with its 64k/not-reasoning defaults. The roster is the canonical
+ * metadata for the models we know; the listing only adds genuinely new ids.
+ */
+export async function discoverInceptionFreeModels(options: {
+  readonly baseUrl: string;
+  readonly credential?: string;
+  readonly fetcher?: typeof fetch;
+}): Promise<readonly ModelDefinition[] | null> {
+  const listed = await fetchOpenAICompatibleModels({
+    baseUrl: options.baseUrl,
+    providerId: "inception",
+    ...(typeof options.credential === "string" && options.credential.trim().length > 0
+      ? { headers: { authorization: `Bearer ${options.credential}` } }
+      : {}),
+    ...(options.fetcher === undefined ? {} : { fetcher: options.fetcher }),
+  });
+  if (listed === null) return null;
+  const known = new Map(INCEPTION_MODELS.map((model) => [model.modelId, model]));
+  return listed.map((model) => {
+    const roster = known.get(model.modelId);
+    if (roster !== undefined) return roster;
+    return {
+      ...model,
+      freeTier: true,
+      cost: { input: 0, output: 0, pricing_model: "pay-per-use" },
+    };
+  });
+}