@bitkyc08/opencodex 2.42.0 → 2.43.0

package/src/adapters/anthropic.ts

@@ -642,6 +642,19 @@ function orphanToolResultText(msg: OcxToolResultMessage): string {
   return `[tool_result without adjacent tool_use: ${label}]\n${content}`;
 }
 
+function orphanToolResultContent(msg: OcxToolResultMessage): string | unknown[] {
+  if (typeof msg.content === "string" || !msg.content.some(p => p.type === "image")) {
+    return orphanToolResultText(msg);
+  }
+  const label = msg.toolName ? `${msg.toolName} (${msg.toolCallId})` : msg.toolCallId;
+  return [
+    { type: "text", text: `[tool_result without adjacent tool_use: ${label}]` },
+    ...msg.content
+      .map(toAnthropicContentPart)
+      .filter(p => !((p as { type?: string }).type === "text" && !(p as { text?: string }).text)),
+  ];
+}
+
 /**
  * AgentRouter answers 400 `content-blocked` when the first user message is not in English
  * (#2074), while the same request in English returns 200. The gateway is inspecting the opening
@@ -737,7 +750,7 @@ function messagesToAnthropicFormat(
         if (toolUseIds.length > 0) {
           const requiredIds = new Set(toolUseIds);
           const resultBlocks: Record<string, unknown>[] = [];
-          const orphanBlocks: Record<string, unknown>[] = [];
+          const orphanBlocks: unknown[] = [];
           const seen = new Set<string>();
           let j = i + 1;
           while (j < parsed.context.messages.length && parsed.context.messages[j].role === "toolResult") {
@@ -750,7 +763,8 @@ function messagesToAnthropicFormat(
               resultBlocks.push(toAnthropicToolResult(tr, wireResultId));
               seen.add(wireResultId);
             } else {
-              orphanBlocks.push({ type: "text", text: orphanToolResultText(tr) });
+              const orphan = orphanToolResultContent(tr);
+              orphanBlocks.push(...(typeof orphan === "string" ? [{ type: "text", text: orphan }] : orphan));
             }
             j++;
           }
@@ -771,8 +785,8 @@ function messagesToAnthropicFormat(
       }
       case "toolResult": {
         // A standalone Anthropic tool_result is invalid unless it immediately follows an
-        // assistant tool_use. Preserve the information as text instead of sending a 400-prone block.
-        messages.push({ role: "user", content: orphanToolResultText(msg as OcxToolResultMessage) });
+        // assistant tool_use. Preserve text and images as user content without fabricating a pairing.
+        messages.push({ role: "user", content: orphanToolResultContent(msg as OcxToolResultMessage) });
         break;
       }
     }
@@ -895,11 +909,20 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
       enforceAnthropicImageLimits(messages);
       const tools = toolsToAnthropicFormat(parsed, toolNames);
 
+      // Codex never sends `max_output_tokens`, so the omitted-limit default decides how
+      // long a Claude answer may run. Honor the provider's configured output budget
+      // (`modelMaxOutputTokens` / `defaultMaxOutputTokens`) before falling back to the
+      // conservative 8192, which truncates long answers with stop_reason=max_tokens.
+      const configuredMaxOut = modelRecordValue(provider.modelMaxOutputTokens, parsed.modelId)
+        ?? provider.defaultMaxOutputTokens;
+      const omittedMaxTokens = typeof configuredMaxOut === "number" && configuredMaxOut > 0
+        ? configuredMaxOut
+        : DEFAULT_MAX_TOKENS;
       const body: Record<string, unknown> = {
         model: parsed.modelId,
         messages,
         stream: parsed.stream,
-        max_tokens: parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+        max_tokens: parsed.options.maxOutputTokens ?? omittedMaxTokens,
       };
       if (isOAuth) {
         // Claude OAuth (Pro/Max) requires the first system block to be the Claude Code identity.
@@ -942,13 +965,13 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
           // so effort=max (budget=32k) still leaves OUTPUT_HEADROOM tokens for visible output.
           body.max_tokens = explicitMaxOut !== undefined
             ? explicitMaxOut
-            : Math.min(ADAPTIVE_THINKING_CEILING, Math.max(DEFAULT_MAX_TOKENS, floor));
+            : Math.max(omittedMaxTokens, Math.min(ADAPTIVE_THINKING_CEILING, Math.max(DEFAULT_MAX_TOKENS, floor)));
         } else {
           // Anthropic requires max_tokens > thinking.budget_tokens (max_tokens caps thinking +
           // visible output) and budget_tokens >= 1024. Codex sends the SAME value for both, which
           // 400s ("max_tokens must be greater than thinking.budget_tokens"). Size them so max_tokens
           // always exceeds the budget within a model-safe ceiling, reserving room for visible output.
-          const maxOut = parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS;
+          const maxOut = parsed.options.maxOutputTokens ?? omittedMaxTokens;
           const wantBudget = reasoningBudget(effectiveReasoning);
           const maxTokens = Math.min(REASONING_MAX_TOKENS_CEILING, Math.max(maxOut, wantBudget + OUTPUT_HEADROOM));
           const budget = Math.max(MIN_THINKING_BUDGET, Math.min(wantBudget, maxTokens - OUTPUT_FLOOR));

package/src/adapters/command-code.ts

@@ -59,7 +59,7 @@ function wireImagePart(imageUrl: string): Record<string, unknown> {
  * (#1383). This builder keeps the pairing invariant:
  *
  * - a `toolResult` that matches a declared assistant call emits the native `tool-result`;
- * - a `toolResult` with no matching declared call degrades to a text carrier so the model
+ * - a `toolResult` with no matching declared call degrades to a user carrier so the model
  *   still sees the outcome without a 400-prone standalone `tool` message;
  * - every declared assistant call that never received a result gets an explicit error
  *   `tool-result`, so the upstream never sees an unpaired call.
@@ -108,6 +108,9 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
       continue;
     }
     if (message.role === "toolResult") {
+      const images = typeof message.content === "string" ? [] : message.content
+        .filter(part => part.type === "image")
+        .map(part => wireImagePart((part as { imageUrl: string }).imageUrl));
       const callIndex = pendingCalls.findIndex(call => call.id === message.toolCallId);
       const paired = callIndex >= 0;
       if (paired) pendingCalls.splice(callIndex, 1);
@@ -116,11 +119,11 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
         // message lands, or their synthesized results would follow the orphan carrier.
         closePendingCalls();
         // The upstream rejects a standalone tool message whose call was never declared by an
-        // assistant turn. Preserve the outcome as text so the model can still act on it.
+        // assistant turn. Preserve the outcome and images so the model can still act on it.
         const label = message.toolName ? `${message.toolName} (${message.toolCallId})` : message.toolCallId;
         const text = toolResultText(message.content);
         // The orphan result cannot ride a `tool` message; carry it in a user message instead.
-        out.push({ role: "user", content: [{ type: "text", text: `[tool result without adjacent tool call: ${label}]\n${text}` }] });
+        out.push({ role: "user", content: [{ type: "text", text: `[tool result without adjacent tool call: ${label}]\n${text}` }, ...images] });
         continue;
       }
       out.push({ role: "tool", content: [{
@@ -132,9 +135,8 @@ function wireMessages(messages: OcxMessage[]): Array<Record<string, unknown>> {
       // The proprietary wire's tool-result output is text-only; image parts returned by a
       // tool (e.g. Codex view_image) cannot live inside it. Carry them in a follow-up user
       // message using the same image encoding as the user branch so the bytes reach the model.
-      const images = typeof message.content === "string" ? [] : message.content.filter(part => part.type === "image");
       if (images.length > 0) {
-        pendingImageCarriers.push({ role: "user", content: images.map(part => wireImagePart((part as { imageUrl: string }).imageUrl)) });
+        pendingImageCarriers.push({ role: "user", content: images });
       }
       continue;
     }

package/src/adapters/cursor/desktop-executor-contract.ts

@@ -0,0 +1,15 @@
+/**
+ * Opt-in external executor for computer-use / record-screen. opencodex is a headless proxy and
+ * cannot drive a screen itself; set these commands only when running on a host that can. Each
+ * command receives the request as JSON on stdin and must print a JSON result on stdout.
+ */
+export interface DesktopExecutorConfig {
+  /** Command (run via the platform shell) handling computer-use. Receives `{toolCallId, actions}` on stdin. */
+  computerUseCommand?: string;
+  /** Command handling record-screen. Receives `{mode, toolCallId, saveAsFilename?}` on stdin. */
+  recordScreenCommand?: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  /** Max time to wait for the external process. Default 30s. */
+  timeoutMs?: number;
+}

