stitchkit 0.62.0 → 0.63.0

package/dist/agent-runtime/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAKL,KAAK,aAAa,EAInB,MAAM,WAAW,CAAC;AAEnB,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AACH,eAAO,MAAM,wBAAwB;;iBAAgD,CAAC;AACtF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlC,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAKzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMxC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAC;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBvC,CAAC;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;iBAQhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;iBAMhC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKtC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7D,uBAAuB,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC3F,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACtE,sBAAsB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACzF,mBAAmB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACnF,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC3E,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACtE,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC/E,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IACvF;;;;;;;OAOG;IACH,eAAe,CAAC,KAAK,EAAE;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,GAAG,OAAO,CAAC,OAAO,gBAAgB,EAAE,oBAAoB,CAAC,CAAC;CAC5D"}

package/dist/agent-runtime/terminal-commit.d.ts

@@ -1,4 +1,4 @@
-import { type AgentMessage, type AgentRun, type AgentSnapshot, type AgentTerminalReason } from './schemas';
+import { type AgentMessage, type AgentRun, type AgentSnapshot, type AgentTerminalReason, type AgentUsage } from './schemas';
 import type { AgentRuntimeStore, AgentStoreMutationResult } from './store';
 export declare class AgentRuntimeConflictError extends Error {
     constructor(operation: string);
@@ -72,12 +72,40 @@ export declare function appliedSnapshot(result: AgentStoreMutationResult, operat
         conversationId: string;
         inputMessageIds: string[];
         assistantMessageId: string;
-        state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+        state: "abandoned" | "absorbed" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
         revision: number;
         ownerId?: string | undefined;
         fencingToken?: number | undefined;
-        terminalReason?: "abandoned" | "cancelled" | "interrupted" | "policy_stop" | "provider_failure" | "shutdown" | "success" | "superseded" | "timeout" | "tool_failure" | undefined;
+        terminalReason?: "abandoned" | "cancelled" | "interrupted" | "policy_stop" | "provider_failure" | "provider_stop" | "shutdown" | "success" | "superseded" | "timeout" | "tool_failure" | undefined;
         terminalPolicyName?: string | undefined;
+        absorbedIntoRunId?: string | undefined;
+        usage?: {
+            inputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            outputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            reasoningTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheReadTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheWriteTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cost?: {
+                value?: number | undefined;
+                currency?: string | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+        } | undefined;
         createdAt: string;
         updatedAt: string;
     }[];
@@ -87,6 +115,8 @@ interface TerminalCommitCandidate {
     assistant: AgentMessage;
     reason: AgentTerminalReason;
     policyName?: string;
+    /** What this run cost, persisted with the terminal record. */
+    usage?: AgentUsage;
 }
 export interface AgentTerminalCommitResolution extends TerminalCommitCandidate {
     snapshot: AgentSnapshot;

package/dist/agent-runtime/terminal-commit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal-commit.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/terminal-commit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAGjB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAG3E,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,YAAY,SAAS,EAAE,MAAM,EAG5B;CACF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlF;AAED,UAAU,uBAAuB;IAC/B,GAAG,EAAE,QAAQ,CAAC;IACd,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA8B,SAAQ,uBAAuB;IAC5E,QAAQ,EAAE,aAAa,CAAC;IACxB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAmFD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE;IAClD,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,uBAAuB,CAAC;IACnC,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CAAC,6BAA6B,CAAC,CA4CzC"}
+{"version":3,"file":"terminal-commit.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/terminal-commit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAGjB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAChB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAG3E,qBAAa,yBAA0B,SAAQ,KAAK;IAClD,YAAY,SAAS,EAAE,MAAM,EAG5B;CACF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlF;AAED,UAAU,uBAAuB;IAC/B,GAAG,EAAE,QAAQ,CAAC;IACd,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,6BAA8B,SAAQ,uBAAuB;IAC5E,QAAQ,EAAE,aAAa,CAAC;IACxB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAoFD,wBAAsB,sBAAsB,CAAC,KAAK,EAAE;IAClD,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,uBAAuB,CAAC;IACnC,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB,GAAG,OAAO,CAAC,6BAA6B,CAAC,CA6CzC"}

package/dist/agent-runtime/terminal-status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal-status.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/terminal-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACnE;;;;;;;;;GASG;AACH;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,OAAO,CAOlF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAWnF"}
+{"version":3,"file":"terminal-status.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/terminal-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACnE;;;;;;;;;GASG;AACH;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,OAAO,CAOlF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,mBAAmB,GAAG,YAAY,CAAC,QAAQ,CAAC,CAanF"}

package/dist/agent-runtime.d.ts

@@ -10,7 +10,7 @@ export { type AgentProtocol, type AgentProtocolConfig, defineAgentProtocol, } fr
 export { type AgentRuntime, type AgentRuntimeAdmission, type AgentRuntimeConfig, type AgentRuntimeInput, type AgentRuntimeInterruptInput, type AgentRuntimePrepareStep, type AgentRuntimeProtocolInput, type AgentRuntimeRecordIds, type AgentRuntimeRecoverOptions, type AgentRuntimeRecoveryDecision, type AgentRuntimeRecoveryInput, type AgentRuntimeRecoveryOutcome, type AgentRuntimeRunContext, type AgentRuntimeStopPolicy, createAgentRuntime, } from './agent-runtime/runtime';
 export type { AgentRuntimeResult } from './agent-runtime/runtime-result';
 export * from './agent-runtime/schemas';
-export { type AcceptInputAndAssignRun, AcceptInputAndAssignRunSchema, type AcquireAgentRun, AcquireAgentRunSchema, type AgentRuntimeStore, AgentStoreAppliedSchema, AgentStoreConflictSchema, AgentStoreDuplicateSchema, type AgentStoreMutationResult, AgentStoreMutationResultSchema, AgentStoreNotFoundSchema, type CheckpointRunAssistant, CheckpointRunAssistantSchema, type CommitRunTerminal, CommitRunTerminalSchema, type RecoverAgentRun, RecoverAgentRunSchema, type ReplaceCompactedRange, ReplaceCompactedRangeSchema, type RequestRunInterrupt, RequestRunInterruptSchema, } from './agent-runtime/store';
+export { type AbsorbQueuedRun, AbsorbQueuedRunSchema, type AcceptInputAndAssignRun, AcceptInputAndAssignRunSchema, type AcquireAgentRun, AcquireAgentRunSchema, type AgentRuntimeStore, AgentStoreAppliedSchema, AgentStoreConflictSchema, AgentStoreDuplicateSchema, type AgentStoreMutationResult, AgentStoreMutationResultSchema, AgentStoreNotFoundSchema, type CheckpointRunAssistant, CheckpointRunAssistantSchema, type CommitRunTerminal, CommitRunTerminalSchema, type RecoverAgentRun, RecoverAgentRunSchema, type ReplaceCompactedRange, ReplaceCompactedRangeSchema, type RequestRunInterrupt, RequestRunInterruptSchema, } from './agent-runtime/store';
 export { type AgentAdmissionReceipt, AgentAdmissionReceiptSchema, type AgentHistoryMutation, AgentHistoryMutationSchema, type AgentRecoverableDescriptor, AgentRecoverableDescriptorSchema, type AgentRecoverablePage, AgentRecoverablePageSchema, type AgentRuntimeHead, AgentRuntimeHeadSchema, type AgentRuntimeStoreDriver, type AgentStoreCompareAndSwapResult, type AgentStoredRun, AgentStoredRunSchema, createAgentRuntimeStore, createMemoryAgentRuntimeStore, } from './agent-runtime/store-driver';
 export { AgentRuntimeConflictError } from './agent-runtime/terminal-commit';
 //# sourceMappingURL=agent-runtime.d.ts.map

package/dist/agent-runtime.d.ts.map

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

package/dist/agent-runtime.js

@@ -29,7 +29,7 @@ import {
   AgentToolResultPartSchema,
   AgentUsageSchema,
   AgentUsageValueSchema
-} from "./index-58vkx74h.js";
+} from "./index-b1k33127.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -50,8 +50,9 @@ function isSpeakableAssistantStatus(status) {
   return status === "completed" || status === "interrupted" || status === "committed";
 }
 function assistantStatus(reason) {
-  if (reason === "success" || reason === "policy_stop")
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
     return "completed";
+  }
   if (reason === "superseded")
     return "superseded";
   if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
@@ -1058,7 +1059,10 @@ function createRuntimeAdmissionLanes() {
 }
 
 // src/agent-runtime/run-execution.ts
-import { stepCountIs, streamText } from "ai";
+import {
+  stepCountIs,
+  streamText
+} from "ai";
 
 // src/agent-runtime/runtime-internals.ts
 import { z as z5 } from "zod";
@@ -1089,7 +1093,8 @@ function canonicalTerminal(snapshot, runId, retainedAssistant) {
     assistant,
     reason: run.terminalReason,
     committedByCaller: false,
-    ...run.terminalPolicyName && { policyName: run.terminalPolicyName }
+    ...run.terminalPolicyName && { policyName: run.terminalPolicyName },
+    ...run.usage && { usage: run.usage }
   };
 }
 function interruptedCandidate(candidate, run, now) {
@@ -1126,7 +1131,8 @@ async function commitAgentRunTerminal(input) {
       },
       assistant: candidate.assistant,
       reason: candidate.reason,
-      ...candidate.policyName && { policyName: candidate.policyName }
+      ...candidate.policyName && { policyName: candidate.policyName },
+      ...candidate.usage && { usage: candidate.usage }
     });
     if (committed.outcome === "applied") {
       const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id);
