@agentex/agent 0.0.38 → 0.0.40

package/src/providers/antigravity/session.ts

@@ -0,0 +1,359 @@
+import type {
+  AgentSession,
+  CancelResult,
+  ClearGoalResult,
+  GoalOptions,
+  GoalState,
+  SendHandle,
+  SendOptions,
+  SessionContext,
+  SessionState,
+  SetGoalResult,
+  StopTaskResult,
+  StreamEvent,
+  TurnResult,
+  TurnTrigger,
+} from "../../types.js";
+import { GoalController, EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+import type { ResolvedBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { resolveInstructions } from "../../utils/instructions.js";
+import { injectHomeSkills } from "../../utils/skills.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import {
+  AgyConnection,
+  firstAgyErrorLine,
+  interruptAgyTurn,
+  type AgyTurnOutcome,
+} from "./connection.js";
+import {
+  ANTIGRAVITY_PROVIDER_TYPE,
+  AgyStreamParser,
+  agyUsageRecord,
+  classifyAgyFailure,
+  mapAgyTurnStatus,
+} from "./parse.js";
+import { AGY_SIGN_IN_MESSAGE, buildAgyArgs, findAgyBinary, readAgyResumeId } from "./runtime.js";
+
+interface ActiveTurn {
+  turnId: string;
+  abort: AbortController;
+  done: Promise<TurnResult>;
+}
+
+/**
+ * Open a multi-turn Antigravity session. Throws when `agy` is not installed.
+ * The process starts on the first `send()`.
+ */
+export async function createAntigravitySession(ctx: SessionContext): Promise<AgentSession> {
+  const binary = await findAgyBinary(ctx);
+  const config = ctx.config ?? {};
+  const instructions = await resolveInstructions(config.instructionsFile);
+  if (config.skillDirs && config.skillDirs.length > 0) {
+    try {
+      await injectHomeSkills(config.skillDirs, "antigravity");
+    } catch {
+      // Non-fatal
+    }
+  }
+  return new AntigravitySession(ctx, binary, instructions);
+}
+
+/**
+ * One `agy --input-format stream-json --output-format stream-json` process
+ * holds the conversation across turns. The CLI has no control protocol, so
+ * an interrupt is a SIGINT (Ctrl+C); when that ends the process, the next
+ * `send()` starts a new one on the same conversation with `--conversation`.
+ */
+class AntigravitySession implements AgentSession {
+  private _state: SessionState = "idle";
+  private conversationId: string | null;
+  private connection: AgyConnection | null = null;
+  private parser: AgyStreamParser | null = null;
+  private active: ActiveTurn | null = null;
+  /** Events received from agy processes, to tell whether one saw a message. */
+  private connectionEvents = 0;
+  private draining = false;
+  /** Instructions go into the first message of a conversation this session starts. */
+  private pendingInstructions: string | null;
+  private readonly cwd: string;
+  private readonly goals: GoalController;
+
+  constructor(
+    private readonly ctx: SessionContext,
+    private readonly binary: ResolvedBinary,
+    instructions: string | null,
+  ) {
+    this.cwd = ctx.cwd ?? process.cwd();
+    this.conversationId = readAgyResumeId(ctx.sessionParams, this.cwd);
+    this.pendingInstructions = this.conversationId ? null : instructions;
+    this.goals = new GoalController({
+      providerType: ANTIGRAVITY_PROVIDER_TYPE,
+      capability: EMULATED_GOAL_CAPABILITY,
+      getSessionId: () => this.sessionId,
+      send: (message) => this.send(message),
+      dispatch: (event) => void this.dispatch(event),
+    });
+    if (ctx.signal) {
+      if (ctx.signal.aborted) void this.close();
+      else ctx.signal.addEventListener("abort", () => void this.close(), { once: true });
+    }
+  }
+
+  get sessionId(): string | null {
+    return this.parser?.conversationId ?? this.conversationId;
+  }
+
+  get state(): SessionState {
+    return this._state;
+  }
+
+  async send(message: string, options?: SendOptions): Promise<SendHandle> {
+    if (this._state === "closed") throw new Error("Session is closed");
+    if (this.draining) throw new Error("Session is draining — no new sends accepted");
+    if (this.active) {
+      throw new Error("Antigravity session is busy — a turn is already in progress (concurrentSend not supported)");
+    }
+
+    const uuid = uuidv7();
+    const turnId = uuidv7();
+    const abort = new AbortController();
+    const text = this.pendingInstructions ? `${this.pendingInstructions}\n\n${message}` : message;
+    this.pendingInstructions = null;
+
+    this._state = "thinking";
+    const done = this.runTurn(text, turnId, abort, options);
+    this.active = { turnId, abort, done };
+    void done.then((result) => this.goals.onTurnSettled(result)).catch(() => undefined);
+    return { uuid, result: done };
+  }
+
+  private ensureConnection(): AgyConnection {
+    if (this.connection?.alive) return this.connection;
+    const config = this.ctx.config ?? {};
+    // A replacement process picks the conversation back up where it stopped.
+    this.conversationId = this.sessionId;
+    const parser = new AgyStreamParser({
+      includePartialMessages: config.includePartialMessages,
+      conversationId: this.conversationId,
+    });
+    const env = buildEnv(this.ctx.env);
+    ensurePathInEnv(env);
+    this.ctx.onLifecycle?.({ phase: "spawning" });
+    const connection = new AgyConnection({
+      command: this.binary.bin,
+      args: [
+        ...this.binary.prefixArgs,
+        ...buildAgyArgs(config, { resumeId: this.conversationId, model: config.model ?? null }),
+      ],
+      cwd: this.cwd,
+      env,
+      parser,
+      // Lines a replaced process prints on its way out belong to no turn.
+      onEvent: async (event): Promise<void> => {
+        if (this.connection === connection) await this.onEvent(event);
+      },
+      ...(this.ctx.onOutput ? { onOutput: this.ctx.onOutput } : {}),
+    });
+    if (connection.pid != null) this.ctx.onLifecycle?.({ phase: "running", pid: connection.pid });
+    this.connection = connection;
+    this.parser = parser;
+    return connection;
+  }
+
+  private async runTurn(
+    text: string,
+    turnId: string,
+    abort: AbortController,
+    options?: SendOptions,
+  ): Promise<TurnResult> {
+    await this.emitTurnEdge({ type: "turn_start", turnId, trigger: "send" });
+
+    const timeoutSec = options?.timeoutSec ?? this.ctx.config?.timeoutSec;
+    const graceSec = this.ctx.config?.graceSec;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const guards: Promise<"timeout" | "aborted">[] = [
+      new Promise((resolve) => abort.signal.addEventListener("abort", () => resolve("aborted"), { once: true })),
+    ];
+    if (timeoutSec && timeoutSec > 0) {
+      guards.push(new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), timeoutSec * 1000); }));
+    }
+    const onSendAbort = () => abort.abort();
+    if (options?.signal) {
+      if (options.signal.aborted) abort.abort();
+      else options.signal.addEventListener("abort", onSendAbort, { once: true });
+    }
+
+    let connection = this.ensureConnection();
+    try {
+      let result: TurnResult | null = null;
+      let reason: "result" | "cancelled" | "session_closed" = "result";
+      for (let attempt = 0; result === null; attempt++) {
+        const eventsBefore = this.connectionEvents;
+        const pending = connection.nextTurn();
+        connection.write(text);
+        const first = await Promise.race([pending, ...guards]);
+        if (first === "timeout" || first === "aborted") {
+          const outcome = await interruptAgyTurn(connection, pending, graceSec);
+          // agy may report INTERRUPTED and then exit. Learn which before the
+          // next send, so it never lands on a process that is going away.
+          if (outcome?.result) await connection.waitForExit(500);
+          // Without an INTERRUPTED result the process was stopped; a late result
+          // from it must never settle the next turn.
+          if ((!outcome?.result || !connection.alive) && this.connection === connection) this.connection = null;
+          result = {
+            summary: outcome?.result?.response.trim() || null,
+            ...this.usageOf(outcome),
+            costUsd: null,
+            status: first,
+            errorCode: first,
+            errorMessage: first === "timeout" ? "Turn exceeded its timeout" : "Turn aborted",
+          };
+          reason = "cancelled";
+        } else if (
+          attempt === 0 && !first.result && first.exited && !first.authRequired
+          && this.connectionEvents === eventsBefore && this._state !== "closed"
+        ) {
+          // The process exited without ever acknowledging the message (it was
+          // already shutting down). Run it on a fresh process for the same
+          // conversation instead of failing a turn agy never started.
+          if (this.connection === connection) this.connection = null;
+          connection = this.ensureConnection();
+        } else {
+          result = this.toTurnResult(first);
+          reason = first.result ? "result" : "session_closed";
+        }
+      }
+      await this.emitTurnEdge({ type: "turn_end", turnId, trigger: "send", reason });
+      return result;
+    } finally {
+      if (timer) clearTimeout(timer);
+      options?.signal?.removeEventListener("abort", onSendAbort);
+      this.active = null;
+      if (!connection.alive && this.connection === connection) this.connection = null;
+      if (this._state !== "closed") this._state = "idle";
+    }
+  }
+
+  private usageOf(outcome: AgyTurnOutcome | null): { usage?: TurnResult["usage"] } {
+    const usage = agyUsageRecord(outcome?.result?.turnUsage ?? null, this.parser?.model ?? this.ctx.config?.model ?? null);
+    return usage ? { usage } : {};
+  }
+
+  private toTurnResult(outcome: AgyTurnOutcome): TurnResult {
+    const { result } = outcome;
+    if (result) {
+      const status = mapAgyTurnStatus(result.status);
+      if (status === "completed") {
+        return { summary: result.response.trim() || null, ...this.usageOf(outcome), costUsd: null, status, errorCode: null, errorMessage: null };
+      }
+      const errorCode = status === "aborted"
+        ? "aborted"
+        : outcome.authRequired ? "auth_required" : classifyAgyFailure(result, outcome.agyError);
+      return {
+        summary: result.response.trim() || null,
+        ...this.usageOf(outcome),
+        costUsd: null,
+        status,
+        errorCode,
+        errorMessage: errorCode === "auth_required"
+          ? AGY_SIGN_IN_MESSAGE
+          : result.error ?? outcome.agyError?.message ?? `Antigravity turn ended with ${result.status}`,
+      };
+    }
+    if (outcome.authRequired) {
+      return { summary: null, costUsd: null, status: "failed", errorCode: "auth_required", errorMessage: AGY_SIGN_IN_MESSAGE };
+    }
+    return {
+      summary: null,
+      costUsd: null,
+      status: "failed",
+      errorCode: "process_exited",
+      errorMessage: outcome.agyError?.message
+        ?? firstAgyErrorLine(outcome.stderr)
+        ?? `Antigravity CLI exited (code ${outcome.exitCode ?? "null"}${outcome.signal ? `, ${outcome.signal}` : ""}) before finishing the turn`,
+    };
+  }
+
+  private async onEvent(event: StreamEvent): Promise<void> {
+    this.connectionEvents++;
+    if (this._state !== "closed") {
+      if (event.type === "tool_call") this._state = "tool_executing";
+      else if (event.type === "assistant" || event.type === "thinking" || event.type === "tool_result") this._state = "thinking";
+    }
+    await this.dispatch(event);
+  }
+
+  private async emitTurnEdge(
+    edge:
+      | { type: "turn_start"; turnId: string; trigger: TurnTrigger }
+      | { type: "turn_end"; turnId: string; trigger: TurnTrigger; reason: "result" | "cancelled" | "session_closed" },
+  ): Promise<void> {
+    await this.dispatch({
+      ...edge,
+      timestamp: new Date().toISOString(),
+      providerType: ANTIGRAVITY_PROVIDER_TYPE,
+      sessionId: this.sessionId,
+      messageId: null,
+      eventId: null,
+      parentToolCallId: null,
+      raw: {},
+    } as StreamEvent);
+  }
+
+  private async dispatch(event: StreamEvent): Promise<void> {
+    if (!this.ctx.onEvent) return;
+    try {
+      await this.ctx.onEvent(event);
+    } catch {
+      /* a throwing handler must not break the stream */
+    }
+  }
+
+  async cancel(_uuid: string): Promise<CancelResult> {
+    // One message per turn and no queue, so there is never a queued message to drop.
+    return { cancelled: false };
+  }
+
+  async stopTask(_taskId: string): Promise<StopTaskResult> {
+    return { stopped: false };
+  }
+
+  setGoal(objective: string, options?: GoalOptions): Promise<SetGoalResult> {
+    return this.goals.setGoal(objective, options);
+  }
+
+  clearGoal(options?: { reason?: "cleared" | "blocked" }): Promise<ClearGoalResult> {
+    return this.goals.clearGoal(options);
+  }
+
+  getGoal(): GoalState | null {
+    return this.goals.getGoal();
+  }
+
+  async interrupt(): Promise<void> {
+    const active = this.active;
+    if (!active) return;
+    active.abort.abort();
+    await active.done.catch(() => undefined);
+  }
+
+  async drain(): Promise<void> {
+    this.draining = true;
+    if (this.active) await this.active.done.catch(() => undefined);
+    await this.close();
+  }
+
+  async close(): Promise<void> {
+    if (this._state === "closed" && !this.connection) return;
+    this._state = "closed";
+    const active = this.active;
+    if (active) {
+      active.abort.abort();
+      await active.done.catch(() => undefined);
+    }
+    const connection = this.connection;
+    this.connection = null;
+    if (connection) await connection.terminate(this.ctx.config?.graceSec);
+  }
+}