package/src/adapters/cursor/images.ts

@@ -84,6 +84,8 @@ export interface ResolvedCursorImage {
   uuid: string;
   /** Codex/OpenAI image detail hint; affects JPEG soft-cap tier. */
   detail?: string;
+  /** Bounded client-supplied provenance for opted-in trailing tool-result images only. */
+  sourceLabel?: string;
 }
 
 export type PrepareCursorImageOutcome =
@@ -546,7 +548,7 @@ export function buildSelectedContext(
 
 /**
  * Resolve data: images for the active user/developer turn onto SelectedImage.
- * Tool-result image promotion is intentionally out of scope in this slice.
+ * Opted-in tool-result runs use prepareCursorRawMessages directly instead.
  */
 export async function resolveActiveCursorImages(
   messages: readonly OcxMessage[] | undefined,
@@ -645,7 +647,7 @@ async function prepareCursorContentParts(
  * Historical messages before this index are left untouched (no decode).
  */
 export function cursorVisionPrepareStartIndex(messages: readonly OcxMessage[]): number {
-  // Tool-result image preparation is out of scope in this slice.
+  // Default window excludes tool results; their preparation requires explicit opt-in.
   if (messages.at(-1)?.role === "toolResult") return messages.length;
   for (let i = messages.length - 1; i >= 0; i--) {
     const role = messages[i]?.role;
@@ -658,7 +660,8 @@ export function cursorVisionPrepareStartIndex(messages: readonly OcxMessage[]):
  * Rewrite image data URLs in the active vision window (last user/developer turn) through
  * the JPEG soft-cap path before protobuf encode. Historical messages are left by
  * reference. Undecodable images become {@link CURSOR_VISION_IMAGE_OMITTED} text so
- * image-only turns stay userMessageAction.
+ * image-only turns stay userMessageAction. Opted-in trailing tool results use the
+ * same preparation path, with an aggregate image cap and ready-image source labels.
  */
 export interface PreparedCursorRawMessages {
   messages: readonly OcxMessage[] | undefined;
@@ -668,10 +671,26 @@ export interface PreparedCursorRawMessages {
 export async function prepareCursorRawMessages(
   messages: readonly OcxMessage[] | undefined,
   signal?: AbortSignal,
+  options?: { trailingToolImages?: boolean },
 ): Promise<PreparedCursorRawMessages> {
   if (!messages?.length) return { messages, images: [] };
   throwIfImagePhaseAborted(signal);
-  const prepareFrom = cursorVisionPrepareStartIndex(messages);
+  const trailingToolImages = options?.trailingToolImages === true && messages.at(-1)?.role === "toolResult";
+  let prepareFrom = cursorVisionPrepareStartIndex(messages);
+  if (trailingToolImages) {
+    let imageCount = 0;
+    // Count the entire contiguous run before any image URL is decoded or normalized.
+    while (prepareFrom > 0) {
+      throwIfImagePhaseAborted(signal);
+      const message = messages[prepareFrom - 1]!;
+      if (message.role !== "toolResult") break;
+      prepareFrom--;
+      imageCount += extractCursorImageParts(message.content).length;
+      if (imageCount > MAX_CURSOR_IMAGES) {
+        throw new CursorImageError(`Too many images in one request (max ${MAX_CURSOR_IMAGES}).`);
+      }
+    }
+  }
   const active = messages[prepareFrom];
   if (
     active
@@ -688,10 +707,21 @@ export async function prepareCursorRawMessages(
     const message = messages[i]!;
     if (
       i >= prepareFrom
-      && (message.role === "user" || message.role === "developer")
+      && (message.role === "user" || message.role === "developer"
+        || (trailingToolImages && message.role === "toolResult"))
     ) {
       const prepared = await prepareCursorContentParts(message.content, signal);
-      images.push(...prepared.images);
+      if (trailingToolImages && message.role === "toolResult") {
+        images.push(...prepared.images.map((image, index) => ({
+          ...image,
+          sourceLabel: `tool result ${i - prepareFrom + 1}, image ${index + 1}: ${JSON.stringify({
+            tool: message.toolName.slice(0, 128),
+            call_id: message.toolCallId.slice(0, 128),
+          })}`,
+        })));
+      } else {
+        images.push(...prepared.images);
+      }
       if (prepared.content !== message.content) {
         changed = true;
         out.push({ ...message, content: prepared.content } as OcxMessage);

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

@@ -14,6 +14,7 @@ import {
 } from "../../lib/translator-budget";
 import { activePromptText, prepareCursorRunRequest } from "./protobuf-request";
 import { prepareCursorRawMessages, resolveActiveCursorImages } from "./images";
+import { isCursorExternalWireModel } from "./discovery";
 import { cursorRequestMessagesFromRaw } from "./request-builder";
 import {
   createCursorContextUsageTracker,
@@ -618,9 +619,13 @@ class LiveCursorTransport implements CursorTransport {
     // JPEG soft-cap rewrite for active-turn data: images before encode. Rebuild text
     // messages from the prepared raw channel so omission markers replace stale
     // pre-rewrite content that activePromptText and the tool filter would otherwise see.
-    const preparedRaw = await prepareCursorRawMessages(request.rawMessages, signal);
+    const externalToolImages = isCursorExternalWireModel(request.modelId)
+      && request.rawMessages?.at(-1)?.role === "toolResult";
+    const preparedRaw = await prepareCursorRawMessages(request.rawMessages, signal, {
+      trailingToolImages: externalToolImages,
+    });
     const preparedRawMessages = preparedRaw.messages;
-    const selectedImages = await resolveActiveCursorImages(
+    const selectedImages = externalToolImages ? preparedRaw.images : await resolveActiveCursorImages(
       preparedRawMessages,
       signal,
       preparedRaw.images,

package/src/adapters/cursor/native-exec-desktop.ts

@@ -17,24 +17,11 @@ import {
 } from "./gen/agent_pb";
 import { errorText } from "./native-exec-common";
 import type { CursorNativeToolDeps } from "./native-exec-tools";
+import type { DesktopExecutorConfig } from "./desktop-executor-contract";
 
 const DEFAULT_DESKTOP_TIMEOUT_MS = 30_000;
 
-/**
- * Opt-in external executor for computer-use / record-screen. opencodex is a headless proxy and
- * cannot drive a screen itself; set these commands only when running on a host that can. Each
- * command receives the request as JSON on stdin and must print a JSON result on stdout.
- */
-export interface DesktopExecutorConfig {
-  /** Command (run via the platform shell) handling computer-use. Receives `{toolCallId, actions}` on stdin. */
-  computerUseCommand?: string;
-  /** Command handling record-screen. Receives `{mode, toolCallId, saveAsFilename?}` on stdin. */
-  recordScreenCommand?: string;
-  cwd?: string;
-  env?: Record<string, string>;
-  /** Max time to wait for the external process. Default 30s. */
-  timeoutMs?: number;
-}
+export type { DesktopExecutorConfig } from "./desktop-executor-contract";
 
 /**
  * Build `computerUse` / `recordScreen` deps from external executor commands. Returns `{}` when no

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

@@ -379,7 +379,7 @@ function rootPromptMessages(
       }
       // Assistant tool CALLS are NOT replayed as a separate visible "[Tool Call]" entry: a model
        // few-shot-mimics that marker and emits later tool calls as inert text (363-B guard in
-      // tests/cursor-tool-continuation.test.ts). The invocation is instead named INSIDE the paired
+      // tests/providers/cursor/cursor-tool-continuation.test.ts). The invocation is instead named INSIDE the paired
       // "[Tool Result]" envelope below, which carries the same information without a mimickable
       // call template (devlog 260829 002_audit_round2).
     } else if (message.role === "toolResult") {
@@ -954,7 +954,7 @@ function toolCallArgumentsText(args: Record<string, unknown>): string {
  *
  * Why not a separate "[Tool Call]" entry: a model few-shot-mimics that marker and starts emitting
  * later tool calls as inert text instead of real tool frames, which halts multi-tool continuations
- * (363-B guard, tests/cursor-tool-continuation.test.ts). Why it must exist at all: without any
+ * (363-B guard, tests/providers/cursor/cursor-tool-continuation.test.ts). Why it must exist at all: without any
  * record of the invocation, the replayed result is orphaned — its `call_id` refers to nothing the
  * model can see — and live cursor/grok-4.6 turns re-ran commands that had already succeeded while
  * narrating a phantom interrupt (devlog 260829 000_rca). A prose line inside the result satisfies
@@ -1388,11 +1388,21 @@ function buildPreparedCursorRunRequest(
   )
     ? "userMessageAction"
     : "resumeAction";
-  const actionText = externalToolContinuation
+  let actionText = externalToolContinuation
     ? (request.echoRetryContinuationText ?? CURSOR_EXTERNAL_TOOL_CONTINUATION_TEXT)
     : request.echoRetryContinuationText
       ? `${text}\n\n[correction] ${request.echoRetryContinuationText}`
       : text;
+  if (lastRawIsToolResult && isCursorExternalWireModel(request.modelId)) {
+    // Image preparation bounds these labels and keeps them in attachment order. The
+    // active action survives root pruning/checkpoint fallback, including echo retries.
+    const sources = selectedImages.flatMap((image, index) => image.sourceLabel
+      ? [`${index + 1}. ${image.sourceLabel}`]
+      : []);
+    if (sources.length > 0) {
+      actionText += `\n\n[Client-supplied tool screenshot sources (attachment order)]\n${sources.join("\n")}`;
+    }
+  }
   const action = create(ConversationActionSchema, {
     action: actionCase === "userMessageAction"
       ? {