@slopus/happy-agent-base 0.0.30 → 0.0.32

package/README.md

@@ -83,8 +83,11 @@ transaction that appends the result. Nothing outside the loop ever executes a to
 drove execution would be deciding inside machinery that also commits results, resumes interrupted
 batches, and settles cancelled ones.
 
-Every executable call receives an internally generated cuid2 `id`, the provider's separate opaque
-`providerCallId`, and a call-bound `kv`. Calling `call.commit(ctx, result)` inside a transaction
+Every tool call receives a Base-generated cuid2 `id`; executable calls also receive a call-bound
+`kv`. Events, hooks, task context, modules, results, and execution use that ID. The provider-native
+ID remains only in the raw stream and private provider-context records so replay and server-tool
+results can still be correlated after a restart; each context record pairs it with the Base ID as
+a separate sidecar, never in `vendor`. Calling `call.commit(ctx, result)` inside a transaction
 atomically saves that result with the tool's writes. The first successful commit wins; later
 commits and the tool's eventual return or throw are ignored. Committed results survive a crash,
 remain ordered with their batch, and the call-bound KV is erased in the result transaction.

package/dist/AgentBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AgentBase.d.ts","sourceRoot":"","sources":["../sources/AgentBase.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AgentBase.d.ts","sourceRoot":"","sources":["../sources/AgentBase.ts"],"names":[],"mappings":"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"}

package/dist/AgentBase.js

@@ -10,6 +10,7 @@ import { outsideAgentDatabaseOperation } from "./AgentDatabaseConnection.js";
 import { taskContextBeforeToolCall, withAgentTaskContext } from "./AgentTaskContext.js";
 import { AgentKV } from "./AgentKV.js";
 import { AGENT_BASE_PENDING_KEY, agentBasePendingStateOf, } from "./AgentBasePending.js";
+import { assistantContextRecord, baseContextMessages, baseSessionEvent, contextFromRecords, providerContextMessages, storedContextToolIds, toolContextRecord, } from "./AgentProviderContext.js";
 import { cuid2Schema, ownAgentMessageMetadata, ownAgentMetadata, } from "./AgentMetadata.js";
 import { DEFAULT_AGENT_PERMISSION_MODE, isAgentPermissionMode, } from "./AgentPermissionMode.js";
 import { AgentProviders } from "./AgentProviders.js";
