@bitkyc08/opencodex 2.83.0 → 2.86.0

package/src/adapters/cursor/freeform-args.ts

@@ -0,0 +1,75 @@
+import { freeformFallbackKeys } from "../../responses/apply-patch-envelope";
+
+/**
+ * Pre-emission gate for Cursor calls to request-declared freeform tools (#7049).
+ *
+ * Cursor carries a freeform body as a JSON object, and the canonical shape is `{input:string}`.
+ * Claude models routed through Cursor also name the body after its content — `{"code": "..."}`
+ * for the code-mode `exec` cell — and the shared Responses repair downstream already unwraps
+ * exactly that (`unwrapFreeformToolInput`: no `input` key, ONE string-valued fallback key).
+ * This gate used to accept only `input`, so it turned a payload the bridge knows how to read
+ * into a fatal adapter error before any host execution. It now applies the same single faithful
+ * reading and re-emits it canonically; anything ambiguous or non-string still fails closed.
+ *
+ * A canonical wrapper is returned byte-identical. Only the repaired shape is re-serialized.
+ */
+export type CursorFreeformArgs =
+  | { ok: true; args: string }
+  | { ok: false; reason: string };
+
+/**
+ * The only key names a diagnostic may print. They are constants written here, so the error can
+ * never carry request-derived text: a model can put body text or an identifier in key position,
+ * and the message is persisted to request logs. Every other key is counted, not named.
+ */
+const NAMEABLE_KEYS: ReadonlySet<string> = new Set([
+  "input",
+  "code", "script", "js", "javascript", "command", "cmd", "content", "patch",
+  "source", "program", "body", "text", "args", "arguments",
+]);
+const MAX_LISTED_KEYS = 8;
+
+function valueKind(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+/**
+ * Shape-only description of a rejected wrapper: allowlisted key names with their value kinds,
+ * then a count of every other key. Never values, never an unlisted key name.
+ */
+function describeKeys(record: Record<string, unknown>): string {
+  const keys = Object.keys(record);
+  if (keys.length === 0) return "received an empty object";
+  const listed = keys.filter(key => NAMEABLE_KEYS.has(key))
+    .slice(0, MAX_LISTED_KEYS)
+    .map(key => `${key}:${valueKind(record[key])}`);
+  const hidden = keys.length - listed.length;
+  if (hidden > 0) listed.push(`+${hidden} other`);
+  return `received keys [${listed.join(", ")}]`;
+}
+
+export function canonicalCursorFreeformArgs(args: string, toolName: string): CursorFreeformArgs {
+  if (args.length === 0) return { ok: false, reason: "received no arguments" };
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(args);
+  } catch {
+    return { ok: false, reason: "received arguments that are not JSON" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, reason: `received a JSON ${valueKind(parsed)}` };
+  }
+  const record = parsed as Record<string, unknown>;
+  if (Object.prototype.hasOwnProperty.call(record, "input")) {
+    return typeof record.input === "string"
+      ? { ok: true, args }
+      : { ok: false, reason: `input was ${valueKind(record.input)}` };
+  }
+  const candidates = freeformFallbackKeys(toolName).filter(key => typeof record[key] === "string");
+  if (candidates.length === 1) {
+    return { ok: true, args: JSON.stringify({ input: record[candidates[0]] as string }) };
+  }
+  return { ok: false, reason: describeKeys(record) };
+}

package/src/adapters/cursor/protobuf-events.ts

@@ -2,6 +2,7 @@ import type { OcxUsage } from "../../types";
 import type { AgentServerMessage, McpArgs, ToolCall } from "./gen/agent_pb";
 import { decodeCursorArgsMap } from "./arg-codec";
 import { normalizeArgKeys } from "./arg-normalize";
