stitchkit 0.56.4 → 0.57.0

package/dist/index-1f4fcj0b.js

@@ -0,0 +1,160 @@
+// src/agent-runtime/schemas.ts
+import { z } from "zod";
+var AgentRecordIdSchema = z.string().min(1);
+var AgentRecordVersionSchema = z.int().nonnegative();
+var AgentTimestampSchema = z.iso.datetime({ offset: true });
+var AgentJsonObjectSchema = z.record(z.string(), z.json());
+var AgentProviderEnvelopeSchema = z.object({
+  schemaVersion: z.int().positive(),
+  provider: z.string().min(1),
+  data: AgentJsonObjectSchema
+});
+var AgentTextPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+var AgentReasoningPartSchema = z.object({
+  type: z.literal("reasoning"),
+  text: z.string(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentFilePartSchema = z.object({
+  type: z.literal("file"),
+  mediaType: z.string().min(1),
+  reference: z.string().min(1),
+  filename: z.string().min(1).optional()
+});
+var AgentSourcePartSchema = z.object({
+  type: z.literal("source"),
+  sourceId: z.string().min(1),
+  url: z.url().optional(),
+  title: z.string().optional()
+});
+var AgentToolCallPartSchema = z.object({
+  type: z.literal("tool-call"),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  input: z.json(),
+  provider: AgentProviderEnvelopeSchema.optional()
+});
+var AgentToolResultPartSchema = z.object({
+  type: z.literal("tool-result"),
+  callId: z.string().min(1),
+  toolName: z.string().min(1),
+  outcome: z.enum(["success", "error", "interrupted"]),
+  output: z.json().optional()
+});
+var AgentOpaquePartSchema = z.object({
+  type: z.literal("provider"),
+  envelope: AgentProviderEnvelopeSchema
+});
+var AgentControlPartSchema = z.object({
+  type: z.literal("control"),
+  reason: z.enum(["run-interrupted", "stale-run"])
+});
+var AgentMessagePartSchema = z.discriminatedUnion("type", [
+  AgentTextPartSchema,
+  AgentReasoningPartSchema,
+  AgentFilePartSchema,
+  AgentSourcePartSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentOpaquePartSchema,
+  AgentControlPartSchema
+]);
+var AgentMessageRoleSchema = z.enum(["user", "assistant", "system", "summary"]);
+var AgentMessageStatusSchema = z.enum([
+  "committed",
+  "streaming",
+  "completed",
+  "interrupted",
+  "failed"
+]);
+var AgentMessageSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema.optional(),
+  role: AgentMessageRoleSchema,
+  status: AgentMessageStatusSchema,
+  parts: z.array(AgentMessagePartSchema),
+  metadata: AgentJsonObjectSchema.optional(),
+  createdAt: AgentTimestampSchema,
+  updatedAt: AgentTimestampSchema
+});
+var AgentAssistantPlaceholderSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  status: z.literal("pending"),
+  createdAt: AgentTimestampSchema,
+  updatedAt: AgentTimestampSchema
+});
+var AgentRunStateSchema = z.enum([
+  "queued",
+  "running",
+  "interrupt_requested",
+  "completed",
+  "interrupted",
+  "failed",
+  "cancelled",
+  "abandoned"
+]);
+var AgentTerminalReasonSchema = z.enum([
+  "success",
+  "policy_stop",
+  "interrupted",
+  "cancelled",
+  "timeout",
+  "shutdown",
+  "provider_failure",
+  "tool_failure",
+  "abandoned"
+]);
+var AgentRunSchema = z.object({
+  schemaVersion: z.literal(1),
+  id: AgentRecordIdSchema,
+  conversationId: AgentRecordIdSchema,
+  inputMessageIds: z.array(AgentRecordIdSchema).min(1),
+  assistantMessageId: AgentRecordIdSchema,
+  state: AgentRunStateSchema,
+  revision: AgentRecordVersionSchema,
+  ownerId: z.string().min(1).optional(),
+  terminalReason: AgentTerminalReasonSchema.optional(),
+  terminalPolicyName: z.string().min(1).optional(),
+  createdAt: AgentTimestampSchema,
+  updatedAt: AgentTimestampSchema
+});
+var AgentSnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema,
+  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(),
+  durationMs: z.number().nonnegative().optional(),
+  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 };