package/src/providers/claude/attach.ts

@@ -1,6 +1,5 @@
 import { createReadStream } from "node:fs";
 import { stat } from "node:fs/promises";
-import * as readline from "node:readline";
 import type {
   AttachOptions,
   CatchUpOptions,
@@ -16,6 +15,7 @@ import {
   createSessionRecord,
   MalformedSessionRecordError,
 } from "../../sessions/record.js";
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 import { getRuntimeHomeEnvVar } from "../../utils/runtime-homes.js";
 import { claudeSessionCodec } from "./codec.js";
 import {
@@ -86,16 +86,15 @@ const EMPTY: AsyncIterable<CatchUpYield> = {
  * preceding completed one.
  */
 async function classifyLastTurn(filePath: string): Promise<LastTurnStatus> {
-  const stream = createReadStream(filePath, { encoding: "utf8" });
+  const stream = createReadStream(filePath);
   stream.on("error", () => {});
-  const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
   let lastTurn: LastTurnStatus = "unknown";
 
   try {
-    for await (const line of lines) {
+    for await (const line of readJsonlLines(stream)) {
       let raw: unknown;
       try {
-        raw = JSON.parse(line);
+        raw = JSON.parse(line.text);
       } catch {
         continue;
       }
@@ -109,7 +108,6 @@ async function classifyLastTurn(filePath: string): Promise<LastTurnStatus> {
     if (fsError?.code !== "ENOENT") throw error;
     return "unknown";
   } finally {
-    lines.close();
     stream.destroy();
   }
 

package/src/providers/claude/transcript.ts

@@ -23,8 +23,8 @@ import { createReadStream } from "node:fs";
 import { readdir, realpath, stat, open as fsOpen } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import * as readline from "node:readline";
 
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 import { getDefaultRuntimeHome, getRuntimeHomeEnvVar } from "../../utils/runtime-homes.js";
 import type { FoundTranscript, StreamEvent, TranscriptOps } from "../../types.js";
 import { parseStreamLine } from "./parse.js";
@@ -273,13 +273,12 @@ async function readCwdFromTranscript(filePath: string): Promise<string | null> {
   if (!fh) return null;
 
   try {
-    const stream = fh.createReadStream({ encoding: "utf8", autoClose: false });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const stream = fh.createReadStream({ autoClose: false });
     let count = 0;
     try {
-      for await (const raw of rl) {
+      for await (const line of readJsonlLines(stream)) {
         if (++count > 50) break;
-        const trimmed = raw.trim();
+        const trimmed = line.text.trim();
         if (!trimmed) continue;
         try {
           const obj = JSON.parse(trimmed) as Record<string, unknown>;
@@ -300,7 +299,6 @@ async function readCwdFromTranscript(filePath: string): Promise<string | null> {
         }
       }
     } finally {
-      rl.close();
       stream.destroy();
     }
   } finally {
@@ -377,26 +375,16 @@ export async function* readClaudeTranscript(
 
   const stream = createReadStream(filePath, { start: fromOffset, encoding: undefined });
 
-  // Suppress stray ENOENT (file deleted between stat and open) — readline
+  // Suppress stray ENOENT (file deleted between stat and open) — the stream
   // raises the same condition through its own iterator, which we catch below.
   stream.on("error", () => {});
 
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-  let pos = fromOffset;
   let stillSkippingPastSince = !!sinceEventId;
 
   try {
-    for await (const line of rl) {
-      // readline strips the trailing `\n` (and the `\r` from `\r\n`). Claude
-      // writes Unix line endings, so we account for `\n` only. A `\r\n` file
-      // would yield offsets 1 byte short per line — accepted as a corner
-      // case; resume from such an offset would skip one stray `\r`.
-      const lineByteLen = Buffer.byteLength(line, "utf8");
-      pos += lineByteLen + 1;
-
-      if (!line) continue;
-      const trimmed = line.trim();
+    for await (const line of readJsonlLines(stream, fromOffset)) {
+      if (!line.text) continue;
+      const trimmed = line.text.trim();
       if (!trimmed) continue;
 
       if (looksLikeSkippedType(trimmed)) continue;
@@ -413,7 +401,7 @@ export async function* readClaudeTranscript(
       }
 
       for (const event of events) {
-        yield { event, offset: pos };
+        yield { event, offset: line.end };
       }
     }
   } catch (err) {
@@ -421,7 +409,6 @@ export async function* readClaudeTranscript(
     const e = err as NodeJS.ErrnoException;
     if (e?.code !== "ENOENT") throw err;
   } finally {
-    rl.close();
     stream.destroy();
   }
 }

package/src/providers/codex/attach.ts

@@ -132,6 +132,10 @@ export async function attachCodexSession(
   if (transcript) {
     const lastEvent = await latestTurnBoundary(transcript.filePath, sessionId);
     if (lastEvent === null) lastTurn = "unknown";
+    // turn_aborted replays as an interrupted result, but the turn never
+    // finished, so it stays "interrupted" for hosts deciding whether to re-send.
+    else if (lastEvent.type === "event_msg" && lastEvent.payload?.["type"] === "turn_aborted")
+      lastTurn = "interrupted";
     else if (codexLineToStreamEvents(lastEvent, { sessionId }).some((event) => event.type === "result"))
       lastTurn = "completed";
     else lastTurn = "interrupted";

package/src/providers/codex/history.ts

@@ -57,6 +57,17 @@ function codexUserText(line: CodexTranscriptLine): string | null {
   if (line.type === "event_msg" && line.payload?.["type"] === "user_message") {
     return meaningfulHumanText(asString(line.payload["message"]));
   }
+  // Paginated rollouts (`session_meta.history_mode: "paginated"`, written by
+  // Codex 0.142 and later) never write `user_message`. What the person typed
+  // is a completed `UserMessage` item instead, and legacy rollouts never
+  // persist that item, so each message is read once. The `response_item` user
+  // message beside it also carries injected context, so it is not the one read.
+  if (line.type === "event_msg" && line.payload?.["type"] === "item_completed") {
+    const item = asRecord(line.payload["item"]);
+    if (item?.["type"] === "UserMessage") {
+      return meaningfulHumanText(textFromContent(item["content"], new Set(["text", "input_text"])));
+    }
+  }
   // Older unwrapped rollouts have no event_msg mirror.
   if (line.type === "message" && line.raw["role"] === "user") {
     return meaningfulHumanText(textFromContent(

package/src/providers/codex/transcript-normalize.ts

@@ -12,11 +12,20 @@ import type { CodexTranscriptLine } from "./transcript.js";
  *   response_item / reasoning                    → thinking
  *   response_item / function_call                → tool_call
  *   response_item / function_call_output         → tool_result
- *   event_msg     / task_complete                → result (completed)
+ *   response_item / custom_tool_call             → tool_call
+ *   response_item / custom_tool_call_output      → tool_result
+ *   event_msg     / task_complete                → result (completed, or failed with `error`)
+ *   event_msg     / turn_aborted                 → result (interrupted)
+ *
+ * Current Codex runs shell work through freeform tools: `exec` takes a script
+ * and `apply_patch` takes a patch, so most tool activity in a current rollout
+ * is a `custom_tool_call`. Its `input` is the raw string the model wrote.
  *
  * Everything else — `session_meta`, `turn_context`, `task_started`,
- * `token_count`, `agent_message`/`agent_reasoning` duplicates, user/developer
- * messages, unwrapped legacy lines, unknown types — yields `[]`.
+ * `token_count`, `agent_message`/`agent_reasoning` duplicates, the
+ * `item_completed` mirrors of response items, inter-agent `agent_message`
+ * items, user/developer messages, unwrapped legacy lines, unknown types —
+ * yields `[]`.
  *
  * The on-disk vocabulary is Codex-internal and version-shifting, so every field
  * is read defensively and a weird line NEVER throws — it returns `[]`. Codex
@@ -89,7 +98,19 @@ function mapLine(line: CodexTranscriptLine, sessionId: string | null): StreamEve
       ];
     }
 
-    if (innerType === "function_call_output") {
+    if (innerType === "custom_tool_call") {
+      return [
+        {
+          type: "tool_call",
+          toolCallId: str(payload["call_id"]) ?? str(payload["id"]),
+          name: str(payload["name"]) ?? "custom_tool_call",
+          input: typeof payload["input"] === "string" ? payload["input"] : null,
+          ...base,
+        },
+      ];
+    }
+
+    if (innerType === "function_call_output" || innerType === "custom_tool_call_output") {
       return [
         {
           type: "tool_result",
@@ -110,16 +131,36 @@ function mapLine(line: CodexTranscriptLine, sessionId: string | null): StreamEve
 
   if (line.type === "event_msg") {
     if (innerType === "task_complete") {
+      // A turn that failed (for example a model the account cannot use) still
+      // ends in task_complete, with `error` set and no agent message.
+      const error = turnErrorMessage(payload["error"]);
+      return [
+        {
+          type: "result",
+          text: error ?? str(payload["last_agent_message"]) ?? "",
+          costUsd: null,
+          isError: error !== null,
+          stopReason: null,
+          terminalReason: error !== null ? "failed" : "completed",
+          numTurns: null,
+          durationMs: num(payload["duration_ms"]),
+          ...base,
+        },
+      ];
+    }
+
+    if (innerType === "turn_aborted") {
+      // Same shape as a live `turn/completed` with status "interrupted".
       return [
         {
           type: "result",
-          text: str(payload["last_agent_message"]) ?? "",
+          text: "",
           costUsd: null,
           isError: false,
           stopReason: null,
-          terminalReason: "completed",
+          terminalReason: str(payload["reason"]) ?? "interrupted",
           numTurns: null,
-          durationMs: null,
+          durationMs: num(payload["duration_ms"]),
           ...base,
         },
       ];
@@ -135,6 +176,28 @@ function str(v: unknown): string | null {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 
+/** Finite number or null. */
+function num(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+
+/**
+ * `task_complete.error` is `{ message, codex_error_info }`. The message is
+ * often the API's JSON error body, so prefer its inner `error.message`.
+ */
+function turnErrorMessage(error: unknown): string | null {
+  if (typeof error === "string") return str(error);
+  if (typeof error !== "object" || error === null) return null;
+  const message = str((error as Record<string, unknown>)["message"]);
+  if (!message) return "Turn failed";
+  try {
+    const body = JSON.parse(message) as { error?: { message?: unknown }; message?: unknown };
+    return str(body?.error?.message) ?? str(body?.message) ?? message;
+  } catch {
+    return message;
+  }
+}
+
 function messagePhase(v: unknown): "commentary" | "final_answer" | undefined {
   return v === "commentary" || v === "final_answer" ? v : undefined;
 }
@@ -171,13 +234,25 @@ function extractReasoningSummary(summary: unknown): string | null {
 }
 
 /**
- * `function_call_output.output` is usually a string, but some versions wrap it
- * as `{ output: "...", metadata: {...} }`. Extract the readable text; fall back
- * to a JSON dump so nothing is silently lost. Returns "" when unreadable
+ * Tool output is usually a string. Some versions wrap it as
+ * `{ output: "...", metadata: {...} }`, and Codex 0.142+ also writes a list of
+ * content parts (`input_text`, `input_image`). Extract the readable text, one
+ * part per line, with images left in `raw`. Fall back to a JSON dump
+ * so nothing is silently lost. Returns "" when unreadable
  * (`tool_result.content` is a required string).
  */
 function extractOutputText(output: unknown): string {
   if (typeof output === "string") return output;
+  if (Array.isArray(output)) {
+    let text = "";
+    for (const part of output) {
+      if (typeof part !== "object" || part === null) continue;
+      const partText = (part as { text?: unknown }).text;
+      if (typeof partText !== "string" || partText.length === 0) continue;
+      text += text && !text.endsWith("\n") ? `\n${partText}` : partText;
+    }
+    return text;
+  }
   if (output && typeof output === "object" && !Array.isArray(output)) {
     const inner = (output as Record<string, unknown>)["output"];
     if (typeof inner === "string") return inner;