@@ -1365,7 +1371,8 @@ function createRunExecutor(dependencies) {
     let eventCount = 0;
     let sequence = 0;
     let terminalReason = "success";
-    let usage;
+    let usage = input.acceptedRun.usage;
+    let sawProviderFinish = false;
     let step = 0;
     let selectedModel;
     let internalCause;
@@ -1407,13 +1414,14 @@ function createRunExecutor(dependencies) {
         expectedRevision: run.revision,
         ownerId: runtimeEpoch,
         ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-        assistant
+        assistant,
+        usage: statedUsage(usage)
       }), "assistant checkpoint");
       run = findRun(snapshot.runs, run.id);
       const checkpointMetrics = {
         partial: true,
         durationMs: performance.now() - runStartedAt,
-        ...usage && { usage },
+        usage: statedUsage(usage),
         ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
       };
       await publish({
@@ -1436,6 +1444,8 @@ function createRunExecutor(dependencies) {
         });
         snapshot = compacted.snapshot;
         run = findRun(snapshot.runs, run.id);
+        if (compacted.usage)
+          usage = addUsage(usage, compacted.usage);
       }
       const assertCurrent = async () => {
         if (executionSignal.aborted)
@@ -1484,7 +1494,7 @@ function createRunExecutor(dependencies) {
       if (prompt.contextDecision === "requires-compaction") {
         throw new Error("Agent context still exceeds the model budget after compaction");
       }
-      const history = await (config.history?.project ? config.history.project(snapshot.messages) : projectAgentHistory(snapshot.messages, {
+      const projectHistory = (source) => config.history?.project ? config.history.project(source.messages) : projectAgentHistory(source.messages, {
         ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
         ...config.history?.unresolvedFile && {
           unresolvedFile: config.history.unresolvedFile
@@ -1492,7 +1502,44 @@ function createRunExecutor(dependencies) {
         ...config.history?.interruptedAssistant && {
           interruptedAssistant: config.history.interruptedAssistant
         }
-      }));
+      });
+      const history = await projectHistory(snapshot);
+      const absorbPending = async () => {
+        if (!input.absorbable?.size || executionSignal.aborted)
+          return;
+        const latest = await config.store.loadSnapshot(run.conversationId);
+        const current = latest.runs.find((candidate) => candidate.id === run.id);
+        if (current?.state !== "running" || current.ownerId !== runtimeEpoch) {
+          return;
+        }
+        const pending = latest.runs.find((candidate) => candidate.state === "queued" && input.absorbable?.has(candidate.id));
+        if (!pending)
+          return;
+        const absorbed = await config.store.absorbQueuedRun({
+          conversationId: run.conversationId,
+          runningRunId: current.id,
+          runningExpectedRevision: current.revision,
+          ownerId: runtimeEpoch,
+          ...current.fencingToken !== undefined && { fencingToken: current.fencingToken },
+          queuedRunId: pending.id,
+          queuedExpectedRevision: pending.revision
+        });
+        if (absorbed.outcome !== "applied")
+          return;
+        input.onAbsorbed?.(pending.id);
+        snapshot = absorbed.snapshot;
+        run = findRun(snapshot.runs, run.id);
+        await publish({
+          type: "run-state",
+          eventId: agentDurableEventId("run-state", run.id, snapshot.version),
+          conversationId: run.conversationId,
+          runId: run.id,
+          snapshotVersion: snapshot.version,
+          state: run.state,
+          emittedAt: now().toISOString()
+        });
+        return [...await projectHistory(snapshot)];
+      };
       const maxStepCondition = stepCountIs(maxSteps);
       const stopConditions = [
         async (options) => {
@@ -1518,8 +1565,10 @@ function createRunExecutor(dependencies) {
         abortSignal: executionSignal,
         maxRetries: 0,
         stopWhen: stopConditions,
-        ...config.loop?.prepareStep && {
-          prepareStep: (options) => config.loop?.prepareStep?.({ ...options, ...runtimeContext })
+        prepareStep: async (options) => {
+          const absorbed = await absorbPending();
+          const prepared = await config.loop?.prepareStep?.({ ...options, ...runtimeContext }) ?? {};
+          return absorbed && !prepared.messages ? { ...prepared, messages: absorbed } : prepared;
         }
       });
       for await (const part of result.stream) {
@@ -1752,9 +1801,13 @@ function createRunExecutor(dependencies) {
           });
           step += 1;
         } else if (part.type === "finish" && part.finishReason !== "stop") {
-          terminalReason = "policy_stop";
+          if (terminalReason === "success") {
+            terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
+            internalCause ??= { finishReason: part.finishReason };
+          }
         }
         if (part.type === "finish") {
+          sawProviderFinish = true;
           usage = mergeRunTotals(normalizeSdkUsage(part.totalUsage), usage);
         }
         if (eventCount % checkpointEveryEvents === 0)
@@ -1822,7 +1875,8 @@ function createRunExecutor(dependencies) {
           run,
           assistant,
           reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName }
+          ...terminalPolicyName && { policyName: terminalPolicyName },
+          usage: spent
         },
         now
       });
@@ -1840,7 +1894,7 @@ function createRunExecutor(dependencies) {
     terminalReason = terminal.reason;
     terminalPolicyName = terminal.policyName;
     const terminalMetrics = terminal.committedByCaller ? {
-      partial: false,
+      partial: !sawProviderFinish,
       durationMs: performance.now() - runStartedAt,
       usage: spent,
       ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
@@ -1898,6 +1952,9 @@ function createAgentRuntime(config) {
   if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
     throw new TypeError("idleTimeoutMs must be a positive safe integer");
   }
+  const absorbable = new Set;
+  const absorbedInto = new Map;
+  const runResults = new Map;
   const policyNames = new Set(["max-steps"]);
   for (const policy of config.loop?.stopPolicies ?? []) {
     if (!policy.name || policyNames.has(policy.name)) {
@@ -2030,7 +2087,8 @@ function createAgentRuntime(config) {
       if (existingTicket)
         return existingTicket;
       const key = config.runs?.key?.(input) ?? input.conversationId;
-      const policy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
+      const declaredPolicy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
+      const policy = declaredPolicy === "inject" ? "queue" : declaredPolicy;
       const nowIso = now().toISOString();
       const inputMessageId = rawInput.recordIds?.inputMessageId ?? generateId();
       const runId = rawInput.recordIds?.runId ?? generateId();
@@ -2156,6 +2214,8 @@ function createAgentRuntime(config) {
             state: acceptedRun.state,
             emittedAt: now().toISOString()
           });
+          if (declaredPolicy === "inject")
+            absorbable.add(acceptedRun.id);
           outerAccepted.resolve();
           if (acceptance.outcome === "duplicate") {
             if (!acceptedRun.terminalReason) {
@@ -2204,7 +2264,25 @@ function createAgentRuntime(config) {
                 await waitForAdmissionAcceptances(reservation.lane);
               return {
                 runId: acceptedRun.id,
-                execute: () => executeRun({ acceptedRun, context, signal })
+                execute: () => {
+                  const answeredBy = absorbedInto.get(acceptedRun.id);
+                  const answer = answeredBy ? runResults.get(answeredBy) : undefined;
+                  if (answer)
+                    return answer;
+                  const running = executeRun({
+                    acceptedRun,
+                    context,
+                    signal,
+                    absorbable,
+                    onAbsorbed: (absorbedRunId) => {
+                      absorbedInto.set(absorbedRunId, acceptedRun.id);
+                    }
+                  });
+                  runResults.set(acceptedRun.id, running);
+                  return running.finally(() => {
+                    absorbable.delete(acceptedRun.id);
+                  });
+                }
               };
             }
           });
@@ -2437,7 +2515,8 @@ var CheckpointRunAssistantSchema = z6.object({
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema
+  assistant: AgentMessageSchema,
+  usage: AgentUsageSchema.optional()
 });
 var CommitRunTerminalSchema = z6.object({
   conversationId: AgentRecordIdSchema,
@@ -2447,7 +2526,17 @@ var CommitRunTerminalSchema = z6.object({
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z6.string().min(1).optional()
+  policyName: z6.string().min(1).optional(),
+  usage: AgentUsageSchema.optional()
+});
+var AbsorbQueuedRunSchema = z6.object({
+  conversationId: AgentRecordIdSchema,
+  runningRunId: AgentRecordIdSchema,
+  runningExpectedRevision: AgentRecordVersionSchema,
+  ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  queuedRunId: AgentRecordIdSchema,
+  queuedExpectedRevision: AgentRecordVersionSchema
 });
 var RequestRunInterruptSchema = z6.object({
   conversationId: AgentRecordIdSchema,
@@ -2593,8 +2682,9 @@ function conflict(actualVersion) {
   return { outcome: "conflict", actualVersion };
 }
 function terminalState(reason) {
-  if (reason === "success" || reason === "policy_stop")
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
     return "completed";
+  }
   if (reason === "interrupted")
     return "interrupted";
   if (reason === "superseded")
@@ -2616,6 +2706,7 @@ function applied(current, input, effects) {
       messages: input.messages ?? current.messages
     }),
     ...effects?.runRecord && { runRecord: effects.runRecord },
+    ...effects?.secondaryRunRecord && { secondaryRunRecord: effects.secondaryRunRecord },
     ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
     ...effects?.historyMutation && { historyMutation: effects.historyMutation }
   };
@@ -2659,6 +2750,39 @@ function reduceStore(current, operation) {
       historyMutation: { type: "admit", input: input.input }
     });
   }
+  if (operation.type === "absorb") {
+    const input = operation.input;
+    if (current.conversationId !== input.conversationId)
+      return { outcome: "not_found" };
+    const running = current.runs.find((candidate) => candidate.id === input.runningRunId);
+    const queued = current.runs.find((candidate) => candidate.id === input.queuedRunId);
+    if (!running || !queued)
+      return { outcome: "not_found" };
+    if (running.revision !== input.runningExpectedRevision || running.state !== "running" || running.ownerId !== input.ownerId || input.fencingToken !== undefined && running.fencingToken !== input.fencingToken) {
+      return conflict(running.revision);
+    }
+    if (queued.revision !== input.queuedExpectedRevision || queued.state !== "queued" || queued.ownerId !== undefined || queued.terminalReason !== undefined || queued.id === running.id) {
+      return conflict(queued.revision);
+    }
+    const stamp = new Date().toISOString();
+    const grown = AgentRunSchema.parse({
+      ...running,
+      inputMessageIds: [...running.inputMessageIds, ...queued.inputMessageIds],
+      revision: running.revision + 1,
+      updatedAt: stamp
+    });
+    const emptied = AgentRunSchema.parse({
+      ...queued,
+      state: "absorbed",
+      absorbedIntoRunId: running.id,
+      revision: queued.revision + 1,
+      updatedAt: stamp
+    });
+    return applied(current, { runs: replaceRun(replaceRun(current.runs, grown), emptied) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: grown }),
+      secondaryRunRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: emptied })
+    });
+  }
   const conversationId = operation.input.conversationId;
   const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
   if (operation.type !== "compact" && !run)
@@ -2688,6 +2812,7 @@ function reduceStore(current, operation) {
     }
     const next = AgentRunSchema.parse({
       ...run,
+      ...input.usage && { usage: input.usage },
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
@@ -2774,6 +2899,7 @@ function reduceStore(current, operation) {
       state: terminalState(input.reason),
       terminalReason: input.reason,
       ...input.policyName && { terminalPolicyName: input.policyName },
+      ...input.usage && { usage: input.usage },
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
@@ -2862,7 +2988,7 @@ function createAgentRuntimeStore(driver) {
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
-    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
+    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.type === "absorb" ? operation.input.queuedRunId : operation.input.runId;
     const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
       driver.head.load(transaction, conversationId),
       driver.history.load(transaction, conversationId),
@@ -2943,6 +3069,9 @@ function createAgentRuntimeStore(driver) {
       return conflict(outcome.actualVersion);
     if (reduced.runRecord)
       await driver.runs.save(transaction, reduced.runRecord);
+    if (reduced.secondaryRunRecord) {
+      await driver.runs.save(transaction, reduced.secondaryRunRecord);
+    }
     if (reduced.admissionReceipt) {
       await driver.admissions.create(transaction, reduced.admissionReceipt);
     }
@@ -2966,6 +3095,7 @@ function createAgentRuntimeStore(driver) {
       type: "interrupt",
       input: RequestRunInterruptSchema.parse(input)
     }),
+    absorbQueuedRun: (input) => mutate({ type: "absorb", input: AbsorbQueuedRunSchema.parse(input) }),
     recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
     commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.parse(input) }),
     replaceCompactedRange: (input) => mutate({
@@ -3138,6 +3268,7 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 export {
+  AbsorbQueuedRunSchema,
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,

package/dist/{index-58vkx74h.js → index-b1k33127.js}

@@ -99,6 +99,7 @@ var AgentRunStateSchema = z.enum([
   "completed",
   "interrupted",
   "superseded",
+  "absorbed",
   "failed",
   "cancelled",
   "abandoned"
@@ -106,6 +107,7 @@ var AgentRunStateSchema = z.enum([
 var AgentTerminalReasonSchema = z.enum([
   "success",
   "policy_stop",
+  "provider_stop",
   "interrupted",
   "superseded",
   "cancelled",
@@ -115,6 +117,23 @@ var AgentTerminalReasonSchema = z.enum([
   "tool_failure",
   "abandoned"
 ]);
+var AgentUsageValueSchema = z.object({
+  value: z.number().nonnegative().optional(),
+  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+});
+var AgentCostValueSchema = z.object({
+  value: z.number().nonnegative().optional(),
+  currency: z.string().length(3).optional(),
+  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+});
+var AgentUsageSchema = z.object({
+  inputTokens: AgentUsageValueSchema,
+  outputTokens: AgentUsageValueSchema,
+  reasoningTokens: AgentUsageValueSchema.optional(),
+  cacheReadTokens: AgentUsageValueSchema.optional(),
+  cacheWriteTokens: AgentUsageValueSchema.optional(),
+  cost: AgentCostValueSchema.optional()
+});
 var AgentRunSchema = z.object({
   schemaVersion: z.literal(1),
   id: AgentRecordIdSchema,
@@ -127,6 +146,8 @@ var AgentRunSchema = z.object({
   fencingToken: AgentRecordVersionSchema.optional(),
   terminalReason: AgentTerminalReasonSchema.optional(),
   terminalPolicyName: z.string().min(1).optional(),
+  absorbedIntoRunId: AgentRecordIdSchema.optional(),
+  usage: AgentUsageSchema.optional(),
   createdAt: AgentTimestampSchema,
   updatedAt: AgentTimestampSchema
 });
@@ -137,23 +158,6 @@ var AgentSnapshotSchema = z.object({
   messages: z.array(AgentMessageSchema),
   runs: z.array(AgentRunSchema)
 });
-var AgentUsageValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
-});
-var AgentCostValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  currency: z.string().length(3).optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
-});
-var AgentUsageSchema = z.object({
-  inputTokens: AgentUsageValueSchema,
-  outputTokens: AgentUsageValueSchema,
-  reasoningTokens: AgentUsageValueSchema.optional(),
-  cacheReadTokens: AgentUsageValueSchema.optional(),
-  cacheWriteTokens: AgentUsageValueSchema.optional(),
-  cost: AgentCostValueSchema.optional()
-});
 var AgentRunMetricsSchema = z.object({
   partial: z.boolean(),
   usage: AgentUsageSchema.optional(),
@@ -161,4 +165,4 @@ var AgentRunMetricsSchema = z.object({
   ttftMs: z.number().nonnegative().optional()
 });
 
-export { AgentRecordIdSchema, AgentRecordVersionSchema, AgentTimestampSchema, AgentJsonObjectSchema, AgentProviderEnvelopeSchema, AgentTextPartSchema, AgentReasoningPartSchema, AgentFilePartSchema, AgentSourcePartSchema, AgentToolCallPartSchema, AgentToolResultPartSchema, AgentOpaquePartSchema, AgentControlPartSchema, AgentMessagePartSchema, AgentMessageRoleSchema, AgentMessageStatusSchema, AgentMessageSchema, AgentAssistantPlaceholderSchema, AgentRunStateSchema, AgentTerminalReasonSchema, AgentRunSchema, AgentSnapshotSchema, AgentUsageValueSchema, AgentCostValueSchema, AgentUsageSchema, AgentRunMetricsSchema };
+export { AgentRecordIdSchema, AgentRecordVersionSchema, AgentTimestampSchema, AgentJsonObjectSchema, AgentProviderEnvelopeSchema, AgentTextPartSchema, AgentReasoningPartSchema, AgentFilePartSchema, AgentSourcePartSchema, AgentToolCallPartSchema, AgentToolResultPartSchema, AgentOpaquePartSchema, AgentControlPartSchema, AgentMessagePartSchema, AgentMessageRoleSchema, AgentMessageStatusSchema, AgentMessageSchema, AgentAssistantPlaceholderSchema, AgentRunStateSchema, AgentTerminalReasonSchema, AgentUsageValueSchema, AgentCostValueSchema, AgentUsageSchema, AgentRunSchema, AgentSnapshotSchema, AgentRunMetricsSchema };

package/dist/testing/agent-store-conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,WAAW,2BAA2B;IAC1C,WAAW,IAAI,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC/D;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CAmRf"}
+{"version":3,"file":"agent-store-conformance.d.ts","sourceRoot":"","sources":["../../src/testing/agent-store-conformance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,WAAW,2BAA2B;IAC1C,WAAW,IAAI,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC/D;AAwCD,gFAAgF;AAChF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,IAAI,CAAC,CA4Sf"}

package/dist/testing.js

@@ -1,7 +1,7 @@
 import {
   AgentMessageSchema,
   AgentRunSchema
-} from "./index-58vkx74h.js";
+} from "./index-b1k33127.js";
 import {
   createApplication
 } from "./index-eabpd4tb.js";
@@ -283,12 +283,20 @@ async function runAgentStoreConformance(config) {
       parts: [{ type: "text", text: "checkpoint" }],
       createdAt: "2026-08-22T00:00:00.000Z",
       updatedAt: "2026-08-22T00:00:01.000Z"
-    })
+    }),
+    usage: {
+      inputTokens: { value: 1000, provenance: "provider-reported" },
+      outputTokens: { value: 100, provenance: "provider-reported" },
+      cost: { value: 0.25, currency: "USD", provenance: "provider-reported" }
+    }
   });
   requireOutcome(checkpoint, "applied");
   const checkpointedRun = checkpoint.snapshot.runs.find((run) => run.id === running.id);
   if (!checkpointedRun)
     throw new Error("Checkpointed run disappeared");
+  if (checkpointedRun.usage?.cost?.value !== 0.25) {
+    throw new Error("Checkpoint did not persist the run usage it was given");
+  }
   const terminalAssistant = AgentMessageSchema.parse({
     schemaVersion: 1,
     id: running.assistantMessageId,
@@ -307,7 +315,12 @@ async function runAgentStoreConformance(config) {
       expectedRevision: checkpointedRun.revision,
       ownerId: "conformance-owner",
       assistant: terminalAssistant,
-      reason: "success"
+      reason: "success",
+      usage: {
+        inputTokens: { value: 3000, provenance: "computed" },
+        outputTokens: { value: 300, provenance: "computed" },
+        cost: { value: 1.5, currency: "USD", provenance: "computed" }
+      }
     }),
     store.commitRunTerminal({
       conversationId,
@@ -315,7 +328,12 @@ async function runAgentStoreConformance(config) {
       expectedRevision: checkpointedRun.revision,
       ownerId: "conformance-owner",
       assistant: terminalAssistant,
-      reason: "success"
+      reason: "success",
+      usage: {
+        inputTokens: { value: 3000, provenance: "computed" },
+        outputTokens: { value: 300, provenance: "computed" },
+        cost: { value: 1.5, currency: "USD", provenance: "computed" }
+      }
     })
   ]);
   const terminalOutcomes = terminalResults.map((result) => result.outcome).sort();
@@ -326,6 +344,10 @@ async function runAgentStoreConformance(config) {
   if (terminalApplied?.outcome !== "applied") {
     throw new Error("Terminal race produced no applied result");
   }
+  const settledRun = terminalApplied.snapshot.runs.find((run) => run.id === running.id);
+  if (settledRun?.usage?.cost?.value !== 1.5) {
+    throw new Error("Terminal commit did not persist the run usage it was given");
+  }
   const compactedTerminal = await store.replaceCompactedRange({
     conversationId,
     expectedVersion: terminalApplied.snapshot.version,