npm - @bitkyc08/opencodex - Versions diffs - 2.57.0 → 2.58.0 - Mend

@bitkyc08/opencodex 2.57.0 → 2.58.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (86) hide show

package/gui/dist/assets/{index-Cz7CLdif.js → index-BbrHOIY0.js} +2 -2
package/gui/dist/index.html +1 -1
package/package.json +2 -2
package/src/adapters/codebuddy/scaffold-guard.ts +5 -4
package/src/adapters/command-code.ts +13 -4
package/src/adapters/cursor/cursor-errors.ts +15 -0
package/src/adapters/cursor/discovery.ts +65 -1
package/src/adapters/cursor/live-transport.ts +5 -1
package/src/adapters/cursor/protobuf-events.ts +110 -11
package/src/adapters/cursor/protobuf-request.ts +19 -1
package/src/adapters/cursor/text-toolcall.ts +230 -0
package/src/adapters/cursor/thread-continuity.ts +67 -0
package/src/adapters/cursor/types.ts +5 -0
package/src/adapters/cursor.ts +55 -5
package/src/adapters/google-http.ts +38 -13
package/src/adapters/mimo-free.ts +32 -17
package/src/adapters/ollama-native.ts +42 -8
package/src/adapters/openai-responses/passthrough.ts +30 -4
package/src/adapters/openai-responses/request-strips.ts +43 -0
package/src/adapters/physical-send.ts +50 -0
package/src/bridge/response-json.ts +1 -1
package/src/bridge/sse.ts +1 -1
package/src/claude/outbound.ts +14 -4
package/src/cli/config-command.ts +35 -18
package/src/cli/dispatch.ts +17 -4
package/src/cli/index.ts +44 -2
package/src/cli/system-command.ts +70 -1
package/src/cli/uninstall-client-state.ts +12 -0
package/src/codex/auth-context.ts +42 -8
package/src/codex/desktop-switches.ts +145 -0
package/src/codex/history-job.ts +5 -1
package/src/codex/history-provider.ts +33 -4
package/src/codex/history-worker.ts +14 -1
package/src/codex/inject/remove.ts +145 -7
package/src/codex/inject/restore.ts +204 -32
package/src/codex/inject.ts +3 -7
package/src/codex/loopback-target.ts +9 -0
package/src/codex/native-profile-startup.ts +64 -20
package/src/config/atomic-write.ts +83 -8
package/src/config/schema/config-schema.ts +2 -0
package/src/config/schema/leaf-validators.ts +1 -0
package/src/generated/compatibility-version.json +132 -68
package/src/lib/bounded-subprocess.ts +62 -10
package/src/lib/windows-secret-acl.ts +151 -15
package/src/lib/windows-user-principal.ts +5 -1
package/src/providers/derive.ts +6 -0
package/src/providers/model-discovery.ts +19 -7
package/src/providers/registry/entries-core.ts +11 -0
package/src/providers/registry/entries-extended.ts +50 -28
package/src/providers/registry/model-seeds.ts +67 -17
package/src/providers/registry/types.ts +9 -0
package/src/responses/spill-store.ts +17 -0
package/src/responses/state/body-policy.ts +25 -0
package/src/responses/state/spill-queue.ts +8 -6
package/src/responses/state.ts +3 -22
package/src/router.ts +4 -0
package/src/server/auth-cors.ts +1 -0
package/src/server/index/websocket-handler.ts +48 -1
package/src/server/management/config-routes.ts +27 -5
package/src/server/models-capabilities.ts +24 -3
package/src/server/responses/codex-ws-exchange.ts +65 -4
package/src/server/responses/combo-stream-preflight.ts +68 -5
package/src/server/responses/core-combo.ts +26 -0
package/src/server/responses/core-options.ts +3 -0
package/src/server/responses/fetch-helpers.ts +4 -1
package/src/server/responses/native-injection-protocol.ts +42 -0
package/src/server/responses/native-injection-replay.ts +105 -0
package/src/server/responses/native-injection.ts +242 -0
package/src/server/responses/native-response-control.ts +56 -0
package/src/server/responses/native-response-json.ts +14 -0
package/src/server/responses/native-response-output.ts +37 -0
package/src/server/responses/native-steering-log.ts +44 -0
package/src/server/responses/native-steering-policy.ts +49 -0
package/src/server/responses/native-steering-replay.ts +126 -0
package/src/server/responses/native-steering-settings.ts +76 -0
package/src/server/responses/native-steering.ts +400 -0
package/src/server/responses/native-tool-results.ts +130 -0
package/src/server/responses/passthrough-delivery.ts +11 -0
package/src/server/responses/passthrough-dispatch.ts +33 -1
package/src/server/responses/request-prepare.ts +41 -0
package/src/server/responses/ws-upstream.ts +21 -1
package/src/server/stop-teardown.ts +8 -1
package/src/server/ws-bridge.ts +16 -1
package/src/service/cli.ts +13 -1
package/src/types/config.ts +4 -0
package/src/types/provider.ts +13 -0

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-Cz7CLdif.js"></script>
+    <script type="module" crossorigin src="/assets/index-BbrHOIY0.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C5-RdDmD.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.57.0",
+  "version": "2.58.0",
   "description": "Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code",
   "type": "module",
   "main": "./bin/package-main.mjs",
