@iislee/opencodex 2.11.0 → 2.35.0

package/src/adapters/base.ts

@@ -1,11 +1,18 @@
 import type { AdapterEvent, OcxParsedRequest } from "../types";
 import type { TranslatorBudget } from "../lib/translator-budget";
+import type { AdapterTierMetadata } from "../providers/fastwire";
 
 /** Metadata about the caller's incoming request, for auth-forwarding adapters. */
 export interface IncomingMeta {
   headers: Headers;
   translatorBudget: TranslatorBudget;
   abortSignal?: AbortSignal;
+  /**
+   * Provider-scoped fetch prepared by the Responses router. Stateful transports that emit more
+   * than one physical HTTP request per logical turn must reuse it so every request participates in
+   * the same pacing queue and custom provider fetch seam.
+   */
+  providerFetch?: typeof globalThis.fetch;
   /**
    * Image-normalization ladder bias for upstream-413 tightened retries: every image
    * starts one tier lower (devlog/260714_image_normalization_pipeline/030). Only the
@@ -30,15 +37,45 @@ export interface ProviderAdapter {
    */
   buildRequest(parsed: OcxParsedRequest, incoming: IncomingMeta): AdapterRequest | Promise<AdapterRequest>;
 
+  /**
+   * Decide, BEFORE any request is built or sent, that this turn has nothing to ask upstream.
+   *
+   * Returning a reason short-circuits the turn to a locally constructed completed response: no
+   * `buildRequest`, no send, no token estimate, and no empty-completion retry. That last part is
+   * why this cannot be expressed as an outputless `done` from `parseStream`: the empty-completion
+   * guard treats a terminal with no content as a failed turn and re-invokes the identical request,
+   * so an adapter that "successfully returned nothing" would be retried into the very loop it was
+   * trying to end.
+   *
+   * Only for turns whose input already contains the answer — see the Kiro adapter, where replayed
+   * history ending in a delivered final answer has nothing left to complete.
+   */
+  localTerminal?(parsed: OcxParsedRequest): AdapterLocalTerminal | undefined;
+
   fetchResponse?(request: AdapterRequest, ctx?: AdapterFetchContext): Promise<Response>;
 
-  parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent>;
-  parseResponse?(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]>;
+  /**
+   * Parse one upstream response. `tierMetadata` is the same live observer returned on the
+   * corresponding AdapterRequest; adapters that receive a documented tier echo may update it.
+   */
+  parseStream(
+    response: Response,
+    budget: TranslatorBudget,
+    tierMetadata?: AdapterTierMetadata,
+  ): AsyncGenerator<AdapterEvent>;
+  parseResponse?(
+    response: Response,
+    budget: TranslatorBudget,
+    tierMetadata?: AdapterTierMetadata,
+  ): Promise<AdapterEvent[]>;
   runTurn?(
     parsed: OcxParsedRequest,
     incoming: IncomingMeta,
     emit: (event: AdapterEvent) => void,
   ): Promise<void>;
+
+  /** Exact no-field observation for runTurn adapters, which expose no AdapterRequest object. */
+  tierLogForRunTurn?(parsed: OcxParsedRequest): AdapterTierMetadata | undefined;
 }
 
 export interface AdapterRequest {
@@ -46,14 +83,39 @@ export interface AdapterRequest {
     method: string;
     headers: Record<string, string>;
     body: string;
+    /** Final upstream wire names of custom tools lowered to functions while building this request. */
+    convertedRoutedCustomToolNames?: ReadonlySet<string>;
+    /** Native custom-tool wire names authorized for representation-only response repair. */
+    routedCustomToolRepairNames?: ReadonlySet<string>;
+    /** Client tool-search names actually lowered to upstream function calls for this request. */
+    convertedRoutedToolSearchNames?: ReadonlySet<string>;
+    /** Upstream-only aliases for namespace tools flattened in this request. */
+    convertedRoutedNamespaceToolAliases?: ReadonlyMap<string, { namespace: string; name: string; kind: "function" | "custom" }>;
     /** Releases observation of a serialized request body after its final fetch attempt settles. */
     releaseBodyObservation?: () => void;
     /** Exact reasoning parameter emitted by the adapter, for request-log diagnostics only. */
-    reasoningLog?: {
-      effectiveEffort: string;
-      wireField: "reasoning_effort" | "thinking_budget" | "thinking.type";
-      wireValue: string | number;
-    };
+    reasoningLog?:
+      | {
+          effectiveEffort: string;
+          wireField: "reasoning.enabled";
+          wireValue: boolean;
+        }
+      | {
+          effectiveEffort: string;
+          wireField: "thinking_budget";
+          wireValue: number;
+        }
+      | {
+          effectiveEffort: string;
+          wireField: "reasoning_effort" | "reasoning.effort" | "thinking.type";
+          wireValue: string;
+        };
+    /**
+     * Exact tier outcome seeded after this adapter serialized the outbound request.
+     * This is a live shared observer: response-phase methods mutate `outcome`, so retain
+     * the reference rather than cloning or snapshotting it.
+     */
+    tierLog?: AdapterTierMetadata;
     usageLog?: {
       inputTokens?: number;
       estimated?: boolean;
@@ -69,4 +131,17 @@ export interface AdapterFetchContext {
   returnRawErrors?: boolean;
   /** Whether the upstream response will be consumed as a stream; adapters may select low-latency transport settings. */
   stream?: boolean;
+  /** Custom fetch executor to use for physical upstream network requests (defaults to globalThis.fetch). */
+  executor?: typeof globalThis.fetch;
+}
+
+/**
+ * An adapter's decision that a turn needs no upstream inference at all.
+ *
+ * `reason` is diagnostic only. It is never sent to the client and never logged as request
+ * content: it names the code path for a maintainer reading a request log, so it must stay a
+ * fixed identifier rather than anything derived from the conversation.
+ */
+export interface AdapterLocalTerminal {
+  reason: string;
 }

package/src/adapters/client-fingerprint.ts

@@ -40,20 +40,26 @@ export function claudeCodeSessionId(token: string | undefined): string {
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${variant}${h.slice(17, 20)}-${h.slice(20, 32)}`;
 }
 
-// ── Antigravity CLI ──
-/** Pinned fallback Antigravity CLI version (real client fetches a manifest; we pin to avoid the network dependency). */
-export const ANTIGRAVITY_CLI_VERSION = "1.0.13";
-const ANTIGRAVITY_CLI_CLIENT_NAME = "aidev_client";
-const ANTIGRAVITY_CLI_PLATFORM = "darwin/arm64";
-/** Secondary Google API client UA the Antigravity client library reports. */
-export const ANTIGRAVITY_GOOG_API_CLIENT_UA = "google-api-nodejs-client/10.3.0";
+// ── Antigravity IDE ──
+/** Pinned fallback Antigravity IDE language-server version (matches the bundled LS 2.5.5). */
+export const ANTIGRAVITY_IDE_VERSION = "2.5.5";
+const ANTIGRAVITY_IDE_CLIENT_NAME = "aidev_client";
+const ANTIGRAVITY_IDE_PLATFORM = "windows/amd64";
 
 /**
- * The real Antigravity CLI User-Agent, e.g.
- * `antigravity/cli/1.0.13 (aidev_client; os_type=darwin; arch=arm64)`.
+ * Real Antigravity IDE User-Agent format, decompiled from 2.5.5 Go LS (`setHeaders` @ `0x1018fbe00`):
+ * `antigravity/ide/${version} (os_type=${osType}; arch=${arch}; aidev_client; auth_method=oauth)`
+ *
+ * Token ordering from decompiled binary: `os_type` -> `arch` -> `aidev_client` -> `auth_method=oauth`.
+ *
+ * Must be the IDE client family (`antigravity/ide/...`): Cloud Code Assist backend gates
+ * newer agent models (e.g. `gemini-3.7-flash`) by User-Agent and answers 404 NOT_FOUND to
+ * CLI-shaped UAs even with a valid OAuth token. Only `antigravity/ide/<ver>` unlocks them.
  * A `GOOGLE_ANTIGRAVITY_USER_AGENT` override (set by the caller) takes precedence upstream.
  */
-export function antigravityUserAgent(version = ANTIGRAVITY_CLI_VERSION): string {
-  const [osType, arch] = ANTIGRAVITY_CLI_PLATFORM.split("/");
-  return `antigravity/cli/${version} (${ANTIGRAVITY_CLI_CLIENT_NAME}; os_type=${osType}; arch=${arch})`;
+export function antigravityUserAgent(version = ANTIGRAVITY_IDE_VERSION, authMethod = "oauth"): string {
+  const ov = process.env.GOOGLE_ANTIGRAVITY_USER_AGENT?.trim();
+  if (ov) return ov;
+  const [osType, arch] = ANTIGRAVITY_IDE_PLATFORM.split("/");
+  return `antigravity/ide/${version} (os_type=${osType}; arch=${arch}; ${ANTIGRAVITY_IDE_CLIENT_NAME}; auth_method=${authMethod})`;
 }

package/src/adapters/cline-pass-deepseek-v4-tool-replay.ts

@@ -0,0 +1,69 @@
+import type { ProviderAdapter } from "./base";
+
+const CLINE_PASS_DEEPSEEK_V4_MODELS = new Set([
+  "cline-pass/deepseek-v4-flash",
+  "cline-pass/deepseek-v4-pro",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function isClinePassDeepSeekV4Model(modelId: string): boolean {
+  return CLINE_PASS_DEEPSEEK_V4_MODELS.has(modelId);
+}
+
+/**
+ * DeepSeek V4 can copy historical pre-tool narration back into the next turn and
+ * eventually degenerate into text-only "I'll call the tool" loops. For the two
+ * affected ClinePass models, replay historical assistant tool turns as the
+ * structured call only. Normal assistant messages, tool results, and separate
+ * reasoning metadata remain untouched.
+ */
+export function stripClinePassDeepSeekV4ToolReplayNarration(
+  body: string,
+  modelId: string,
+): string {
+  if (!isClinePassDeepSeekV4Model(modelId)) return body;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return body;
+  }
+  if (!isRecord(parsed) || !Array.isArray(parsed.messages)) return body;
+
+  let changed = false;
+  const messages = parsed.messages.map(message => {
+    if (!isRecord(message) || message.role !== "assistant") return message;
+    const toolCalls = message.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) return message;
+    if (message.content === "") return message;
+
+    changed = true;
+    return { ...message, content: "" };
+  });
+
+  return changed ? JSON.stringify({ ...parsed, messages }) : body;
+}
+
+/**
+ * Apply the ClinePass DeepSeek V4 replay compatibility policy after the ordinary
+ * OpenAI-chat request has been serialized. The adapter's response parsing and all
+ * non-target request behavior stay identical.
+ */
+export function withClinePassDeepSeekV4ToolReplayCompatibility(
+  adapter: ProviderAdapter,
+): ProviderAdapter {
+  return {
+    ...adapter,
+    async buildRequest(parsed, incoming) {
+      const request = await adapter.buildRequest(parsed, incoming);
+      if (!isClinePassDeepSeekV4Model(parsed.modelId)) return request;
+
+      const body = stripClinePassDeepSeekV4ToolReplayNarration(request.body, parsed.modelId);
+      return body === request.body ? request : { ...request, body };
+    },
+  };
+}