@@ -47,7 +48,6 @@ const insideLoops = new AsyncLocalStorage();
 const INSIDE_CLOSE_REPORT_MS = 15;
 const storedToolCallSchema = Type.Object({
     id: cuid2Schema,
-    providerCallId: Type.String(),
     call: Type.Object({
         type: Type.Literal("tool_call"),
         name: Type.String(),
@@ -61,7 +61,7 @@ const storedToolCallSchema = Type.Object({
 /** A durable first-writer-wins claim on the result one call will append. */
 const storedToolResultSchema = Type.Object({
     role: Type.Literal("tool"),
-    callId: Type.String(),
+    callId: cuid2Schema,
     content: Type.Array(Type.Unknown()),
     isError: Type.Optional(Type.Boolean()),
     vendor: Type.Optional(Type.Unknown()),
@@ -271,8 +271,10 @@ export class AgentBase {
     #session;
     /** The provider-facing configuration the current session was created with. */
     #sessionConfig;
-    /** The conversation as this instance last knew it, reloaded from the store every turn. */
+    /** The conversation under Base-owned identities, reloaded from the store every turn. */
     #messages = [];
+    /** Provider-native tool IDs used only when serializing the private provider context. */
+    #providerToolIds = new Map();
     /** The durable steering queue, in the order its keys sort. */
     #steering = [];
     /** The durable send queue, in the order its keys sort. */
@@ -2266,6 +2268,15 @@ export class AgentBase {
                 context: { instructions, messages: snapshot },
                 ...(this.#model === undefined ? {} : { model: this.#model }),
             });
+            const cancelledContext = result.status === "cancelled"
+                ? baseContextMessages(result.context.messages, this.#providerToolIds)
+                : undefined;
+            let hookResult = result.status === "cancelled" && cancelledContext !== undefined
+                ? {
+                    ...result,
+                    context: { ...result.context, messages: cancelledContext.messages },
+                }
+                : result;
             if (result.status === "failed") {
                 await this.#preserveCompactionContinuation(ctx, continueWithInference && !signal.aborted);
                 await this.#invokeHook(ctx, this.#hooks.afterCompaction, {
@@ -2275,7 +2286,18 @@ export class AgentBase {
                 throw new Error(result.message);
             }
             if (result.status === "completed") {
-                const completed = { ...compactionStart, result };
+                const replacement = baseContextMessages(result.context.messages, this.#providerToolIds);
+                const preserved = baseContextMessages(result.preservedMessages, this.#providerToolIds);
+                const publicResult = {
+                    ...result,
+                    preservedMessages: preserved.messages,
+                    context: { ...result.context, messages: replacement.messages },
+                };
+                hookResult = publicResult;
+                const completed = {
+                    ...compactionStart,
+                    result: publicResult,
+                };
                 await this.#runPersistenceStep(this.#workContext(ctx), async (lockCtx) => {
                     // Physically delete the superseded records and write the replacement —
                     // which keeps the messages that stay — in one atomic step.
@@ -2288,7 +2310,8 @@ export class AgentBase {
                         }
                         await this.#persistence.append(txCtx, {
                             type: "compaction",
-                            messages: result.context.messages,
+                            contextToolIds: storedContextToolIds(replacement.toolIds),
+                            messages: replacement.messages,
                         });
                         if (continueWithInference) {
                             // The replacement and the response it still owes are one durable
@@ -2300,7 +2323,8 @@ export class AgentBase {
                         }
                     });
                     this.#rotateHistoryKV();
-                    this.#messages = [...result.context.messages];
+                    this.#messages = replacement.messages;
+                    this.#providerToolIds = replacement.toolIds;
                     this.#lastRecordType = "compaction";
                 });
                 // The conversation the measurement described is gone; its size is unknown
@@ -2312,7 +2336,7 @@ export class AgentBase {
             }
             await this.#invokeHook(ctx, this.#hooks.afterCompaction, {
                 ...compactionStart,
-                result,
+                result: hookResult,
             });
             this.#compaction = undefined;
             pending.resolve();
@@ -2355,7 +2379,7 @@ export class AgentBase {
                 // it independently without racing that batch, and it cannot settle the agent
                 // while the call remains open, so leave the durable stage untouched for resume.
                 const pending = await this.#persistence.readValues(lockCtx, "tool.");
-                const dispatched = new Set(pending.map(({ key, value }) => this.#restoreToolEntry(key, value).providerCallId));
+                const dispatched = new Set(pending.map(({ key, value }) => this.#restoreToolEntry(key, value).id));
                 if (owed.some((call) => dispatched.has(call.callId))) {
                     this.#durableWorkBlocked = true;
                     return;
@@ -2364,7 +2388,7 @@ export class AgentBase {
                     const entry = this.#newToolEntry(index, call);
                     return {
                         ...entry,
-                        committed: toolFailure(entry.providerCallId, reason),
+                        committed: toolFailure(entry.id, reason),
                     };
                 });
                 // Give every otherwise-undispatched call a durable internal identity and staged
@@ -2380,12 +2404,12 @@ export class AgentBase {
                 await this.#recordTransaction(lockCtx, async (txCtx) => {
                     for (const entry of entries) {
                         const result = entry.committed;
-                        await this.#appendRecord(txCtx, { type: "tool", message: result });
+                        await this.#appendRecord(txCtx, toolContextRecord(result, this.#providerToolIds));
                         await this.#persistence.deleteValue(txCtx, entry.key);
                         // A result the conversation records is a result the hook sees, however
                         // little of a run produced it. A hook that fails here leaves the calls
                         // unsettled, which is what lets a later attempt answer them properly.
-                        await this.#invokeToolTransactHook(txCtx, entry.id, entry.providerCallId, this.#hooks.afterToolCallTransact, result);
+                        await this.#invokeToolTransactHook(txCtx, entry.id, this.#hooks.afterToolCallTransact, result);
                         await this.#kv.scoped("call", entry.id).clear(txCtx);
                     }
                     await this.#recordPending(txCtx, "inference");
@@ -2739,6 +2763,7 @@ export class AgentBase {
             queue.splice(0, count);
             if (reset) {
                 this.#messages = injected === undefined ? [] : [injected];
+                this.#providerToolIds.clear();
                 this.#contextTokens = undefined;
             }
             this.#messages.push(...batch.map((entry) => entry.message));
@@ -2838,14 +2863,15 @@ export class AgentBase {
             const records = await this.#persistence.load(lockCtx);
             const last = records[records.length - 1];
             this.#lastRecordType = last?.type;
-            let restored = messagesFromRecords(records);
+            const restored = contextFromRecords(records);
             const steering = await this.#persistence.readValues(lockCtx, "steering.");
             const sends = await this.#persistence.readValues(lockCtx, "send.");
             const injections = await this.#persistence.readValues(lockCtx, "inject.");
             const pendingTools = await this.#persistence.readValues(lockCtx, "tool.");
             const settings = await this.#persistence.readValues(lockCtx, "settings");
             const context = await this.#persistence.readValues(lockCtx, "context");
-            this.#messages = restored;
+            this.#messages = restored.messages;
+            this.#providerToolIds = restored.toolIds;
             // The measured size of the restored context, so the first turn after a reload can
             // still decide whether it needs a compaction.
             const measured = context[0]?.value;
@@ -2882,7 +2908,7 @@ export class AgentBase {
                 // context would keep an unanswered tool call for ever, which most providers
                 // reject outright. They are recovered as the batch that was about to be
                 // dispatched.
-                const owed = this.#unansweredCalls(restored);
+                const owed = this.#unansweredCalls(restored.messages);
                 if (owed.length > 0) {
                     this.#pendingTools = owed.map((call, index) => this.#newToolEntry(index, call));
                     this.#pendingToolsUndispatched = true;
@@ -2918,7 +2944,8 @@ export class AgentBase {
                 // Last, so a hook noting a call about to happen sees a transaction holding
                 // the whole batch it belongs to.
                 for (const entry of entries) {
-                    await this.#invokeToolTransactHook(txCtx, entry.id, entry.providerCallId, this.#hooks.beforeToolCallTransact, entry.call);
+                    const { vendor: _vendor, ...call } = entry.call;
+                    await this.#invokeToolTransactHook(txCtx, entry.id, this.#hooks.beforeToolCallTransact, call);
                 }
             }));
         }
@@ -2962,20 +2989,17 @@ export class AgentBase {
                                 throw new Error(`The committed result claim for tool "${entry.id}" is not valid.`);
                             }
                             const result = stored;
-                            if (result.callId !== entry.providerCallId) {
-                                throw new Error(`The committed result claim for tool "${entry.id}" has the wrong provider call ID.`);
+                            if (result.callId !== entry.id) {
+                                throw new Error(`The committed result claim for tool "${entry.id}" has the wrong identity.`);
                             }
                             winner = result;
                             results[committed] = result;
-                            await this.#appendRecord(txCtx, {
-                                type: "tool",
-                                message: result,
-                            });
+                            await this.#appendRecord(txCtx, toolContextRecord(result, this.#providerToolIds));
                             // The call is answered, so both its retry record and its temporary
                             // invocation store disappear in this same result transaction.
                             await this.#persistence.deleteValue(txCtx, entry.key);
                             await this.#persistence.deleteValue(txCtx, resultKey);
-                            await this.#invokeToolTransactHook(txCtx, entry.id, entry.providerCallId, this.#hooks.afterToolCallTransact, result);
+                            await this.#invokeToolTransactHook(txCtx, entry.id, this.#hooks.afterToolCallTransact, result);
                             await this.#kv.scoped("call", entry.id).clear(txCtx);
                         });
                         this.#messages.push(winner);
@@ -3004,7 +3028,7 @@ export class AgentBase {
                 outcome = entry.committed;
             }
             else if (resume && !(await this.#isDurable(ctx, entry.call))) {
-                outcome = toolFailure(entry.call.callId, "The tool call was interrupted by a restart and was not retried.");
+                outcome = toolFailure(entry.id, "The tool call was interrupted by a restart and was not retried.");
             }
             else {
                 const toolLifetime = AbortSignal.any([signal, this.#closeController.signal]);
@@ -3027,7 +3051,7 @@ export class AgentBase {
                 outcome === ABORTED
                     ? {
                         role: "tool",
-                        callId: entry.call.callId,
+                        callId: entry.id,
                         content: [
                             {
                                 type: "text",
@@ -3131,19 +3155,20 @@ export class AgentBase {
                     ordered.push(result);
             }
         }
-        return ordered;
+        return providerContextMessages(ordered, this.#providerToolIds);
     }
-    /** Allocate one internal identity before the call becomes durable or executable. */
+    /** Turn one canonical call into its durable Base-owned batch entry. */
     #newToolEntry(index, call) {
-        const id = createId();
+        if (!Value.Check(cuid2Schema, call.callId)) {
+            throw new Error(`Tool call "${call.callId}" is not a Base-generated ID.`);
+        }
         return {
-            key: this.#toolKey(index, id),
-            id,
-            providerCallId: call.callId,
+            key: this.#toolKey(index, call.callId),
+            id: call.callId,
             call,
         };
     }
-    /** Restore the exact internal/provider identity pair that was dispatched before a restart. */
+    /** Restore the Base/provider context identity pair dispatched before a restart. */
     #restoreToolEntry(key, value) {
         if (!Value.Check(storedToolCallSchema, value)) {
             throw new Error(`The pending tool call under "${key}" is not valid.`);
@@ -3153,26 +3178,27 @@ export class AgentBase {
             !Value.Check(storedToolResultSchema, stored.committed)) {
             throw new Error(`The committed result under "${key}" is not valid.`);
         }
-        const call = {
-            ...stored.call,
-            callId: stored.providerCallId,
-        };
+        const call = { ...stored.call, callId: stored.id };
         return {
             key,
             id: stored.id,
-            providerCallId: stored.providerCallId,
             call,
             ...(stored.committed === undefined
                 ? {}
                 : { committed: stored.committed }),
         };
     }
-    /** The explicit durable representation keeps provider and internal identities separate. */
+    /** The durable representation pairs one Base identity with provider-context replay data. */
     #storedToolEntry(entry) {
-        const { callId: _providerCallId, server: _server, ...call } = entry.call;
+        if (entry.call.callId !== entry.id) {
+            throw new Error(`Pending tool "${entry.id}" has a mismatched Base identity.`);
+        }
+        if (entry.committed !== undefined && entry.committed.callId !== entry.id) {
+            throw new Error(`Pending tool "${entry.id}" has a mismatched committed result ID.`);
+        }
+        const { callId: _callId, server: _server, ...call } = entry.call;
         return {
             id: entry.id,
-            providerCallId: entry.providerCallId,
             call,
             ...(entry.committed === undefined ? {} : { committed: entry.committed }),
         };
@@ -3186,24 +3212,23 @@ export class AgentBase {
         return `toolResult.${id}`;
     }
     /**
-     * The scope one call owns: state lives under its internal ID, never under the provider's
-     * opaque ID or another call's scope, and is erased when the call commits. The task context
-     * still locates the provider call in conversation history.
+     * The scope one call owns: state lives under its Base ID and is erased when the call commits.
+     * The same ID locates the call in conversation history.
      */
-    #callScoped(ctx, id, providerCallId) {
-        return withAgentTaskContext(withAgentRunKV(withAgentKV(ctx, this.#kv.scoped("call", id)), this.#runKV.scoped("call", id)), taskContextBeforeToolCall(this.#messages, providerCallId));
+    #callScoped(ctx, id) {
+        return withAgentTaskContext(withAgentRunKV(withAgentKV(ctx, this.#kv.scoped("call", id)), this.#runKV.scoped("call", id)), taskContextBeforeToolCall(this.#messages, id));
     }
     /**
      * Call a tool hook that writes inside a transaction of its own call's. The lifetime ends with
      * the callback, so a context kept afterwards cannot outlive the transaction it belongs to.
      * Its failure is not contained: it rolls that transaction back.
      */
-    async #invokeToolTransactHook(txCtx, id, providerCallId, hook, argument) {
+    async #invokeToolTransactHook(txCtx, id, hook, argument) {
         if (hook === undefined)
             return;
         const lifetime = new AbortController();
         try {
-            await hook(this.#callScoped(withLifetime(txCtx, lifetime.signal), id, providerCallId), argument);
+            await hook(this.#callScoped(withLifetime(txCtx, lifetime.signal), id), argument);
         }
         finally {
             lifetime.abort();
@@ -3218,7 +3243,7 @@ export class AgentBase {
         const { call } = entry;
         const failure = (text) => ({
             role: "tool",
-            callId: call.callId,
+            callId: entry.id,
             content: [{ type: "text", text }],
             isError: true,
         });
@@ -3259,7 +3284,7 @@ export class AgentBase {
         const callLifetime = new AbortController();
         let committing = false;
         const boundedCallKV = callKV.until(callLifetime.signal, () => !committing);
-        const callCtx = withAgentKV(this.#callScoped(ctx, entry.id, entry.providerCallId), boundedCallKV);
+        const callCtx = withAgentKV(this.#callScoped(ctx, entry.id), boundedCallKV);
         // From here the call is one the two tool hooks bracket: a tool that exists, a call that
         // finished, and arguments its schema accepts. A call refused before that reaches neither
         // hook, because there is nothing yet to decide about or to report.
@@ -3273,7 +3298,7 @@ export class AgentBase {
             resolveCommitted = resolve;
         });
         const outcomeFor = (result) => ({
-            callId: call.callId,
+            callId: entry.id,
             tool: ran,
             arguments: ranArguments,
             content: [...ran.toLLM(result)],
@@ -3292,7 +3317,7 @@ export class AgentBase {
             const candidate = outcomeFor(result);
             const message = {
                 role: "tool",
-                callId: entry.providerCallId,
+                callId: entry.id,
                 content: candidate.content,
                 ...(candidate.isError ? { isError: true } : {}),
             };
@@ -3341,7 +3366,7 @@ export class AgentBase {
         };
         try {
             const decision = await this.#hooks.beforeToolCall?.(callCtx, {
-                callId: call.callId,
+                callId: entry.id,
                 tool,
                 arguments: args,
             });
@@ -3349,7 +3374,7 @@ export class AgentBase {
                 // The hook answered the model itself, so the tool never runs and there is no
                 // structured result — only what the model is told.
                 outcome = {
-                    callId: call.callId,
+                    callId: entry.id,
                     tool,
                     arguments: args,
                     content: [...decision.content],
@@ -3376,7 +3401,6 @@ export class AgentBase {
                     : [runCtx.lifetime, callLifetime.signal]));
                 const toolCall = {
                     id: entry.id,
-                    providerCallId: entry.providerCallId,
                     kv: boundedCallKV,
                     commit,
                 };
@@ -3415,7 +3439,7 @@ export class AgentBase {
             outcome =
                 committedOutcome ??
                     {
-                        callId: call.callId,
+                        callId: entry.id,
                         tool: ran,
                         arguments: ranArguments,
                         content: [
@@ -3431,7 +3455,7 @@ export class AgentBase {
             await this.#invokeHookOn(callCtx, this.#hooks.afterToolCall, outcome);
             return {
                 role: "tool",
-                callId: call.callId,
+                callId: entry.id,
                 content: outcome.content,
                 ...(outcome.isError ? { isError: true } : {}),
             };
@@ -3487,21 +3511,26 @@ export class AgentBase {
         // in-memory assistant message never diverges from what a reload would rebuild.
         const persisted = [];
         const toolCallIndexes = new Map();
-        const persist = async (event) => {
-            if (event === undefined)
+        const toolResultIndexes = new Map();
+        // Provider IDs remain only in the private context blocks. Every event and transactional
+        // projection leaving this method uses the generated Base ID instead.
+        const responseToolIds = new Map();
+        const persist = async (block, event) => {
+            if (block === undefined)
                 return;
+            const record = assistantContextRecord(block, this.#providerToolIds);
             await this.#runPersistenceStep(this.#workContext(ctx), async (lockCtx) => {
-                if (this.#hooks.onEventTransact === undefined) {
-                    await this.#appendRecord(lockCtx, { type: "block", block: event.block });
+                if (event === undefined || this.#hooks.onEventTransact === undefined) {
+                    await this.#appendRecord(lockCtx, record);
                 }
                 else {
                     await this.#recordTransaction(lockCtx, async (txCtx) => {
-                        await this.#appendRecord(txCtx, { type: "block", block: event.block });
+                        await this.#appendRecord(txCtx, record);
                         await this.#withTransactionalContext(txCtx, (hookCtx) => this.#hooks.onEventTransact?.(hookCtx, event));
                     });
                 }
             });
-            persisted.push(event.block);
+            persisted.push(block);
         };
         const iterator = stream[Symbol.asyncIterator]();
         // A response usually ends before its stream does — at the done event, or at an abort —
@@ -3522,7 +3551,8 @@ export class AgentBase {
                     exhausted = true;
                     break;
                 }
-                const event = next.value;
+                const providerEvent = next.value;
+                const event = baseSessionEvent(providerEvent, responseToolIds, this.#providerToolIds);
                 await this.#emit(ctx, event);
                 switch (event.type) {
                     case "text_start":
@@ -3540,7 +3570,7 @@ export class AgentBase {
                     }
                     case "text_end": {
                         const last = content[content.length - 1];
-                        await persist(last?.type === "text" ? { ...event, block: last } : undefined);
+                        await persist(last?.type === "text" ? last : undefined, last?.type === "text" ? { ...event, block: last } : undefined);
                         break;
                     }
                     case "reasoning_start":
@@ -3566,11 +3596,14 @@ export class AgentBase {
                                     : { reasoning: event.reasoning }),
                             };
                             content[content.length - 1] = finished;
-                            await persist({ ...event, block: finished });
+                            await persist(finished, { ...event, block: finished });
                         }
                         break;
                     }
-                    case "toolcall_start":
+                    case "toolcall_start": {
+                        if (providerEvent.type !== "toolcall_start") {
+                            throw new Error("The provider tool-call start changed event type.");
+                        }
                         toolCallIndexes.set(event.callId, content.length);
                         content.push({
                             type: "tool_call",
@@ -3581,9 +3614,12 @@ export class AgentBase {
                                 ? {}
                                 : { namespace: event.namespace }),
                             ...(event.server === undefined ? {} : { server: event.server }),
-                            ...(event.vendor === undefined ? {} : { vendor: event.vendor }),
+                            ...(providerEvent.vendor === undefined
+                                ? {}
+                                : { vendor: providerEvent.vendor }),
                         });
                         break;
+                    }
                     case "toolcall_end": {
                         const index = toolCallIndexes.get(event.callId);
                         const block = index === undefined ? undefined : content[index];
@@ -3596,17 +3632,59 @@ export class AgentBase {
                                     : { incomplete: event.incomplete }),
                             };
                             content[index] = finished;
-                            await persist({ ...event, block: finished });
+                            const { vendor: _vendor, ...publicBlock } = finished;
+                            await persist(finished, {
+                                ...event,
+                                block: publicBlock,
+                            });
+                        }
+                        break;
+                    }
+                    case "toolcall_result_start": {
+                        if (providerEvent.type !== "toolcall_result_start") {
+                            throw new Error("The provider tool-result start changed event type.");
+                        }
+                        const callIndex = toolCallIndexes.get(event.callId);
+                        const call = callIndex === undefined ? undefined : content[callIndex];
+                        if (call?.type !== "tool_call") {
+                            throw new Error("A provider tool result has no matching call.");
                         }
+                        toolResultIndexes.set(event.callId, content.length);
+                        content.push({
+                            type: "tool_result",
+                            callId: event.callId,
+                            content: [],
+                            ...(providerEvent.vendor === undefined
+                                ? {}
+                                : { vendor: providerEvent.vendor }),
+                        });
                         break;
                     }
-                    // The provider settled a server tool call on its own backend and streams the
-                    // result here. The agent simply ignores it: nothing to execute, nothing to
-                    // store — the events still reach the hooks like every other event.
-                    case "toolcall_result_start":
                     case "toolcall_result_delta":
-                    case "toolcall_result_end":
                         break;
+                    case "toolcall_result_end": {
+                        const callIndex = toolCallIndexes.get(event.callId);
+                        const call = callIndex === undefined ? undefined : content[callIndex];
+                        const resultIndex = toolResultIndexes.get(event.callId);
+                        if (resultIndex === undefined || call?.type !== "tool_call") {
+                            throw new Error("A provider tool-result end has no matching start.");
+                        }
+                        const result = content[resultIndex];
+                        if (result?.type !== "tool_result") {
+                            throw new Error("A provider tool-result end has no matching start.");
+                        }
+                        const finished = {
+                            ...result,
+                            content: event.content,
+                            ...(event.isError === undefined ? {} : { isError: event.isError }),
+                            ...(event.incomplete === undefined
+                                ? {}
+                                : { incomplete: event.incomplete }),
+                        };
+                        content[resultIndex] = finished;
+                        await persist(finished, undefined);
+                        break;
+                    }
                     case "done":
                         return {
                             // Only blocks that finished, which are exactly the blocks that were
@@ -3683,41 +3761,11 @@ export class AgentBase {
         }
     }
 }
-/**
- * The conversation a run of records spells out. A compaction record carries the complete
- * replacement context and supersedes everything before it; consecutive blocks belong to one
- * response. Used both to restore the whole history and to read the tail of it, which is why it
- * takes any run of records rather than the store itself.
- */
-function messagesFromRecords(records) {
-    let messages = [];
-    for (const record of records) {
-        if (record.type === "compaction") {
-            messages = [...record.messages];
-            continue;
-        }
-        if (record.type === "user" || record.type === "tool" || record.type === "system") {
-            messages.push(record.message);
-            continue;
-        }
-        const last = messages[messages.length - 1];
-        if (last?.role === "assistant") {
-            messages[messages.length - 1] = {
-                role: "assistant",
-                content: [...last.content, record.block],
-            };
-        }
-        else {
-            messages.push({ role: "assistant", content: [record.block] });
-        }
-    }
-    return messages;
-}
 /** The result that stands in for a call the agent could not, or must not, carry out. */
-function toolFailure(callId, reason) {
+function toolFailure(id, reason) {
     return {
         role: "tool",
-        callId,
+        callId: id,
         content: [{ type: "text", text: reason }],
         isError: true,
     };