@spexcode/transcript 0.7.0-next.4 → 0.7.0-next.6

package/dist/parsers.d.ts

@@ -8,6 +8,7 @@ export type MutableTool = {
     output?: string;
     outputLines: number;
     outputBytes: number;
+    outcome?: ToolOutcome;
 };
 export type MutableTurn = {
     id: string | null;
@@ -16,12 +17,14 @@ export type MutableTurn = {
     text?: string;
     tools: MutableTool[];
 };
+export type ToolOutcome = 'failed' | 'rejected';
 export type ParsedEvent = {
     at: number | null;
     turn: MutableTurn | null;
     toolOutputs?: readonly {
         id: string;
         text: string;
+        outcome?: ToolOutcome;
     }[];
 };
 export type Parse = (value: unknown) => ParsedEvent | null;

package/dist/parsers.js

@@ -82,7 +82,7 @@ export function claudeEvent(value) {
         const outputs = blocks.flatMap((block) => {
             const b = object(block);
             const id = string(b?.tool_use_id);
-            return b?.type === 'tool_result' && id ? [{ id, text: compact(b?.content ?? '') }] : [];
+            return b?.type === 'tool_result' && id ? [{ id, text: compact(b?.content ?? ''), ...(b?.is_error === true ? { outcome: 'failed' } : {}) }] : [];
         });
         if (outputs.length)
             return { at: eventAt, turn: null, toolOutputs: outputs };
@@ -204,9 +204,14 @@ export function codexAppServerEvent(value) {
         output = item.result ?? item.error;
     else if (type === 'dynamicToolCall')
         output = item.contentItems ?? item.output ?? item.error;
-    return output === undefined || output === null
-        ? { at: eventAt, turn: null }
-        : { at: eventAt, turn: null, toolOutputs: [{ id, text: compact(output) }] };
+    // the item status is the app-server's own verdict: `failed`, or `declined` when the person refused the call —
+    // a declined call has no output, so the empty result is what ends its "running"
+    const status = string(item.status);
+    const outcome = status === 'failed' ? 'failed' : status === 'declined' ? 'rejected' : undefined;
+    if (output === undefined || output === null) {
+        return outcome ? { at: eventAt, turn: null, toolOutputs: [{ id, text: '', outcome }] } : { at: eventAt, turn: null };
+    }
+    return { at: eventAt, turn: null, toolOutputs: [{ id, text: compact(output), ...(outcome ? { outcome } : {}) }] };
 }
 // Agent-message deltas are fragments of one native item. The closure remembers only that item's text and
 // re-emits its native id, allowing IntervalCollector to replace the earlier turn in place.
@@ -268,7 +273,7 @@ export function piEvent(value) {
     }
     if (message.role === 'toolResult') {
         const id = string(message.toolCallId);
-        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? '') }] } : null;
+        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? ''), ...(message.isError === true ? { outcome: 'failed' } : {}) }] } : null;
     }
     return null;
 }
@@ -303,7 +308,7 @@ export function geminiEvent(value) {
         for (const callValue of items(message.toolCalls)) {
             const call = object(callValue);
             const id = string(call?.id) ?? `tool-${turn.tools.length}`;
-            turn.tools.push({ id, name: string(call?.name) ?? 'tool', input: call?.args === undefined ? undefined : compact(call.args), outputLines: 0, outputBytes: 0 });
+            turn.tools.push({ id, name: string(call?.name) ?? 'tool', input: call?.args === undefined ? undefined : compact(call.args), outputLines: 0, outputBytes: 0, ...(call?.status === 'error' ? { outcome: 'failed' } : {}) });
         }
         if (!turn.text && !turn.tools.length)
             return null;
@@ -325,7 +330,7 @@ export function openclawEvent(value) {
     }
     if (message.role === 'toolResult') {
         const id = string(message.toolCallId);
-        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? '') }] } : null;
+        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: [] };
@@ -414,6 +419,8 @@ export function opencodeEvents(value) {
                     tool.output = output.slice(0, MAX_OUTPUT_BYTES);
                     tool.outputBytes = Buffer.byteLength(output);
                     tool.outputLines = lineCount(output);
+                    if (status === 'error')
+                        tool.outcome = 'failed';
                 }
                 turn.tools.push(tool);
             }
@@ -466,6 +473,8 @@ export class IntervalCollector {
                 tool.outputLines += lineCount(output.text);
                 if (tool.output === undefined)
                     tool.output = '';
+                if (output.outcome)
+                    tool.outcome = output.outcome;
                 const remaining = Math.max(0, MAX_OUTPUT_BYTES - Buffer.byteLength(tool.output));
                 tool.output += output.text.slice(0, remaining);
                 if (bytes > remaining)

package/dist/turns.d.ts

@@ -9,6 +9,7 @@ export type TranscriptTool = Readonly<{
     output?: string;
     outputLines: number;
     outputBytes: number;
+    outcome?: 'failed' | 'rejected';
 }>;
 export type TranscriptTurn = Readonly<{
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.4",
+  "version": "0.7.0-next.6",
   "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": [