@code-yeongyu/senpi-agent-core 2026.9.29 → 2026.10.1-2

package/dist/agent.js

@@ -3,7 +3,10 @@ import { buildProviderContext as buildProviderContextFromAgentContext, runAgentL
 import { ProviderRetryWatchdogAbortError } from "./assistant-terminal-state.js";
 import { getDefaultStreamFn } from "./stream-fn.js";
 function defaultConvertToLlm(messages) {
-    return messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+    return messages.filter((message) => message.role === "system" ||
+        message.role === "user" ||
+        message.role === "assistant" ||
+        message.role === "toolResult");
 }
 const EMPTY_USAGE = {
     input: 0,
@@ -68,18 +71,16 @@ class PendingMessageQueue {
     getClearGeneration() {
         return this.clearGeneration;
     }
-    drain() {
-        if (this.mode === "all") {
-            const drained = this.messages.slice();
-            this.messages = [];
-            return drained;
-        }
+    peek() {
+        if (this.mode === "all")
+            return this.messages.slice();
         const first = this.messages[0];
-        if (!first) {
-            return [];
-        }
-        this.messages = this.messages.slice(1);
-        return [first];
+        return first ? [first] : [];
+    }
+    drain() {
+        const drained = this.peek();
+        this.messages = this.messages.slice(drained.length);
+        return drained;
     }
     prepend(messages) {
         this.messages = [...messages, ...this.messages];
@@ -110,9 +111,11 @@ export class Agent {
         this.getApiKey = runtimeOptions.getApiKey;
         this.onPayload = runtimeOptions.onPayload;
         this.onResponse = runtimeOptions.onResponse;
+        this.onProviderStreamEvent = runtimeOptions.onProviderStreamEvent;
         this.beforeToolCall = runtimeOptions.beforeToolCall;
         this.afterToolCall = runtimeOptions.afterToolCall;
-        this.shouldStopAfterTurn = runtimeOptions.shouldStopAfterTurn;
+        this.finishTurn = runtimeOptions.finishTurn;
+        this.prepareRequest = runtimeOptions.prepareRequest;
         this.prepareNextTurn = runtimeOptions.prepareNextTurn;
         this.prepareNextTurnWithContext = runtimeOptions.prepareNextTurnWithContext;
         this.steeringQueue = new PendingMessageQueue(runtimeOptions.steeringMode ?? "one-at-a-time");
@@ -190,6 +193,11 @@ export class Agent {
     hasQueuedMessages() {
         return this.steeringQueue.hasItems() || this.followUpQueue.hasItems();
     }
+    /** Preview the messages selected for the next turn without consuming them. */
+    peekQueuedMessages() {
+        const steering = this.steeringQueue.peek();
+        return steering.length > 0 ? steering : this.followUpQueue.peek();
+    }
     /** Active abort signal for the current run, if any. */
     get signal() {
         return this.activeRun?.abortController.signal;
@@ -217,7 +225,10 @@ export class Agent {
     waitForIdle() {
         return this.activeRun?.promise ?? Promise.resolve();
     }
-    /** Clear transcript state, runtime state, and queued messages. */
+    /**
+     * Clear transcript state, runtime state, and queued messages. Fork: the prompt/tool baseline is agent state
+     * (`systemPrompt`, `tools`), so transcript system messages are conversation content and are cleared too.
+     */
     reset() {
         if (this.activeRun) {
             throw new Error("Agent is already processing. Wait for completion before resetting.");
@@ -280,7 +291,7 @@ export class Agent {
             throw new Error("Agent is already processing. Wait for completion before continuing.");
         }
         const lastMessage = this._state.messages[this._state.messages.length - 1];
-        if (!lastMessage) {
+        if (!lastMessage || this._state.messages.every((message) => message.role === "system")) {
             throw new Error("No messages to continue from");
         }
         if (lastMessage.role === "assistant") {
@@ -344,7 +355,7 @@ export class Agent {
         let skipInitialSteeringPoll = options.skipInitialSteeringPoll === true;
         let steeringQueueGeneration = this.steeringQueue.getClearGeneration();
         let followUpQueueGeneration = this.followUpQueue.getClearGeneration();
-        const shouldStopAfterTurn = this.shouldStopAfterTurn;
+        const finishTurn = this.finishTurn;
         const reasoning = this._state.reasoningBaseline ?? this._state.thinkingLevel;
         return {
             model: this._state.model,
@@ -353,6 +364,7 @@ export class Agent {
             sessionId: this.sessionId,
             onPayload: this.onPayload,
             onResponse: this.onResponse,
+            onProviderStreamEvent: this.onProviderStreamEvent,
             transport: this.transport,
             thinkingBudgets: this.thinkingBudgets,
             timeoutMs: this.timeoutMs,
@@ -367,9 +379,17 @@ export class Agent {
             resolveUnknownToolCall: this.resolveUnknownToolCall,
             beforeToolCall: this.beforeToolCall,
             afterToolCall: this.afterToolCall,
-            shouldStopAfterTurn: shouldStopAfterTurn
-                ? async (context) => await shouldStopAfterTurn(context, this.signal)
+            // `{ action: "end" }` ends the run without polling queues, so the fork's post-run queue drain is
+            // suppressed for this run as well: queued input stays for its owner.
+            finishTurn: finishTurn
+                ? async (turn, signal) => {
+                    const decision = (await finishTurn(turn, signal)) ?? undefined;
+                    if (decision?.action === "end")
+                        this.suppressQueuedMessageDrain();
+                    return decision;
+                }
                 : undefined,
+            prepareRequest: this.prepareRequest,
             prepareNextTurn: this.prepareNextTurnWithContext || this.prepareNextTurn
                 ? async (context) => {
                     if (this.prepareNextTurnWithContext) {

package/dist/harness/execution/tools.d.ts

@@ -61,7 +61,7 @@ export declare function executeToolCall<TContext extends object | undefined>(cal
 /** Apply an after-tool patch field by field. */
 export declare function finalizeToolCall<TContext extends object | undefined>(call: ClearedToolCall<TContext>, executed: ExecutedToolCall, patch: AfterToolPatch | undefined): FinalizedToolCall;
 /** Reconstruct the canonical tool result represented by a staged transcript message. */
-export declare function toolResultFromMessage(message: ToolResultMessage<unknown>, terminate: boolean): AgentToolResult<unknown>;
+export declare function toolResultFromMessage(message: ToolResultMessage, terminate: boolean): AgentToolResult;
 /** Convert finalized tool output to the provider-facing transcript message. */
 export declare function createToolResultMessage(call: FinalizedToolCall): ToolResultMessage;
 //# sourceMappingURL=tools.d.ts.map

package/dist/harness/execution/tools.js

@@ -100,7 +100,6 @@ export function toolResultFromMessage(message, terminate) {
         content: message.content,
         details: message.details,
         ...(message.usage === undefined ? {} : { usage: message.usage }),
-        ...(message.addedToolNames === undefined ? {} : { addedToolNames: message.addedToolNames }),
         ...(terminate ? { terminate: true } : {}),
     };
 }
@@ -113,7 +112,6 @@ export function createToolResultMessage(call) {
         content: call.result.content ?? [],
         ...(call.result.details === undefined ? {} : { details: call.result.details }),
         ...(call.result.usage === undefined ? {} : { usage: call.result.usage }),
-        ...(call.result.addedToolNames?.length ? { addedToolNames: call.result.addedToolNames } : {}),
         isError: call.isError,
         timestamp: Date.now(),
     };

package/dist/harness/messages.js

@@ -90,6 +90,7 @@ export function convertToLlm(messages) {
                     ],
                     timestamp: m.timestamp,
                 };
+            case "system":
             case "user":
             case "assistant":
             case "toolResult":

package/dist/harness/pico3/bash.d.ts

@@ -0,0 +1,10 @@
+import { Type } from "typebox";
+import type { ToolDeclaration } from "./types.ts";
+declare const parameters: Type.TObject<{
+    command: Type.TString;
+    cwd: Type.TOptional<Type.TString>;
+}>;
+/** Run a shell command. Output is piped to the kernel; bounds come from `output`. */
+export declare function bashTool(output?: ToolDeclaration["output"]): ToolDeclaration<typeof parameters>;
+export {};
+//# sourceMappingURL=bash.d.ts.map

package/dist/harness/pico3/bash.js

@@ -0,0 +1,25 @@
+import { spawn } from "node:child_process";
+import { Type } from "typebox";
+const parameters = Type.Object({ command: Type.String(), cwd: Type.Optional(Type.String()) });
+/** Run a shell command. Output is piped to the kernel; bounds come from `output`. */
+export function bashTool(output = {}) {
+    return {
+        name: "bash",
+        description: "Run a shell command",
+        parameters,
+        replay: "unsafe",
+        output,
+        async execute({ command, cwd }, api, ctx) {
+            const started = Date.now();
+            const child = spawn("bash", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+            const onAbort = () => child.kill("SIGKILL");
+            ctx.abortSignal?.addEventListener("abort", onAbort);
+            child.stdout.on("data", (c) => api.stream(c));
+            child.stderr.on("data", (c) => api.stream(c));
+            const { code, signal } = await new Promise((r) => child.on("close", (code, signal) => r({ code, signal })));
+            ctx.abortSignal?.removeEventListener("abort", onAbort);
+            return { isError: code !== 0, details: { exitCode: code, signal, ms: Date.now() - started } };
+        },
+    };
+}
+//# sourceMappingURL=bash.js.map

package/dist/harness/pico3/bounded.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bounded byte collector. It retains a prefix or suffix constrained by both a byte
+ * budget and a newline budget, and accounts for every discarded byte/newline.
+ */
+export declare class Bounded {
+    private bytes;
+    private readonly maxBytes;
+    private readonly maxLines;
+    private readonly retain;
+    droppedBytes: number;
+    droppedLines: number;
+    total: number;
+    constructor(maxBytes: number, maxLines: number, retain: "head" | "tail");
+    push(chunk: Uint8Array): void;
+    private pushHead;
+    private pushTail;
+    private drop;
+    get dropped(): number;
+    text(): string;
+}
+//# sourceMappingURL=bounded.d.ts.map

package/dist/harness/pico3/bounded.js

@@ -0,0 +1,95 @@
+/**
+ * Bounded byte collector. It retains a prefix or suffix constrained by both a byte
+ * budget and a newline budget, and accounts for every discarded byte/newline.
+ */
+export class Bounded {
+    constructor(maxBytes, maxLines, retain) {
+        this.bytes = new Uint8Array();
+        this.droppedBytes = 0;
+        this.droppedLines = 0;
+        this.total = 0;
+        this.maxBytes = Math.max(0, maxBytes);
+        this.maxLines = Math.max(0, maxLines);
+        this.retain = retain;
+    }
+    push(chunk) {
+        this.total += chunk.length;
+        if (chunk.length === 0)
+            return;
+        if (this.maxBytes === 0 || this.maxLines === 0) {
+            this.drop(chunk);
+            return;
+        }
+        if (this.retain === "head") {
+            this.pushHead(chunk);
+            return;
+        }
+        this.pushTail(chunk);
+    }
+    pushHead(chunk) {
+        const remainingBytes = this.maxBytes - this.bytes.length;
+        const remainingLines = this.maxLines - countNewlines(this.bytes);
+        if (remainingBytes <= 0 || remainingLines <= 0) {
+            this.drop(chunk);
+            return;
+        }
+        let take = Math.min(chunk.length, remainingBytes);
+        let lines = 0;
+        for (let i = 0; i < take; i++) {
+            if (chunk[i] !== 0x0a)
+                continue;
+            lines++;
+            if (lines === remainingLines) {
+                take = i + 1;
+                break;
+            }
+        }
+        this.bytes = concat(this.bytes, chunk.subarray(0, take));
+        this.drop(chunk.subarray(take));
+    }
+    pushTail(chunk) {
+        const incomingStart = tailStart(chunk, this.maxBytes, this.maxLines);
+        this.drop(chunk.subarray(0, incomingStart));
+        const combined = concat(this.bytes, chunk.subarray(incomingStart));
+        const start = tailStart(combined, this.maxBytes, this.maxLines);
+        this.drop(combined.subarray(0, start));
+        this.bytes = combined.slice(start);
+    }
+    drop(bytes) {
+        this.droppedBytes += bytes.length;
+        this.droppedLines += countNewlines(bytes);
+    }
+    get dropped() {
+        return this.droppedBytes;
+    }
+    text() {
+        return new TextDecoder().decode(this.bytes);
+    }
+}
+function tailStart(bytes, maxBytes, maxLines) {
+    let start = Math.max(0, bytes.length - maxBytes);
+    let excessLines = countNewlines(bytes.subarray(start)) - maxLines;
+    for (; start < bytes.length && excessLines > 0; start++) {
+        if (bytes[start] === 0x0a)
+            excessLines--;
+    }
+    return start;
+}
+function concat(a, b) {
+    if (a.length === 0)
+        return b.slice();
+    if (b.length === 0)
+        return a;
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+}
+function countNewlines(bytes) {
+    let count = 0;
+    for (const byte of bytes)
+        if (byte === 0x0a)
+            count++;
+    return count;
+}
+//# sourceMappingURL=bounded.js.map

package/dist/harness/pico3/chord.d.ts

@@ -0,0 +1,41 @@
+import { type Context, type MutableReplicatedState, type ReplicatedState } from "@earendil-works/chord";
+import type { ConversationHandle, Harness } from "./harness.ts";
+import type { ConversationSpec, ConversationView, Entry, EntryScan, Id, JsonObject, NewEntry, SendInput, ViewEvent } from "./types.ts";
+export type PublishedConversationView = ConversationView & {
+    commit: {
+        events: ViewEvent[];
+    };
+};
+export interface PicoConversationService {
+    readonly view: ReplicatedState<PublishedConversationView>;
+    send(input: SendInput, ctx: Context): Promise<Id>;
+    write(entry: NewEntry, ctx: Context): Promise<Id>;
+    inputAbort(id: Id, ctx: Context): Promise<"aborted" | "already_placed" | "not_found">;
+    configSet(patch: JsonObject, ctx: Context): Promise<void>;
+    abort(ctx: Context): Promise<void>;
+    reset(handoff: string | null, ctx: Context): Promise<void>;
+    collapse(instructions: string | null, ctx: Context): Promise<Id>;
+    fork(at: Id | "start", spec: Omit<ConversationSpec, "parent">, ctx: Context): Promise<Id>;
+    entries(scan: EntryScan, ctx: Context): Promise<Entry[]>;
+}
+/** Local registration/control plane and remote keyed conversation contract used by Chord facets. */
+export declare const PicoHarnessService: import("@earendil-works/chord").Service<Harness<[]>>;
+export declare const PicoConversationService: import("@earendil-works/chord").Service<PicoConversationService>;
+export declare function createPicoConversationService<Cfg extends object>(harness: Pick<Harness, "abortInput" | "entries">, conversation: ConversationHandle<Cfg>, view: ReplicatedState<PublishedConversationView>): PicoConversationService;
+export interface ChordViewBridge {
+    readonly view: MutableReplicatedState<PublishedConversationView>;
+    readonly closed: boolean;
+    close(): void;
+}
+export interface ChordViewBridgeOptions {
+    capacity?: number;
+    /** Called after the raw watch is closed. The owner should close and respawn its keyed service instance. */
+    onFailure?: (error: Error) => void;
+}
+/**
+ * Adapt Pico's commit-granular envelopes to one Chord publication per commit.
+ * The raw listener only enqueues. Applying ops and publishing happen together,
+ * off the Session line, with no await between them.
+ */
+export declare function attachChordView(conversation: Pick<ConversationHandle, "watch">, createState: (initial: PublishedConversationView) => MutableReplicatedState<PublishedConversationView>, ctx: Context, opts?: ChordViewBridgeOptions): Promise<ChordViewBridge>;
+//# sourceMappingURL=chord.d.ts.map

package/dist/harness/pico3/chord.js

@@ -0,0 +1,147 @@
+import { defineService, } from "@earendil-works/chord";
+import { WATCH_CAPACITY } from "./view.js";
+/** Local registration/control plane and remote keyed conversation contract used by Chord facets. */
+export const PicoHarnessService = defineService("pi.harness", { local: true });
+export const PicoConversationService = defineService("pi.conversation");
+export function createPicoConversationService(harness, conversation, view) {
+    return {
+        view,
+        send: (input, ctx) => conversation.send(input, ctx).then((handle) => handle.id),
+        write: (entry, ctx) => conversation.write(entry, ctx),
+        inputAbort: (id, ctx) => harness.abortInput(id, ctx, conversation.id),
+        configSet: (patch, ctx) => conversation.config.set(patch, ctx),
+        abort: (ctx) => conversation.abort(ctx),
+        reset: (handoff, ctx) => conversation.reset(handoff ?? undefined, ctx),
+        collapse: (instructions, ctx) => conversation.collapse(instructions ?? undefined, ctx),
+        fork: (at, spec, ctx) => conversation.fork(at, spec, ctx).then((child) => child.id),
+        entries: (scan, ctx) => harness.entries({ ...scan, conversationId: conversation.id }, ctx),
+    };
+}
+/**
+ * Adapt Pico's commit-granular envelopes to one Chord publication per commit.
+ * The raw listener only enqueues. Applying ops and publishing happen together,
+ * off the Session line, with no await between them.
+ */
+export async function attachChordView(conversation, createState, ctx, opts = {}) {
+    const watch = await conversation.watch(ctx);
+    const view = createState({ ...structuredClone(watch.view), commit: { events: [] } });
+    return bridgeWatch(watch, view, ctx, opts);
+}
+function bridgeWatch(watch, view, ctx, opts) {
+    const capacity = opts.capacity ?? WATCH_CAPACITY;
+    if (!Number.isSafeInteger(capacity) || capacity < 1)
+        throw new RangeError("Chord view queue capacity must be positive");
+    const queue = [];
+    let scheduled = false;
+    let closed = false;
+    const fail = (cause) => {
+        if (closed)
+            return;
+        closed = true;
+        queue.length = 0;
+        watch.stop();
+        try {
+            opts.onFailure?.(cause instanceof Error ? cause : new Error(String(cause)));
+        }
+        catch { }
+    };
+    const drain = () => {
+        scheduled = false;
+        while (!closed && queue.length > 0) {
+            const envelope = queue.shift();
+            try {
+                view.change(ctx, (draft) => {
+                    applyTracked(draft, envelope.ops);
+                    draft.commit.events = envelope.events;
+                });
+            }
+            catch (error) {
+                fail(error);
+            }
+        }
+    };
+    watch.start((envelope) => {
+        if (closed)
+            return;
+        if (queue.length >= capacity) {
+            fail(new Error(`Pico-to-Chord view queue exceeded ${capacity} envelopes`));
+            return;
+        }
+        queue.push(envelope);
+        if (scheduled)
+            return;
+        scheduled = true;
+        queueMicrotask(drain);
+    });
+    return {
+        view,
+        get closed() {
+            return closed;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            queue.length = 0;
+            watch.stop();
+        },
+    };
+}
+function applyTracked(root, ops) {
+    for (const op of ops) {
+        if (op[0] === "r")
+            throw new Error("live Pico envelope unexpectedly replaced the view root");
+        const path = op[1];
+        if (op[0] === "p") {
+            const target = resolve(root, path);
+            if (!Array.isArray(target))
+                throw new Error(`Pico splice path is not an array: ${path.join(".")}`);
+            target.splice(op[2], op[3], ...op[4]);
+            continue;
+        }
+        if (op[0] === "m") {
+            const target = resolve(root, path);
+            if (!Array.isArray(target) || target.length !== op[2].length) {
+                throw new Error(`Pico permutation path is not a matching array: ${path.join(".")}`);
+            }
+            const array = target;
+            const previous = array.slice();
+            const rank = new Map();
+            for (let index = 0; index < op[2].length; index++) {
+                const value = previous[op[2][index]];
+                if (!rank.has(value))
+                    rank.set(value, index);
+            }
+            array.sort((left, right) => rank.get(left) - rank.get(right));
+            continue;
+        }
+        const parent = resolve(root, path.slice(0, -1));
+        if (parent === null || typeof parent !== "object")
+            throw new Error(`Pico operation parent is not an object: ${path.join(".")}`);
+        const key = path[path.length - 1];
+        if (op[0] === "d") {
+            if (Array.isArray(parent))
+                parent.splice(key, 1);
+            else
+                delete parent[key];
+            continue;
+        }
+        const record = parent;
+        if (op[0] === "s")
+            record[key] = op[2];
+        else if (op[0] === "a")
+            record[key] = `${String(record[key])}${op[2]}`;
+        else
+            record[key] = String(record[key]).slice(op[2]);
+    }
+}
+function resolve(root, path) {
+    let value = root;
+    for (const segment of path) {
+        if (value === null || typeof value !== "object")
+            return undefined;
+        value = value[segment];
+    }
+    return value;
+}
+//# sourceMappingURL=chord.js.map

package/dist/harness/pico3/context.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "@earendil-works/chord";
+import type { ContextView, Id, Storage } from "./types.ts";
+/**
+ * pico §1.3, verbatim:
+ *   H       = newest fork-visible entry at or before T with a head
+ *   from    = H ? H.head : transcript start
+ *   range   = fork-visible entries from `from` through T
+ *   edits   = per target, newest edit in range wins
+ *   entries = H ? [H, ...range without any head entries] : range
+ *   model   = concat(entries.map(e => edits[e.id] ? apply : e.model)), then reorder tool results
+ *
+ * Display-only entries (aborted/error assistants, pi.usage, model-less plugin entries) have no
+ * `model` and contribute nothing. Nothing here inspects an error string.
+ */
+export declare function deriveContext(storage: Storage, conversationId: Id, at: Id | undefined, ctx: Context): Promise<ContextView>;
+//# sourceMappingURL=context.d.ts.map

package/dist/harness/pico3/context.js

@@ -0,0 +1,88 @@
+/**
+ * pico §1.3, verbatim:
+ *   H       = newest fork-visible entry at or before T with a head
+ *   from    = H ? H.head : transcript start
+ *   range   = fork-visible entries from `from` through T
+ *   edits   = per target, newest edit in range wins
+ *   entries = H ? [H, ...range without any head entries] : range
+ *   model   = concat(entries.map(e => edits[e.id] ? apply : e.model)), then reorder tool results
+ *
+ * Display-only entries (aborted/error assistants, pi.usage, model-less plugin entries) have no
+ * `model` and contribute nothing. Nothing here inspects an error string.
+ */
+export async function deriveContext(storage, conversationId, at, ctx) {
+    const [head] = await storage.scanEntries({ conversationId, withHead: true, ...(at === undefined ? {} : { before: at + 1 }), limit: 1 }, ctx);
+    const from = head?.head;
+    // Walk newest-first until we pass `from`.
+    const range = [];
+    let before = at === undefined ? undefined : at + 1;
+    for (;;) {
+        const page = await storage.scanEntries({ conversationId, ...(before === undefined ? {} : { before }), limit: 256 }, ctx);
+        let done = page.length < 256;
+        for (const e of page) {
+            if (from !== undefined && e.id < from) {
+                done = true;
+                break;
+            }
+            range.push(e);
+        }
+        if (done)
+            break;
+        before = page[page.length - 1].id;
+    }
+    range.reverse();
+    const edits = new Map();
+    for (const e of range)
+        for (const edit of e.edits ?? [])
+            edits.set(edit.target, edit); // later wins by iteration order
+    const entries = head === undefined ? range : [head, ...range.filter((e) => e.head === undefined)];
+    const messages = [];
+    for (const e of entries) {
+        const edit = edits.get(e.id);
+        if (edit?.action === "omit")
+            continue;
+        if (edit?.action === "replace") {
+            messages.push(...(edit.messages ?? []));
+            continue;
+        }
+        if (e.model)
+            messages.push(...e.model);
+    }
+    return { head, entries, messages: reorderToolResults(messages) };
+}
+function reorderToolResults(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        out.push(m);
+        if (m.role !== "assistant")
+            continue;
+        const calls = m.content.filter((c) => c.type === "toolCall");
+        if (calls.length === 0)
+            continue;
+        const results = new Map();
+        let j = i + 1;
+        while (j < messages.length && messages[j].role === "toolResult") {
+            const r = messages[j];
+            results.set(r.toolCallId, r);
+            j++;
+        }
+        for (const call of calls) {
+            out.push(results.get(call.id) ??
+                {
+                    role: "toolResult",
+                    toolCallId: call.id,
+                    toolName: call.name,
+                    content: [
+                        { type: "text", text: "Tool result unavailable: history ends before this call completed." },
+                    ],
+                    isError: true,
+                    details: { reason: "missing_after_fork" },
+                    timestamp: m.timestamp,
+                });
+        }
+        i = j - 1;
+    }
+    return out;
+}
+//# sourceMappingURL=context.js.map