package/dist/server/error-hook.d.ts

@@ -5,7 +5,8 @@
  * Every project writes the same `onError`: turn a thrown value into one wire
  * shape, mapping stitchkit's own error codes to the app's public codes. The map
  * is partial — list the codes you have an opinion about, and an unlisted one
- * travels as itself, exactly like a code the project threw on its own. A
+ * travels as itself unless `unmappedCode` supplies one declarative fallback.
+ * Codes the project throws on its own always pass through unchanged. A
  * project whose envelope is a published contract adds `satisfies
  * Record<StitchErrorCode, …>` to its own map and buys the stricter deal: a code
  * added by a later release then breaks the build instead of reaching the wire
@@ -58,6 +59,12 @@ export interface ErrorHookConfig<TWireCode extends string = string> {
      * error here. Codes you threw yourself (not stitchkit's) pass through as-is.
      */
     codeMap?: Partial<Record<StitchErrorCode, TWireCode>>;
+    /**
+     * Wire code for every unmapped stitchkit code, or a resolver for grouping
+     * them. Explicit `codeMap` entries win. Project-owned codes never use this
+     * fallback and continue to pass through unchanged.
+     */
+    unmappedCode?: TWireCode | ((code: StitchErrorCode) => TWireCode);
     /** Build the response body from the resolved error. */
     /**
      * Build the response body from the resolved error. `ctx` is the request's

package/dist/server/error-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-hook.d.ts","sourceRoot":"","sources":["../../src/server/error-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,+FAA+F;IAC/F,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe,CAAC,SAAS,SAAS,MAAM,GAAG,MAAM;IAChE;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC;IACtD,uDAAuD;IACvD;;;;;OAKG;IACH,MAAM,EAAE,CACN,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,cAAc,EACnB,QAAQ,CAAC,EAAE,SAAS,KACjB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CACR,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,cAAc,EACnB,QAAQ,CAAC,EAAE,SAAS,KACjB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,SAAS,SAAS,MAAM,GAAG,MAAM,EAC/D,MAAM,EAAE,eAAe,CAAC,SAAS,CAAC,GACjC,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAgCxC"}
+{"version":3,"file":"error-hook.d.ts","sourceRoot":"","sources":["../../src/server/error-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,+FAA+F;IAC/F,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe,CAAC,SAAS,SAAS,MAAM,GAAG,MAAM;IAChE;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,CAAC;IACtD;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,eAAe,KAAK,SAAS,CAAC,CAAC;IAClE,uDAAuD;IACvD;;;;;OAKG;IACH,MAAM,EAAE,CACN,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,cAAc,EACnB,QAAQ,CAAC,EAAE,SAAS,KACjB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CACR,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,cAAc,EACnB,QAAQ,CAAC,EAAE,SAAS,KACjB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACjC;AAED,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,SAAS,SAAS,MAAM,GAAG,MAAM,EAC/D,MAAM,EAAE,eAAe,CAAC,SAAS,CAAC,GACjC,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAkCxC"}

package/dist/server/index.js

@@ -351,8 +351,10 @@ function cacheHeaders(maxAge, scope = "public") {
 function createErrorHook(config) {
   return async (ctx, error, endpoint) => {
     const appErr = normalizeError(error);
-    const mapped = config.codeMap && isStitchErrorCode(appErr.code) ? config.codeMap[appErr.code] : undefined;
-    const code = mapped ?? appErr.code;
+    const stitchCode = isStitchErrorCode(appErr.code) ? appErr.code : undefined;
+    const mapped = stitchCode === undefined ? undefined : config.codeMap?.[stitchCode];
+    const fallback = mapped === undefined && stitchCode !== undefined ? typeof config.unmappedCode === "function" ? config.unmappedCode(stitchCode) : config.unmappedCode : undefined;
+    const code = mapped ?? fallback ?? appErr.code;
     const info = {
       code,
       status: appErr.status,

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

@@ -0,0 +1,7 @@
+import type { AgentRuntimeStore } from '../agent-runtime/store';
+export interface AgentStoreConformanceConfig {
+    createStore(): AgentRuntimeStore | Promise<AgentRuntimeStore>;
+}
+/** Black-box contract shared by memory and third-party durable agent stores. */
+export declare function runAgentStoreConformance(config: AgentStoreConformanceConfig): Promise<void>;
+//# sourceMappingURL=agent-store-conformance.d.ts.map

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

@@ -0,0 +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,CAuJf"}

package/dist/testing.d.ts

@@ -31,6 +31,7 @@ export declare function createHandlerTestClient<T extends Record<string, Endpoin
 export declare function createHandlerTestClients<T extends Record<string, ContractDef<Record<string, EndpointDef>, string>>, TServer = unknown, const K extends string = never>(config: HandlerTestClientsConfig<T, TServer, K>): {
     [P in keyof T]: ScopedHttpClient<T[P]['endpoints'], ScopedKeys<K>>;
 };
+export { type AgentStoreConformanceConfig, runAgentStoreConformance, } from './testing/agent-store-conformance';
 export { assertSurfaceDiscovery, type ConformanceTransport, type CreateRealtimeProbeDriverConfig, createRealtimeProbeDriver, type DefineRealtimeProbeConfig, defineRealtimeProbe, type RealtimeDisconnectObservation, RealtimeDisconnectObservationSchema, type RealtimeProbeAdapter, type RealtimeProbeFixture, type RealtimeProbeScenario, type RealtimeRejectionObservation, RealtimeRejectionObservationSchema, type RunSurfaceProbesConfig, runSurfaceProbes, type SurfaceDiscoveryObservation, type SurfaceProbe, type SurfaceProbeDriver, type SurfaceRealtimeDiscoveryObservation, type SurfaceToolDiscoveryObservation, type TransportObservation, TransportObservationSchema, } from './testing/surface-conformance';
 export { assertSurfaceManifestSnapshot, buildSurfaceManifest, type IncompatibleSchemaPolicy, type McpSchemaValidationConfig, type SurfaceAgentProjection, type SurfaceManifest, type SurfaceManifestConfig, type SurfaceManifestExtension, SurfaceManifestExtensionSchema, type SurfaceManifestOperation, SurfaceManifestOperationSchema, type SurfaceManifestRealtimeEvent, SurfaceManifestRealtimeEventSchema, SurfaceManifestSchema, type SurfaceManifestTool, SurfaceManifestToolSchema, type SurfaceManifestToolSurface, SurfaceManifestToolSurfaceSchema, type SurfaceMcpPreparation, SurfaceRealtimeSchemaPairSchema, type SurfaceRuntimeToolDefinition, SurfaceSchemaDigestsSchema, type SurfaceToolDefinition, type SurfaceToolExtension, serializeSurfaceValue, } from './testing/surface-manifest';
 //# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

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

package/dist/testing.js

@@ -1,3 +1,7 @@
+import {
+  AgentMessageSchema,
+  AgentRunSchema
+} from "./index-1f4fcj0b.js";
 import {
   RealtimeRequestDisconnectedError,
   RealtimeRequestInvalidAcknowledgementError,
@@ -23,6 +27,167 @@ import {
 } from "./index-smpbdg6k.js";
 import"./index-1bx83sw4.js";
 
+// src/testing/agent-store-conformance.ts
+function userMessage(conversationId, id) {
+  return AgentMessageSchema.parse({
+    schemaVersion: 1,
+    id,
+    conversationId,
+    role: "user",
+    status: "committed",
+    parts: [{ type: "text", text: id }],
+    createdAt: "2026-08-22T00:00:00.000Z",
+    updatedAt: "2026-08-22T00:00:00.000Z"
+  });
+}
+function queuedRun(conversationId, inputMessageId, id) {
+  return AgentRunSchema.parse({
+    schemaVersion: 1,
+    id,
+    conversationId,
+    inputMessageIds: [inputMessageId],
+    assistantMessageId: `${id}-assistant`,
+    state: "queued",
+    revision: 0,
+    createdAt: "2026-08-22T00:00:00.000Z",
+    updatedAt: "2026-08-22T00:00:00.000Z"
+  });
+}
+function requireOutcome(actual, expected) {
+  if (actual.outcome !== expected) {
+    throw new Error(`Agent store conformance expected ${expected}, received ${actual.outcome}`);
+  }
+}
+async function runAgentStoreConformance(config) {
+  const store = await config.createStore();
+  const conversationId = `conformance-${crypto.randomUUID()}`;
+  const firstInput = userMessage(conversationId, "input-1");
+  const firstRun = queuedRun(conversationId, firstInput.id, "run-1");
+  const accepted = await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-1",
+    input: firstInput,
+    run: firstRun
+  });
+  requireOutcome(accepted, "applied");
+  const duplicate = await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-1",
+    input: userMessage(conversationId, "discarded-input"),
+    run: queuedRun(conversationId, "discarded-input", "discarded-run")
+  });
+  requireOutcome(duplicate, "duplicate");
+  if (duplicate.input.id !== firstInput.id || duplicate.inputMessageId !== firstInput.id || duplicate.runId !== firstRun.id || duplicate.assistantMessageId !== firstRun.assistantMessageId) {
+    throw new Error("Duplicate admission did not return its original durable identity");
+  }
+  const secondInput = userMessage(conversationId, "input-2");
+  const coalesced = await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-2",
+    input: secondInput,
+    run: queuedRun(conversationId, secondInput.id, "discarded-coalesced-run"),
+    coalesceIntoRunId: firstRun.id
+  });
+  requireOutcome(coalesced, "applied");
+  const assigned = coalesced.snapshot.runs.find((run) => run.id === firstRun.id);
+  if (assigned?.inputMessageIds.join(",") !== "input-1,input-2") {
+    throw new Error("Coalesced admission did not preserve ordered input identities");
+  }
+  const collidingInput = userMessage(conversationId, assigned.assistantMessageId);
+  await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-collision",
+    input: collidingInput,
+    run: queuedRun(conversationId, collidingInput.id, "discarded-collision-run"),
+    coalesceIntoRunId: assigned.id
+  }).then(() => {
+    throw new Error("Coalesced input reused the reserved assistant identity");
+  }, (error) => {
+    if (!(error instanceof TypeError))
+      throw error;
+  });
+  await store.replaceCompactedRange({
+    conversationId,
+    expectedVersion: coalesced.snapshot.version,
+    replacedMessageIds: [firstInput.id, secondInput.id],
+    summary: AgentMessageSchema.parse({
+      schemaVersion: 1,
+      id: assigned.assistantMessageId,
+      conversationId,
+      role: "summary",
+      status: "committed",
+      parts: [{ type: "text", text: "invalid reserved identity" }],
+      createdAt: "2026-08-22T00:00:02.000Z",
+      updatedAt: "2026-08-22T00:00:02.000Z"
+    })
+  }).then(() => {
+    throw new Error("Compaction reused a reserved assistant identity");
+  }, (error) => {
+    if (!(error instanceof TypeError))
+      throw error;
+  });
+  const compacted = await store.replaceCompactedRange({
+    conversationId,
+    expectedVersion: coalesced.snapshot.version,
+    replacedMessageIds: [firstInput.id, secondInput.id],
+    summary: AgentMessageSchema.parse({
+      schemaVersion: 1,
+      id: "summary-1",
+      conversationId,
+      role: "summary",
+      status: "committed",
+      parts: [{ type: "text", text: "two inputs" }],
+      createdAt: "2026-08-22T00:00:02.000Z",
+      updatedAt: "2026-08-22T00:00:02.000Z"
+    })
+  });
+  requireOutcome(compacted, "applied");
+  const duplicateAfterCompaction = await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-1",
+    input: userMessage(conversationId, "discarded-after-compaction"),
+    run: queuedRun(conversationId, "discarded-after-compaction", "discarded-run-2")
+  });
+  requireOutcome(duplicateAfterCompaction, "duplicate");
+  if (duplicateAfterCompaction.input.id !== firstInput.id) {
+    throw new Error("Compaction discarded the canonical duplicate admission input");
+  }
+  const acquired = await store.acquireRun({
+    conversationId,
+    runId: assigned.id,
+    expectedRevision: assigned.revision,
+    ownerId: "conformance-owner"
+  });
+  requireOutcome(acquired, "applied");
+  const running = acquired.snapshot.runs.find((run) => run.id === assigned.id);
+  if (!running)
+    throw new Error("Acquired run disappeared");
+  const stale = await store.checkpointRunAssistant({
+    conversationId,
+    runId: running.id,
+    expectedRevision: running.revision - 1,
+    ownerId: "conformance-owner",
+    assistant: AgentMessageSchema.parse({
+      schemaVersion: 1,
+      id: running.assistantMessageId,
+      conversationId,
+      runId: running.id,
+      role: "assistant",
+      status: "streaming",
+      parts: [],
+      createdAt: "2026-08-22T00:00:00.000Z",
+      updatedAt: "2026-08-22T00:00:01.000Z"
+    })
+  });
+  requireOutcome(stale, "conflict");
+  const abandoned = await store.recoverRun({
+    conversationId,
+    runId: running.id,
+    expectedRevision: running.revision,
+    action: "abandon"
+  });
+  requireOutcome(abandoned, "applied");
+  const terminalRun = abandoned.snapshot.runs.find((run) => run.id === running.id);
+  const terminalMessage = abandoned.snapshot.messages.find((message) => message.id === running.assistantMessageId);
+  if (terminalRun?.state !== "abandoned" || terminalMessage?.status !== "failed") {
+    throw new Error("Abandon recovery did not atomically terminalize its assistant record");
+  }
+}
 // src/testing/surface-conformance.ts
 import { z as z2 } from "zod";
 
