@tangle-network/harness-sessions 0.1.5 → 0.1.7

package/dist/formats/codex.js

@@ -66,14 +66,59 @@ function contentParts(content) {
     }
     return parts;
 }
-function outputOf(output) {
+// `exec_command` and `write_stdin` answer with a text header (`Chunk ID`, `Wall time`, then
+// `Process exited with code N` once the process is done) before `Output:`; a still-running process
+// says `Process running with session ID` instead and has no status yet.
+const PROCESS_EXIT = /^Process exited with code (-?\d+)\s*$/mu;
+function processFailed(text) {
+    const header = text.split(/^Output:/mu, 1)[0] ?? '';
+    const match = PROCESS_EXIT.exec(header);
+    return match !== null && Number(match[1]) !== 0;
+}
+/** A nonzero numeric `exit_code` anywhere in a parsed JSON value (code-mode tool results nest it). */
+function jsonExitFailed(value, depth = 0) {
+    if (depth > 4)
+        return false;
+    if (Array.isArray(value))
+        return value.some((v) => jsonExitFailed(v, depth + 1));
+    if (!isRecord(value))
+        return false;
+    if (typeof value.exit_code === 'number' && value.exit_code !== 0)
+        return true;
+    return Object.values(value).some((v) => jsonExitFailed(v, depth + 1));
+}
+/**
+ * Code mode runs JavaScript in an `exec` call; its `tools.exec_command(...)` results are printed
+ * as JSON items carrying `exit_code`. The first item is `Script failed` when the script threw.
+ */
+function codeModeFailed(output) {
+    if (!Array.isArray(output))
+        return false;
+    return output.some((item, i) => {
+        const text = isRecord(item) && typeof item.text === 'string' ? item.text : '';
+        if (i === 0 && /^Script failed\b/u.test(text))
+            return true;
+        if (!text.includes('exit_code'))
+            return false;
+        try {
+            return jsonExitFailed(JSON.parse(text));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function outputOf(output, tool) {
+    const execFailed = () => tool.name === 'exec_command' || tool.name === 'write_stdin'
+        ? typeof output === 'string' && processFailed(output)
+        : tool.name === 'exec' && tool.input.includes('exec_command') && codeModeFailed(output);
     if (typeof output === 'string')
-        return { output, text: output, isError: false };
+        return { output, text: output, isError: execFailed() };
     if (isRecord(output)) {
         const content = output.content ?? output.output;
         return { output, text: textOf(content) ?? (typeof content === 'string' ? content : null), isError: output.success === false };
     }
-    return { output: output ?? null, text: textOf(output), isError: false };
+    return { output: output ?? null, text: textOf(output), isError: execFailed() };
 }
 const MODEL_OUTPUT = new Set(['message', 'reasoning']);
 export function createFold(ref, mode, stats) {
@@ -97,6 +142,7 @@ export function createFold(ref, mode, stats) {
     let inherited = false;
     let inheritedRecords = 0;
     const foreignThreads = new Set();
+    const tools = new Map();
     const openCall = (at) => {
         if (open)
             return open;
@@ -196,6 +242,7 @@ export function createFold(ref, mode, stats) {
                     const raw = kind === 'function_call' ? payload.arguments : kind === 'custom_tool_call' ? payload.input : (payload.action ?? payload.arguments ?? payload.input);
                     const call = openCall(at);
                     assistantMessage(at, call, [{ type: 'tool-call', toolCallId: callId }]);
+                    tools.set(callId, { name, input: typeof raw === 'string' ? raw : '' });
                     builder.toolCall({ id: callId, name, ...argumentsOf(raw), at, messageId: openMessage });
                     // A web search is answered inside the response; there is no output item.
                     if (kind === 'web_search_call')
@@ -203,7 +250,7 @@ export function createFold(ref, mode, stats) {
                 }
                 else if (kind.endsWith('_call_output')) {
                     const callId = str(payload.call_id) ?? '';
-                    const result = outputOf(payload.output);
+                    const result = outputOf(payload.output, tools.get(callId) ?? { name: '', input: '' });
                     const id = `${callId}:output`;
                     builder.message({ id, role: 'tool', actor: 'tool-result', at, modelCallId: null, parts: [{ type: 'tool-result', toolCallId: callId }] });
                     builder.toolResult(callId, { ...result, at, messageId: id });

package/dist/input.d.ts

@@ -11,6 +11,12 @@ export interface SessionInputInit {
     parentNativeSessionId?: string | null;
     /** Names the source in integrity records (a path, a blob ref). */
     label?: string;
+    /**
+     * The file line `input` starts on, when it continues a longer file (records appended since a
+     * previous read). A record without an id of its own is named by its line, so the same record
+     * gets the same id whichever way the file is read. Default 1.
+     */
+    firstLine?: number;
 }
 /** Read a JSONL-format session (Claude Code, Codex, Pi, Kimi) from text or parsed records, synchronously. */
 export declare function readSessionInput(harness: string, input: SessionInput, init?: SessionInputInit, options?: Pick<ReadOptions, 'corruption'>): HarnessSession;

package/dist/input.js

@@ -31,7 +31,10 @@ function foldInput(harness, input, init, mode, options) {
         parentNativeSessionId: init.parentNativeSessionId ?? null,
     };
     const fold = create(ref, mode, stats);
-    const records = 'text' in input ? textRecordsSync(input.text, stats, { strict: options.corruption === 'strict' }) : arrayRecordsSync(input.records, stats);
+    const firstLine = init.firstLine ?? 1;
+    const records = 'text' in input
+        ? textRecordsSync(input.text, stats, { strict: options.corruption === 'strict', firstLine })
+        : arrayRecordsSync(input.records, stats, firstLine);
     for (const record of records)
         fold.observe(record);
     return fold.finish();

package/dist/source.d.ts

@@ -40,12 +40,16 @@ export declare function fileRecords(path: string, options?: {
 }): RecordSource;
 /** Stats for bytes already in memory. */
 export declare function memoryStats(label: string, text?: string): SourceStats;
-/** The records of JSONL text already in memory (a retained copy, a blob), read synchronously. */
+/**
+ * The records of JSONL text already in memory (a retained copy, a blob), read synchronously.
+ * `firstLine` numbers the text's first line, for text that continues a longer file.
+ */
 export declare function textRecordsSync(text: string, stats: SourceStats, options?: {
     strict?: boolean;
+    firstLine?: number;
 }): Generator<Record<string, unknown>>;
-/** Records a caller already parsed (one per line, in order). Non-objects count as unparsed. */
-export declare function arrayRecordsSync(values: readonly unknown[], stats: SourceStats): Generator<Record<string, unknown>>;
+/** Records a caller already parsed (one per line, in order, the first on line `firstLine`). Non-objects count as unparsed. */
+export declare function arrayRecordsSync(values: readonly unknown[], stats: SourceStats, firstLine?: number): Generator<Record<string, unknown>>;
 /**
  * Run `use` against a SQLite store opened read-only in place ({@link openSqlite}). A store SQLite
  * cannot open in place is read from a private copy instead: a write-ahead log with no `-shm` in a

package/dist/source.js

@@ -116,10 +116,15 @@ export function memoryStats(label, text) {
     const bytes = Buffer.from(text, 'utf8');
     return { path: label, sha256: `sha256:${createHash('sha256').update(bytes).digest('hex')}`, bytes: bytes.length, unparsed: 0, tornTail: false, line: 0 };
 }
-/** The records of JSONL text already in memory (a retained copy, a blob), read synchronously. */
+/**
+ * The records of JSONL text already in memory (a retained copy, a blob), read synchronously.
+ * `firstLine` numbers the text's first line, for text that continues a longer file.
+ */
 export function* textRecordsSync(text, stats, options = {}) {
     const lines = text.split('\n');
-    for (const [index, raw] of lines.entries()) {
+    const first = options.firstLine ?? 1;
+    for (const [position, raw] of lines.entries()) {
+        const index = first - 1 + position;
         const line = raw.replace(/\r$/u, '');
         if (line.trim().length === 0)
             continue;
@@ -128,7 +133,7 @@ export function* textRecordsSync(text, stats, options = {}) {
             value = JSON.parse(line);
         }
         catch {
-            if (index === lines.length - 1) {
+            if (position === lines.length - 1) {
                 stats.tornTail = true;
                 continue;
             }
@@ -147,9 +152,10 @@ export function* textRecordsSync(text, stats, options = {}) {
         yield value;
     }
 }
-/** Records a caller already parsed (one per line, in order). Non-objects count as unparsed. */
-export function* arrayRecordsSync(values, stats) {
-    for (const [index, value] of values.entries()) {
+/** Records a caller already parsed (one per line, in order, the first on line `firstLine`). Non-objects count as unparsed. */
+export function* arrayRecordsSync(values, stats, firstLine = 1) {
+    for (const [position, value] of values.entries()) {
+        const index = firstLine - 1 + position;
         if (value === null || typeof value !== 'object' || Array.isArray(value)) {
             noteUnparsed(stats, index + 1);
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/harness-sessions",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "One reader for every coding-agent harness's native session (Claude Code, Codex, OpenCode, Pi): store layouts, a normalized session with messages, tool calls, served models, usage and ending errors, and projections to chat messages, OTLP spans and turns",
   "type": "module",
   "sideEffects": false,