stitchkit 0.100.2 → 0.101.0

package/dist/{index-gtj3zc53.js → index-8kzct1d6.js}

@@ -1,94 +1,94 @@
 // 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({
+var AgentRecordIdSchema2 = z.string().min(1);
+var AgentRecordVersionSchema2 = z.int().nonnegative();
+var AgentTimestampSchema2 = z.iso.datetime({ offset: true });
+var AgentJsonObjectSchema2 = z.record(z.string(), z.json());
+var AgentProviderEnvelopeSchema2 = z.object({
   schemaVersion: z.int().positive(),
   provider: z.string().min(1),
-  data: AgentJsonObjectSchema
+  data: AgentJsonObjectSchema2
 });
-var AgentProviderResponseSchema = z.object({
+var AgentProviderResponseSchema2 = z.object({
   id: z.string().min(1),
   provider: z.string().min(1).optional()
 }).strict();
-var AgentTextPartSchema = z.object({
+var AgentTextPartSchema2 = z.object({
   type: z.literal("text"),
   text: z.string()
 });
-var AgentReasoningPartSchema = z.object({
+var AgentReasoningPartSchema2 = z.object({
   type: z.literal("reasoning"),
   text: z.string(),
-  provider: AgentProviderEnvelopeSchema.optional()
+  provider: AgentProviderEnvelopeSchema2.optional()
 });
-var AgentFilePartSchema = z.object({
+var AgentFilePartSchema2 = 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({
+var AgentSourcePartSchema2 = z.object({
   type: z.literal("source"),
   sourceId: z.string().min(1),
   url: z.url().optional(),
   title: z.string().optional()
 });
-var AgentToolCallPartSchema = z.object({
+var AgentToolCallPartSchema2 = z.object({
   type: z.literal("tool-call"),
   callId: z.string().min(1),
   toolName: z.string().min(1),
   input: z.json(),
-  provider: AgentProviderEnvelopeSchema.optional()
+  provider: AgentProviderEnvelopeSchema2.optional()
 });
-var AgentToolResultPartSchema = z.object({
+var AgentToolResultPartSchema2 = 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 AgentToolApprovalRequestPartSchema = z.object({
+var AgentToolApprovalRequestPartSchema2 = z.object({
   type: z.literal("tool-approval-request"),
   approvalId: z.string().min(1),
   callId: z.string().min(1),
   isAutomatic: z.boolean().optional(),
   signature: z.string().min(1).optional()
 });
-var AgentToolApprovalResponsePartSchema = z.object({
+var AgentToolApprovalResponsePartSchema2 = z.object({
   type: z.literal("tool-approval-response"),
   approvalId: z.string().min(1),
   approved: z.boolean(),
   reason: z.string().min(1).optional()
 });
-var AgentOpaquePartSchema = z.object({
+var AgentOpaquePartSchema2 = z.object({
   type: z.literal("provider"),
-  envelope: AgentProviderEnvelopeSchema
+  envelope: AgentProviderEnvelopeSchema2
 });
-var AgentControlPartSchema = z.object({
+var AgentControlPartSchema2 = z.object({
   type: z.literal("control"),
   reason: z.enum(["run-interrupted", "stale-run"])
 });
-var AgentMessagePartSchema = z.discriminatedUnion("type", [
-  AgentTextPartSchema,
-  AgentReasoningPartSchema,
-  AgentFilePartSchema,
-  AgentSourcePartSchema,
-  AgentToolCallPartSchema,
-  AgentToolResultPartSchema,
-  AgentToolApprovalRequestPartSchema,
-  AgentToolApprovalResponsePartSchema,
-  AgentOpaquePartSchema,
-  AgentControlPartSchema
+var AgentMessagePartSchema2 = z.discriminatedUnion("type", [
+  AgentTextPartSchema2,
+  AgentReasoningPartSchema2,
+  AgentFilePartSchema2,
+  AgentSourcePartSchema2,
+  AgentToolCallPartSchema2,
+  AgentToolResultPartSchema2,
+  AgentToolApprovalRequestPartSchema2,
+  AgentToolApprovalResponsePartSchema2,
+  AgentOpaquePartSchema2,
+  AgentControlPartSchema2
 ]);
-var AgentMessageRoleSchema = z.enum([
+var AgentMessageRoleSchema2 = z.enum([
   "user",
   "assistant",
   "tool",
   "system",
   "summary"
 ]);
-var AgentMessageStatusSchema = z.enum([
+var AgentMessageStatusSchema2 = z.enum([
   "committed",
   "streaming",
   "completed",
@@ -96,28 +96,28 @@ var AgentMessageStatusSchema = z.enum([
   "superseded",
   "failed"
 ]);
-var AgentMessageSchema = z.object({
+var AgentMessageSchema2 = 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
+  id: AgentRecordIdSchema2,
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2.optional(),
+  role: AgentMessageRoleSchema2,
+  status: AgentMessageStatusSchema2,
+  parts: z.array(AgentMessagePartSchema2),
+  metadata: AgentJsonObjectSchema2.optional(),
+  createdAt: AgentTimestampSchema2,
+  updatedAt: AgentTimestampSchema2
 });
-var AgentAssistantPlaceholderSchema = z.object({
+var AgentAssistantPlaceholderSchema2 = z.object({
   schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
+  id: AgentRecordIdSchema2,
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
   status: z.literal("pending"),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
+  createdAt: AgentTimestampSchema2,
+  updatedAt: AgentTimestampSchema2
 });
-var AgentRunStateSchema = z.enum([
+var AgentRunStateSchema2 = z.enum([
   "queued",
   "running",
   "interrupt_requested",
@@ -128,9 +128,9 @@ var AgentRunStateSchema = z.enum([
   "cancelled",
   "abandoned"
 ]);
-var AgentRunQueuePrioritySchema = z.enum(["interrupt-next"]);
-var AgentRunOperationKindSchema = z.enum(["model-request", "compaction"]);
-var AgentRunOperationPhaseSchema = z.enum([
+var AgentRunQueuePrioritySchema2 = z.enum(["interrupt-next"]);
+var AgentRunOperationKindSchema2 = z.enum(["model-request", "compaction"]);
+var AgentRunOperationPhaseSchema2 = z.enum([
   "started",
   "first-output",
   "completed",
@@ -138,15 +138,15 @@ var AgentRunOperationPhaseSchema = z.enum([
   "cancelled"
 ]);
 var AgentRunOperationFieldsSchema = z.object({
-  operationId: AgentRecordIdSchema,
-  kind: AgentRunOperationKindSchema,
-  phase: AgentRunOperationPhaseSchema,
+  operationId: AgentRecordIdSchema2,
+  kind: AgentRunOperationKindSchema2,
+  phase: AgentRunOperationPhaseSchema2,
   step: z.int().nonnegative().optional(),
-  startedAt: AgentTimestampSchema,
-  firstOutputAt: AgentTimestampSchema.optional(),
-  finishedAt: AgentTimestampSchema.optional()
+  startedAt: AgentTimestampSchema2,
+  firstOutputAt: AgentTimestampSchema2.optional(),
+  finishedAt: AgentTimestampSchema2.optional()
 });
-var AgentRunOperationSchema = AgentRunOperationFieldsSchema.superRefine((operation, ctx) => {
+var AgentRunOperationSchema2 = AgentRunOperationFieldsSchema.superRefine((operation, ctx) => {
   if (operation.kind === "model-request" !== (operation.step !== undefined)) {
     ctx.addIssue({
       code: "custom",
@@ -177,7 +177,7 @@ var AgentRunOperationSchema = AgentRunOperationFieldsSchema.superRefine((operati
     });
   }
 });
-var AgentTerminalReasonSchema = z.enum([
+var AgentTerminalReasonSchema2 = z.enum([
   "success",
   "policy_stop",
   "provider_stop",
@@ -194,7 +194,7 @@ var AgentTerminalReasonSchema = z.enum([
   "absorbed",
   "abandoned"
 ]);
-function runStateForTerminalReason(reason) {
+function runStateForTerminalReason2(reason) {
   if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
     return "completed";
   }
@@ -209,61 +209,61 @@ function runStateForTerminalReason(reason) {
     return "abandoned";
   return "failed";
 }
-var AgentProvenanceSchema = z.enum([
+var AgentProvenanceSchema2 = z.enum([
   "provider-reported",
   "measured",
   "computed",
   "estimated",
   "unavailable"
 ]);
-var AgentUsageValueSchema = z.object({
+var AgentUsageValueSchema2 = z.object({
   value: z.int().nonnegative().optional(),
-  provenance: AgentProvenanceSchema.extract([
+  provenance: AgentProvenanceSchema2.extract([
     "provider-reported",
     "computed",
     "estimated",
     "unavailable"
   ])
 });
-var AgentCostValueSchema = z.object({
+var AgentCostValueSchema2 = z.object({
   value: z.number().nonnegative().optional(),
   currency: z.string().length(3).optional(),
-  provenance: AgentProvenanceSchema.extract([
+  provenance: AgentProvenanceSchema2.extract([
     "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 AgentUsageSchema2 = z.object({
+  inputTokens: AgentUsageValueSchema2,
+  outputTokens: AgentUsageValueSchema2,
+  reasoningTokens: AgentUsageValueSchema2.optional(),
+  cacheReadTokens: AgentUsageValueSchema2.optional(),
+  cacheWriteTokens: AgentUsageValueSchema2.optional(),
+  cost: AgentCostValueSchema2.optional()
 });
 var AgentRunFieldsSchema = z.object({
   schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  inputMessageIds: z.array(AgentRecordIdSchema).min(1),
-  assistantMessageId: AgentRecordIdSchema,
-  state: AgentRunStateSchema,
-  revision: AgentRecordVersionSchema,
-  queuePriority: AgentRunQueuePrioritySchema.optional(),
-  executionSequence: AgentRecordVersionSchema.optional(),
+  id: AgentRecordIdSchema2,
+  conversationId: AgentRecordIdSchema2,
+  inputMessageIds: z.array(AgentRecordIdSchema2).min(1),
+  assistantMessageId: AgentRecordIdSchema2,
+  state: AgentRunStateSchema2,
+  revision: AgentRecordVersionSchema2,
+  queuePriority: AgentRunQueuePrioritySchema2.optional(),
+  executionSequence: AgentRecordVersionSchema2.optional(),
   ownerId: z.string().min(1).optional(),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  terminalReason: AgentTerminalReasonSchema.optional(),
+  fencingToken: AgentRecordVersionSchema2.optional(),
+  terminalReason: AgentTerminalReasonSchema2.optional(),
   terminalPolicyName: z.string().min(1).optional(),
-  absorbedIntoRunId: AgentRecordIdSchema.optional(),
-  usage: AgentUsageSchema.optional(),
-  lastOperation: AgentRunOperationSchema.optional(),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
+  absorbedIntoRunId: AgentRecordIdSchema2.optional(),
+  usage: AgentUsageSchema2.optional(),
+  lastOperation: AgentRunOperationSchema2.optional(),
+  createdAt: AgentTimestampSchema2,
+  updatedAt: AgentTimestampSchema2
 });
-var AgentRunSchema = AgentRunFieldsSchema.superRefine((run, ctx) => {
+var AgentRunSchema2 = AgentRunFieldsSchema.superRefine((run, ctx) => {
   if (run.terminalReason !== "absorbed" && run.absorbedIntoRunId !== undefined) {
     ctx.addIssue({
       code: "custom",
@@ -281,7 +281,7 @@ var AgentRunSchema = AgentRunFieldsSchema.superRefine((run, ctx) => {
     }
     return;
   }
-  const expected = runStateForTerminalReason(run.terminalReason);
+  const expected = runStateForTerminalReason2(run.terminalReason);
   if (run.state !== expected) {
     ctx.addIssue({
       code: "custom",
@@ -319,18 +319,18 @@ var TERMINAL_RUN_STATES = new Set([
   "abandoned",
   "failed"
 ]);
-var AgentSnapshotSchema = z.object({
+var AgentSnapshotSchema2 = z.object({
   schemaVersion: z.literal(1),
-  conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  messages: z.array(AgentMessageSchema),
-  runs: z.array(AgentRunSchema)
+  conversationId: AgentRecordIdSchema2,
+  version: AgentRecordVersionSchema2,
+  messages: z.array(AgentMessageSchema2),
+  runs: z.array(AgentRunSchema2)
 });
-var AgentRunMetricsSchema = z.object({
+var AgentRunMetricsSchema2 = z.object({
   partial: z.boolean(),
-  usage: AgentUsageSchema,
+  usage: AgentUsageSchema2,
   durationMs: z.number().nonnegative().optional(),
   ttftMs: z.number().nonnegative().optional()
 });
 
-export { AgentRecordIdSchema, AgentRecordVersionSchema, AgentTimestampSchema, AgentJsonObjectSchema, AgentProviderEnvelopeSchema, AgentProviderResponseSchema, AgentTextPartSchema, AgentReasoningPartSchema, AgentFilePartSchema, AgentSourcePartSchema, AgentToolCallPartSchema, AgentToolResultPartSchema, AgentToolApprovalRequestPartSchema, AgentToolApprovalResponsePartSchema, AgentOpaquePartSchema, AgentControlPartSchema, AgentMessagePartSchema, AgentMessageRoleSchema, AgentMessageStatusSchema, AgentMessageSchema, AgentAssistantPlaceholderSchema, AgentRunStateSchema, AgentRunQueuePrioritySchema, AgentRunOperationKindSchema, AgentRunOperationPhaseSchema, AgentRunOperationSchema, AgentTerminalReasonSchema, runStateForTerminalReason, AgentProvenanceSchema, AgentUsageValueSchema, AgentCostValueSchema, AgentUsageSchema, AgentRunSchema, AgentSnapshotSchema, AgentRunMetricsSchema };
+export { AgentRecordIdSchema2, AgentRecordVersionSchema2, AgentTimestampSchema2, AgentJsonObjectSchema2, AgentProviderEnvelopeSchema2, AgentProviderResponseSchema2, AgentTextPartSchema2, AgentReasoningPartSchema2, AgentFilePartSchema2, AgentSourcePartSchema2, AgentToolCallPartSchema2, AgentToolResultPartSchema2, AgentToolApprovalRequestPartSchema2, AgentToolApprovalResponsePartSchema2, AgentOpaquePartSchema2, AgentControlPartSchema2, AgentMessagePartSchema2, AgentMessageRoleSchema2, AgentMessageStatusSchema2, AgentMessageSchema2, AgentAssistantPlaceholderSchema2, AgentRunStateSchema2, AgentRunQueuePrioritySchema2, AgentRunOperationKindSchema2, AgentRunOperationPhaseSchema2, AgentRunOperationSchema2, AgentTerminalReasonSchema2, runStateForTerminalReason2, AgentProvenanceSchema2, AgentUsageValueSchema2, AgentCostValueSchema2, AgentUsageSchema2, AgentRunSchema2, AgentSnapshotSchema2, AgentRunMetricsSchema2 };

package/dist/{index-1zbbzgfh.js → index-9pw0a51a.js}

@@ -1,9 +1,9 @@
 import {
   safeJsonParse
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/tools/schema/coerce.ts
 import { z } from "zod";
@@ -81,9 +81,9 @@ function coerceValue(value, schema) {
   }
   return current;
 }
-function coerceJsonArgs(args, schema) {
+function coerceJsonArgs2(args, schema) {
   const coerced = coerceValue(args, schema);
   return isRecord(coerced) ? coerced : args;
 }
 
-export { coerceJsonArgs };
+export { coerceJsonArgs2 };

package/dist/{index-79z7m7dt.js → index-a9pd417t.js}

@@ -1,6 +1,6 @@
 // src/durability/contract.ts
 import { z } from "zod";
-var DURABILITY_STEP_EVENT_KIND = "durability/step";
+var DURABILITY_STEP_EVENT_KIND2 = "durability/step";
 var DURABILITY_PARK_EVENT_KIND = "durability/park";
 var DURABILITY_EVENT_EVENT_KIND = "durability/event";
 var DURABILITY_EFFECT_EVENT_KIND = "durability/effect";
@@ -43,14 +43,14 @@ var EffectEventPayloadSchema = z.discriminatedUnion("phase", [
   z.object({ ...EffectIdentity, phase: z.literal("uncertain") })
 ]);
 
-class StepResultDecodeError extends Error {
+class StepResultDecodeError2 extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "StepResultDecodeError";
   }
 }
 
-class StepResultNotSerializableError extends Error {
+class StepResultNotSerializableError2 extends Error {
   constructor(stepName, cause) {
     super(`Step "${stepName}" returned a value that is not JSON-serializable`, {
       cause
@@ -59,14 +59,14 @@ class StepResultNotSerializableError extends Error {
   }
 }
 
-class StepAbortedError extends Error {
+class StepAbortedError2 extends Error {
   constructor(stepName) {
     super(`Step "${stepName}" was aborted before it started`);
     this.name = "StepAbortedError";
   }
 }
 
-class EffectUnresolvedError extends Error {
+class EffectUnresolvedError2 extends Error {
   effectName;
   reason;
   constructor(effectName, reason, options) {
@@ -77,14 +77,14 @@ class EffectUnresolvedError extends Error {
   }
 }
 
-class ParkRecordDecodeError extends Error {
+class ParkRecordDecodeError2 extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "ParkRecordDecodeError";
   }
 }
 
-class ParkAbortedError extends Error {
+class ParkAbortedError2 extends Error {
   constructor(park) {
     super(`Park "${park}" was aborted before it was satisfied`);
     this.name = "ParkAbortedError";
@@ -153,10 +153,10 @@ function encodeStepResult(stepName, value) {
   try {
     encoded = JSON.stringify(DurableJsonSchema.parse(value));
   } catch (cause) {
-    throw new StepResultNotSerializableError(stepName, cause);
+    throw new StepResultNotSerializableError2(stepName, cause);
   }
   if (encoded === undefined) {
-    throw new StepResultNotSerializableError(stepName, value);
+    throw new StepResultNotSerializableError2(stepName, value);
   }
   return encoded;
 }
@@ -177,7 +177,7 @@ function encodeDeliveredPayload(event, id, payload) {
 function decodeStepPayload(event) {
   const parsed = StepEventPayloadSchema.safeParse(event.payload);
   if (!parsed.success) {
-    throw new StepResultDecodeError(`Recorded step event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+    throw new StepResultDecodeError2(`Recorded step event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
   }
   return parsed.data;
 }
@@ -185,20 +185,20 @@ function decodeRecordedResult(payload, event) {
   try {
     return DurableJsonSchema.parse(JSON.parse(payload.encoded));
   } catch (cause) {
-    throw new StepResultDecodeError(`Recorded result for step "${payload.stepName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+    throw new StepResultDecodeError2(`Recorded result for step "${payload.stepName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
   }
 }
 function decodeParkPayload(event) {
   const parsed = ParkEventPayloadSchema.safeParse(event.payload);
   if (!parsed.success) {
-    throw new ParkRecordDecodeError(`Recorded park event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+    throw new ParkRecordDecodeError2(`Recorded park event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
   }
   return parsed.data;
 }
 function decodeDeliveredPayload(event) {
   const parsed = DeliveredEventPayloadSchema.safeParse(event.payload);
   if (!parsed.success) {
-    throw new ParkRecordDecodeError(`Delivered event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+    throw new ParkRecordDecodeError2(`Delivered event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
   }
   return parsed.data;
 }
@@ -206,13 +206,13 @@ function decodeDeliveredResult(payload, event) {
   try {
     return JSON.parse(payload.encoded);
   } catch (cause) {
-    throw new ParkRecordDecodeError(`Delivered payload for "${payload.event}#${payload.id}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+    throw new ParkRecordDecodeError2(`Delivered payload for "${payload.event}#${payload.id}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
   }
 }
 function decodeEffect(event) {
   const parsed = EffectEventPayloadSchema.safeParse(event.payload);
   if (!parsed.success) {
-    throw new StepResultDecodeError(`Recorded effect event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+    throw new StepResultDecodeError2(`Recorded effect event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
   }
   const payload = parsed.data;
   if (payload.phase === "intent")
@@ -223,7 +223,7 @@ function decodeEffect(event) {
     const proof = DurableJsonSchema.parse(JSON.parse(payload.encoded));
     return { payload, record: { outcome: "accepted", proof } };
   } catch (cause) {
-    throw new StepResultDecodeError(`Recorded proof for effect "${payload.effectName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+    throw new StepResultDecodeError2(`Recorded proof for effect "${payload.effectName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
   }
 }
 async function readDurabilityLedger(store, conversationId, view) {
@@ -236,7 +236,7 @@ async function readDurabilityLedger(store, conversationId, view) {
       limit: 1e4
     });
     for (const event of page.items) {
-      if (event.kind === DURABILITY_STEP_EVENT_KIND) {
+      if (event.kind === DURABILITY_STEP_EVENT_KIND2) {
         const payload = decodeStepPayload(event);
         steps.set(stepKey(event.conversationId, payload.runId, payload.stepName), decodeRecordedResult(payload, event));
       } else if (event.kind === DURABILITY_PARK_EVENT_KIND) {
@@ -272,11 +272,11 @@ function encodeProof(name, proof) {
   try {
     encoded = encodeStepResult(name, proof);
   } catch (cause) {
-    throw new EffectUnresolvedError(name, "proof-rejected", { cause });
+    throw new EffectUnresolvedError2(name, "proof-rejected", { cause });
   }
   const bytes = new TextEncoder().encode(encoded).byteLength;
   if (bytes > MAX_PROOF_BYTES) {
-    throw new EffectUnresolvedError(name, "proof-rejected", {
+    throw new EffectUnresolvedError2(name, "proof-rejected", {
       cause: new RangeError(`the proof is ${bytes} bytes; at most ${MAX_PROOF_BYTES} are kept`)
     });
   }
@@ -308,12 +308,12 @@ async function reconcile(context, name, handlers, timeoutMs) {
       deadline
     ]);
   } catch (cause) {
-    throw new EffectUnresolvedError(name, "reconcile-failed", { cause });
+    throw new EffectUnresolvedError2(name, "reconcile-failed", { cause });
   } finally {
     clearTimeout(timer);
   }
   if (found === "timeout") {
-    throw new EffectUnresolvedError(name, "reconcile-timeout", {
+    throw new EffectUnresolvedError2(name, "reconcile-timeout", {
       cause: controller.signal.reason
     });
   }
@@ -338,7 +338,7 @@ async function executeEffect(context, name, handlers, options) {
     return outcomeOf(JSON.stringify(recorded.proof));
   }
   if (options?.signal?.aborted || context.signal?.aborted)
-    throw new StepAbortedError(name);
+    throw new StepAbortedError2(name);
   if (recorded)
     return reconcile(context, name, handlers, timeoutMs);
   await append(context, { phase: "intent" }, name);
@@ -346,7 +346,7 @@ async function executeEffect(context, name, handlers, options) {
   try {
     proof = await handlers.run();
   } catch (cause) {
-    throw new EffectUnresolvedError(name, "run-failed", { cause });
+    throw new EffectUnresolvedError2(name, "run-failed", { cause });
   }
   const encoded = encodeProof(name, proof);
   await append(context, { phase: "accepted", encoded, via: "run" }, name);
@@ -395,13 +395,13 @@ function waitForTimer(clock, delayMs, signal) {
 async function waitForDeadline(clock, deadline, park, signal) {
   for (;; ) {
     if (signal?.aborted)
-      throw new ParkAbortedError(park);
+      throw new ParkAbortedError2(park);
     const remaining = deadline - clock.now();
     if (remaining <= 0)
       return;
     const outcome = await waitForTimer(clock, remaining, signal);
     if (outcome === "aborted")
-      throw new ParkAbortedError(park);
+      throw new ParkAbortedError2(park);
   }
 }
 function createParkWaiter(parkWaiters, key, signal) {
@@ -446,7 +446,7 @@ async function executeSleep(park, name, seconds, runOptions) {
   let deadline;
   if (existing) {
     if (existing.kind !== "sleep") {
-      throw new ParkRecordDecodeError(`Recorded park "${name}" is not a sleep record`);
+      throw new ParkRecordDecodeError2(`Recorded park "${name}" is not a sleep record`);
     }
     deadline = existing.deadline;
   } else {
@@ -460,7 +460,7 @@ async function executeSleep(park, name, seconds, runOptions) {
     });
   }
   if (signal?.aborted)
-    throw new ParkAbortedError(name);
+    throw new ParkAbortedError2(name);
   await waitForDeadline(park.clock, deadline, name, signal);
 }
 async function executeWait(park, eventName, id, runOptions) {
@@ -469,7 +469,7 @@ async function executeWait(park, eventName, id, runOptions) {
   const signal = park.signal && runOptions?.signal ? AbortSignal.any([park.signal, runOptions.signal]) : runOptions?.signal ?? park.signal;
   for (;; ) {
     if (signal?.aborted)
-      throw new ParkAbortedError(label);
+      throw new ParkAbortedError2(label);
     const waiter = createParkWaiter(park.waiters, key, signal);
     let unsubscribe;
     try {
@@ -487,7 +487,7 @@ async function executeWait(park, eventName, id, runOptions) {
       }
       const outcome = await waiter.outcome;
       if (outcome === "aborted")
-        throw new ParkAbortedError(label);
+        throw new ParkAbortedError2(label);
     } finally {
       waiter.cancel();
       unsubscribe?.();
@@ -506,7 +506,7 @@ function releaseSettled(registry, key, pending) {
 function detachedResult(pending) {
   return pending.then((value) => JSON.parse(JSON.stringify(value)));
 }
-function createLocalStepDurability(options) {
+function createLocalStepDurability2(options) {
   const { store, conversationId, runId } = options;
   const inFlight = stores.get(store) ?? {
     steps: new Map,
@@ -556,12 +556,12 @@ function createLocalStepDurability(options) {
       return recorded;
     }
     if (runOptions?.signal?.aborted || options.signal?.aborted)
-      throw new StepAbortedError(name);
+      throw new StepAbortedError2(name);
     const value = await body();
     const encoded = encodeStepResult(name, value);
     await store.appendEvent({
       conversationId,
-      kind: DURABILITY_STEP_EVENT_KIND,
+      kind: DURABILITY_STEP_EVENT_KIND2,
       payload: { runId, stepName: name, encoded }
     });
     return JSON.parse(encoded);
@@ -642,7 +642,7 @@ function createLocalStepDurability(options) {
 // src/tools/agent-tool-error.ts
 var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
 
-class AgentToolError extends Error {
+class AgentToolError2 extends Error {
   output;
   constructor(output, cause) {
     let message = "Tool execution failed";
@@ -655,7 +655,7 @@ class AgentToolError extends Error {
     Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
   }
 }
-function isAgentToolError(value) {
+function isAgentToolError2(value) {
   return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
 }
 
@@ -672,4 +672,4 @@ function resolveToolDurability(context, callId, signal) {
   return contexts.get(context)?.(callId, signal);
 }
 
-export { DURABILITY_STEP_EVENT_KIND, StepResultDecodeError, StepResultNotSerializableError, StepAbortedError, EffectUnresolvedError, ParkRecordDecodeError, ParkAbortedError, createLocalStepDurability, AgentToolError, isAgentToolError, createToolDurabilityContext, resolveToolDurability };
+export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };