@janole/ai-sdk-provider-codex-asp 0.3.2 → 0.3.3

package/dist/index.cjs

@@ -958,7 +958,7 @@ var DynamicToolsDispatcher = class {
 // package.json
 var package_default = {
   name: "@janole/ai-sdk-provider-codex-asp",
-  version: "0.3.2"};
+  version: "0.3.3"};
 
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
@@ -1003,6 +1003,8 @@ function toFinishReason(status) {
       return { unified: "other", raw: void 0 };
   }
 }
+var NOOP = () => [];
+var DEFAULT_MAX_TOOL_RESULT_OUTPUT_CHARS = 32768;
 var CodexEventMapper = class {
   options;
   streamStarted = false;
@@ -1014,9 +1016,45 @@ var CodexEventMapper = class {
   threadId;
   turnId;
   latestUsage;
+  handlers;
   constructor(options) {
     this.options = {
-      emitPlanUpdates: options?.emitPlanUpdates ?? true
+      emitPlanUpdates: options?.emitPlanUpdates ?? true,
+      maxToolResultOutputChars: options?.maxToolResultOutputChars ?? DEFAULT_MAX_TOOL_RESULT_OUTPUT_CHARS
+    };
+    this.handlers = {
+      "turn/started": (p) => this.handleTurnStarted(p),
+      "item/started": (p) => this.handleItemStarted(p),
+      "item/agentMessage/delta": (p) => this.handleAgentMessageDelta(p),
+      "item/completed": (p) => this.handleItemCompleted(p),
+      "item/reasoning/textDelta": (p) => this.handleReasoningDelta(p),
+      "item/reasoning/summaryTextDelta": (p) => this.handleReasoningDelta(p),
+      "item/plan/delta": (p) => this.handleReasoningDelta(p),
+      "item/fileChange/outputDelta": (p) => this.handleReasoningDelta(p),
+      "item/reasoning/summaryPartAdded": (p) => this.handleSummaryPartAdded(p),
+      "turn/plan/updated": (p) => this.handlePlanUpdated(p),
+      "item/commandExecution/outputDelta": (p) => this.handleCommandOutputDelta(p),
+      "codex/event/mcp_tool_call_begin": (p) => this.handleMcpToolCallBegin(p),
+      "codex/event/mcp_tool_call_end": (p) => this.handleMcpToolCallEnd(p),
+      "item/mcpToolCall/progress": (p) => this.handleMcpToolCallProgress(p),
+      "item/tool/callStarted": (p) => this.handleToolCallStarted(p),
+      "item/tool/callDelta": (p) => this.handleToolCallDelta(p),
+      "item/tool/callFinished": (p) => this.handleToolCallFinished(p),
+      "item/tool/call": (p) => this.handleToolCall(p),
+      "thread/tokenUsage/updated": (p) => this.handleTokenUsageUpdated(p),
+      "turn/completed": (p) => this.handleTurnCompleted(p),
+      // Intentionally ignored: wrapper/duplicate events handled by their canonical forms above.
+      "codex/event/agent_reasoning": NOOP,
+      "codex/event/agent_reasoning_section_break": NOOP,
+      "codex/event/plan_update": NOOP,
+      // Intentionally ignored: web search wrappers mirror item events.
+      // We emit web-search reasoning only from item/started + item/completed.
+      "codex/event/web_search_begin": NOOP,
+      "codex/event/web_search_end": NOOP,
+      // Intentionally ignored: full diffs (often 50-100 KB) crash/freeze frontend renderers.
+      // If these need to surface, they should use a dedicated part type with lazy rendering.
+      "turn/diff/updated": NOOP,
+      "codex/event/turn_diff": NOOP
     };
   }
   setThreadId(threadId) {
@@ -1028,331 +1066,478 @@ var CodexEventMapper = class {
   getTurnId() {
     return this.turnId;
   }
+  map(event) {
+    const handler = this.handlers[event.method];
+    return handler ? handler(event.params) : [];
+  }
+  // ── Helpers ──────────────────────────────────────────────────────────────
+  withMeta(part) {
+    return withProviderMetadata(part, this.threadId, this.turnId);
+  }
+  ensureStreamStarted(parts) {
+    if (!this.streamStarted) {
+      parts.push({ type: "stream-start", warnings: [] });
+      this.streamStarted = true;
+    }
+  }
+  emitReasoningDelta(parts, id, delta) {
+    this.ensureStreamStarted(parts);
+    if (!this.openReasoningParts.has(id)) {
+      this.openReasoningParts.add(id);
+      parts.push(this.withMeta({ type: "reasoning-start", id }));
+    }
+    if (delta) {
+      parts.push(this.withMeta({ type: "reasoning-delta", id, delta }));
+    }
+  }
   nextPlanSequence(turnId) {
     const next = (this.planSequenceByTurnId.get(turnId) ?? 0) + 1;
     this.planSequenceByTurnId.set(turnId, next);
     return next;
   }
-  map(event) {
+  applyOutputLimit(output) {
+    const limit = this.options.maxToolResultOutputChars;
+    if (limit <= 0) {
+      return { output, droppedChars: 0 };
+    }
+    if (output.length <= limit) {
+      return { output, droppedChars: 0 };
+    }
+    const droppedChars = output.length - limit;
+    return { output: output.slice(droppedChars), droppedChars };
+  }
+  appendTrackedOutput(tracked, delta) {
+    if (!delta) {
+      return;
+    }
+    const combined = tracked.output + delta;
+    const limited = this.applyOutputLimit(combined);
+    tracked.output = limited.output;
+    tracked.droppedChars += limited.droppedChars;
+  }
+  formatToolOutput(output, droppedChars) {
+    if (droppedChars <= 0) {
+      return output;
+    }
+    return `[output truncated: ${droppedChars} chars omitted]
+${output}`;
+  }
+  // ── Handlers ─────────────────────────────────────────────────────────────
+  // turn/started
+  handleTurnStarted(params) {
+    const p = params;
+    if (p?.turn?.id) {
+      this.turnId = p.turn.id;
+    }
     const parts = [];
-    const withMeta = (part) => withProviderMetadata(part, this.threadId, this.turnId);
-    const pushStreamStart = () => {
-      if (!this.streamStarted) {
-        parts.push({ type: "stream-start", warnings: [] });
-        this.streamStarted = true;
-      }
-    };
-    const pushReasoningDelta = (id, delta) => {
-      pushStreamStart();
-      if (!this.openReasoningParts.has(id)) {
-        this.openReasoningParts.add(id);
-        parts.push(withMeta({ type: "reasoning-start", id }));
-      }
-      if (!delta) {
-        return;
-      }
-      parts.push(withMeta({ type: "reasoning-delta", id, delta }));
-    };
-    switch (event.method) {
-      case "turn/started": {
-        const turnStartedParams = event.params;
-        if (turnStartedParams?.turn?.id) {
-          this.turnId = turnStartedParams.turn.id;
-        }
-        pushStreamStart();
-        break;
-      }
-      case "item/started": {
-        const params = event.params ?? {};
-        const item = params.item;
-        if (!item?.id) {
-          break;
-        }
-        switch (item.type) {
-          case "agentMessage": {
-            pushStreamStart();
-            this.openTextParts.add(item.id);
-            parts.push(withMeta({ type: "text-start", id: item.id }));
-            break;
-          }
-          case "commandExecution": {
-            pushStreamStart();
-            const toolName = "codex_command_execution";
-            this.openToolCalls.set(item.id, { toolName, output: "" });
-            parts.push(withMeta({
-              type: "tool-call",
-              toolCallId: item.id,
-              toolName,
-              input: JSON.stringify({ command: item.command, cwd: item.cwd }),
-              providerExecuted: true,
-              dynamic: true
-            }));
-            break;
-          }
-          case "reasoning":
-          case "plan":
-          case "fileChange":
-          case "mcpToolCall":
-          case "collabAgentToolCall":
-          case "webSearch":
-          case "imageView":
-          case "contextCompaction":
-          case "enteredReviewMode":
-          case "exitedReviewMode": {
-            pushReasoningDelta(item.id, "");
-            break;
-          }
-        }
-        break;
-      }
-      case "item/agentMessage/delta": {
-        const delta = event.params ?? {};
-        if (!delta.itemId || !delta.delta) {
-          break;
-        }
-        pushStreamStart();
-        if (!this.openTextParts.has(delta.itemId)) {
-          this.openTextParts.add(delta.itemId);
-          parts.push(withMeta({ type: "text-start", id: delta.itemId }));
-        }
-        parts.push(withMeta({ type: "text-delta", id: delta.itemId, delta: delta.delta }));
-        this.textDeltaReceived.add(delta.itemId);
+    this.ensureStreamStarted(parts);
+    return parts;
+  }
+  // item/started
+  handleItemStarted(params) {
+    const p = params ?? {};
+    const item = p.item;
+    if (!item?.id) {
+      return [];
+    }
+    const parts = [];
+    switch (item.type) {
+      case "agentMessage": {
+        this.ensureStreamStarted(parts);
+        this.openTextParts.add(item.id);
+        parts.push(this.withMeta({ type: "text-start", id: item.id }));
         break;
       }
-      case "item/completed": {
-        const params = event.params ?? {};
-        const item = params.item;
-        if (!item?.id) {
-          break;
-        }
-        if (item.type === "agentMessage") {
-          if (!this.textDeltaReceived.has(item.id) && item.text) {
-            pushStreamStart();
-            if (!this.openTextParts.has(item.id)) {
-              this.openTextParts.add(item.id);
-              parts.push(withMeta({ type: "text-start", id: item.id }));
-            }
-            parts.push(withMeta({ type: "text-delta", id: item.id, delta: item.text }));
-          }
-          if (this.openTextParts.has(item.id)) {
-            parts.push(withMeta({ type: "text-end", id: item.id }));
-            this.openTextParts.delete(item.id);
-          }
-        } else if (item.type === "commandExecution" && this.openToolCalls.has(item.id)) {
-          const tracked = this.openToolCalls.get(item.id);
-          const output = item.aggregatedOutput ?? tracked.output;
-          const exitCode = item.exitCode;
-          const status = item.status;
-          parts.push(withMeta({
-            type: "tool-result",
-            toolCallId: item.id,
-            toolName: tracked.toolName,
-            result: { output, exitCode, status }
-          }));
-          this.openToolCalls.delete(item.id);
-        } else if (this.openReasoningParts.has(item.id)) {
-          parts.push(withMeta({ type: "reasoning-end", id: item.id }));
-          this.openReasoningParts.delete(item.id);
-        }
+      case "commandExecution": {
+        this.ensureStreamStarted(parts);
+        const toolName = "codex_command_execution";
+        this.openToolCalls.set(item.id, { toolName, output: "", droppedChars: 0 });
+        parts.push(this.withMeta({
+          type: "tool-call",
+          toolCallId: item.id,
+          toolName,
+          input: JSON.stringify({ command: item.command, cwd: item.cwd }),
+          providerExecuted: true,
+          dynamic: true
+        }));
         break;
       }
-      case "item/reasoning/textDelta":
-      case "item/reasoning/summaryTextDelta":
-      case "item/plan/delta":
-      case "item/fileChange/outputDelta": {
-        const delta = event.params ?? {};
-        if (delta.itemId && delta.delta) {
-          pushReasoningDelta(delta.itemId, delta.delta);
-        }
+      case "dynamicToolCall": {
+        parts.push(...this.startDynamicToolCall(item));
         break;
       }
-      case "item/reasoning/summaryPartAdded": {
-        const params = event.params ?? {};
-        if (params.itemId) {
-          pushReasoningDelta(params.itemId, "\n\n");
-        }
+      case "reasoning":
+      case "plan":
+      case "fileChange":
+      case "mcpToolCall":
+      case "collabAgentToolCall":
+      case "webSearch":
+      case "imageView":
+      case "contextCompaction":
+      case "enteredReviewMode":
+      case "exitedReviewMode": {
+        this.emitReasoningDelta(parts, item.id, "");
         break;
       }
-      // codex/event/agent_reasoning mirrors canonical reasoning summary
-      // stream events in current logs. Ignore wrapper to avoid duplicate
-      // reasoning text in consumers.
-      case "codex/event/agent_reasoning":
-        break;
-      // codex/event/agent_reasoning_section_break is the wrapper form of
-      // item/reasoning/summaryPartAdded (identical 1:1). Handled by the
-      // canonical event above — skip the wrapper to avoid double "\n\n".
-      case "codex/event/agent_reasoning_section_break":
-        break;
-      case "turn/plan/updated": {
-        if (!this.options.emitPlanUpdates) {
-          break;
-        }
-        const params = event.params ?? {};
-        const turnId = params.turnId;
-        const plan = params.plan;
-        if (turnId && plan) {
-          pushStreamStart();
-          const planSequence = this.nextPlanSequence(turnId);
-          const toolCallId = `plan:${turnId}:${planSequence}`;
-          const toolName = "codex_plan_update";
-          parts.push(withMeta({
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            input: JSON.stringify({}),
-            providerExecuted: true,
-            dynamic: true
-          }));
-          parts.push(withMeta({
-            type: "tool-result",
-            toolCallId,
-            toolName,
-            result: { plan, explanation: params.explanation ?? void 0 }
-          }));
+    }
+    return parts;
+  }
+  // item/agentMessage/delta
+  handleAgentMessageDelta(params) {
+    const delta = params ?? {};
+    if (!delta.itemId || !delta.delta) {
+      return [];
+    }
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    if (!this.openTextParts.has(delta.itemId)) {
+      this.openTextParts.add(delta.itemId);
+      parts.push(this.withMeta({ type: "text-start", id: delta.itemId }));
+    }
+    parts.push(this.withMeta({ type: "text-delta", id: delta.itemId, delta: delta.delta }));
+    this.textDeltaReceived.add(delta.itemId);
+    return parts;
+  }
+  // item/completed
+  handleItemCompleted(params) {
+    const p = params ?? {};
+    const item = p.item;
+    if (!item?.id) {
+      return [];
+    }
+    const parts = [];
+    if (item.type === "agentMessage") {
+      if (!this.textDeltaReceived.has(item.id) && item.text) {
+        this.ensureStreamStarted(parts);
+        if (!this.openTextParts.has(item.id)) {
+          this.openTextParts.add(item.id);
+          parts.push(this.withMeta({ type: "text-start", id: item.id }));
         }
-        break;
+        parts.push(this.withMeta({ type: "text-delta", id: item.id, delta: item.text }));
       }
-      // codex/event/plan_update is the wrapper form of turn/plan/updated (1:1).
-      case "codex/event/plan_update":
-        break;
-      // NOTE: turn/diff/updated and codex/event/turn_diff are intentionally
-      // NOT mapped. They carry full unified diffs (often 50-100 KB) which,
-      // when emitted as reasoning deltas, crash or freeze the frontend
-      // markdown renderer. If these need to surface in the UI, they should
-      // use a dedicated part type with lazy/collapsed rendering — not
-      // reasoning text.
-      case "turn/diff/updated":
-      case "codex/event/turn_diff":
-        break;
-      case "item/commandExecution/outputDelta": {
-        const delta = event.params ?? {};
-        if (delta.itemId && delta.delta && this.openToolCalls.has(delta.itemId)) {
-          const tracked = this.openToolCalls.get(delta.itemId);
-          tracked.output += delta.delta;
-          parts.push(withMeta({
-            type: "tool-result",
-            toolCallId: delta.itemId,
-            toolName: tracked.toolName,
-            result: { output: tracked.output },
-            preliminary: true
-          }));
-        }
-        break;
+      if (this.openTextParts.has(item.id)) {
+        parts.push(this.withMeta({ type: "text-end", id: item.id }));
+        this.openTextParts.delete(item.id);
       }
-      case "codex/event/mcp_tool_call_begin": {
-        const params = event.params ?? {};
-        const callId = params.msg?.call_id;
-        const inv = params.msg?.invocation;
-        if (callId && inv) {
-          pushStreamStart();
-          const toolName = `mcp:${inv.server}/${inv.tool}`;
-          this.openToolCalls.set(callId, { toolName, output: "" });
-          parts.push(withMeta({
-            type: "tool-call",
-            toolCallId: callId,
-            toolName,
-            input: JSON.stringify(inv.arguments ?? {}),
-            providerExecuted: true,
-            dynamic: true
-          }));
+    } else if (item.type === "commandExecution" && this.openToolCalls.has(item.id)) {
+      const tracked = this.openToolCalls.get(item.id);
+      const outputSource = item.aggregatedOutput ?? tracked.output;
+      const limitedOutput = this.applyOutputLimit(outputSource);
+      const output = this.formatToolOutput(
+        limitedOutput.output,
+        item.aggregatedOutput !== void 0 && item.aggregatedOutput !== null ? limitedOutput.droppedChars : tracked.droppedChars
+      );
+      const exitCode = item.exitCode;
+      const status = item.status;
+      parts.push(this.withMeta({
+        type: "tool-result",
+        toolCallId: item.id,
+        toolName: tracked.toolName,
+        result: { output, exitCode, status }
+      }));
+      this.openToolCalls.delete(item.id);
+    } else if (item.type === "dynamicToolCall") {
+      const dynamic = item;
+      const tracked = this.openToolCalls.get(item.id);
+      const toolName = tracked?.toolName ?? dynamic.tool ?? "dynamic_tool_call";
+      const rawOutput = this.stringifyDynamicToolResult(dynamic);
+      const limitedOutput = this.applyOutputLimit(rawOutput);
+      parts.push(this.withMeta({
+        type: "tool-result",
+        toolCallId: item.id,
+        toolName,
+        result: {
+          output: this.formatToolOutput(limitedOutput.output, limitedOutput.droppedChars),
+          success: dynamic.success ?? void 0
         }
-        break;
+      }));
+      this.openToolCalls.delete(item.id);
+    } else if (item.type === "webSearch") {
+      const webSearchSummary = this.formatWebSearchItemSummary(item);
+      if (webSearchSummary) {
+        this.emitReasoningDelta(parts, item.id, webSearchSummary);
       }
-      case "codex/event/mcp_tool_call_end": {
-        const params = event.params ?? {};
-        const callId = params.msg?.call_id;
-        if (callId && this.openToolCalls.has(callId)) {
-          const tracked = this.openToolCalls.get(callId);
-          const result = params.msg?.result;
-          const textParts = result?.Ok?.content?.filter((c) => c.type === "text").map((c) => c.text) ?? [];
-          const output = textParts.join("\n") || (result?.Err ? JSON.stringify(result.Err) : "");
-          parts.push(withMeta({
-            type: "tool-result",
-            toolCallId: callId,
-            toolName: tracked.toolName,
-            result: { output }
-          }));
-          this.openToolCalls.delete(callId);
-        }
-        break;
+      if (this.openReasoningParts.has(item.id)) {
+        parts.push(this.withMeta({ type: "reasoning-end", id: item.id }));
+        this.openReasoningParts.delete(item.id);
       }
-      case "item/mcpToolCall/progress": {
-        const params = event.params ?? {};
-        if (params.itemId && params.message) {
-          pushReasoningDelta(params.itemId, params.message);
-        }
-        break;
+    } else if (this.openReasoningParts.has(item.id)) {
+      parts.push(this.withMeta({ type: "reasoning-end", id: item.id }));
+      this.openReasoningParts.delete(item.id);
+    }
+    return parts;
+  }
+  // item/reasoning/textDelta, item/reasoning/summaryTextDelta, item/plan/delta, item/fileChange/outputDelta
+  handleReasoningDelta(params) {
+    const delta = params ?? {};
+    if (!delta.itemId || !delta.delta) {
+      return [];
+    }
+    const parts = [];
+    this.emitReasoningDelta(parts, delta.itemId, delta.delta);
+    return parts;
+  }
+  // item/reasoning/summaryPartAdded
+  handleSummaryPartAdded(params) {
+    const p = params ?? {};
+    if (!p.itemId) {
+      return [];
+    }
+    const parts = [];
+    this.emitReasoningDelta(parts, p.itemId, "\n\n");
+    return parts;
+  }
+  // turn/plan/updated
+  handlePlanUpdated(params) {
+    if (!this.options.emitPlanUpdates) {
+      return [];
+    }
+    const p = params ?? {};
+    const turnId = p.turnId;
+    const plan = p.plan;
+    if (!turnId || !plan) {
+      return [];
+    }
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    const planSequence = this.nextPlanSequence(turnId);
+    const toolCallId = `plan:${turnId}:${planSequence}`;
+    const toolName = "codex_plan_update";
+    parts.push(this.withMeta({
+      type: "tool-call",
+      toolCallId,
+      toolName,
+      input: JSON.stringify({}),
+      providerExecuted: true,
+      dynamic: true
+    }));
+    parts.push(this.withMeta({
+      type: "tool-result",
+      toolCallId,
+      toolName,
+      result: { plan, explanation: p.explanation ?? void 0 }
+    }));
+    return parts;
+  }
+  // item/commandExecution/outputDelta
+  handleCommandOutputDelta(params) {
+    const delta = params ?? {};
+    if (!delta.itemId || !delta.delta || !this.openToolCalls.has(delta.itemId)) {
+      return [];
+    }
+    const tracked = this.openToolCalls.get(delta.itemId);
+    this.appendTrackedOutput(tracked, delta.delta);
+    return [this.withMeta({
+      type: "tool-result",
+      toolCallId: delta.itemId,
+      toolName: tracked.toolName,
+      result: { output: this.formatToolOutput(tracked.output, tracked.droppedChars) },
+      preliminary: true
+    })];
+  }
+  // codex/event/mcp_tool_call_begin
+  handleMcpToolCallBegin(params) {
+    const p = params ?? {};
+    const callId = p.msg?.call_id;
+    const inv = p.msg?.invocation;
+    if (!callId || !inv) {
+      return [];
+    }
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    const toolName = `mcp:${inv.server}/${inv.tool}`;
+    this.openToolCalls.set(callId, { toolName, output: "", droppedChars: 0 });
+    parts.push(this.withMeta({
+      type: "tool-call",
+      toolCallId: callId,
+      toolName,
+      input: JSON.stringify(inv.arguments ?? {}),
+      providerExecuted: true,
+      dynamic: true
+    }));
+    return parts;
+  }
+  // codex/event/mcp_tool_call_end
+  handleMcpToolCallEnd(params) {
+    const p = params ?? {};
+    const callId = p.msg?.call_id;
+    if (!callId || !this.openToolCalls.has(callId)) {
+      return [];
+    }
+    const tracked = this.openToolCalls.get(callId);
+    const result = p.msg?.result;
+    const textParts = result?.Ok?.content?.filter((c) => c.type === "text").map((c) => c.text) ?? [];
+    const rawOutput = textParts.join("\n") || (result?.Err ? JSON.stringify(result.Err) : "");
+    const limitedOutput = this.applyOutputLimit(rawOutput);
+    this.openToolCalls.delete(callId);
+    return [this.withMeta({
+      type: "tool-result",
+      toolCallId: callId,
+      toolName: tracked.toolName,
+      result: { output: this.formatToolOutput(limitedOutput.output, limitedOutput.droppedChars) }
+    })];
+  }
+  // item/mcpToolCall/progress
+  handleMcpToolCallProgress(params) {
+    const p = params ?? {};
+    if (!p.itemId || !p.message) {
+      return [];
+    }
+    const parts = [];
+    this.emitReasoningDelta(parts, p.itemId, p.message);
+    return parts;
+  }
+  // item/tool/callStarted
+  handleToolCallStarted(params) {
+    const p = params ?? {};
+    if (!p.callId || !p.tool) {
+      return [];
+    }
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    parts.push(this.withMeta({ type: "tool-input-start", id: p.callId, toolName: p.tool, dynamic: true }));
+    return parts;
+  }
+  // item/tool/callDelta
+  handleToolCallDelta(params) {
+    const p = params ?? {};
+    if (!p.callId || !p.delta) {
+      return [];
+    }
+    return [this.withMeta({ type: "tool-input-delta", id: p.callId, delta: p.delta })];
+  }
+  // item/tool/callFinished
+  handleToolCallFinished(params) {
+    const p = params ?? {};
+    if (!p.callId) {
+      return [];
+    }
+    return [this.withMeta({ type: "tool-input-end", id: p.callId })];
+  }
+  // item/tool/call
+  handleToolCall(params) {
+    const p = params ?? {};
+    if (!p.callId || !p.tool) {
+      return [];
+    }
+    return this.startDynamicToolCall({
+      id: p.callId,
+      tool: p.tool,
+      arguments: p.arguments ?? {}
+    });
+  }
+  startDynamicToolCall(item) {
+    if (!item.id || !item.tool) {
+      return [];
+    }
+    if (this.openToolCalls.has(item.id)) {
+      return [];
+    }
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    this.openToolCalls.set(item.id, { toolName: item.tool, output: "", droppedChars: 0 });
+    parts.push(this.withMeta({
+      type: "tool-call",
+      toolCallId: item.id,
+      toolName: item.tool,
+      input: JSON.stringify(item.arguments ?? {}),
+      providerExecuted: true,
+      dynamic: true
+    }));
+    return parts;
+  }
+  stringifyDynamicToolResult(item) {
+    const contentItems = item.contentItems ?? [];
+    if (!contentItems.length) {
+      return "";
+    }
+    const chunks = [];
+    for (const contentItem of contentItems) {
+      if (contentItem.type === "inputText" && contentItem.text) {
+        chunks.push(contentItem.text);
+        continue;
       }
-      case "item/tool/callStarted": {
-        const params = event.params ?? {};
-        if (params.callId && params.tool) {
-          pushStreamStart();
-          parts.push(withMeta({ type: "tool-input-start", id: params.callId, toolName: params.tool, dynamic: true }));
-        }
-        break;
+      if (contentItem.type === "inputImage" && contentItem.imageUrl) {
+        chunks.push(`[image] ${contentItem.imageUrl}`);
       }
-      case "item/tool/callDelta": {
-        const params = event.params ?? {};
-        if (params.callId && params.delta) {
-          parts.push(withMeta({ type: "tool-input-delta", id: params.callId, delta: params.delta }));
-        }
-        break;
+    }
+    return chunks.join("\n");
+  }
+  formatWebSearchItemSummary(item) {
+    const query = item.query?.trim();
+    const actionType = item.action?.type;
+    if (actionType === "search") {
+      if (query) {
+        return `Web search: ${query}`;
       }
-      case "item/tool/callFinished": {
-        const params = event.params ?? {};
-        if (params.callId) {
-          parts.push(withMeta({ type: "tool-input-end", id: params.callId }));
-        }
-        break;
+      const actionQuery = item.action?.query?.trim();
+      return actionQuery ? `Web search: ${actionQuery}` : "Web search";
+    }
+    if (actionType === "openPage" || actionType === "open_page") {
+      const url = item.action?.url?.trim();
+      return url ? `Open page: ${url}` : "Open page";
+    }
+    if (actionType === "findInPage" || actionType === "find_in_page") {
+      const pattern = item.action?.pattern?.trim();
+      const url = item.action?.url?.trim();
+      if (pattern && url) {
+        return `Find in page: "${pattern}" (${url})`;
       }
-      case "thread/tokenUsage/updated": {
-        const params = event.params ?? {};
-        const last = params.tokenUsage?.last;
-        if (last) {
-          this.latestUsage = {
-            inputTokens: {
-              total: last.inputTokens,
-              noCache: void 0,
-              cacheRead: last.cachedInputTokens,
-              cacheWrite: void 0
-            },
-            outputTokens: {
-              total: last.outputTokens,
-              text: void 0,
-              reasoning: last.reasoningOutputTokens
-            }
-          };
-        }
-        break;
+      if (pattern) {
+        return `Find in page: "${pattern}"`;
       }
-      case "turn/completed": {
-        pushStreamStart();
-        for (const itemId of this.openTextParts) {
-          parts.push(withMeta({ type: "text-end", id: itemId }));
-        }
-        this.openTextParts.clear();
-        for (const itemId of this.openReasoningParts) {
-          parts.push(withMeta({ type: "reasoning-end", id: itemId }));
-        }
-        this.openReasoningParts.clear();
-        for (const [itemId, tracked] of this.openToolCalls) {
-          parts.push(withMeta({
-            type: "tool-result",
-            toolCallId: itemId,
-            toolName: tracked.toolName,
-            result: { output: tracked.output }
-          }));
-        }
-        this.openToolCalls.clear();
-        const completed = event.params ?? {};
-        if (completed.turn?.id) {
-          this.planSequenceByTurnId.delete(completed.turn.id);
+      return url ? `Find in page: ${url}` : "Find in page";
+    }
+    return query ? `Web search: ${query}` : "";
+  }
+  // thread/tokenUsage/updated
+  handleTokenUsageUpdated(params) {
+    const p = params ?? {};
+    const last = p.tokenUsage?.last;
+    if (last) {
+      this.latestUsage = {
+        inputTokens: {
+          total: last.inputTokens,
+          noCache: void 0,
+          cacheRead: last.cachedInputTokens,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: last.outputTokens,
+          text: void 0,
+          reasoning: last.reasoningOutputTokens
         }
-        const usage = this.latestUsage ?? EMPTY_USAGE;
-        parts.push(withMeta({ type: "finish", finishReason: toFinishReason(completed.turn?.status), usage }));
-        break;
-      }
+      };
+    }
+    return [];
+  }
+  // turn/completed
+  handleTurnCompleted(params) {
+    const parts = [];
+    this.ensureStreamStarted(parts);
+    for (const itemId of this.openTextParts) {
+      parts.push(this.withMeta({ type: "text-end", id: itemId }));
+    }
+    this.openTextParts.clear();
+    for (const itemId of this.openReasoningParts) {
+      parts.push(this.withMeta({ type: "reasoning-end", id: itemId }));
+    }
+    this.openReasoningParts.clear();
+    for (const [itemId, tracked] of this.openToolCalls) {
+      parts.push(this.withMeta({
+        type: "tool-result",
+        toolCallId: itemId,
+        toolName: tracked.toolName,
+        result: { output: this.formatToolOutput(tracked.output, tracked.droppedChars) }
+      }));
+    }
+    this.openToolCalls.clear();
+    const completed = params ?? {};
+    if (completed.turn?.id) {
+      this.planSequenceByTurnId.delete(completed.turn.id);
     }
+    const usage = this.latestUsage ?? EMPTY_USAGE;
+    parts.push(this.withMeta({ type: "finish", finishReason: toFinishReason(completed.turn?.status), usage }));
     return parts;
   }
 };
@@ -1839,7 +2024,7 @@ var CodexLanguageModel = class {
   }
   doStream(options) {
     const resumeThreadId = extractResumeThreadId(options.prompt);
-    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory(options.abortSignal, resumeThreadId) : this.config.providerSettings.transport?.type === "websocket" ? new WebSocketTransport(this.config.providerSettings.transport.websocket) : new StdioTransport(this.config.providerSettings.transport?.stdio);
+    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory(stripUndefined({ signal: options.abortSignal, threadId: resumeThreadId })) : this.config.providerSettings.transport?.type === "websocket" ? new WebSocketTransport(this.config.providerSettings.transport.websocket) : new StdioTransport(this.config.providerSettings.transport?.stdio);
     const packetLogger = this.config.providerSettings.debug?.logPackets === true ? this.config.providerSettings.debug.logger ?? ((packet) => {
       if (packet.direction === "inbound") {
         console.debug("[codex packet]", packet.message);
@@ -1855,7 +2040,8 @@ var CodexLanguageModel = class {
       onPacket: packetLogger
     }));
     const mapper = new CodexEventMapper(stripUndefined({
-      emitPlanUpdates: this.config.providerSettings.emitPlanUpdates
+      emitPlanUpdates: this.config.providerSettings.emitPlanUpdates,
+      maxToolResultOutputChars: this.config.providerSettings.maxToolResultOutputChars
     }));
     let activeThreadId;
     let activeTurnId;
@@ -2272,7 +2458,7 @@ function createCodexAppServer(settings = {}) {
     const scope = settings.persistent.scope ?? "provider";
     const poolSize = settings.persistent.poolSize ?? 1;
     const idleTimeoutMs = settings.persistent.idleTimeoutMs ?? 3e5;
-    const poolTransportFactory = baseTransportFactory ?? (settings.transport?.type === "websocket" ? () => new WebSocketTransport(settings.transport?.websocket) : () => new StdioTransport(settings.transport?.stdio));
+    const poolTransportFactory = baseTransportFactory ? () => baseTransportFactory({}) : settings.transport?.type === "websocket" ? () => new WebSocketTransport(settings.transport?.websocket) : () => new StdioTransport(settings.transport?.stdio);
     persistentPoolHandle = acquirePersistentPool({
       scope,
       ...stripUndefined({ key: settings.persistent.key }),
@@ -2282,7 +2468,7 @@ function createCodexAppServer(settings = {}) {
     });
   }
   const persistentPool = persistentPoolHandle?.pool ?? null;
-  const effectiveTransportFactory = persistentPool ? (signal, threadId) => new PersistentTransport(stripUndefined({ pool: persistentPool, signal, threadId })) : baseTransportFactory;
+  const effectiveTransportFactory = persistentPool ? (context) => new PersistentTransport(stripUndefined({ pool: persistentPool, signal: context.signal, threadId: context.threadId })) : baseTransportFactory;
   const resolvedSettings = Object.freeze(stripUndefined({
     defaultModel: settings.defaultModel,
     experimentalApi: settings.experimentalApi,
@@ -2308,6 +2494,7 @@ function createCodexAppServer(settings = {}) {
     approvals: settings.approvals ? { ...settings.approvals } : void 0,
     debug: settings.debug ? { ...settings.debug } : void 0,
     emitPlanUpdates: settings.emitPlanUpdates,
+    maxToolResultOutputChars: settings.maxToolResultOutputChars,
     onSessionCreated: settings.onSessionCreated
   }));
   const createLanguageModel = (modelId, modelSettings = {}) => new CodexLanguageModel(modelId, modelSettings, {
@@ -2331,7 +2518,7 @@ function createCodexAppServer(settings = {}) {
       throw createNoSuchModelError(modelId, "imageModel");
     },
     async listModels(params) {
-      const transport = effectiveTransportFactory ? effectiveTransportFactory() : resolvedSettings.transport?.type === "websocket" ? new WebSocketTransport(resolvedSettings.transport.websocket) : new StdioTransport(resolvedSettings.transport?.stdio);
+      const transport = effectiveTransportFactory ? effectiveTransportFactory({}) : resolvedSettings.transport?.type === "websocket" ? new WebSocketTransport(resolvedSettings.transport.websocket) : new StdioTransport(resolvedSettings.transport?.stdio);
       const client = new AppServerClient(transport);
       try {
         await client.connect();