stitchkit 0.116.0 → 0.118.0

package/dist/{index-jq2ky8fw.js → index-cycp3r3e.js}

@@ -38,8 +38,14 @@ import {
   assistantStatus,
   ProviderJournalMessageSchema,
   ProviderJournalRequestSchema,
-  ProviderJournalResponseSchema
-} from "./index-fggxgbrk.js";
+  ProviderJournalResponseSchema,
+  AgentRuntimeHeadSchema2,
+  AgentStoredRunSchema2,
+  AgentAdmissionReceiptSchema2,
+  AgentSeedReceiptSchema2,
+  isActiveRunState,
+  emptyHead
+} from "./index-xx1j310k.js";
 import {
   StepEventPayloadSchema,
   ParkEventPayloadSchema,
@@ -114,78 +120,15 @@ async function purgeAgentConversation2(store, input) {
   return AgentConversationPurgeResultSchema2.parse(await store.purgeConversation(parsed));
 }
 
-// src/agent-runtime/store-driver-contract.ts
-import { z as z3 } from "zod";
-var AgentRuntimeHeadSchema2 = z3.object({
-  schemaVersion: z3.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  version: AgentRecordVersionSchema2
-});
-var AgentStoredRunSchema2 = z3.object({
-  schemaVersion: z3.literal(1),
-  run: AgentRunSchema2,
-  terminalAssistant: AgentMessageSchema2.optional()
-});
-var AgentAdmissionReceiptSchema2 = z3.object({
-  schemaVersion: z3.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  idempotencyKey: z3.string().min(1),
-  input: AgentMessageSchema2,
-  runId: AgentRecordIdSchema2,
-  assistantMessageId: AgentRecordIdSchema2
-});
-var AgentSeedReceiptSchema2 = z3.object({
-  schemaVersion: z3.literal(1),
-  conversationId: AgentRecordIdSchema2,
-  seedKey: z3.string().min(1),
-  messageIds: z3.array(AgentRecordIdSchema2).min(1)
-});
-var AgentHistoryMutationSchema2 = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("admit"), input: AgentMessageSchema2 }),
-  z3.object({
-    type: z3.literal("upsert-assistant"),
-    message: AgentMessageSchema2
-  }),
-  z3.object({
-    type: z3.literal("replace-compacted-range"),
-    replacedMessageIds: z3.array(AgentRecordIdSchema2).min(1),
-    summary: AgentMessageSchema2
-  }),
-  z3.object({
-    type: z3.literal("seed"),
-    message: AgentMessageSchema2
-  }),
-  z3.object({
-    type: z3.literal("insert"),
-    message: AgentMessageSchema2,
-    beforeMessageId: AgentRecordIdSchema2.optional()
-  })
-]);
-var ACTIVE_AGENT_RUN_STATES2 = [
-  "queued",
-  "running",
-  "interrupt_requested"
-];
-function isActiveRunState(state) {
-  return ACTIVE_AGENT_RUN_STATES2.includes(state);
-}
-function emptyHead(conversationId) {
-  return AgentRuntimeHeadSchema2.parse({
-    schemaVersion: 1,
-    conversationId,
-    version: 0
-  });
-}
-
 // src/agent-runtime/store-create.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // src/agent-runtime/store-archive.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/agent-runtime/branch-replay.ts
 import { createHash as createHash2 } from "node:crypto";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/agent-runtime/store-reducer.ts
 import { createHash } from "node:crypto";
@@ -687,14 +630,14 @@ function operationConversationId(operation) {
 }
 
 // src/agent-runtime/branch-replay.ts
