stitchkit 0.85.2 → 0.87.0

package/dist/{index-fq492hg0.js → index-5wezxcxx.js}

@@ -1,51 +1,49 @@
 import {
-  assistantStatus
-} from "./index-y2s6h5bf.js";
+  AcceptInputAndAssignRunSchema,
+  AcquireAgentRunSchema,
+  AgentRecoverablePageSchema,
+  AgentRunViewSchema,
+  AgentStoreEventEnvelopeSchema,
+  AgentStoreEventPageSchema,
+  AgentStoreTransitionSchema,
+  AppendAgentStoreEventSchema,
+  CheckpointRunAssistantSchema,
+  CommitRunTerminalSchema,
+  ReadAgentStoreEventsSchema,
+  RecordRunOperationSchema,
+  RecoverAgentRunSchema,
+  ReplaceCompactedRangeSchema,
+  RequestRunInterruptSchema,
+  agentStoreEventDraft,
+  assistantStatus,
+  canonicalAgentJson,
+  decodeAgentConversationArchive,
+  encodeAgentConversationArchive
+} from "./index-z1m86vc8.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema,
   AgentRecordVersionSchema,
-  AgentRunOperationSchema,
   AgentRunSchema,
   AgentSnapshotSchema,
-  AgentTerminalReasonSchema,
-  AgentUsageSchema,
   runStateForTerminalReason
-} from "./index-x15ss2dx.js";
-
-// src/agent-runtime/conversations.ts
-import { z } from "zod";
-var AgentConversationSummarySchema = z.object({
-  conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  updatedAt: z.iso.datetime({ offset: true }),
-  preview: z.string(),
-  activeRuns: z.int().nonnegative()
-}).strict();
-var AgentConversationPageSchema = z.object({
-  items: z.array(AgentConversationSummarySchema),
-  nextCursor: z.string().min(1).optional()
-}).strict();
-var AgentConversationMessagePageSchema = z.object({
-  items: z.array(AgentMessageSchema),
-  nextCursor: z.string().min(1).optional()
-}).strict();
+} from "./index-p1b1y93x.js";
 
 // src/agent-runtime/purge.ts
-import { z as z2 } from "zod";
-var AgentConversationPurgeInputSchema = z2.strictObject({
+import { z } from "zod";
+var AgentConversationPurgeInputSchema = z.strictObject({
   conversationId: AgentRecordIdSchema,
   expectedVersion: AgentRecordVersionSchema.optional()
 });
-var AgentConversationPurgeResultSchema = z2.discriminatedUnion("outcome", [
-  z2.strictObject({ outcome: z2.literal("purged") }),
-  z2.strictObject({ outcome: z2.literal("already_purged") }),
-  z2.strictObject({ outcome: z2.literal("unsupported") }),
-  z2.strictObject({
-    outcome: z2.literal("active"),
-    runIds: z2.array(AgentRecordIdSchema).min(1)
+var AgentConversationPurgeResultSchema = z.discriminatedUnion("outcome", [
+  z.strictObject({ outcome: z.literal("purged") }),
+  z.strictObject({ outcome: z.literal("already_purged") }),
+  z.strictObject({ outcome: z.literal("unsupported") }),
+  z.strictObject({
+    outcome: z.literal("active"),
+    runIds: z.array(AgentRecordIdSchema).min(1)
   }),
-  z2.strictObject({ outcome: z2.literal("conflict"), actualVersion: AgentRecordVersionSchema })
+  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema })
 ]);
 
 class AgentConversationPurgedError extends Error {
@@ -61,112 +59,9 @@ async function purgeAgentConversation(store, input) {
   return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
 }
 
-// src/agent-runtime/store.ts
-import { z as z3 } from "zod";
-var AgentStoreConflictSchema = z3.object({
-  outcome: z3.literal("conflict"),
-  actualVersion: AgentRecordVersionSchema
-});
-var AgentStoreNotFoundSchema = z3.object({ outcome: z3.literal("not_found") });
-var AgentStoreAppliedSchema = z3.object({
-  outcome: z3.literal("applied"),
-  snapshot: AgentSnapshotSchema
-});
-var AgentStoreDuplicateSchema = z3.object({
-  outcome: z3.literal("duplicate"),
-  input: AgentMessageSchema,
-  inputMessageId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  assistantMessageId: AgentRecordIdSchema,
-  run: AgentRunSchema,
-  assistant: AgentMessageSchema.optional(),
-  snapshot: AgentSnapshotSchema
-});
-var AgentStoreMutationResultSchema = z3.discriminatedUnion("outcome", [
-  AgentStoreAppliedSchema,
-  AgentStoreDuplicateSchema,
-  AgentStoreConflictSchema,
-  AgentStoreNotFoundSchema
-]);
-var AgentRunViewSchema = z3.object({
-  snapshotVersion: AgentRecordVersionSchema,
-  run: AgentRunSchema,
-  assistant: AgentMessageSchema.optional()
-});
-var AcceptInputAndAssignRunSchema = z3.object({
-  idempotencyKey: z3.string().min(1),
-  expectedVersion: AgentRecordVersionSchema.optional(),
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  coalesceIntoRunId: AgentRecordIdSchema.optional()
-});
-var AcquireAgentRunSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
-  ownerId: z3.string().min(1)
-});
-var CheckpointRunAssistantSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
-  ownerId: z3.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema,
-  usage: AgentUsageSchema.optional()
-});
-var RecordRunOperationSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
-  ownerId: z3.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  operation: AgentRunOperationSchema
-});
-var CommitRunTerminalSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
-  ownerId: z3.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema,
-  reason: AgentTerminalReasonSchema,
-  policyName: z3.string().min(1).optional(),
-  usage: AgentUsageSchema.optional(),
-  absorb: z3.array(z3.object({
-    runId: AgentRecordIdSchema,
-    inputMessageIds: z3.array(AgentRecordIdSchema).min(1)
-  })).min(1).optional()
-});
-var RequestRunInterruptSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema
-});
-var RecoverAgentRunSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
-  action: z3.enum(["requeue", "abandon"]),
-  replaySafe: z3.boolean().optional()
-});
-var ReplaceCompactedRangeSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
-  summary: AgentMessageSchema
-});
-var AgentRecoverableDescriptorSchema = z3.object({
-  conversationId: AgentRecordIdSchema,
-  run: AgentRunSchema
-});
-var AgentRecoverablePageSchema = z3.object({
-  items: z3.array(AgentRecoverableDescriptorSchema),
-  nextCursor: z3.string().min(1).optional()
-});
-
 // src/agent-runtime/store-driver.ts
