stitchkit 0.62.0 → 0.64.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":"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"}

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

@@ -4,13 +4,13 @@ export { AgentAdmissionEventSchema, AgentCheckpointEventSchema, AgentReasoningDe
 export { type AgentHistoryProjectionDecision, type AgentHistoryProjectionOptions, type AgentHistoryProjectionResult, projectAgentHistory, projectAgentHistoryDetailed, } from './agent-runtime/history';
 export { type AgentToolFenceConfig, type AgentToolFenceContext, createAgentToolFenceLifecycle, } from './agent-runtime/managed-tools';
 export { type AgentLanguageModelProvider, type AgentModelCapability, AgentModelCapabilitySchema, type AgentModelDescriptor, AgentModelDescriptorSchema, type AgentModelRegistry, type AgentModelRegistryConfig, type AgentModelRegistrySnapshot, AgentModelRegistrySnapshotSchema, type AgentModelSnapshotPolicy, type AgentResolvedModel, defineModelRegistry, validateAgentModelSnapshot, } from './agent-runtime/models';
-export { type AgentObservability, type AgentRunEvent, AgentRunEventSchema, type AgentRunSinkConfig, type AgentRunSinkDrop, type AgentRunSinkError, createAgentObservability, } from './agent-runtime/observability';
+export { type AgentObservability, type AgentRunEvent, AgentRunEventSchema, type AgentRunSinkConfig, type AgentRunSinkDrop, type AgentRunSinkError, type AgentRunStartedEvent, AgentRunStartedEventSchema, type AgentRunTerminalEvent, AgentRunTerminalEventSchema, type AgentStepFinishedEvent, AgentStepFinishedEventSchema, createAgentObservability, } from './agent-runtime/observability';
 export { type AgentHistoryBudgetDecision, type AgentHistoryBudgetResult, type AgentPromptBudget, type AgentPromptSection, type AgentPromptSectionContext, type AgentTokenCount, AgentTokenCountSchema, type ComposeAgentPromptOptions, type ComposedAgentPrompt, composeAgentPrompt, type SelectAgentHistoryOptions, selectAgentHistory, } from './agent-runtime/prompt';
 export { type AgentProtocol, type AgentProtocolConfig, defineAgentProtocol, } from './agent-runtime/protocol';
 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") {
@@ -757,26 +758,41 @@ function validateAgentModelSnapshot(input, policy) {
 }
 // src/agent-runtime/observability.ts
 import { z as z3 } from "zod";
-var AgentRunEventSchema = z3.object({
+var AgentRunEventBaseSchema = z3.object({
   schemaVersion: z3.literal(1),
   eventId: AgentRecordIdSchema,
-  type: z3.enum(["run-started", "step-finished", "run-terminal"]),
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   traceId: z3.string().min(1),
   spanId: z3.string().min(1),
   parentSpanId: z3.string().min(1).optional(),
   state: AgentRunStateSchema,
-  terminalReason: AgentTerminalReasonSchema.optional(),
   modelId: z3.string().min(1).optional(),
-  step: z3.int().nonnegative().optional(),
-  queueWaitMs: z3.number().nonnegative().optional(),
   durationMs: z3.number().nonnegative().optional(),
+  emittedAt: AgentTimestampSchema
+});
+var AgentRunStartedEventSchema = AgentRunEventBaseSchema.extend({
+  type: z3.literal("run-started"),
+  queueWaitMs: z3.number().nonnegative().optional()
+});
+var AgentStepFinishedEventSchema = AgentRunEventBaseSchema.extend({
+  type: z3.literal("step-finished"),
+  step: z3.int().nonnegative(),
+  ttftMs: z3.number().nonnegative().optional(),
+  usage: AgentUsageSchema
+});
+var AgentRunTerminalEventSchema = AgentRunEventBaseSchema.extend({
+  type: z3.literal("run-terminal"),
+  terminalReason: AgentTerminalReasonSchema,
   ttftMs: z3.number().nonnegative().optional(),
-  usage: AgentUsageSchema.optional(),
   internalCause: z3.unknown().optional(),
-  emittedAt: AgentTimestampSchema
+  usage: AgentUsageSchema
 });
+var AgentRunEventSchema = z3.discriminatedUnion("type", [
+  AgentRunStartedEventSchema,
+  AgentStepFinishedEventSchema,
+  AgentRunTerminalEventSchema
+]);
 function createAgentObservability(config) {
   const manager = createBoundedSinkManager({
     write: config.write,
@@ -807,7 +823,13 @@ function createAgentObservability(config) {
       if ((config.deduplicate ?? true) && emitted.has(parsed.eventId))
         return;
       remember(parsed.eventId);
-      manager.submit(() => config.includeInternalCause ? parsed : AgentRunEventSchema.omit({ internalCause: true }).parse(parsed));
+      manager.submit(() => {
+        if (config.includeInternalCause)
+          return parsed;
+        if (parsed.type !== "run-terminal")
+          return parsed;
+        return AgentRunTerminalEventSchema.omit({ internalCause: true }).parse(parsed);
+      });
     },
     flush: () => manager.flush(),
     getStatus: () => manager.getStatus(),
@@ -1058,7 +1080,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 +1114,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 +1152,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 +1392,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 +1435,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 +1465,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 +1515,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 +1523,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 +1586,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 +1822,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 +1896,8 @@ function createRunExecutor(dependencies) {
           run,
           assistant,
           reason: terminalReason,
-          ...terminalPolicyName && { policyName: terminalPolicyName }
+          ...terminalPolicyName && { policyName: terminalPolicyName },
+          usage: spent
         },
         now
       });
@@ -1840,7 +1915,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 +1973,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 +2108,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 +2235,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 +2285,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 +2536,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 +2547,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 +2703,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 +2727,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 +2771,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 +2833,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 +2920,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 +3009,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 +3090,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 +3116,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 +3289,7 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 export {
+  AbsorbQueuedRunSchema,
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,
@@ -3169,14 +3321,17 @@ export {
   AgentRunEventSchema,
   AgentRunMetricsSchema,
   AgentRunSchema,
+  AgentRunStartedEventSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
+  AgentRunTerminalEventSchema,
   AgentRuntimeConflictError,
   AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
   AgentRuntimeHeadSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
+  AgentStepFinishedEventSchema,
   AgentStoreAppliedSchema,
   AgentStoreConflictSchema,
   AgentStoreDuplicateSchema,