@@ -744,6 +909,7 @@ export {
   createHandlerTestClients,
   createRealtimeProbeDriver,
   defineRealtimeProbe,
+  runAgentStoreConformance,
   runSurfaceProbes,
   serializeSurfaceValue
 };

package/llms-full.txt

@@ -3482,7 +3482,8 @@ const terminal = await ticket.result
 
 `recordIds` is optional. Supply stable application record IDs when an accepted-response transport must
 return durable placeholders before the run finishes. `ticket.admission` resolves after the store
-acceptance CAS and reports the actually assigned `runId`, `assistantMessageId` and snapshot version.
+acceptance CAS and reports the canonical committed `input`, assigned `run`, a typed `pending`
+assistant projection, compatibility IDs and snapshot version.
 Those assigned IDs can differ from the proposal when an input coalesces into an existing queued
 successor. Reuse the same `inputMessageId` for retries carrying the same idempotency key; input
 identity is caller-stable, while the receipt reports the run/assistant identities that assignment
@@ -3490,8 +3491,35 @@ may change. Await `admission` first on the immediate accepted-response path. `ti
 remains the signal-only compatibility surface and additionally waits for admission publication.
 
 The in-memory store is a reference adapter and has process-local durability
-only. Production applications implement `AgentRuntimeStore` with their own
-database transaction and, when needed, distributed lease/fencing token.
+only. Production applications normally call `createAgentRuntimeStore()` and
+provide one database transaction driver:
+
+```ts
+const store = createAgentRuntimeStore({
+  transaction: work => db.transaction(tx => work(tx)),
+  state: {
+    load: (tx, conversationId) => loadRuntimeState(tx, conversationId),
+    compareAndSwap: (tx, operation) => casRuntimeState(tx, operation),
+  },
+  history: {
+    load: (tx, conversationId) => loadCanonicalMessages(tx, conversationId),
+    loadById: (tx, identity) => loadActiveOrArchivedMessage(tx, identity),
+    apply: (tx, mutation) => applyCanonicalHistoryMutation(tx, mutation),
+  },
+  scanRecoverable: page => scanRecoverableRuns(page),
+})
+```
+
+The same opaque `tx` reaches state and history callbacks. The adapter maps rows
+and supplies atomicity; Stitchkit owns transition validation and revision
+arithmetic. The executable reference is
+[`examples/agent-store-prisma/adapter.ts`](../../examples/agent-store-prisma/adapter.ts).
+`compareAndSwap` returns either `{ outcome: 'applied' }` or
+`{ outcome: 'conflict', actualVersion }`; on a winning write it also persists the
+framework-provided `recoverable` descriptors in the same transaction. Recovery
+scans that bounded index instead of loading every aggregate. Compaction may hide
+rows from `history.load`, but `history.loadById` must retain canonical admitted
+inputs for durable duplicate receipts.
 
 ## Durable order
 
@@ -3533,8 +3561,8 @@ hatch.
 
 ## Store operations
 
-An adapter implements the aggregate `AgentRuntimeStore`, not separate message
-and run CRUD stores:
+`AgentRuntimeStore` remains the runtime-facing aggregate. Application adapters
+implement the smaller `AgentRuntimeStoreDriver`, not these eight transitions:
 
 - `acceptInputAndAssignRun`
 - `acquireRun`
@@ -3549,13 +3577,13 @@ Every mutation carries an expected run revision or snapshot version. Input
 assignment additionally carries an idempotency identity. A conflict is a
 control outcome; stale data is never silently overwritten.
 
-On startup, `scanRecoverable` returns queued/acquired records. `recoverRun`
-may abandon them, or requeue an already acquired run only with explicit
-`replaySafe: true` evidence. The framework never guesses that an external
-side effect is replayable. After an application reconstructs its typed context,
-`runtime.resume({ conversationId, runId, context })` admits that queued record
-through the same acquisition CAS and coordinator lane; it never creates a
-second input message.
+On startup, `runtime.recover({ resolveContext })` consumes bounded lightweight
+pages. Its safe default resumes queued runs and reports acquired or
+`interrupt_requested` runs as skipped. A policy may requeue acquired work only
+with explicit replay-safe evidence, or abandon it only with stale-owner
+evidence. Each attempted run returns its own outcome/error; `pageSize`,
+`maxRuns`, and `signal` bound the pass. `runtime.resume(...)` remains available
+for one known queued record.
 
 Canonical records currently write `schemaVersion: 1`. A durable adapter owns
 read-time migration of older rows: migrate to the current shape at its storage
@@ -3567,14 +3595,24 @@ or silently accept an unknown future version.
 
 `publish` receives event classes with different guarantees:
 
+- `admission` follows a successful acceptance CAS and carries the same complete
+  projection as `ticket.admission`;
+
 - `assistant-delta` is transient and ordered by
   `(runId, runtimeEpoch, sequence)`;
+- `reasoning-start`, `reasoning-delta` and `reasoning-end` are transient and
+  ordered by the same identity; delta carries only the current text fragment,
+  while provider metadata stays inside a validated canonical envelope;
 - `assistant-checkpoint` follows a successful checkpoint CAS;
 - `run-state` follows durable queue/acquire/interrupt transitions;
 - `tool-status` is transient lifecycle presentation with JSON-safe input on
   start and output on completion; internal tool failures remain generic;
 - `terminal` follows the winning terminal CAS.
 
+These are post-commit notifications, not a transactional outbox: a process can
+crash between the database commit and `publish`. Reconnect should load canonical
+state. Exactly-once external delivery remains an application-owned outbox.
+
 A named custom stop condition terminalizes with `policy_stop`; its `policyName`
 is persisted on the run and included in the terminal event/result. `max-steps`
 is the reserved built-in policy name. `loop.prepareStep` is the controlled AI
@@ -5129,7 +5167,7 @@ never-leak-an-internal-message rule for a raw throw):
 
 ```ts
 const onError = createErrorHook({
-  // Map the codes you have an opinion about; the rest travel as themselves.
+  // Map the codes you have an opinion about.
   codeMap: {
     BAD_REQUEST: 'bad_request', VALIDATION_ERROR: 'bad_request',
     UNAUTHORIZED: 'unauthenticated', FORBIDDEN: 'forbidden',
@@ -5137,6 +5175,9 @@ const onError = createErrorHook({
     CONFLICT: 'conflict', RATE_LIMITED: 'rate_limited',
     INTERNAL_SERVER_ERROR: 'internal',
   },
+  // Optional: one public vocabulary entry for every other stitchkit code.
+  // A resolver `(code) => ...` is also accepted for grouping code families.
+  unmappedCode: 'framework_error',
   // `ctx` is the request's RuntimeContext — read `ctx.traceId` for a
   // correlation id in the envelope. Declaring it is optional.
   render: (info, ctx) => ({
@@ -5149,10 +5190,13 @@ const onError = createErrorHook({
 createServer({ services, hooks: { onError } })
 ```
 
-`codeMap` is partial: map the codes you have an opinion about. A stitchkit code
-you did not list travels as itself — the same thing a code you threw yourself
-always did. That is what keeps a code added by a future release from being a
-compile break for every project that translates codes at all.
+`codeMap` is partial: map the codes you have an opinion about. By default a
+stitchkit code you did not list travels as itself. Set `unmappedCode` to one
+wire-code when your public vocabulary has a catch-all, or to a function such as
+`(code) => code.startsWith('FILE_') ? 'storage_error' : 'framework_error'` when
+framework code families need different buckets. An explicit `codeMap` entry
+always wins. Codes your project throws itself do not belong to Stitchkit's
+vocabulary, so they never pass through this fallback and remain unchanged.
 
 One `satisfies` is the **opt-in** to the stricter deal:
 
@@ -5164,9 +5208,7 @@ That makes the map exhaustive on your side, so a release that adds a code stops
 your build until you decide what the new code is called on your wire. Take it
 when your envelope is a published contract and a code surfacing in stitchkit's
 spelling would violate it; leave it off when passing one through is fine.
-Neither choice is silent — the changelog names every added code. For a single
-catch-all instead of either, decide it in `render`, where `info.code` is the
-resolved value.
+Neither choice is silent — the changelog names every added code.
 
 Both `onError` and `render` may be asynchronous and receive the matched endpoint
 as their final argument. The observer is awaited before rendering, so it can
@@ -6503,6 +6545,34 @@ current one *up to* your target, and apply each snippet.
    runtime): bootstrap the server, one HTTP request, and any feature you rely on
    (Socket.IO connect, an MCP tool call, a multipart upload, …).
 
+## Unreleased migration: complete agent admission identity
+
+Custom `AgentRuntimeStore` adapters must persist and return the input and
+assistant identities associated with an idempotency key:
+
+```ts
+// before
+return { outcome: 'duplicate', runId, snapshot }
+
+// after
+return { outcome: 'duplicate', input, inputMessageId, runId, assistantMessageId, snapshot }
+```
+
+Prefer replacing the custom aggregate reducer with `createAgentRuntimeStore()`;
+its `AgentStoredState.admissions` record and transaction driver implement this
+contract automatically. `history.loadById()` must retain access to compacted
+admitted inputs so the framework can return the canonical record.
+
+`AgentRuntimeEvent` also adds a post-commit `admission` variant. Add it to any
+exhaustive publisher switch. Its `assistant` is either the pending placeholder
+for a new assignment or the canonical persisted assistant for a duplicate:
+
+```ts
+case 'admission':
+  await persistProductProjection(event.input, event.run, event.assistant)
+  break
+```
+
 ## Released migration: 0.56.0
 
 ### Surface manifests are version 2
@@ -7816,7 +7886,7 @@ Also re-exports the error helpers from `stitchkit/contract`.
 | `createAuthHook` | function | one scope gate for HTTP `authorize` and tool `beforeHandle` — [guide](../guide/auth-and-errors.md#createauthhook) |
 | `composeAuthHooks` | function | route multiple canonical auth domains by owned scope and atomically commit their typed contributions |
 | `createErrorHook` | function | an async-capable, endpoint-aware `onError` hook from a code map + envelope renderer — [guide](../guide/auth-and-errors.md#createerrorhook) |
-| `ErrorHookConfig` | _type_ | async observer/renderer config for `createErrorHook` |
+| `ErrorHookConfig` | _type_ | async observer/renderer config with partial `codeMap` and optional typed `unmappedCode` fallback |
 | `ResolvedError` | _type_ | the normalised error handed to `createErrorHook`'s `render` |
 | `createBearerResolver` | function | a bearer-token identity resolver |
 | `signJwt` | function | sign an HS256 JWT |
@@ -7942,6 +8012,10 @@ Server-only optional application runtime. See the
 | `defineAgentProtocol` | function | declare and validate context, input metadata and canonical message parts |
 | `AgentMessageSchema` / `AgentRunSchema` / `AgentSnapshotSchema` | schema | versioned canonical engine records |
 | `AgentRuntimeStore` | _type_ | aggregate CAS transaction boundary for message, run and compaction mutations |
+| `createAgentRuntimeStore` | function | build the aggregate store from one coherent transaction driver; framework owns every state transition |
+| `AgentRuntimeStoreDriver` | _type_ | ORM-neutral transactional state load/exact-version CAS, active-plus-archived history codec and bounded recoverable-run index scan |
+| `AgentStoredStateSchema` | schema | versioned runs and full idempotency admission identities without duplicated message history |
+| `AgentHistoryMutationSchema` | schema | typed canonical message mutation applied inside the winning state transaction |
 | `RecoverAgentRunSchema` | schema | explicit abandon/requeue recovery decision; acquired runs require replay-safe evidence |
 | `createMemoryAgentRuntimeStore` | function | process-local reference adapter, not production durability |
 | `projectAgentHistory` | function | asynchronously project canonical records and resolved multimodal files into provider-valid AI SDK messages |
@@ -7952,11 +8026,14 @@ Server-only optional application runtime. See the
 | `AgentRuntimeStopPolicy` | _type_ | named custom AI SDK stop condition persisted and published on policy stop |
 | `AgentRuntimePrepareStep` | _type_ | per-run controlled step callback with typed domain context and managed run signal/fence |
 | `AgentRuntimeRecordIds` | _type_ | optional caller-provided input, run and assistant IDs for stable application records |
-| `AgentRuntimeAdmission` | _type_ | actual assigned run/assistant identity and snapshot version after durable admission |
+| `AgentRuntimeAdmission` | _type_ | canonical committed input, assigned run, pending assistant projection, compatibility IDs and snapshot version |
+| `AgentAdmissionEventSchema` | schema | post-commit admission projection; removes store rereads but does not imply exactly-once delivery |
+| `AgentRunMetricsSchema` | schema | optional provenance-aware usage and timings; `partial` distinguishes checkpoint from terminal totals |
+| `AgentRuntimeRecoverOptions` | _type_ | bounded paged startup recovery with context resolver and explicit evidence policy |
 | `AgentSessionCloseOptions` | _type_ | natural `drainTimeoutMs` followed by shutdown abort and optional bounded `forceTimeoutMs` settlement wait |
 | `AgentHistoryProjectionOptions` | _type_ | storage-neutral file resolver and explicit unresolved-file behavior |
 | `createAgentToolFenceLifecycle` | function | pre-effect and post-effect run ownership fence for `mountAgent` |
-| `AgentRuntimeEventSchema` | schema | transient delta, durable checkpoint/run-state/tool and terminal event union |
+| `AgentRuntimeEventSchema` | schema | transient stream lifecycle plus post-commit admission/checkpoint/run-state/terminal projections |
 | `createAgentObservability` | function | separate agent-run sink over the shared bounded observability lifecycle |
 
 ## `stitchkit/agent-runtime/openrouter`
@@ -8294,6 +8371,8 @@ handler pipeline without opening a TCP port.
 |--------|------|---------|
 | `createHandlerTestClient` | function | one contract client backed by an in-process `FetchHandler` |
 | `createHandlerTestClients` | function | exact contract-registry batch form |
+| `runAgentStoreConformance` | function | reusable black-box duplicate/coalescing/stale/recovery contract for durable agent-store adapters |
+| `AgentStoreConformanceConfig` | _type_ | factory configuration for running the same contract against a fresh adapter |
 | `HandlerTestClientDefaults` | _type_ | ordinary bare-client defaults with handler-owned `baseUrl` and `fetch` removed |
 | `HandlerTestClientConfig` | _type_ | handler, contract, path prefix, scoped config and client request defaults |
 | `HandlerTestClientsConfig` | _type_ | batch helper configuration |