@agentex/agent 0.0.39 → 0.0.40

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;

package/src/providers/codex/transcript.ts

@@ -28,10 +28,10 @@ import { createReadStream } from "node:fs";
 import { readdir, 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 { getDefaultRuntimeHome, getRuntimeHomeEnvVar } from "../../utils/runtime-homes.js";
 import type { FoundTranscript, TranscriptOps } from "../../types.js";
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 
 /** Bytes scanned from the tail of the file in {@link peekCodexTranscript}. */
 const PEEK_TAIL_BYTES = 16 * 1024;
@@ -316,16 +316,11 @@ export async function* readCodexTranscript(
 
   const stream = createReadStream(filePath, { start: fromOffset, encoding: undefined });
   stream.on("error", () => {});
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   const fileIdentity = rolloutIdentityFromPath(filePath);
-  let pos = fromOffset;
   try {
-    for await (const line of rl) {
-      const lineStart = pos;
-      pos += Buffer.byteLength(line, "utf8") + 1;
-
-      const trimmed = line.trim();
+    for await (const line of readJsonlLines(stream, fromOffset)) {
+      const trimmed = line.text.trim();
       if (!trimmed) continue;
 
       const parsed = parseCodexLine(trimmed);
@@ -334,15 +329,14 @@ export async function* readCodexTranscript(
       // Replay-stable synthetic identity: (rollout identity, line start offset).
       // Codex emits no native per-event uuid, so this is the idempotency key
       // hosts use to dedup transcript replays. Deterministic across reads.
-      parsed.eventId = `codex:${fileIdentity}:${lineStart}`;
+      parsed.eventId = `codex:${fileIdentity}:${line.start}`;
 
-      yield { event: parsed, offset: pos };
+      yield { event: parsed, offset: line.end };
     }
   } catch (err) {
     const e = err as NodeJS.ErrnoException;
     if (e?.code !== "ENOENT") throw err;
   } finally {
-    rl.close();
     stream.destroy();
   }
 }

package/src/providers/codex/usage-scanner.ts

@@ -1,9 +1,9 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
-import * as readline from "node:readline";
 import { createReadStream } from "node:fs";
 import type { TokenUsage } from "../../types.js";
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 
 // ---------------------------------------------------------------------------
 // Log path resolution
@@ -104,16 +104,14 @@ async function scanFile(
 ): Promise<void> {
   let stream: ReturnType<typeof createReadStream>;
   try {
-    stream = createReadStream(filePath, { encoding: "utf-8" });
+    stream = createReadStream(filePath);
   } catch {
     return;
   }
 
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
   try {
-    for await (const line of rl) {
-      const trimmed = line.trim();
+    for await (const line of readJsonlLines(stream)) {
+      const trimmed = line.text.trim();
       if (!trimmed) continue;
 
       let parsed: Record<string, unknown>;
@@ -172,7 +170,6 @@ async function scanFile(
       usageByModel.set(model, existing);
     }
   } finally {
-    rl.close();
     stream.destroy();
   }
 }

package/src/utils/jsonl-lines.ts

@@ -0,0 +1,80 @@
+/**
+ * Line splitting for JSONL files on disk.
+ *
+ * `node:readline` also breaks lines at U+2028 (LINE SEPARATOR), U+2029
+ * (PARAGRAPH SEPARATOR) and a lone `\r`. JSON allows U+2028/U+2029 unescaped
+ * inside strings, and both `JSON.stringify` (Claude Code) and serde_json
+ * (Codex) write them raw, typically in text copied from web pages. readline
+ * cuts such a record in two, both halves fail to parse, and the record
+ * silently disappears. Every byte offset after it also drifts by two bytes
+ * per separator, so a resume offset can land mid-record.
+ *
+ * {@link readJsonlLines} splits on `\n` only, drops the `\r` of a `\r\n`
+ * ending, and reports exact byte offsets.
+ */
+
+export interface JsonlLine {
+  /** Line text without its `\n` or `\r\n` terminator. */
+  text: string;
+  /** Byte offset of the line's first byte. */
+  start: number;
+  /**
+   * Byte offset just past the line's `\n`, which is where the next line
+   * starts. For a final line with no `\n`, the end of the file.
+   */
+  end: number;
+}
+
+const NEWLINE = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+
+function decodeLine(bytes: Buffer): string {
+  const length = bytes.length > 0 && bytes[bytes.length - 1] === CARRIAGE_RETURN
+    ? bytes.length - 1
+    : bytes.length;
+  return bytes.toString("utf8", 0, length);
+}
+
+/**
+ * Yield the lines of a byte stream, typically `createReadStream(path, { start })`
+ * opened without an encoding. `startOffset` is the stream's starting byte
+ * offset in the file, so reported offsets are file offsets.
+ *
+ * Splitting happens on bytes before decoding. A `\n` byte never occurs inside
+ * a multi-byte UTF-8 sequence, so no character is split across lines.
+ */
+export async function* readJsonlLines(
+  input: AsyncIterable<Buffer | string>,
+  startOffset = 0,
+): AsyncGenerator<JsonlLine> {
+  let pending: Buffer[] = [];
+  let pendingBytes = 0;
+  let lineStart = startOffset;
+
+  for await (const value of input) {
+    const chunk = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+    let from = 0;
+    let newline = chunk.indexOf(NEWLINE, from);
+    while (newline !== -1) {
+      const piece = chunk.subarray(from, newline);
+      const bytes = pendingBytes > 0 ? Buffer.concat([...pending, piece], pendingBytes + piece.length) : piece;
+      const end = lineStart + bytes.length + 1;
+      yield { text: decodeLine(bytes), start: lineStart, end };
+      lineStart = end;
+      pending = [];
+      pendingBytes = 0;
+      from = newline + 1;
+      newline = chunk.indexOf(NEWLINE, from);
+    }
+    if (from < chunk.length) {
+      const tail = chunk.subarray(from);
+      pending.push(tail);
+      pendingBytes += tail.length;
+    }
+  }
+
+  if (pendingBytes > 0) {
+    const bytes = Buffer.concat(pending, pendingBytes);
+    yield { text: decodeLine(bytes), start: lineStart, end: lineStart + bytes.length };
+  }
+}