@spexcode/transcript 0.7.0-next.11 → 0.7.0-next.12

package/dist/parsers.d.ts

@@ -1,4 +1,4 @@
-import { type TranscriptRange, type TranscriptRead } from './turns.js';
+import { type TranscriptRange, type TranscriptRead, type TurnOutcome } from './turns.js';
 export declare const MAX_TURNS = 200;
 export declare const MAX_OUTPUT_BYTES: number;
 export type MutableTool = {
@@ -16,6 +16,8 @@ export type MutableTurn = {
     role: 'user' | 'assistant';
     text?: string;
     tools: MutableTool[];
+    outcome?: TurnOutcome;
+    error?: string;
 };
 export type ToolOutcome = 'failed' | 'rejected';
 export type ParsedEvent = {
@@ -34,7 +36,7 @@ export declare function codexAppServerEvent(value: unknown): ParsedEvent | null;
 export declare function codexAppServerStream(): Parse;
 export declare function piEvent(value: unknown): ParsedEvent | null;
 export declare function geminiEvent(value: unknown): ParsedEvent | null;
-export declare function openclawEvent(value: unknown): ParsedEvent | null;
+export declare const openclawEvent: typeof piEvent;
 export declare function hermesEvents(value: unknown): ParsedEvent[];
 export declare function opencodeEvents(value: unknown): ParsedEvent[];
 export declare class IntervalCollector {

package/dist/parsers.js

@@ -183,6 +183,18 @@ export function codexEvent(value) {
         const rawInput = payload.input === undefined && payload.arguments === undefined ? undefined : compact(payload.input ?? payload.arguments);
         return { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', tools: [{ id, name: string(payload.name ?? payload.tool_name) ?? 'tool', input: codexExecCommand(rawInput), outputLines: 0, outputBytes: 0 }] } };
     }
+    // THE ROLLOUT PUTS THE VERDICT IN A THIRD RECORD. Unlike every other source here, a codex result item
+    // carries no failure field at all — `function_call_output` and `custom_tool_call_output` have only
+    // `{call_id, output}`. The harness records how the command ended in a separate `event_msg`, joined by the
+    // same `call_id`: `exec_command_end.status` (completed | failed, 6,194 failed of 83,990 in the rollouts on
+    // this box, matching exactly the nonzero exit codes) and `patch_apply_end.success`. Without this second
+    // join every failed command in a codex transcript reads as an ordinary one. The outcome is carried alone,
+    // with no text, so it lands on the call the output record already filled.
+    if (entry.type === 'event_msg' && (type === 'exec_command_end' || type === 'patch_apply_end')) {
+        const id = string(payload.call_id);
+        const failed = string(payload.status) === 'failed' || payload.success === false;
+        return id && failed ? { at: eventAt, turn: null, toolOutputs: [{ id, text: '', outcome: 'failed' }] } : { at: eventAt, turn: null };
+    }
     if (entry.type === 'response_item' && (type === 'custom_tool_call_output' || type === 'function_call_output')) {
         const id = string(payload.call_id ?? payload.id);
         const output = payload.output ?? payload.result ?? '';
@@ -203,7 +215,12 @@ export function codexAppServerEvent(value) {
     const recognized = method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed';
     if (!recognized)
         return null;
-    const eventAt = timestamp(params.emittedAtMs) ?? timestamp(params.startedAtMs) ?? timestamp(params.completedAtMs);
+    // `emittedAtMs` is a SIBLING of `method` and `params`, not a field inside them — the app-server's own
+    // generated envelope type puts it there, and every line of the capture in `fixtures/codex-app-server` has
+    // exactly the keys `method`, `params`, `emittedAtMs`. Reading it from `params` found nothing, which made
+    // every `item/agentMessage/delta` clockless and therefore dropped: the streaming path parsed and produced
+    // nothing at all. The lifecycle clocks below do sit in `params`.
+    const eventAt = timestamp(entry.emittedAtMs) ?? timestamp(params.startedAtMs) ?? timestamp(params.completedAtMs);
     if (eventAt === null)
         return { at: null, turn: null };
     if (method === 'item/agentMessage/delta') {
@@ -313,6 +330,16 @@ export function piEvent(value) {
                 turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
             }
         }
+        // the producer's verdict on the TURN (`StopReason` in pi's shipped types): `error` is the provider's own
+        // failure, `aborted` the turn a stop ended. These are exactly the turns that carry no text and no calls —
+        // 13 of 578 assistant messages in the sessions on this box — so without them the turn is an empty gap.
+        const stop = string(message.stopReason);
+        if (stop === 'error' || stop === 'aborted') {
+            turn.outcome = stop === 'aborted' ? 'cancelled' : 'failed';
+            const reason = string(message.errorMessage);
+            if (reason)
+                turn.error = reason;
+        }
         return { at: eventAt, turn };
     }
     if (message.role === 'toolResult') {
@@ -360,37 +387,23 @@ export function geminiEvent(value) {
     }
     return null;
 }
-export function openclawEvent(value) {
-    const entry = object(value);
-    const message = object(entry?.message);
-    if (!entry || entry.type !== 'message' || !message)
-        return null;
-    const eventAt = at(message) ?? at(entry);
-    if (eventAt === null)
-        return { at: null, turn: null };
-    if (message.role === 'user') {
-        const text = blockText(message.content);
-        return text ? { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
-    }
-    if (message.role === 'toolResult') {
-        const id = string(message.toolCallId);
-        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? ''), ...(message.isError === true ? { outcome: 'failed' } : {}) }] } : null;
-    }
-    if (message.role === 'assistant') {
-        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
-        for (const blockValue of items(message.content)) {
-            const block = object(blockValue);
-            if (block?.type === 'text')
-                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
-            if (block?.type === 'toolCall') {
-                const id = string(block.id) ?? `tool-${turn.tools.length}`;
-                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
-            }
-        }
-        return turn.text || turn.tools.length ? { at: eventAt, turn } : null;
-    }
-    return null;
-}
+// OPENCLAW WRITES PI'S FORMAT. Verified field by field against pi's shipped schema: the `{"type":"session",
+// "version":3}` header, the 8-char hex id tree, the `user|assistant|toolResult` roles, the `text`/`thinking`/
+// `toolCall` blocks, `toolResult`'s exact key set. The only OpenClaw-specific things are its own `customType`
+// namespace and where the file lives — neither of which a parser reads. So this is not a second parser: two
+// hand-written copies had already drifted into two defects (a different clock preference on identical bytes,
+// and dropping every turn with no text and no calls, which is precisely the failed and aborted ones). Where a
+// harness differs only in where its file sits, the adapter row is the LOCATOR ([[transcript-reader]]), never a
+// second copy of the parse.
+export const openclawEvent = piEvent;
+// HERMES COUNTS IN SECONDS. Its export writes `timestamp` as a float epoch SECOND (`1787942674.556185`),
+// where every other harness here writes milliseconds and `at()` reads a bare number as one. Unconverted, a
+// Hermes turn lands in January 1970 and every interval read of a real thread — the session API hands `from`
+// and `to` as epoch ms — comes back empty. The unit is this producer's, so the conversion is this adapter's.
+const hermesAt = (message) => {
+    const seconds = at(message);
+    return seconds === null ? null : Math.round(seconds * 1000);
+};
 export function hermesEvents(value) {
     const root = object(value);
     const events = [];
@@ -398,7 +411,7 @@ export function hermesEvents(value) {
         const message = object(messageValue);
         if (!message)
             continue;
-        const eventAt = at(message);
+        const eventAt = hermesAt(message);
         if (eventAt === null) {
             events.push({ at: null, turn: null });
             continue;

package/dist/turns.d.ts

@@ -11,12 +11,15 @@ export type TranscriptTool = Readonly<{
     outputBytes: number;
     outcome?: 'failed' | 'rejected';
 }>;
+export type TurnOutcome = 'failed' | 'cancelled';
 export type TranscriptTurn = Readonly<{
     id: string;
     at: number;
     role: 'user' | 'assistant';
     text?: string;
     tools?: readonly TranscriptTool[];
+    outcome?: TurnOutcome;
+    error?: string;
 }>;
 export type TranscriptRead = Readonly<{
     revision: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.11",
+  "version": "0.7.0-next.12",
   "type": "module",
   "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
   "files": [