+import { canonicalCursorFreeformArgs } from "./freeform-args";
 import {
   CODEX_APPLY_PATCH_TOOL,
   CURSOR_MULTI_EDIT_TOOL,
@@ -334,9 +335,20 @@ function toolSchemaForWireName(state: CursorProtobufEventState, toolName: string
   return resolveShellBridgeAliasKey(toolName, alias => state.toolSchemas!.get(alias));
 }
 
-function decodeMcpArgsNormalized(args: McpArgs | undefined, state: CursorProtobufEventState): string {
-  const decoded = decodeCursorArgsMap(args?.args);
+function isFreeformCall(state: CursorProtobufEventState, responsesName: string | undefined): boolean {
+  return responsesName !== undefined && state.freeformToolNames?.has(responsesName) === true;
+}
+
+function decodeMcpArgsNormalized(
+  args: McpArgs | undefined,
+  state: CursorProtobufEventState,
+  openResponsesName?: string,
+): string {
   const toolName = mcpWireNameFromArgs(args);
+  const responsesName = toolName
+    ? responsesToolNameFromCursorWire(toolName, state.cursorToolNameMap)
+    : openResponsesName;
+  const decoded = decodeCursorArgsMap(args?.args, { preserveStrings: isFreeformCall(state, responsesName) });
   const schema = toolSchemaForWireName(state, toolName);
   if (schema) return JSON.stringify(normalizeArgKeys(decoded, schema));
   return JSON.stringify(decoded);
@@ -381,8 +393,13 @@ function normalizeJsonText(text: string, toolName: string | undefined, state: Cu
  * preserved verbatim so the bridge can reject malformed or truncated JSON instead of silently
  * converting it to `{}`. A genuinely empty buffer remains the no-argument case.
  */
-function resolveCompletedArgs(buffered: string, args: McpArgs | undefined, state: CursorProtobufEventState): string {
-  if (hasMcpArgBytes(args)) return decodeMcpArgsNormalized(args, state);
+function resolveCompletedArgs(
+  buffered: string,
+  args: McpArgs | undefined,
+  state: CursorProtobufEventState,
+  openResponsesName?: string,
+): string {
+  if (hasMcpArgBytes(args)) return decodeMcpArgsNormalized(args, state, openResponsesName);
   const name = mcpWireNameFromArgs(args);
   if (isCompleteJson(buffered)) return normalizeJsonText(buffered, name, state);
   return buffered;
@@ -1092,7 +1109,7 @@ export function mapSyntheticMcpExecToToolEvents(
     const out: CursorServerMessage[] = [...recordToolCall(options.state, callId, cursorWireName)];
     if (out.some(event => event.type === "error")) return out;
     const open = options.state.openToolCalls.get(callId);
-    const finalArgs = resolveCompletedArgs(open?.args ?? "", args, options.state);
+    const finalArgs = resolveCompletedArgs(open?.args ?? "", args, options.state, open?.name);
     out.push(...commitToolCall(options.state, callId, finalArgs));
     return out;
   }
@@ -1167,23 +1184,16 @@ function discardBufferedTextToolCalls(state: CursorProtobufEventState): void {
  * recorded in `openToolCalls`. Because each completion emits a whole non-interleaved unit, the bridge
  * (which tracks a single current tool call) serializes parallel Cursor calls correctly.
  */
-function cursorFreeformWrapperValid(args: string): boolean {
-  try {
-    const parsed = JSON.parse(args) as unknown;
-    return !!parsed
-      && typeof parsed === "object"
-      && !Array.isArray(parsed)
-      && typeof (parsed as Record<string, unknown>).input === "string";
-  } catch {
-    return false;
-  }
+/** True when the args already carry a body this call can commit, canonical or repairable (#7049). */
+function cursorFreeformArgsCommittable(args: string, toolName: string): boolean {
+  return canonicalCursorFreeformArgs(args, toolName).ok;
 }
 
-function dropInvalidFreeformCall(state: CursorProtobufEventState, callId: string, toolName: string): CursorServerMessage[] {
+function dropInvalidFreeformCall(state: CursorProtobufEventState, callId: string, toolName: string, reason: string): CursorServerMessage[] {
   state.openToolCalls.delete(callId);
   state.translatorBudget?.closeCall(callId);
   state.completedToolCalls.add(callId);
-  return [{ type: "error", message: `${toolName} call had invalid freeform arguments; expected {input:string}` }];
+  return [{ type: "error", message: `${toolName} call had invalid freeform arguments; expected {input:string} (${reason})` }];
 }
 
 function dropShellBridgeCall(state: CursorProtobufEventState, callId: string, toolName: string): CursorServerMessage[] {
@@ -1202,11 +1212,14 @@ function dropStructuredEditCall(state: CursorProtobufEventState, callId: string,
   return [{ type: "text", text: `\n${toolName} call was not converted to apply_patch: ${reason}` }];
 }
 
-function commitToolCall(state: CursorProtobufEventState, callId: string, finalArgs: string): CursorServerMessage[] {
+function commitToolCall(state: CursorProtobufEventState, callId: string, committedArgs: string): CursorServerMessage[] {
   const open = state.openToolCalls.get(callId);
   if (!open) return [];
-  if (state.freeformToolNames?.has(open.name) && !cursorFreeformWrapperValid(finalArgs)) {
-    return dropInvalidFreeformCall(state, callId, open.name);
+  let finalArgs = committedArgs;
+  if (isFreeformCall(state, open.name)) {
+    const freeform = canonicalCursorFreeformArgs(finalArgs, open.name);
+    if (!freeform.ok) return dropInvalidFreeformCall(state, callId, open.name, freeform.reason);
+    finalArgs = freeform.args;
   }
   const schema = toolSchemaForWireName(state, open.name);
   if (!cursorShellBridgeArgsValid(finalArgs, open.name, schema)) {
@@ -1386,7 +1399,7 @@ export function mapCursorProtobufServerMessage(
         && (
           (name !== undefined && openBeforeStart.args.length === 0)
           || (state.freeformToolNames?.has(openBeforeStart.name) === true
-            && !cursorFreeformWrapperValid(openBeforeStart.args)
+            && !cursorFreeformArgsCommittable(openBeforeStart.args, openBeforeStart.name)
           )
         )
       ) {
@@ -1410,13 +1423,13 @@ export function mapCursorProtobufServerMessage(
       if (
         !openBeforeStart && open && !hasMcpArgBytes(args)
         && state.freeformToolNames?.has(open.name) === true
-        && !cursorFreeformWrapperValid(open.args)
+        && !cursorFreeformArgsCommittable(open.args, open.name)
       ) {
         open.awaitingNativeArgs = true;
         return [];
       }
       if (open) {
-        const finalArgs = resolveCompletedArgs(open.args, args, state);
+        const finalArgs = resolveCompletedArgs(open.args, args, state, open.name);
         out.push(...commitToolCall(state, update.value.callId, finalArgs));
       }
       return out;

package/src/adapters/google-antigravity-wire.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { OcxContentPart, OcxParsedRequest } from "../types";
-import { antigravityUserAgent } from "./client-fingerprint";
+import { antigravityCliUserAgent, antigravityUserAgent } from "./client-fingerprint";
 
 /**
  * Antigravity request User-Agent. Mirrors the real Antigravity IDE UA
@@ -11,6 +11,27 @@ import { antigravityUserAgent } from "./client-fingerprint";
  */
 export const ANTIGRAVITY_REQUEST_UA = antigravityUserAgent();
 
+/**
+ * Antigravity CLI User-Agent. CCA serves Gemini 4 Argon only to the CLI client family, and it
+ * 404s other agent models (`gemini-3.7-flash-tiered`, `gemini-3.1-pro-low`) under it, so the
+ * choice is per wire model: see `antigravityUserAgentForWireModel`.
+ */
+export const ANTIGRAVITY_CLI_REQUEST_UA = antigravityCliUserAgent();
+
+/**
+ * Model discovery (`:fetchAvailableModels`) uses the CLI UA so Argon's wire ids are listed;
+ * under the IDE UA they are absent.
+ */
+export const ANTIGRAVITY_DISCOVERY_UA = ANTIGRAVITY_CLI_REQUEST_UA;
+
+/** Wire ids CCA serves only to the CLI client family (verified 2026-10-14). */
+const ANTIGRAVITY_CLI_ONLY_WIRE_MODEL = /^gemini-4-argon(?:-(?:low|medium|high))?$/;
+
+/** The User-Agent an Antigravity inference request for `wireModelId` must carry. */
+export function antigravityUserAgentForWireModel(wireModelId: string): string {
+  return ANTIGRAVITY_CLI_ONLY_WIRE_MODEL.test(wireModelId) ? ANTIGRAVITY_CLI_REQUEST_UA : ANTIGRAVITY_REQUEST_UA;
+}
+
 /**
  * Whether a stored `OcxToolCall.thoughtSignature` is a REAL upstream Gemini signature versus a
  * foreign id that must not be forwarded to Gemini/Antigravity.

package/src/adapters/google.ts

@@ -21,7 +21,7 @@ import { getVertexAccessToken } from "../lib/gcp-adc";
 import { fetchAntigravityWithRetry, fetchVertexWithRetry } from "./google-http";
 import { safeAntigravityHttpErrorMessage, safeVertexHttpErrorMessage } from "./google-errors";
 import { isVertexTruncatedTurn, vertexTruncationErrorEvent } from "./google-truncation";
-import { ANTIGRAVITY_REQUEST_UA, antigravitySessionAnchor, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
+import { antigravitySessionAnchor, antigravityUserAgentForWireModel, antigravitySessionId, isLikelyRealThoughtSignature, sanitizeAntigravityClaudeSignatures } from "./google-antigravity-wire";
 import { summarizeGoogleWireShape } from "./google-wire-shape";
 import { compileGoogleWireBody } from "./google-wire-compiler";
 import type { GoogleToolSchemaLossReport, GoogleToolSchemaProfile } from "./google-tool-schema";
@@ -1155,7 +1155,7 @@ export function createGoogleAdapter(provider: OcxProviderConfig): ProviderAdapte
           requestId: `agent-${crypto.randomUUID()}`,
           request,
         };
-        headers["User-Agent"] = ANTIGRAVITY_REQUEST_UA;
+        headers["User-Agent"] = antigravityUserAgentForWireModel(wireModelId);
         headers["Authorization"] = `Bearer ${token}`;
         return { url, method: "POST", headers, body: JSON.stringify(envelope) };
       }

package/src/adapters/ollama-native.ts

@@ -31,6 +31,7 @@ import {
 } from "../lib/translator-budget";
 import { redactSecretString, SENSITIVE_KEY_PATTERN } from "../lib/redact";
 import { parseDataUrl } from "./image";
+import { jsonStringPartsUtf8Bytes, jsonUtf8Bytes } from "../lib/json-byte-size";
 import {
   ollamaNativeChatUrl,
   ollamaNativeEndpointKind,
@@ -110,6 +111,21 @@ const NATIVE_THINK_VALUES = new Set(["low", "medium", "high", "max"]);
 const NATIVE_TOOL_ID_MAX_LENGTH = 256;
 const NATIVE_TOOL_NAME_MAX_BYTES = 1024;
 const NATIVE_MAX_PENDING_TOOL_CALLS = 128;
+const NATIVE_MAX_LATE_ATTRIBUTION_BYTES = 256 * 1024;
+/** Proxy-owned refusal text for an exhausted late-attribution budget. A compaction on the same
+ *  Ollama route resends the same history, so the only reliable recovery is a new thread. */
+export const OLLAMA_LATE_ATTRIBUTION_LIMIT_MESSAGE =
+  "Late tool-output attribution for this conversation exceeded the 256 KiB per-request limit. Start a new thread to continue.";
+
+/** The late-attribution budget refusal, reporting the full limit rather than the bytes left. */
+export class OllamaLateAttributionBudgetError extends TranslatorBudgetExceededError {
+  readonly publicMessage = OLLAMA_LATE_ATTRIBUTION_LIMIT_MESSAGE;
+
+  constructor() {
+    super("request_copies", NATIVE_MAX_LATE_ATTRIBUTION_BYTES);
+    this.name = "OllamaLateAttributionBudgetError";
+  }
+}
 // Account for the retained Map key and call bookkeeping in addition to the provider's name.
 const NATIVE_TOOL_CALL_BOOKKEEPING_BYTES = 128;
 const NATIVE_TOOL_ID_CONTROL = /[\u0000-\u001f\u007f]/u;
@@ -325,6 +341,7 @@ function buildNativeMessages(
   reservedToolCallIds.clear();
   let pending: PendingToolBatch | undefined;
   const issuedCalls = new Map<string, PendingToolCall>();
+  let lateAttributionBytes = 0;
   // Codex records mid-turn injections (a PostToolUse hook verdict, a context notice) between an
   // assistant tool call and that call's own tool result. Native Ollama needs the call and its
   // results adjacent, so those conversational messages wait here instead of closing the batch
@@ -392,9 +409,20 @@ function buildNativeMessages(
         // Reopening a settled batch would split a later call/result pair. Keep known late
         // output explicitly attributed as conversation text instead of dropping it or
         // fabricating another executable call. Unknown/mismatched identities still fail above.
+        // Generated attribution is not present in the inbound size estimate. Reserve its
+        // JSON wire bytes before joining strings, across all late outputs and all calls.
+        // Count the joined JSON string exactly, without constructing a measurement copy.
+        const attribution = ['[ocx] additional output for previously issued tool "',
+          call.wireName, '" (', call.id, '):\n', message.isError ? "ERROR: " : ""];
+        try {
+          lateAttributionBytes += jsonStringPartsUtf8Bytes(attribution, NATIVE_MAX_LATE_ATTRIBUTION_BYTES - lateAttributionBytes);
+        } catch (error) {
+          if (error instanceof TranslatorBudgetExceededError) throw new OllamaLateAttributionBudgetError();
+          throw error;
+        }
         const translated = contentToNative(message.content, "late tool result");
         const late: OllamaNativeMessage = { role: "user",
-          content: `[ocx] additional output for previously issued tool "${call.wireName}" (${call.id}):\n${message.isError ? "ERROR: " : ""}${translated.content}`,
+          content: attribution.join("") + translated.content,
           ...(translated.images ? { images: translated.images } : {}),
         };
         if (pending) deferred.push(late);

package/src/adapters/openai-chat/messages.ts

@@ -142,12 +142,12 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
   };
 
   const nativeOpenAI = isNativeOpenAIChatTarget(provider);
-  // Two pinned chat templates reject non-leading system and every developer role while a
-  // later user renders in place: Qwen3.8-27B and the OrcaSAQ-2-Cyber-27B GGUF family.
+  // Leading-system chat templates reject non-leading system and every developer role while a
+  // later user renders in place: Qwen3.8-27B, Flash-Next, and the OrcaSAQ-2-Cyber-27B GGUF family.
   // Gateways serve them under namespaced ids (LiteLLM's openai/Qwen3.8-27B, #6674), so any
   // number of leading path segments is accepted; the final segment names the checkpoint.
   // Orca's GGUF marker must precede any colon quant tag; other Orca variants are unchanged.
-  const leadingSystemTemplate = !nativeOpenAI && /^(?:[^/]+\/)*(?:Qwen3\.8-27B|qwen3-8-27b(?:-(?:fp8|lora))?|OrcaSAQ-2-Cyber-27B(?=[^:/\s]*GGUF)[^:/\s]*(?::[\w-]+)?)$/i.test(parsed.modelId);
+  const leadingSystemTemplate = !nativeOpenAI && /^(?:[^/]+\/)*(?:flash-next|Qwen3\.8-Flash-Next|Qwen3\.8-27B|qwen3-8-27b(?:-(?:fp8|lora))?|OrcaSAQ-2-Cyber-27B(?=[^:/\s]*GGUF)[^:/\s]*(?::[\w-]+)?)$/i.test(parsed.modelId);
   // Which role a developer message carries, and why the unrecorded state folds, is stated once
   // in ./developer-role.ts and read from there by the native passthrough as well. Either way the
   // message keeps the slot it arrived in — only the role changes, never the position.
@@ -292,7 +292,11 @@ export function messagesToChatFormat(parsed: OcxParsedRequest, provider: OcxProv
           }
         }
         const hasReplayedReasoning = chatMsg.reasoning_content !== undefined || chatMsg.reasoning_details !== undefined;
-        if (chatMsg.content === undefined && toolCalls.length === 0 && !hasReplayedReasoning) break;
+        // A turn with no answer text, tools or reasoning carries nothing. Between a call and its
+        // result it would also split the pair, so drop it there; a standalone empty answer keeps
+        // its slot so templates that require strict user/assistant alternation still accept it.
+        const carriesNothing = !chatMsg.content && toolCalls.length === 0 && !hasReplayedReasoning;
+        if (carriesNothing && (chatMsg.content === undefined || pendingToolCalls.length > 0)) break;
         flushPendingToolCalls();
         const wireToolCalls = toolCalls.map(tc => {
           let id = tc.id;

package/src/adapters/openai-chat/response-events.ts

@@ -1,6 +1,7 @@
 import { diagnoseInvalidToolCalls, isRecord, type InvalidToolCallDiagnostic } from "./tool-call-validation";
 import { TranslatorBudgetExceededError, type TranslatorBudget } from "../../lib/translator-budget";
-import type { AdapterEvent, OcxUsage } from "../../types";
+import type { AdapterEvent, OcxProviderConfig, OcxUsage } from "../../types";
+import { createInlineThinkContentSplitter } from "../inline-think-tags";
 
 export function stopReasonFor(finishReason: unknown): "max_tokens" | "content_filter" | undefined {
   return finishReason === "length"
@@ -18,6 +19,63 @@ export function reasoningTextFrom(record: Record<string, unknown>): string | und
       : undefined;
 }
 
+type ChatContentEvent = Extract<AdapterEvent, { type: "text_delta" | "reasoning_raw_delta" | "error" }>;
+
+/** Mistral can mix typed blocks and strings in one response. Other destinations keep their parser. */
+export function chatContentEvents(content: unknown, baseUrl: string, usage?: OcxUsage, buffered = false): ChatContentEvent[] {
+  if (typeof content === "string") return content.length > 0 || buffered ? [{ type: "text_delta", text: content }] : [];
+  if (!Array.isArray(content)) return [];
+  let host: string;
+  try { host = new URL(baseUrl).hostname; } catch { return []; }
+  if (host !== "api.mistral.ai") return [];
+  const invalid = (): ChatContentEvent[] => [{
+    type: "error", status: 502, errorType: "upstream_error",
+    message: "unsupported Mistral content block", ...(usage ? { usage } : {}),
+  }];
+  const events: ChatContentEvent[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) return invalid();
+    if (block.type === "text" && typeof block.text === "string") {
+      if (block.text.length > 0 || buffered) events.push({ type: "text_delta", text: block.text });
+    } else if (block.type === "thinking" && Array.isArray(block.thinking)) {
+      for (const inner of block.thinking) {
+        if (!isRecord(inner) || inner.type !== "text" || typeof inner.text !== "string") return invalid();
+        if (inner.text.length > 0) events.push({ type: "reasoning_raw_delta", text: inner.text });
+      }
+    } else return invalid();
+  }
+  return events;
+}
+
+/** Keep adjacent text together; typed reasoning flushes and resets inline-tag parsing. */
+export function createChatContentSplitter(provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget) {
+  let splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
+  return {
+    feed(event: ChatContentEvent): AdapterEvent[] {
+      if (event.type === "error") return [event];
+      if (event.type === "text_delta") return splitter.feed(event.text);
+      const pending = splitter.flush();
+      splitter.dispose();
+      splitter = createInlineThinkContentSplitter(provider.inlineThinkTagModels, modelId, budget);
+      return [...pending, event];
+    },
+    flush: () => splitter.flush(),
+    dispose: () => splitter.dispose(),
+  };
+}
+
+/** Split a buffered answer with the same typed-reasoning boundaries as a stream. */
+export function splitChatContentEvents(content: unknown, provider: OcxProviderConfig, modelId: string | undefined, budget: TranslatorBudget, usage?: OcxUsage): AdapterEvent[] {
+  const events = chatContentEvents(content, provider.baseUrl, usage, true);
+  if (events.some(event => event.type === "error")) return events;
+  const splitter = createChatContentSplitter(provider, modelId, budget);
+  try {
+    return [...events.flatMap(event => splitter.feed(event)), ...splitter.flush()];
+  } finally {
+    splitter.dispose();
+  }
+}
+
 export interface ReasoningDetailSegment {
   key: string;
   text: string;

package/src/adapters/openai-chat.ts

@@ -5,7 +5,6 @@ import { applyExplicitChatReasoningWirePolicy } from "./openai-chat/reasoning-wi
 import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "./base";
 import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig, OcxUsage } from "../types";
 import { modelInList } from "../types";
-import { createInlineThinkContentSplitter, splitInlineThinkContent } from "./inline-think-tags";
 import { mapReasoningEffort } from "../reasoning-effort";
 import { debugProviderDiagnostic } from "../lib/debug";
 import { sseFieldValue } from "../lib/sse-decoder";
@@ -28,6 +27,7 @@ import {
   type InvalidToolCallDiagnostic,
 } from "./openai-chat/tool-call-validation";
 import {
+  chatContentEvents, createChatContentSplitter, splitChatContentEvents,
   createReasoningDetailSnapshotTracker,
   invalidChoicesEvent,
   invalidToolCallsEvent,
@@ -368,7 +368,7 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       const reasoningDetailsOptIn = modelInList(provider.reasoningDetailsModels, lastRequestedModelId ?? "");
       // A gateway with no server-side reasoning parser leaves thinking inline in `content` as
       // <think> blocks, which would otherwise render as the answer. Passthrough unless opted in.
-      const inlineThink = createInlineThinkContentSplitter(provider.inlineThinkTagModels, lastRequestedModelId, budget);
+      const inlineThink = createChatContentSplitter(provider, lastRequestedModelId, budget);
       const emitContent = function* (events: AdapterEvent[]): Generator<AdapterEvent> {
         for (const event of events) {
           // Any other event keeps its place behind held text instead of overtaking it.
@@ -444,8 +444,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
             const reasoningText = reasoningTextFrom(delta);
             if (reasoningText !== undefined) yield* toolCallContent.hold({ type: "reasoning_raw_delta", text: reasoningText });
           }
-          if (typeof delta.content === "string" && delta.content.length > 0) {
-            yield* emitContent(inlineThink.feed(delta.content));
+          for (const event of chatContentEvents(delta.content, provider.baseUrl, pendingUsage)) {
+            if (event.type === "error") return yield* terminateWithError(event);
+            yield* emitContent(inlineThink.feed(event));
           }
 
           const rawToolCalls = delta.tool_calls;
@@ -767,7 +768,9 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         }
         if (reasoningText !== undefined) events.push({ type: "reasoning_raw_delta", text: reasoningText });
         const contentStart = events.length;
-        if (typeof msg.content === "string") events.push(...splitInlineThinkContent(provider.inlineThinkTagModels, lastRequestedModelId, budget, msg.content));
+        const contentEvents = splitChatContentEvents(msg.content, provider, lastRequestedModelId, budget, usage);
+        if (contentEvents.some(event => event.type === "error")) return contentEvents;
+        events.push(...contentEvents);
         const contentEnd = events.length;
         const answerText = events.slice(contentStart).map(event => (event.type === "text_delta" ? event.text : "")).join("");
         // Each call holds the delta event it emitted, so the batch repair sets its arguments later.

package/src/adapters/openai-responses/empty-assistant.ts

@@ -0,0 +1,32 @@
+import { isPlainObject } from "./internal";
+
+const MESSAGE_FIELDS = new Set(["type", "role", "content", "id", "status", "phase"]);
+
+function isEmptyTextPart(part: unknown): boolean {
+  if (!isPlainObject(part) || !["text", "input_text", "output_text"].includes(String(part.type)) || part.text !== "") return false;
+  // Nonempty annotations and unknown fields may carry information despite the blank text.
+  return Object.keys(part).every(key => key === "type" || key === "text"
+    || ((key === "annotations" || key === "logprobs") && Array.isArray(part[key]) && part[key].length === 0));
+}
+
+function isEmptyAssistantMessage(item: unknown): boolean {
+  if (!isPlainObject(item) || item.role !== "assistant" || (item.type !== undefined && item.type !== "message")) return false;
+  // Never discard tools, reasoning, opaque state or unknown extension fields on a message.
+  if (!Object.keys(item).every(key => MESSAGE_FIELDS.has(key))) return false;
+  return item.content === "" || (Array.isArray(item.content) && item.content.every(isEmptyTextPart));
+}
+
+/** Kimi Code rejects content-empty assistant messages even on its native Responses endpoint. */
+export function stripKimiEmptyAssistantMessages(body: unknown, responseUrl: string): unknown {
+  let url: URL;
+  try { url = new URL(responseUrl); } catch { return body; }
+  if (url.hostname !== "api.kimi.com" || !/^\/coding\/v1\/responses\/?$/.test(url.pathname)) return body;
+  if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
+  const referencedIds = new Set<string>();
+  for (const item of body.input) {
+    if (isPlainObject(item) && item.type === "item_reference" && typeof item.id === "string") referencedIds.add(item.id);
+  }
+  const input = body.input.filter(item => !isEmptyAssistantMessage(item)
+    || (isPlainObject(item) && typeof item.id === "string" && referencedIds.has(item.id)));
+  return input.length === body.input.length ? body : { ...body, input };
+}

package/src/adapters/openai-responses/passthrough.ts

@@ -50,6 +50,7 @@ import { observeOutbound } from "../../usage/cache-diagnostic";
 import { normalizeForwardedClientHeaderName } from "../../lib/provider-client-headers";
 import { normalizeMuseToolChoice } from "./muse-tool-choice";
 import { renderCompactionSearchHistoryItems } from "./compaction-search-history";
+import { stripKimiEmptyAssistantMessages } from "./empty-assistant";
 
 /**
  * Identifies DeepSeek's strict Responses replay contract: tool-bearing continuations need
@@ -477,6 +478,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       // Run after routed compaction so nested input_image parts are replaced before a malformed
       // tool output is flattened to text and can no longer be inspected structurally.
       outBody = repairUnidentifiedToolOutputItems(outBody);
+      outBody = stripKimiEmptyAssistantMessages(outBody, url);
       if (parsed._plaintextV2AgentMessages === true && isCanonicalOpenAiForwardProvider(provider)) {
         const prepared = preparePlaintextV2AgentMessages(outBody);
         outBody = prepared.body;
@@ -499,6 +501,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
                   outBody,
                   destinationDecodesNativeCompactionBlob(provider),
                   threadServingIdentityChanged,
+                  parsed._compactionRequest !== true,
                 ),
                 {
                   preserveRawReasoningContent: provider.preserveResponsesReasoningContent === true,

package/src/adapters/openai-responses/request-strips.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { COMPACT_PROMPT, compactionItemToText, decodeCompactionSummary, isCompactionItemType } from "../../responses/compaction";
+import { COMPACT_PROMPT, appendCheckpointContinuationNote, compactionItemToText, decodeCompactionSummary, isCompactionItemType } from "../../responses/compaction";
 import { debugProviderDiagnostic } from "../../lib/debug";
 import { modelInList } from "../../types";
 import { isPlainObject } from "./internal";
@@ -260,10 +260,12 @@ export function scrubOcxCompactionItems(
   body: unknown,
   destinationDecodesNativeBlob: boolean,
   threadServingIdentityChanged: boolean,
+  addContinuationNote = false,
 ): unknown {
   if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
 
   let changed = false;
+  let decodedCheckpoint = false;
   const input = body.input.map(item => {
     if (!isPlainObject(item) || !isCompactionItemType(item.type)) return item;
     const encrypted = typeof item.encrypted_content === "string" ? item.encrypted_content : undefined;
@@ -274,6 +276,7 @@ export function scrubOcxCompactionItems(
       && !threadServingIdentityChanged
     ) return item;
     changed = true;
+    if (decodeCompactionSummary(encrypted) !== null) decodedCheckpoint = true;
     return {
       type: "message",
       role: "user",
@@ -281,5 +284,10 @@ export function scrubOcxCompactionItems(
     };
   });
 
-  return changed ? { ...body, input } : body;
+  if (!changed) return body;
+  // #6764: a decoded checkpoint is plain user text from here on, so name its role in the
+  // instructions. Compaction requests skip this; the summarizer must not be told to continue.
+  return addContinuationNote && decodedCheckpoint
+    ? { ...body, input, instructions: appendCheckpointContinuationNote(body.instructions) }
+    : { ...body, input };
 }