@@ -86,7 +86,7 @@
   "overrides": {
     "@hono/node-server": "2.1.0",
     "fast-uri": "^3.1.7",
-    "hono": "4.13.1",
+    "hono": "4.13.8",
     "ip-address": "^10.4.0",
     "qs": "^6.16.0"
   },

package/src/adapters/codebuddy/scaffold-guard.ts CHANGED Viewed

@@ -5,10 +5,10 @@ export const CODEBUDDY_SCAFFOLD_ERROR_CODE = "vendor_scaffold_detected";
 // The observed control protocol uses FULLWIDTH VERTICAL LINE (U+FF5C). Detection stays
 // deliberately narrower than the marker spelling: a calls control line must be followed by an
-// invoke line for a functions.* tool. That distinguishes an agent scaffold from prose quoting or
+// invoke line with a non-empty tool name. That distinguishes an agent scaffold from prose quoting or
 // discussing one tag.
 const DSML_CALLS_LINE = "<｜｜dsml｜｜ calls>";
-const DSML_INVOKE_PREFIX = "<｜｜dsml｜｜ invoke name=\"functions.";
+const DSML_INVOKE_PREFIX = "<｜｜dsml｜｜ invoke name=\"";
 export interface CodeBuddyScaffoldFilterResult {
   /** Bytes released from a suffix withheld by an earlier event on this channel. */
@@ -39,7 +39,7 @@ function prefixAtEnd(text: string, at: number, expected: string): boolean {
  * Control tags are recognized only at column zero and outside fenced Markdown. Inline code,
  * quoted strings, blockquotes, indented source, and prose all add syntax before the tag and are
  * therefore forwarded unchanged. A calls line alone is harmless; refusal requires the observed
- * two-line calls-plus-functions-invoke grammar.
+ * two-line calls-plus-named-invoke grammar.
  */
 function scan(
   text: string,
@@ -77,7 +77,8 @@ function scan(
           if (invokeAt >= 0) {
             const invokeRest = text.slice(invokeAt).toLowerCase();
-            if (invokeRest.startsWith(DSML_INVOKE_PREFIX)) {
+            const invokeNameStart = invokeRest[DSML_INVOKE_PREFIX.length];
+            if (invokeRest.startsWith(DSML_INVOKE_PREFIX) && invokeNameStart && !/[\s"]/.test(invokeNameStart)) {
               return { safe: text.slice(0, index), held: "", fail: true, fence, lineStart };
             }
             if (invokeRest.length === 0 || DSML_INVOKE_PREFIX.startsWith(invokeRest)) {

package/src/adapters/command-code.ts CHANGED Viewed

@@ -13,6 +13,8 @@ import { commandCodeReasoningEfforts, refreshCommandCodeReasoningEfforts } from
 import { identifyRoutedModel } from "./identity";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
 import { parseDataUrl } from "./image";
+import { createAdapterPhysicalSend } from "./physical-send";
+import { SendBudgetExhaustedError } from "../lib/upstream-retry";
 // Retain the short ids emitted by the first local integration. New requests use the live catalog's
 // provider-native IDs directly; this map is compatibility-only and is not a model fallback list.
@@ -469,7 +471,7 @@ async function fetchCommandCode(request: AdapterRequest, ctx: AdapterFetchContex
   const timer = setTimeout(() => timeout.abort(new DOMException("Timeout elapsed", "TimeoutError")), ctx?.timeoutMs ?? 200_000);
   const callerSignal = ctx?.abortSignal ?? new AbortController().signal;
   try {
-    return await (ctx?.executor ?? executor)(request.url, {
+    return await executor(request.url, {
       method: request.method,
       headers: request.headers,
       body: request.body,
@@ -556,7 +558,8 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
       };
     },
     async fetchResponse(request: AdapterRequest, ctx?: AdapterFetchContext): Promise<Response> {
-      const response = await fetchCommandCode(request, ctx, executor);
+      const send = createAdapterPhysicalSend(ctx, executor);
+      const response = await send({ url: request.url, dispatch: physical => fetchCommandCode(request, ctx, physical) });
       if (response.ok) return response;
       const currentEffort = (() => {
         try { return (JSON.parse(request.body) as { params?: { reasoning_effort?: unknown } }).params?.reasoning_effort; } catch { return undefined; }
@@ -577,8 +580,14 @@ export function createCommandCodeAdapter(provider: OcxProviderConfig): ProviderA
       if (!refreshed || refreshed.includes(currentEffort)) return response;
       const retry = requestWithoutReasoningEffort(request);
       if (!retry) return response;
-      try { void response.body?.cancel(); } catch { /* already closed */ }
-      return fetchCommandCode(retry, ctx, executor);
+      try {
+        return await send({ url: retry.url, sendClass: "repair", recovery: "reasoning-effort-downgrade",
+          beforeDispatch: () => { try { void response.body?.cancel().catch(() => {}); } catch { /* already closed */ } },
+          dispatch: physical => fetchCommandCode(retry, ctx, physical) });
+      } catch (error) {
+        if (error instanceof SendBudgetExhaustedError) return response;
+        throw error;
+      }
     },
     async *parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> {
       let sawFinish = false;

package/src/adapters/cursor/cursor-errors.ts CHANGED Viewed

@@ -46,6 +46,21 @@ export class CursorStreamTruncatedError extends Error {
   }
 }
+export const CURSOR_INCOMPLETE_TOOL_CALL_MESSAGE_PREFIX =
+  "Cursor stream ended with incomplete tool call(s):";
+/**
+ * True when Cursor ended the stream with a client tool still open. The adapter fail-closes
+ * the current turn (no partial `tool_call_start`) and remints the conversation afterwards
+ * so the next turn does not resume a session left waiting for `mcpResult`.
+ */
+export function isCursorIncompleteToolCallMessage(value: unknown): boolean {
+  const message = typeof value === "string" ? value : errorMessage(value);
+  const lower = message.toLowerCase();
+  return lower.includes(CURSOR_INCOMPLETE_TOOL_CALL_MESSAGE_PREFIX.toLowerCase())
+    || lower.includes("tool call(s) left incomplete");
+}
 /**
  * A cancel-shaped stream failure that WE did not request. `cancelCursorRun` is the only place
  * that cancels our own stream, and it sets `expectedClose` first, so a cancel arriving without it

package/src/adapters/cursor/discovery.ts CHANGED Viewed

@@ -24,8 +24,54 @@ const CONTEXT_272K = 272_000;
 const CONTEXT_262K = 262_144;
 const CONTEXT_256K = 256_000;
 const CONTEXT_200K = 200_000;
+export const CURSOR_OBSERVED_CONTEXT_WINDOW_MAX_ENTRIES = 2_048;
-export function inferCursorContextWindow(modelId: string): number {
+/**
+ * Process-local ceilings from `ConversationTokenDetails.maxTokens` on live
+ * checkpoints. Each observation belongs to the Cursor identity scope that
+ * produced it; plan-gated accounts sharing one proxy must not overwrite each
+ * other's overflow prior (senpi `cursor-context-limit`).
+ */
+const observedCursorContextWindows = new Map<string, number>();
+interface CursorContextWindowOptions {
+  identityScope?: string;
+  observed?: number;
+}
+function normalizeObservedWindowKey(modelId: string, identityScope?: string): string {
+  return `${identityScope?.trim() || "local"}\0${modelId.trim().toLowerCase()}`;
+}
+export function recordObservedCursorContextWindow(
+  modelId: string,
+  maxTokens: number | undefined,
+  options: Pick<CursorContextWindowOptions, "identityScope"> = {},
+): void {
+  if (!modelId.trim()) return;
+  if (typeof maxTokens !== "number" || !Number.isFinite(maxTokens) || maxTokens <= 0) return;
+  const key = normalizeObservedWindowKey(modelId, options.identityScope);
+  observedCursorContextWindows.delete(key);
+  observedCursorContextWindows.set(key, Math.floor(maxTokens));
+  while (observedCursorContextWindows.size > CURSOR_OBSERVED_CONTEXT_WINDOW_MAX_ENTRIES) {
+    const oldest = observedCursorContextWindows.keys().next().value;
+    if (oldest === undefined) break;
+    observedCursorContextWindows.delete(oldest);
+  }
+}
+export function observedCursorContextWindow(
+  modelId: string,
+  options: Pick<CursorContextWindowOptions, "identityScope"> = {},
+): number | undefined {
+  return observedCursorContextWindows.get(normalizeObservedWindowKey(modelId, options.identityScope));
+}
+export function resetObservedCursorContextWindowsForTests(): void {
+  observedCursorContextWindows.clear();
+}
+function inferCursorContextWindowHeuristic(modelId: string): number {
   const id = modelId.trim().toLowerCase();
   if (id.includes("1m")) return CONTEXT_1M;
   if (id.startsWith("gemini-")) return CONTEXT_1M;
@@ -40,6 +86,24 @@ export function inferCursorContextWindow(modelId: string): number {
   return CURSOR_DEFAULT_CONTEXT_WINDOW;
 }
+/**
+ * Infer a conservative context window for a Cursor model id.
+ *
+ * A positive explicit observation wins, then an identity-scoped process-local
+ * checkpoint `maxTokens`, then the id heuristic. Cursor's `AvailableModelsResponse`
+ * does not currently include per-model context window metadata.
+ */
+export function inferCursorContextWindow(
+  modelId: string,
+  options: CursorContextWindowOptions = {},
+): number {
+  const { observed } = options;
+  if (typeof observed === "number" && Number.isFinite(observed) && observed > 0) {
+    return Math.floor(observed);
+  }
+  return observedCursorContextWindow(modelId, options) ?? inferCursorContextWindowHeuristic(modelId);
+}
 function normalizeInputModalities(input: string[] | undefined): string[] {
   const values = (input ?? [...CURSOR_DEFAULT_INPUT_MODALITIES])
     .map(item => item.trim())

package/src/adapters/cursor/live-transport.ts CHANGED Viewed

@@ -20,6 +20,7 @@ import {
   createCursorContextUsageTracker,
   createCursorProtobufEventState,
   finalizeTurnEvents,
+  hasBufferedTextToolCalls,
   mapCursorProtobufServerMessage,
   mapSyntheticMcpExecToToolEvents,
   reportableContextTokens,
@@ -732,6 +733,8 @@ class LiveCursorTransport implements CursorTransport {
         syntheticStructuredEditToolNames,
         translatorBudget: this.translatorBudget,
         contextUsage,
+        wireModelId: request.modelId,
+        identityScope: request._cursorIdentityScope,
         ...(prepared.estimatedInputTokens !== undefined
           ? { estimatedInputTokens: prepared.estimatedInputTokens }
           : {}),
@@ -1265,6 +1268,7 @@ class LiveCursorTransport implements CursorTransport {
             state.openToolCalls.size > 0
             || this.sawAssistantText
             || hasPendingClientToolFinalization
+            || hasBufferedTextToolCalls(state)
           )
         ) {
           const terminal = hasPendingClientToolFinalization && state.openToolCalls.size === 0
@@ -1431,7 +1435,7 @@ class LiveCursorTransport implements CursorTransport {
           settler.settleFinish();
           return;
         }
-        if (this.framesReceived > 0 && this.sawAssistantText) {
+        if (this.framesReceived > 0 && (this.sawAssistantText || hasBufferedTextToolCalls(state))) {
           for (const event of finalizeTurnEvents(state)) push(event);
           releaseBacklogLease();
           settler.settleFinish();

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

@@ -11,13 +11,19 @@ import {
   isCodexShellBridgeToolName,
   isCursorStructuredEditToolName,
   normalizeCursorWireName,
-  normalizeCursorTextToolMarkers,
   OCX_RESPONSES_TOOL_PROVIDER,
   resolveShellBridgeAliasKey,
   responsesToolNameFromCursorWire,
 } from "./tool-definitions";
+import {
+  drainCursorTextToolCalls,
+  type DrainedTextToolCall,
+  type SuppressedTextToolCallScan,
+} from "./text-toolcall";
+import { recordObservedCursorContextWindow } from "./discovery";
 import type { CursorServerMessage } from "./types";
 import type { TranslatorBudget } from "../../lib/translator-budget";
+import { CURSOR_INCOMPLETE_TOOL_CALL_MESSAGE_PREFIX } from "./cursor-errors";
 const DEFAULT_CONTEXT_USAGE_MAX_ENTRIES = 200;
 const DEFAULT_CONTEXT_USAGE_TTL_MS = 60 * 60 * 1_000;
@@ -176,6 +182,23 @@ export interface CursorProtobufEventState {
    */
   syntheticStructuredEditToolNames?: ReadonlySet<string>;
   translatorBudget?: TranslatorBudget;
+  /**
+   * Incomplete `[TOOL_CALL]…[ARGS]{` prefix held across `textDelta` frames so a
+   * marker split by the stream cannot leak into assistant text.
+   */
+  pendingTextToolCall?: string;
+  /** Constant-space scanner used after an incomplete textual marker exceeds its retained byte cap. */
+  suppressedTextToolCall?: SuppressedTextToolCallScan;
+  /** Parsed textual fallback calls held until turn finalization establishes that no real frame won. */
+  bufferedTextToolCalls?: DrainedTextToolCall[];
+  /** True once this turn carries any real client-tool frame, including an incomplete one. */
+  sawRealClientToolCall?: boolean;
+  /** Monotonic id suffix for tool calls promoted from text markers. */
+  textToolCallSeq?: number;
+  /** Wire model id used to record checkpoint `maxTokens` for the next turn. */
+  wireModelId?: string;
+  /** Normalized Cursor identity scope that owns the observed checkpoint ceiling. */
+  identityScope: string;
 }
@@ -215,6 +238,10 @@ export function createCursorProtobufEventState(options: {
    */
   estimatedInputTokens?: number;
   translatorBudget?: TranslatorBudget;
+  /** Wire model id for recording checkpoint `maxTokens` into the process-local window map. */
+  wireModelId?: string;
+  /** Cursor request identity scope; normalized identically to request-builder continuity. */
+  identityScope?: string;
 } = {}): CursorProtobufEventState {
   return {
     // Cursor provides no authoritative usage frame; token counts are heuristic estimates from
@@ -244,6 +271,8 @@ export function createCursorProtobufEventState(options: {
       && options.estimatedInputTokens > 0
       ? { estimatedInputTokens: options.estimatedInputTokens }
       : {}),
+    ...(options.wireModelId?.trim() ? { wireModelId: options.wireModelId.trim() } : {}),
+    identityScope: options.identityScope?.trim() || "local",
   };
 }
@@ -1048,6 +1077,7 @@ export function mapSyntheticMcpExecToToolEvents(
 ): CursorServerMessage[] {
   if (args.providerIdentifier !== OCX_RESPONSES_TOOL_PROVIDER) return [];
   if (options.state?.terminated) return [];
+  if (options.state) options.state.sawRealClientToolCall = true;
   if (options.allowEmptyArgs !== true && !hasMcpArgBytes(args)) return [];
   const cursorWireName = mcpWireNameFromArgs(args);
   if (!cursorWireName) return [{ type: "error", message: "Cursor requested a Responses tool without a tool name" }];
@@ -1117,6 +1147,11 @@ function recordToolCall(state: CursorProtobufEventState, callId: string, cursorW
   return [];
 }
+function recordRealToolCall(state: CursorProtobufEventState, callId: string, cursorWireName: string): CursorServerMessage[] {
+  state.sawRealClientToolCall = true;
+  return recordToolCall(state, callId, cursorWireName);
+}
 /**
  * Emit a completed client tool call as one atomic unit: `tool_call_start` (deferred from open time),
  * the full normalized arguments delta when present, then `tool_call_end`. The call must already be
@@ -1232,33 +1267,70 @@ export function mapCursorProtobufServerMessage(
   if (state.terminated) return [];
   if (serverMessage.message.case === "conversationCheckpointUpdate") {
-    const usedTokens = serverMessage.message.value.tokenDetails?.usedTokens ?? 0;
+    const tokenDetails = serverMessage.message.value.tokenDetails;
+    const usedTokens = tokenDetails?.usedTokens ?? 0;
     // `usedTokens` is the ABSOLUTE conversation context size, not a per-turn output delta. Track it
     // separately (monotonic max) and surface it as `done.usage.totalTokens`; folding it into
     // `outputTokens` (which also accumulates `tokenDelta`) double-counts in Codex. See contextTokens.
     observeContextTokens(state, usedTokens);
+    // First checkpoints often send maxTokens=0 (senpi). Only a positive ceiling
+    // replaces the id heuristic for the next turn's overflow vs 429 size prior.
+    if (state.wireModelId) {
+      recordObservedCursorContextWindow(state.wireModelId, tokenDetails?.maxTokens, {
+        identityScope: state.identityScope,
+      });
+    }
     return [];
   }
   if (serverMessage.message.case !== "interactionUpdate") return [];
   const update = serverMessage.message.value.message;
   switch (update.case) {
-    case "textDelta":
-      // #2305: fold Cursor display aliases inside textual pseudo tool-call markers back to
-      // the advertised wire name before any client sees the text. Real frames are already
-      // normalized structurally (mcpWireNameFromArgs above).
-      return update.value.text ? [{ type: "text", text: normalizeCursorTextToolMarkers(update.value.text) }] : [];
+    case "textDelta": {
+      // Textual `[TOOL_CALL]name[ARGS]{…}` is not assistant prose. Leaving it in
+      // the text channel (even after #2305 renamed the display alias) leaks a
+      // synthetic protocol marker that later turns few-shot-mimic as inert text.
+      // Strip complete markers, buffer advertised fallbacks until finalize,
+      // and hold or suppress-scan an incomplete opener across deltas.
+      const chunk = update.value.text ?? "";
+      if (!chunk && !state.pendingTextToolCall && !state.suppressedTextToolCall) return [];
+      const drained = drainCursorTextToolCalls(
+        state.pendingTextToolCall ?? "",
+        chunk,
+        state.suppressedTextToolCall,
+      );
+      if (drained.pending) state.pendingTextToolCall = drained.pending;
+      else delete state.pendingTextToolCall;
+      if (drained.suppressed) state.suppressedTextToolCall = drained.suppressed;
+      else delete state.suppressedTextToolCall;
+      const out: CursorServerMessage[] = [];
+      if (drained.text) out.push({ type: "text", text: drained.text });
+      for (const call of drained.calls) {
+        const advertised = resolveAdvertisedClientToolName(state, call.name);
+        if (
+          state.sawRealClientToolCall
+          || !state.clientToolNames
+          || !advertised
+          || (state.bufferedTextToolCalls?.length ?? 0) >= state.maxClientToolCalls
+        ) continue;
+        (state.bufferedTextToolCalls ??= []).push({
+          name: advertised,
+          args: normalizeJsonText(call.args, advertised, state),
+        });
+      }
+      return out;
+    }
     case "thinkingDelta":
       return update.value.text ? [{ type: "thinking", thinking: update.value.text }] : [];
     case "toolCallStarted": {
       const name = mcpCursorWireName(update.value.toolCall);
       // Record the open call but defer the outward tool_call_start to completion (atomic emission).
-      return name ? recordToolCall(state, update.value.callId, name) : [];
+      return name ? recordRealToolCall(state, update.value.callId, name) : [];
     }
     case "partialToolCall": {
       const out: CursorServerMessage[] = [];
       const name = mcpCursorWireName(update.value.toolCall);
-      if (name) out.push(...recordToolCall(state, update.value.callId, name));
+      if (name) out.push(...recordRealToolCall(state, update.value.callId, name));
       if (out.some(event => event.type === "error")) return out;
       // Buffer cumulative args; do not emit a delta. Args are emitted once, normalized, at completion.
       if (state.openToolCalls.has(update.value.callId)) {
@@ -1274,6 +1346,7 @@ export function mapCursorProtobufServerMessage(
       const out: CursorServerMessage[] = [];
       if (state.completedToolCalls.has(update.value.callId)) return [];
       const name = mcpCursorWireName(update.value.toolCall);
+      if (name) state.sawRealClientToolCall = true;
       const args = mcpArgsFromToolCall(update.value.toolCall);
       const openBeforeStart = state.openToolCalls.get(update.value.callId);
       // Empty-arg completion handling:
@@ -1362,20 +1435,46 @@ export function resolvedTurnUsage(state: CursorProtobufEventState): OcxUsage {
  * with corrupt/empty arguments. Emit an explicit error instead of done (fail-closed).
  * Mirrors kiro-truncation.ts behavior.
  */
+/**
+ * True when this turn holds textual fallback tool calls that only turn finalization can emit.
+ *
+ * Cursor can close a stream with a clean Connect END_STREAM and no turnEnded frame. The transport
+ * finalizes that path only for a turn it can see is unfinished, and a turn whose entire visible
+ * text was a stripped marker looks empty from the outside. Without this the deferred fallback
+ * would be dropped exactly when the marker was the turn's only content.
+ */
+export function hasBufferedTextToolCalls(state: CursorProtobufEventState): boolean {
+  return (state.bufferedTextToolCalls?.length ?? 0) > 0;
+}
 export function finalizeTurnEvents(state: CursorProtobufEventState): CursorServerMessage[] {
   state.terminated = true;
+  delete state.pendingTextToolCall;
+  delete state.suppressedTextToolCall;
+  const bufferedTextToolCalls = state.bufferedTextToolCalls ?? [];
+  delete state.bufferedTextToolCalls;
   if (state.openToolCalls.size > 0) {
     const openCallIds = [...state.openToolCalls.keys()];
     const openIds = openCallIds.join(", ");
     // Clear so a second turnEnded (should not happen, but defensive) doesn't re-emit.
     for (const callId of openCallIds) state.translatorBudget?.closeCall(callId);
     state.openToolCalls.clear();
-    return [{ type: "error", message: `Cursor stream ended with incomplete tool call(s): ${openIds}. Arguments may be truncated; the call was not committed.` }];
+    return [{ type: "error", message: `${CURSOR_INCOMPLETE_TOOL_CALL_MESSAGE_PREFIX} ${openIds}. Arguments may be truncated; the call was not committed.` }];
+  }
+  const out: CursorServerMessage[] = [];
+  if (!state.sawRealClientToolCall) {
+    for (const call of bufferedTextToolCalls) {
+      state.textToolCallSeq = (state.textToolCallSeq ?? 0) + 1;
+      const callId = `textcall_${state.textToolCallSeq}`;
+      out.push(...recordToolCall(state, callId, call.name));
+      if (state.openToolCalls.has(callId)) out.push(...commitToolCall(state, callId, call.args));
+    }
   }
   // Surface the absolute context size (when Cursor reported a checkpoint) as both totalTokens and
   // the estimated input side of Codex's visible `input + output` counter. Codex status lines can
   // render the additive pair instead of total_tokens, so leaving inputTokens at 0 makes a 16k-context
   // first turn display as "9 used". Keep outputTokens as the per-turn delta and clamp the inferred
   // input to 0 in case Cursor reports a checkpoint smaller than the streamed output delta.
-  return [{ type: "done", usage: resolvedTurnUsage(state) }];
+  out.push({ type: "done", usage: resolvedTurnUsage(state) });
+  return out;
 }

package/src/adapters/cursor/protobuf-request.ts CHANGED Viewed

@@ -75,6 +75,8 @@ export const CURSOR_ROUTING_LEVEL_PARAMETER_ID = "optimization";
 export const CURSOR_EXTERNAL_ROOT_BLOB_LIMIT = 192;
 /** Approximate prompt-size guard; tool schemas and protocol framing consume context separately. */
 export const CURSOR_EXTERNAL_ROOT_BYTE_LIMIT = 512 * 1024;
+/** Honest placeholder when native Composer history has a toolCall with no matching toolResult. */
+export const CURSOR_MISSING_TOOL_RESULT = "[missing tool_result for this tool_use in history]";
 /**
  * Byte budget for the serialized arguments named inside ONE replayed tool-result envelope. The
  * invocation identifies the call; the result is the payload. Without an independent cap, a single
@@ -1218,6 +1220,20 @@ function argBytes(value: unknown): Uint8Array {
   }
 }
+function missingToolResultFor(
+  part: Extract<OcxAssistantContentPart, { type: "toolCall" }>,
+): OcxToolResultMessage {
+  return {
+    role: "toolResult",
+    toolCallId: part.id,
+    toolName: part.name,
+    ...(part.namespace ? { toolNamespace: part.namespace } : {}),
+    content: CURSOR_MISSING_TOOL_RESULT,
+    isError: true,
+    timestamp: 0,
+  };
+}
 function toolCallStep(
   part: Extract<OcxAssistantContentPart, { type: "toolCall" }>,
   requestScope: CursorBlobRequestScopeToken,
@@ -1332,7 +1348,9 @@ function conversationTurns(
   const pendingToolCalls = new Map<string, Extract<OcxAssistantContentPart, { type: "toolCall" }>>();
   const flush = () => {
     if (!current) return;
-    for (const part of pendingToolCalls.values()) current.steps.push(toolCallStep(part, requestScope));
+    for (const part of pendingToolCalls.values()) {
+      current.steps.push(toolCallStep(part, requestScope, missingToolResultFor(part), codeMode));
+    }
     turns.push(storeCursorBlob(toBinary(ConversationTurnStructureSchema, create(ConversationTurnStructureSchema, {
       turn: {
         case: "agentConversationTurn",