-import { z as z4 } from "zod";
+import { createHash } from "node:crypto";
+import { z as z2 } from "zod";
 
 // src/agent-runtime/store-purge.ts
 function createStoreConversationPurge(driver, conversations) {
@@ -192,40 +87,59 @@ function createStoreConversationPurge(driver, conversations) {
 }
 
 // src/agent-runtime/store-driver.ts
-var AgentRuntimeHeadSchema = z4.object({
-  schemaVersion: z4.literal(1),
+var AgentRuntimeHeadSchema = z2.object({
+  schemaVersion: z2.literal(1),
   conversationId: AgentRecordIdSchema,
   version: AgentRecordVersionSchema
 });
-var AgentStoredRunSchema = z4.object({
-  schemaVersion: z4.literal(1),
+var AgentStoredRunSchema = z2.object({
+  schemaVersion: z2.literal(1),
   run: AgentRunSchema,
   terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentAdmissionReceiptSchema = z4.object({
-  schemaVersion: z4.literal(1),
+var AgentAdmissionReceiptSchema = z2.object({
+  schemaVersion: z2.literal(1),
   conversationId: AgentRecordIdSchema,
-  idempotencyKey: z4.string().min(1),
+  idempotencyKey: z2.string().min(1),
   input: AgentMessageSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema
 });
-var AgentHistoryMutationSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("admit"), input: AgentMessageSchema }),
-  z4.object({
-    type: z4.literal("upsert-assistant"),
+var AgentHistoryMutationSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema }),
+  z2.object({
+    type: z2.literal("upsert-assistant"),
     message: AgentMessageSchema
   }),
-  z4.object({
-    type: z4.literal("replace-compacted-range"),
-    replacedMessageIds: z4.array(AgentRecordIdSchema).min(1),
+  z2.object({
+    type: z2.literal("replace-compacted-range"),
+    replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
     summary: AgentMessageSchema
   })
 ]);
-var AgentRecoverableScanInputSchema = z4.object({
-  cursor: z4.string().min(1).optional(),
-  limit: z4.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z2.object({
+  cursor: z2.string().min(1).optional(),
+  limit: z2.number().int().min(1).max(1000)
 });
+function transitionRecord(operation) {
+  if (operation.type !== "checkpoint")
+    return operation;
+  const { assistant, ...rest } = operation.input;
+  const body = canonicalAgentJson(assistant);
+  return {
+    type: operation.type,
+    input: {
+      ...rest,
+      assistant: {
+        id: assistant.id,
+        status: assistant.status,
+        sha256: createHash("sha256").update(body).digest("hex"),
+        parts: assistant.parts.length,
+        bytes: Buffer.byteLength(body)
+      }
+    }
+  };
+}
 function emptyHead(conversationId) {
   return AgentRuntimeHeadSchema.parse({
     schemaVersion: 1,
@@ -328,7 +242,7 @@ function validateSnapshot(head, messages, records) {
     }
   }
 }
-var RecoverableCursorSchema = z4.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -650,7 +564,7 @@ function validateAdmissionReceipt(receipt, record, conversationId) {
   }
 }
 function createAgentRuntimeStore(driver) {
-  const loadSnapshot = (conversationId) => driver.transaction(async (transaction) => {
+  const snapshotIn = async (transaction, conversationId) => {
     const [stored, messages, activeRecords] = await Promise.all([
       driver.head.load(transaction, conversationId),
       driver.history.load(transaction, conversationId),
@@ -662,7 +576,10 @@ function createAgentRuntimeStore(driver) {
       runIds: referencedRunIds(messages)
     });
     return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
-  }, { access: "read" });
+  };
+  const loadSnapshot = (conversationId) => driver.transaction((transaction) => snapshotIn(transaction, conversationId), {
+    access: "read"
+  });
   const loadRun = (input) => driver.transaction(async (transaction) => {
     const [stored, record] = await Promise.all([
       driver.head.load(transaction, input.conversationId),
@@ -798,12 +715,142 @@ function createAgentRuntimeStore(driver) {
     for (const mutation of reduced.historyMutations ?? []) {
       await driver.history.apply(transaction, mutation);
     }
+    await driver.events.append(transaction, agentStoreEventDraft({
+      conversationId,
+      kind: "runtime/transition",
+      payload: z2.json().parse(transitionRecord(operation))
+    }));
     return { outcome: "applied", snapshot: reduced.snapshot };
   });
+  const appendEvent = (input) => {
+    const parsed = AppendAgentStoreEventSchema.parse(input);
+    return driver.transaction(async (transaction) => {
+      if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+        throw new AgentConversationPurgedError;
+      }
+      return driver.events.append(transaction, agentStoreEventDraft(parsed));
+    });
+  };
+  const readEvents = (input) => {
+    const parsed = ReadAgentStoreEventsSchema.parse(input);
+    return driver.transaction(async (transaction) => AgentStoreEventPageSchema.parse(await driver.events.list(transaction, parsed)), { access: "read" });
+  };
+  const exportConversation = (conversationId) => driver.transaction(async (transaction) => {
+    const events = [];
+    let fromSeq;
+    do {
+      const page = AgentStoreEventPageSchema.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema.parse({
+        conversationId,
+        ...fromSeq && { fromSeq },
+        limit: 1e4
+      })));
+      events.push(...page.items);
+      fromSeq = page.nextSeq;
+    } while (fromSeq !== undefined);
+    const durable = await driver.archive?.export(transaction, conversationId) ?? {
+      projections: [],
+      spills: []
+    };
+    const snapshot = await snapshotIn(transaction, conversationId);
+    return encodeAgentConversationArchive({
+      format: "stitchkit.agent-conversation",
+      formatVersion: 1,
+      conversationId,
+      events,
+      projections: [
+        { archiveType: "runtime-snapshot", snapshot: z2.json().parse(snapshot) },
+        ...durable.projections
+      ],
+      spills: durable.spills
+    });
+  }, { access: "read" });
+  const importConversation = async (bytes) => {
+    const archive = decodeAgentConversationArchive(bytes);
+    return driver.transaction(async (transaction) => {
+      const existing = await driver.events.list(transaction, {
+        conversationId: archive.conversationId,
+        limit: 1
+      });
+      if (existing.items.length > 0) {
+        throw new TypeError("Conversation event log must be empty before import");
+      }
+      for (const event of archive.events) {
+        const appended = await driver.events.append(transaction, {
+          schemaVersion: event.schemaVersion,
+          eventId: event.eventId,
+          conversationId: event.conversationId,
+          kind: event.kind,
+          occurredAt: event.occurredAt,
+          payload: event.payload,
+          ...event.ignorable && { ignorable: true }
+        });
+        if (appended.seq !== event.seq) {
+          throw new TypeError("Conversation archive event sequence is not contiguous");
+        }
+      }
+      const snapshotEntry = archive.projections.find((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.archiveType === "runtime-snapshot");
+      if (snapshotEntry && typeof snapshotEntry === "object" && !Array.isArray(snapshotEntry)) {
+        const snapshot = AgentSnapshotSchema.parse(snapshotEntry.snapshot);
+        if (snapshot.conversationId !== archive.conversationId) {
+          throw new TypeError("Conversation archive snapshot belongs to another conversation");
+        }
+        if (snapshot.version > 0 || snapshot.messages.length > 0 || snapshot.runs.length > 0) {
+          const outcome = await driver.head.compareAndSwap(transaction, {
+            conversationId: snapshot.conversationId,
+            expectedVersion: 0,
+            next: AgentRuntimeHeadSchema.parse({
+              schemaVersion: 1,
+              conversationId: snapshot.conversationId,
+              version: snapshot.version
+            })
+          });
+          if (outcome.outcome !== "applied") {
+            throw new TypeError("Conversation archive snapshot target is not empty");
+          }
+        }
+        for (const run of snapshot.runs) {
+          const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
+          await driver.runs.save(transaction, AgentStoredRunSchema.parse({
+            schemaVersion: 1,
+            run,
+            ...terminalAssistant && { terminalAssistant }
+          }));
+        }
+        for (const message of snapshot.messages) {
+          await driver.history.apply(transaction, { type: "admit", input: message });
+        }
+        for (const event of archive.events) {
+          if (event.kind !== "runtime/transition")
+            continue;
+          const transition = AgentStoreTransitionSchema.parse(event.payload);
+          if (transition.type !== "accept")
+            continue;
+          const assigned = snapshot.runs.find((run) => run.inputMessageIds.includes(transition.input.input.id));
+          if (!assigned) {
+            throw new TypeError("Conversation archive admission has no assigned run");
+          }
+          await driver.admissions.create(transaction, AgentAdmissionReceiptSchema.parse({
+            schemaVersion: 1,
+            conversationId: archive.conversationId,
+            idempotencyKey: transition.input.idempotencyKey,
+            input: transition.input.input,
+            runId: assigned.id,
+            assistantMessageId: assigned.assistantMessageId
+          }));
+        }
+      }
+      await driver.archive?.import(transaction, archive);
+      return { conversationId: archive.conversationId, events: archive.events.length };
+    });
+  };
   return {
     loadSnapshot,
     loadRun,
     listActiveRuns,
+    appendEvent,
+    readEvents,
+    exportConversation,
+    importConversation,
     ...driver.conversations && {
       purgeConversation: createStoreConversationPurge(driver, driver.conversations)
     },
@@ -860,6 +907,7 @@ function createMemoryAgentRuntimeStore() {
   let runs = new Map;
   let admissions = new Map;
   let histories = new Map;
+  let events = new Map;
   let transactionTail = Promise.resolve();
   const driver = {
     async transaction(work) {
@@ -876,7 +924,11 @@ function createMemoryAgentRuntimeStore() {
         heads: cloneHeadMap(heads),
         runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
         admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
-        histories: cloneHistoryMap(histories)
+        histories: cloneHistoryMap(histories),
+        events: new Map([...events].map(([conversationId, stored]) => [
+          conversationId,
+          stored.map((event) => AgentStoreEventEnvelopeSchema.parse(structuredClone(event)))
+        ]))
       };
       try {
         const result = await work(transaction);
@@ -885,6 +937,7 @@ function createMemoryAgentRuntimeStore() {
         runs = transaction.runs;
         admissions = transaction.admissions;
         histories = transaction.histories;
+        events = transaction.events;
         return result;
       } finally {
         release.resolve();
@@ -900,6 +953,7 @@ function createMemoryAgentRuntimeStore() {
         transaction.runs.delete(conversationId);
         transaction.admissions.delete(conversationId);
         transaction.histories.delete(conversationId);
+        transaction.events.delete(conversationId);
       }
     },
     head: {
@@ -995,6 +1049,29 @@ function createMemoryAgentRuntimeStore() {
         ]);
       }
     },
+    events: {
+      async append(transaction, draft) {
+        const current = transaction.events.get(draft.conversationId) ?? [];
+        const event = AgentStoreEventEnvelopeSchema.parse({
+          ...draft,
+          seq: (current.at(-1)?.seq ?? 0) + 1
+        });
+        if (current.some((candidate) => candidate.eventId === event.eventId)) {
+          throw new TypeError("Agent store event identity is already present");
+        }
+        transaction.events.set(draft.conversationId, [...current, event]);
+        return event;
+      },
+      async list(transaction, input) {
+        const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
+        const items = selected.slice(0, input.limit);
+        const last = items.at(-1);
+        return AgentStoreEventPageSchema.parse({
+          items,
+          ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
+        });
+      }
+    },
     async scanRecoverable(input) {
       const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
       const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
@@ -1014,4 +1091,4 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 
-export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, RecordRunOperationSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };
+export { AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };

package/dist/index-9553432s.js

@@ -0,0 +1,26 @@
+import {
+  AgentMessageSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema
+} from "./index-p1b1y93x.js";
+
+// src/agent-runtime/conversations.ts
+import { z } from "zod";
+var AgentConversationSummarySchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema,
+  updatedAt: z.iso.datetime({ offset: true }),
+  preview: z.string(),
+  activeRuns: z.int().nonnegative()
+}).strict();
+var AgentConversationPageSchema = z.object({
+  items: z.array(AgentConversationSummarySchema),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+var AgentConversationMessagePageSchema = z.object({
+  items: z.array(AgentMessageSchema),
+  compacted: z.array(z.string().min(1)),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+
+export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema };

package/dist/{index-27487ay5.js → index-9hw9eq48.js}

@@ -3,19 +3,19 @@ import {
 } from "./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-s4ckmrac.js";
+} from "./index-rcgsnrr6.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-fwbkp2jn.js";
+} from "./index-0vfdh685.js";
 import {
   toolResultFromError
-} from "./index-dggwnnjv.js";
+} from "./index-wn9cb82y.js";
 import {
   assertUniqueToolName,
   buildToolPresentationSchema,
   objectShapeKeys
-} from "./index-mgtxfe6b.js";
+} from "./index-r159gjwy.js";
 import {
   jsonSchemaFields
 } from "./index-cby4ar3v.js";

package/dist/index-cnyk6te3.js

@@ -0,0 +1,77 @@
+// src/agent-runtime/testing.ts
+function createAgentRaceBarrier(timeoutMs = 5000) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
+    throw new TypeError("Agent race barrier timeoutMs must be a positive safe integer");
+  }
+  const reached = Promise.withResolvers();
+  const released = Promise.withResolvers();
+  let announced = false;
+  return {
+    reached: reached.promise,
+    async wait() {
+      if (!announced) {
+        announced = true;
+        reached.resolve();
+      }
+      let timer;
+      try {
+        await Promise.race([
+          released.promise,
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new Error(`Agent race barrier exceeded ${timeoutMs}ms teardown bound`)), timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    },
+    release: released.resolve
+  };
+}
+function createAgentRaceTrace() {
+  const recorded = [];
+  return {
+    record(name) {
+      const entry = { name, sequence: recorded.length };
+      recorded.push(entry);
+      return entry;
+    },
+    entries: () => recorded.map((entry) => ({ ...entry })),
+    assertBefore(first, second) {
+      const firstEntry = recorded.find((entry) => entry.name === first);
+      const secondEntry = recorded.find((entry) => entry.name === second);
+      if (!firstEntry || !secondEntry || firstEntry.sequence >= secondEntry.sequence) {
+        throw new Error(`Expected ${first} before ${second}`);
+      }
+    },
+    assertSequence(names) {
+      const actual = recorded.map((entry) => entry.name);
+      if (actual.length !== names.length || actual.some((name, index) => name !== names[index])) {
+        throw new Error(`Expected trace ${names.join(" -> ")}, received ${actual.join(" -> ")}`);
+      }
+    },
+    count: (name) => recorded.filter((entry) => entry.name === name).length
+  };
+}
+function createAgentRaceDriver(timeoutMs = 5000) {
+  const trace = createAgentRaceTrace();
+  const barriers = new Map;
+  return {
+    trace,
+    barrier(name) {
+      const existing = barriers.get(name);
+      if (existing)
+        return existing;
+      const created = createAgentRaceBarrier(timeoutMs);
+      barriers.set(name, created);
+      return created;
+    },
+    releaseAll() {
+      for (const barrier of barriers.values())
+        barrier.release();
+    }
+  };
+}
+
+export { createAgentRaceBarrier, createAgentRaceTrace, createAgentRaceDriver };