-var BranchBaselineSchema = z4.object({
-  migratedAt: z4.iso.datetime({ offset: true }),
-  asOf: z4.iso.datetime({ offset: true }).optional(),
+var BranchBaselineSchema = z3.object({
+  migratedAt: z3.iso.datetime({ offset: true }),
+  asOf: z3.iso.datetime({ offset: true }).optional(),
   head: AgentRuntimeHeadSchema2,
-  messages: z4.array(AgentMessageSchema2),
-  compacted: z4.array(z4.string().min(1)).optional(),
-  runs: z4.array(AgentStoredRunSchema2),
-  admissions: z4.array(AgentAdmissionReceiptSchema2)
+  messages: z3.array(AgentMessageSchema2),
+  compacted: z3.array(z3.string().min(1)).optional(),
+  runs: z3.array(AgentStoredRunSchema2),
+  admissions: z3.array(AgentAdmissionReceiptSchema2)
 }).strict();
 function branchTransition(event) {
   const checkpoint = AgentStoreCheckpointRecordSchema.safeParse(event.payload);
@@ -1020,7 +963,7 @@ async function exportConversationIn(driver, transaction, conversationId) {
     conversationId,
     events,
     projections: [
-      { archiveType: "runtime-snapshot", snapshot: z5.json().parse(snapshot) },
+      { archiveType: "runtime-snapshot", snapshot: z4.json().parse(snapshot) },
       ...durable.projections
     ],
     spills: durable.spills
@@ -1029,13 +972,13 @@ async function exportConversationIn(driver, transaction, conversationId) {
 
 // src/agent-runtime/store-branch.ts
 import { createHash as createHash7 } from "node:crypto";
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 
 // src/agent-runtime/branch-events.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/agent-runtime/branch-messages.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 function branchOpaqueJson(value) {
   if (Array.isArray(value))
     return value.map(branchOpaqueJson);
@@ -1059,26 +1002,26 @@ function branchOpaqueJson(value) {
   }
   return value;
 }
-var ArtifactReadSchema = z6.object({
-  reference: z6.string(),
-  offset: z6.int().nonnegative(),
-  maxBytes: z6.int().positive().optional()
+var ArtifactReadSchema = z5.object({
+  reference: z5.string(),
+  offset: z5.int().nonnegative(),
+  maxBytes: z5.int().positive().optional()
 }).strict();
-var ArtifactSearchSchema = z6.object({
-  reference: z6.string(),
-  query: z6.string(),
-  maxMatches: z6.int().positive().optional()
+var ArtifactSearchSchema = z5.object({
+  reference: z5.string(),
+  query: z5.string(),
+  maxMatches: z5.int().positive().optional()
 }).strict();
-var ArtifactReadResultSchema = z6.object({
-  reference: z6.string(),
-  offset: z6.int().nonnegative(),
-  text: z6.string(),
-  bytes: z6.int().nonnegative(),
-  totalBytes: z6.int().nonnegative().optional()
+var ArtifactReadResultSchema = z5.object({
+  reference: z5.string(),
+  offset: z5.int().nonnegative(),
+  text: z5.string(),
+  bytes: z5.int().nonnegative(),
+  totalBytes: z5.int().nonnegative().optional()
 }).strict();
-var ArtifactSearchResultSchema = z6.object({
-  reference: z6.string(),
-  matches: z6.array(z6.object({ line: z6.int().positive(), text: z6.string() }).strict())
+var ArtifactSearchResultSchema = z5.object({
+  reference: z5.string(),
+  matches: z5.array(z5.object({ line: z5.int().positive(), text: z5.string() }).strict())
 }).strict();
 function branchToolJson(ids, name, value, output) {
   if (name === AGENT_CODING_TOOL_NAMES.readOutput || name === AGENT_CODING_TOOL_NAMES.searchOutput) {
@@ -1148,7 +1091,7 @@ function branchMessage(ids, sourceConversationId, message) {
     ...message.runId && { runId: ids.reference("run", message.runId) },
     parts: message.parts.map((part) => branchPart(ids, part)),
     ...message.metadata && {
-      metadata: z6.record(z6.string(), z6.json()).parse(branchOpaqueJson(message.metadata))
+      metadata: z5.record(z5.string(), z5.json()).parse(branchOpaqueJson(message.metadata))
     }
   };
 }
@@ -1177,61 +1120,61 @@ function branchRun(ids, sourceConversationId, run, settled) {
 }
 
 // src/agent-runtime/branch-observations.ts
-import { z as z7 } from "zod";
-var Id = z7.string().min(1);
-var Hash2 = z7.string().regex(/^[a-f0-9]{64}$/);
-var State = z7.object({
+import { z as z6 } from "zod";
+var Id = z6.string().min(1);
+var Hash2 = z6.string().regex(/^[a-f0-9]{64}$/);
+var State = z6.object({
   name: Id,
-  version: z7.int().positive(),
-  value: z7.json(),
-  actor: z7.enum(["agent", "human", "system"])
+  version: z6.int().positive(),
+  value: z6.json(),
+  actor: z6.enum(["agent", "human", "system"])
 }).strict();
-var Retry = z7.object({
-  attempt: z7.int().positive(),
-  delayMs: z7.number().nonnegative().optional(),
-  reason: z7.string().optional()
+var Retry = z6.object({
+  attempt: z6.int().positive(),
+  delayMs: z6.number().nonnegative().optional(),
+  reason: z6.string().optional()
 }).strict();
-var Spill = z7.object({ reference: Id, bytes: z7.int().nonnegative(), sha256: Hash2.optional() }).strict();
-var Schedule = z7.object({
+var Spill = z6.object({ reference: Id, bytes: z6.int().nonnegative(), sha256: Hash2.optional() }).strict();
+var Schedule = z6.object({
   id: Id,
-  kind: z7.enum(["at", "after", "every"]).optional(),
-  nextAt: z7.string().nullable().optional(),
-  occurrence: z7.int().nonnegative().optional(),
-  lateByMs: z7.number().nonnegative().optional(),
-  state: z7.string().optional(),
-  message: z7.string().optional(),
-  attempts: z7.int().nonnegative().optional(),
-  retryAt: z7.string().nullable().optional(),
-  terminal: z7.boolean().optional(),
-  skipped: z7.boolean().optional()
+  kind: z6.enum(["at", "after", "every"]).optional(),
+  nextAt: z6.string().nullable().optional(),
+  occurrence: z6.int().nonnegative().optional(),
+  lateByMs: z6.number().nonnegative().optional(),
+  state: z6.string().optional(),
+  message: z6.string().optional(),
+  attempts: z6.int().nonnegative().optional(),
+  retryAt: z6.string().nullable().optional(),
+  terminal: z6.boolean().optional(),
+  skipped: z6.boolean().optional()
 }).strict();
-var Child = z7.object({
+var Child = z6.object({
   childConversationId: Id.optional(),
   parentConversationId: Id.optional(),
-  seedUptoSeq: z7.int().nonnegative().optional(),
-  budget: z7.json().optional(),
-  state: z7.string().optional(),
+  seedUptoSeq: z6.int().nonnegative().optional(),
+  budget: z6.json().optional(),
+  state: z6.string().optional(),
   resultReference: Id.optional(),
-  reason: z7.string().optional(),
-  action: z7.enum(["message-sent", "blocking-presented", "blocking-resolved"]).optional(),
+  reason: z6.string().optional(),
+  action: z6.enum(["message-sent", "blocking-presented", "blocking-resolved"]).optional(),
   approvalId: Id.optional(),
   childApprovalId: Id.optional(),
   callId: Id.optional(),
   toolName: Id.optional(),
-  input: z7.json().optional(),
+  input: z6.json().optional(),
   batchId: Id.optional(),
-  kind: z7.string().optional(),
-  presentedAt: z7.string().optional(),
-  approved: z7.boolean().optional()
+  kind: z6.string().optional(),
+  presentedAt: z6.string().optional(),
+  approved: z6.boolean().optional()
 }).strict();
-var Rejection = z7.object({ approvalId: Id, callId: Id, toolName: Id, reason: z7.string() }).strict();
+var Rejection = z6.object({ approvalId: Id, callId: Id, toolName: Id, reason: z6.string() }).strict();
 function branchObservation(ids, kind, raw) {
   if (kind.startsWith("durability/")) {
     const value = kind === "durability/step" ? StepEventPayloadSchema.parse(raw) : kind === "durability/park" ? ParkEventPayloadSchema.parse(raw) : kind === "durability/event" ? DeliveredEventPayloadSchema.parse(raw) : kind === "durability/effect" ? EffectEventPayloadSchema.parse(raw) : undefined;
     if (!value || canonicalAgentJson2(value) !== canonicalAgentJson2(raw))
       throw new TypeError("Branch cannot rekey opaque durability payload");
     if ("encoded" in value)
-      branchOpaqueJson(z7.json().parse(JSON.parse(value.encoded)));
+      branchOpaqueJson(z6.json().parse(JSON.parse(value.encoded)));
     return {
       ...value,
       runId: ids.reference("run", value.runId),
@@ -1239,10 +1182,10 @@ function branchObservation(ids, kind, raw) {
     };
   }
   if (kind === "sandbox/probed")
-    return z7.object({
+    return z6.object({
       result: AgentSandboxGradeSchema2,
-      required: z7.array(AgentSandboxRestrictionSchema2),
-      missing: z7.array(AgentSandboxRestrictionSchema2)
+      required: z6.array(AgentSandboxRestrictionSchema2),
+      missing: z6.array(AgentSandboxRestrictionSchema2)
     }).strict().parse(raw);
   if (kind === "state/set") {
     const value = State.parse(raw);
@@ -1294,7 +1237,7 @@ function branchObservation(ids, kind, raw) {
   }
   throw new TypeError(`Branch cannot rekey opaque event kind ${kind}`);
 }
-var BranchObservationSchema = z7.object({ sourceKind: Id, payload: z7.json() }).strict();
+var BranchObservationSchema = z6.object({ sourceKind: Id, payload: z6.json() }).strict();
 
 // src/agent-runtime/branch-provider.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -1406,7 +1349,7 @@ class BranchProvider {
 }
 
 // src/agent-runtime/branch-transitions.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 function rekeyBranchTransition(ids, source, operation) {
   const message = (value) => branchMessage(ids, source, value);
   const input = operation.input;
@@ -1477,11 +1420,11 @@ function rekeyBranchTransition(ids, source, operation) {
   }
 }
 function branchJson(value) {
-  return z8.json().parse(value);
+  return z7.json().parse(value);
 }
 
 // src/agent-runtime/branch-events.ts
-var Hash3 = z9.string().regex(/^[a-f0-9]{64}$/);
+var Hash3 = z8.string().regex(/^[a-f0-9]{64}$/);
 function rekeyBranchEvents(ids, source, events, retainedMessages = new Map) {
   const hydrated = events.map((event) => {
     const assistant = retainedMessages.get(event.eventId);
@@ -1528,14 +1471,14 @@ function rekeyBranchEvent(ids, source, event, provider) {
   if (event.kind === "runtime/transition") {
     const operation = branchTransition(event);
     const rekeyed = rekeyBranchTransition(ids, source, operation);
-    const raw = z9.object({
-      type: z9.string(),
-      input: z9.object({
-        assistant: z9.object({
+    const raw = z8.object({
+      type: z8.string(),
+      input: z8.object({
+        assistant: z8.object({
           sha256: Hash3.optional(),
           sourceSha256: Hash3.optional(),
-          bytes: z9.int(),
-          parts: z9.int()
+          bytes: z8.int(),
+          parts: z8.int()
         }).passthrough()
       }).passthrough()
     }).passthrough().safeParse(event.payload);
@@ -1693,32 +1636,32 @@ class BranchIdentities {
 
 // src/agent-runtime/branch-source.ts
 import { createHash as createHash6 } from "node:crypto";
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 
 // src/agent-runtime/archive-projection.ts
-import { z as z10 } from "zod";
-var ArchiveProjectionSchema = z10.object({
-  name: z10.string(),
-  version: z10.int().positive(),
-  uptoSeq: z10.int().nonnegative(),
-  value: z10.json(),
-  updatedAt: z10.string()
+import { z as z9 } from "zod";
+var ArchiveProjectionSchema = z9.object({
+  name: z9.string(),
+  version: z9.int().positive(),
+  uptoSeq: z9.int().nonnegative(),
+  value: z9.json(),
+  updatedAt: z9.string()
 }).strict();
 
 // src/agent-runtime/archive-spill.ts
 import { createHash as createHash5 } from "node:crypto";
-import { z as z11 } from "zod";
-var ArchiveSpillSchema = z11.object({
-  reference: z11.string().min(1),
-  runId: z11.string().min(1).optional(),
-  toolCallId: z11.string().min(1).optional(),
-  mediaType: z11.string().min(1),
-  bytes: z11.int().nonnegative(),
-  sha256: z11.string().regex(/^[a-f0-9]{64}$/),
-  createdAt: z11.iso.datetime({ offset: true }),
-  expiresAt: z11.iso.datetime({ offset: true }).optional(),
+import { z as z10 } from "zod";
+var ArchiveSpillSchema = z10.object({
+  reference: z10.string().min(1),
+  runId: z10.string().min(1).optional(),
+  toolCallId: z10.string().min(1).optional(),
+  mediaType: z10.string().min(1),
+  bytes: z10.int().nonnegative(),
+  sha256: z10.string().regex(/^[a-f0-9]{64}$/),
+  createdAt: z10.iso.datetime({ offset: true }),
+  expiresAt: z10.iso.datetime({ offset: true }).optional(),
   authorization: AgentCodingToolAuthorizationSchema2.optional(),
-  base64: z11.string()
+  base64: z10.string()
 }).strict().superRefine((spill, ctx) => {
   const bytes = Buffer.from(spill.base64, "base64");
   if (bytes.toString("base64") !== spill.base64 || bytes.byteLength !== spill.bytes || createHash5("sha256").update(bytes).digest("hex") !== spill.sha256) {
@@ -1730,7 +1673,7 @@ var ArchiveSpillSchema = z11.object({
 });
 
 // src/agent-runtime/branch-source.ts
-var SnapshotProjection = z12.object({ archiveType: z12.literal("runtime-snapshot"), snapshot: AgentSnapshotSchema2 }).strict();
+var SnapshotProjection = z11.object({ archiveType: z11.literal("runtime-snapshot"), snapshot: AgentSnapshotSchema2 }).strict();
 function branchHash(value) {
   return createHash6("sha256").update(canonicalAgentJson2(value)).digest("hex");
 }
@@ -1747,13 +1690,13 @@ function boundary(events, throughRunId) {
   for (const event of events) {
     if (event.kind !== "runtime/transition")
       continue;
-    const candidate = z12.object({
-      type: z12.string(),
-      input: z12.object({
-        runId: z12.string().optional(),
-        reason: z12.string().optional(),
-        action: z12.string().optional(),
-        absorb: z12.array(z12.object({ runId: z12.string() })).optional()
+    const candidate = z11.object({
+      type: z11.string(),
+      input: z11.object({
+        runId: z11.string().optional(),
+        reason: z11.string().optional(),
+        action: z11.string().optional(),
+        absorb: z11.array(z11.object({ runId: z11.string() })).optional()
       })
     }).safeParse(event.payload);
     if (!candidate.success)
@@ -1772,7 +1715,7 @@ function prepareBranchSource(bytes, source) {
     if (event.seq !== index + 1)
       throw new TypeError("Branch source event sequence is incomplete");
   }
-  const projections = archive.projections.map((value) => z12.union([SnapshotProjection, ArchiveProjectionSchema]).parse(value));
+  const projections = archive.projections.map((value) => z11.union([SnapshotProjection, ArchiveProjectionSchema]).parse(value));
   if (projections.some((value, index) => canonicalAgentJson2(value) !== canonicalAgentJson2(archive.projections[index])))
     throw new TypeError("Branch archive snapshot contains an unknown opaque field");
   const snapshots = projections.filter((value) => ("archiveType" in value));
@@ -1942,12 +1885,12 @@ async function branchConversation(driver, raw) {
       conversationId: input.destinationConversationId,
       events: [],
       projections: [],
-      spills: z13.array(z13.json()).parse(spills)
+      spills: z12.array(z12.json()).parse(spills)
     });
     await driver.events.append(tx, agentStoreEventDraft({
       conversationId: input.destinationConversationId,
       kind: "runtime/branched",
-      payload: z13.json().parse(receipt)
+      payload: z12.json().parse(receipt)
     }));
     return { outcome: "created", receipt };
   });
@@ -2000,7 +1943,7 @@ function findEventOnce(driver, input) {
 }
 
 // src/agent-runtime/store-mutate.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function validateAdmissionReceipt(receipt, record, conversationId) {
   const input = receipt.input;
   const run = record.run;
@@ -2147,7 +2090,7 @@ async function persistApplied(driver, transaction, read, operation, reduced) {
   await driver.events.append(transaction, agentStoreEventDraft({
     conversationId,
     kind: "runtime/transition",
-    payload: z14.json().parse(transitionRecord(operation, reduced))
+    payload: z13.json().parse(transitionRecord(operation, reduced))
   }));
   return { outcome: "applied", snapshot: reduced.snapshot };
 }
@@ -2196,9 +2139,9 @@ function createStoreConversationPurge(driver, conversations) {
 }
 
 // src/agent-runtime/store-create.ts
-var AgentRecoverableScanInputSchema = z15.object({
-  cursor: z15.string().min(1).optional(),
-  limit: z15.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z14.object({
+  cursor: z14.string().min(1).optional(),
+  limit: z14.number().int().min(1).max(1000)
 });
 function createAgentRuntimeStore2(driver) {
   const mutate = (operation) => mutateStore(driver, operation);
@@ -2250,4 +2193,4 @@ function createAgentRuntimeStore2(driver) {
   };
 }
 
-export { BranchAgentConversationInputSchema2, AgentConversationBranchReceiptSchema2, AgentConversationBranchResultSchema2, AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, ArchiveProjectionSchema, ArchiveSpillSchema, createAgentRuntimeStore2 };
+export { BranchAgentConversationInputSchema2, AgentConversationBranchReceiptSchema2, AgentConversationBranchResultSchema2, AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, replaceMessage, appendEventIn, ArchiveProjectionSchema, ArchiveSpillSchema, createAgentRuntimeStore2 };

package/dist/{index-4g6qmgdx.js → index-ghtpfz4z.js}

@@ -1,23 +1,23 @@
 import {
   AgentStoreEventEnvelopeSchema2,
   AgentStoreEventPageSchema2,
-  AgentRecoverablePageSchema2
-} from "./index-fggxgbrk.js";
-import {
-  AgentRecordIdSchema2,
-  AgentMessageSchema2
-} from "./index-8kzct1d6.js";
-import {
+  AgentRecoverablePageSchema2,
   AgentRuntimeHeadSchema2,
   AgentStoredRunSchema2,
   AgentAdmissionReceiptSchema2,
   AgentSeedReceiptSchema2,
   AgentHistoryMutationSchema2,
-  isActiveRunState,
+  isActiveRunState
+} from "./index-xx1j310k.js";
+import {
+  AgentRecordIdSchema2,
+  AgentMessageSchema2
+} from "./index-8kzct1d6.js";
+import {
   replaceMessage,
   ArchiveSpillSchema,
   createAgentRuntimeStore2
-} from "./index-jq2ky8fw.js";
+} from "./index-cycp3r3e.js";
 
 // src/agent-runtime/store-memory.ts
 import { z as z2 } from "zod";