stitchkit 0.100.2 → 0.100.3

package/dist/{index-v260df89.js → index-qjeggp8w.js}

@@ -1,11 +1,11 @@
 import {
-  createTraceContext,
-  formatTraceparent
-} from "./index-zcgf3gqf.js";
+  createTraceContext2,
+  formatTraceparent2
+} from "./index-hby4qhax.js";
 import {
   isRecord,
   transportResult
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/browser/http.ts
 import ky, {
@@ -150,7 +150,7 @@ function messageForCode(code, message) {
   return message !== undefined && message.length > 0 ? message : `${code} (no message supplied)`;
 }
 
-class ApiError extends Error {
+class ApiError2 extends Error {
   code;
   status;
   details;
@@ -171,7 +171,7 @@ class ApiError extends Error {
   }
 }
 function refuseLocally(path, message) {
-  return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
+  return new ApiError2("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
 }
 function isAbortLikeError(error) {
   if (error instanceof RequestCancellationError)
@@ -179,7 +179,7 @@ function isAbortLikeError(error) {
   return typeof error === "object" && error !== null && "name" in error && (error.name === "AbortError" || error.name === "TimeoutError");
 }
 function shouldRetryBunNetworkError(error) {
-  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || isAbortLikeError(error)) {
+  if (ApiError2.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || isAbortLikeError(error)) {
     return;
   }
   if (!(error instanceof Error))
@@ -215,17 +215,17 @@ function assertTransportChoice(config) {
 }
 function requestFailure(error, emit) {
   if (error instanceof RequestCancellationError) {
-    return new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
+    return new ApiError2(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
   }
-  if (ApiError.is(error))
+  if (ApiError2.is(error))
     return error;
   emit({ type: "network_error" });
   const response = isHTTPError(error) ? error.response : undefined;
   const status = response?.status ?? 0;
   const msg = error instanceof Error ? error.message : undefined;
-  return new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
+  return new ApiError2("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
 }
-function createHttpClient(config) {
+function createHttpClient2(config) {
   assertTransportChoice(config);
   let ssrCookies = null;
   let isLoggedOut = false;
@@ -251,30 +251,30 @@ function createHttpClient(config) {
     },
     hooks: {
       beforeRequest: [
-        ({ request: request2 }) => {
+        ({ request }) => {
           if (ssrCookies) {
-            request2.headers.set("Cookie", ssrCookies);
+            request.headers.set("Cookie", ssrCookies);
           }
           const extra = typeof config.headers === "function" ? config.headers() : config.headers;
           if (extra) {
             for (const [key, value] of Object.entries(extra)) {
-              request2.headers.set(key, value);
+              request.headers.set(key, value);
             }
           }
-          if (config.trace && !request2.headers.has("traceparent")) {
-            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
+          if (config.trace && !request.headers.has("traceparent")) {
+            request.headers.set("traceparent", formatTraceparent2(createTraceContext2()));
           }
         }
       ],
       afterResponse: [
-        async ({ request: request2, response }) => {
+        async ({ request, response }) => {
           if (config.release) {
             try {
               config.release.observe(response.headers.get("x-build-id"));
             } catch {}
           }
           if (response.status === 401) {
-            const url = new URL(request2.url).pathname;
+            const url = new URL(request.url).pathname;
             if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
               isLoggedOut = true;
               emit({ type: "unauthorized" });
@@ -285,7 +285,7 @@ function createHttpClient(config) {
             if (body) {
               const parsed = parseError(body);
               if (parsed) {
-                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
+                throw new ApiError2(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
               }
             }
           }
@@ -339,4 +339,4 @@ function createHttpClient(config) {
   };
 }
 
-export { RequestCancellationError, createRequestCancellation, responseTraceId, ApiError, refuseLocally, isAbortLikeError, parseApiErrorBody, createHttpClient };
+export { RequestCancellationError, createRequestCancellation, responseTraceId, ApiError2, refuseLocally, isAbortLikeError, parseApiErrorBody, createHttpClient2 };

package/dist/{index-zfrhfn82.js → index-r1z0rd9c.js}

@@ -1,13 +1,13 @@
 import {
-  getClientInfo,
-  resolveSocketIp
-} from "./index-35mh5bhj.js";
+  resolveTraceContext2
+} from "./index-hby4qhax.js";
 import {
-  resolveTraceContext
-} from "./index-zcgf3gqf.js";
+  resolveSocketIp2,
+  getClientInfo2
+} from "./index-kw1ws0cs.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 
 // src/observability/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -16,24 +16,24 @@ var requestStorage = () => {
   storage ??= new AsyncLocalStorage;
   return storage;
 };
-function runWithRequestContext(ctx, fn) {
+function runWithRequestContext2(ctx, fn) {
   return requestStorage().run(ctx, fn);
 }
-function getRequestContext() {
+function getRequestContext2() {
   return requestStorage().getStore();
 }
-function getTraceId() {
+function getTraceId2() {
   return requestStorage().getStore()?.trace.traceId;
 }
-function getUserId() {
+function getUserId2() {
   return requestStorage().getStore()?.userId;
 }
-function setRequestUser(userId) {
+function setRequestUser2(userId) {
   const ctx = requestStorage().getStore();
   if (ctx)
     ctx.userId = userId;
 }
-function setRequestEndpoint(serviceName, action) {
+function setRequestEndpoint2(serviceName, action) {
   const ctx = requestStorage().getStore();
   if (ctx) {
     ctx.serviceName = serviceName;
@@ -41,7 +41,7 @@ function setRequestEndpoint(serviceName, action) {
       ctx.action = action;
   }
 }
-function setRequestDimensions(dimensions, options = {}) {
+function setRequestDimensions2(dimensions, options = {}) {
   const ctx = requestStorage().getStore();
   if (!ctx)
     return;
@@ -59,27 +59,27 @@ function setRequestDimensions(dimensions, options = {}) {
   }
   ctx.dimensions = next;
 }
-function setRequestError(error) {
+function setRequestError2(error) {
   const ctx = requestStorage().getStore();
   if (ctx)
     ctx.error = error;
 }
-function wrapInRequestContext(handler, options = {}) {
+function wrapInRequestContext2(handler, options = {}) {
   return (req, server) => {
     const ctx = {
-      trace: resolveTraceContext(req),
+      trace: resolveTraceContext2(req),
       source: "http",
       kind: "request",
       method: req.method,
       path: new URL(req.url, "http://localhost").pathname,
       startedAt: process.hrtime.bigint(),
-      ...getClientInfo(req, {
+      ...getClientInfo2(req, {
         trustProxy: options.trustProxy,
-        socketIp: resolveSocketIp(req, server)
+        socketIp: resolveSocketIp2(req, server)
       })
     };
-    return runWithRequestContext(ctx, () => handler(req, server));
+    return runWithRequestContext2(ctx, () => handler(req, server));
   };
 }
 
-export { runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };
+export { runWithRequestContext2, getRequestContext2, getTraceId2, getUserId2, setRequestUser2, setRequestEndpoint2, setRequestDimensions2, setRequestError2, wrapInRequestContext2 };

package/dist/{index-wqgjfstn.js → index-r5c4fedv.js}

@@ -1,7 +1,7 @@
 // src/contract/stream.ts
 import { z } from "zod";
-var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
-var ContractStreamFrameSchema = z.discriminatedUnion("type", [
+var DEFAULT_CONTRACT_STREAM_FRAME_BYTES2 = 256 * 1024;
+var ContractStreamFrameSchema2 = z.discriminatedUnion("type", [
   z.object({ type: z.literal("data"), data: z.unknown() }).strict(),
   z.object({
     type: z.literal("error"),
@@ -15,4 +15,4 @@ var ContractStreamFrameSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("end") }).strict()
 ]);
 
-export { DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };
+export { DEFAULT_CONTRACT_STREAM_FRAME_BYTES2, ContractStreamFrameSchema2 };

package/dist/{index-cyktc4bp.js → index-r5hsgkz5.js}

@@ -1,20 +1,20 @@
 import {
-  AgentMessageSchema,
-  AgentRecordIdSchema,
-  AgentRecordVersionSchema,
-  AgentRunOperationSchema,
-  AgentRunSchema,
-  AgentSnapshotSchema,
-  AgentTerminalReasonSchema,
-  AgentUsageSchema
-} from "./index-gtj3zc53.js";
+  AgentRecordIdSchema2,
+  AgentRecordVersionSchema2,
+  AgentMessageSchema2,
+  AgentRunOperationSchema2,
+  AgentTerminalReasonSchema2,
+  AgentUsageSchema2,
+  AgentRunSchema2,
+  AgentSnapshotSchema2
+} from "./index-8kzct1d6.js";
 import {
   serializeCanonicalJson
-} from "./index-k5hsfc3j.js";
+} from "./index-zsvzhjtk.js";
 
 // src/durability/events.ts
 import { z } from "zod";
-var AgentStoreEventKindSchema = z.enum([
+var AgentStoreEventKindSchema2 = z.enum([
   "runtime/baseline",
   "runtime/transition",
   "invocation/started",
@@ -42,7 +42,7 @@ var AgentStoreEventKindSchema = z.enum([
   "durability/event",
   "durability/effect"
 ]);
-var AgentStoreEventEnvelopeSchema = z.object({
+var AgentStoreEventEnvelopeSchema2 = z.object({
   schemaVersion: z.int().positive(),
   eventId: z.string().min(1),
   conversationId: z.string().min(1),
@@ -52,152 +52,152 @@ var AgentStoreEventEnvelopeSchema = z.object({
   payload: z.json(),
   ignorable: z.literal(true).optional()
 }).strict();
-var AppendAgentStoreEventSchema = z.object({
+var AppendAgentStoreEventSchema2 = z.object({
   conversationId: z.string().min(1),
-  kind: AgentStoreEventKindSchema,
+  kind: AgentStoreEventKindSchema2,
   occurredAt: z.iso.datetime({ offset: true }).optional(),
   payload: z.json(),
   ignorable: z.literal(true).optional()
 }).strict();
-var ReadAgentStoreEventsSchema = z.object({
+var ReadAgentStoreEventsSchema2 = z.object({
   conversationId: z.string().min(1),
   fromSeq: z.int().positive().optional(),
   toSeq: z.int().positive().optional(),
   limit: z.int().positive().max(1e4).default(1000)
 }).strict().refine((input) => input.fromSeq === undefined || input.toSeq === undefined || input.fromSeq <= input.toSeq, { message: "fromSeq must not exceed toSeq" });
-var AgentStoreEventPageSchema = z.object({
-  items: z.array(AgentStoreEventEnvelopeSchema),
+var AgentStoreEventPageSchema2 = z.object({
+  items: z.array(AgentStoreEventEnvelopeSchema2),
   nextSeq: z.int().positive().optional()
 }).strict();
 
 // src/agent-runtime/store.ts
 import { z as z2 } from "zod";
-var AgentStoreConflictSchema = z2.object({
+var AgentStoreConflictSchema2 = z2.object({
   outcome: z2.literal("conflict"),
-  actualVersion: AgentRecordVersionSchema
+  actualVersion: AgentRecordVersionSchema2
 });
-var AgentStoreNotFoundSchema = z2.object({ outcome: z2.literal("not_found") });
-var AgentStoreAppliedSchema = z2.object({
+var AgentStoreNotFoundSchema2 = z2.object({ outcome: z2.literal("not_found") });
+var AgentStoreAppliedSchema2 = z2.object({
   outcome: z2.literal("applied"),
-  snapshot: AgentSnapshotSchema
+  snapshot: AgentSnapshotSchema2
 });
-var AgentStoreDuplicateSchema = z2.object({
+var AgentStoreDuplicateSchema2 = z2.object({
   outcome: z2.literal("duplicate"),
-  input: AgentMessageSchema,
-  inputMessageId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  assistantMessageId: AgentRecordIdSchema,
-  run: AgentRunSchema,
-  assistant: AgentMessageSchema.optional(),
-  snapshot: AgentSnapshotSchema
+  input: AgentMessageSchema2,
+  inputMessageId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  assistantMessageId: AgentRecordIdSchema2,
+  run: AgentRunSchema2,
+  assistant: AgentMessageSchema2.optional(),
+  snapshot: AgentSnapshotSchema2
 });
-var AgentStoreMutationResultSchema = z2.discriminatedUnion("outcome", [
-  AgentStoreAppliedSchema,
-  AgentStoreDuplicateSchema,
-  AgentStoreConflictSchema,
-  AgentStoreNotFoundSchema
+var AgentStoreMutationResultSchema2 = z2.discriminatedUnion("outcome", [
+  AgentStoreAppliedSchema2,
+  AgentStoreDuplicateSchema2,
+  AgentStoreConflictSchema2,
+  AgentStoreNotFoundSchema2
 ]);
-var AgentRunViewSchema = z2.object({
-  snapshotVersion: AgentRecordVersionSchema,
-  run: AgentRunSchema,
-  assistant: AgentMessageSchema.optional()
+var AgentRunViewSchema2 = z2.object({
+  snapshotVersion: AgentRecordVersionSchema2,
+  run: AgentRunSchema2,
+  assistant: AgentMessageSchema2.optional()
 });
-var AcceptInputAndAssignRunSchema = z2.object({
+var AcceptInputAndAssignRunSchema2 = z2.object({
   idempotencyKey: z2.string().min(1),
-  expectedVersion: AgentRecordVersionSchema.optional(),
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  coalesceIntoRunId: AgentRecordIdSchema.optional()
+  expectedVersion: AgentRecordVersionSchema2.optional(),
+  input: AgentMessageSchema2,
+  run: AgentRunSchema2,
+  coalesceIntoRunId: AgentRecordIdSchema2.optional()
 });
-var AcquireAgentRunSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
+var AcquireAgentRunSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2,
   ownerId: z2.string().min(1)
 });
-var CheckpointRunAssistantSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
+var CheckpointRunAssistantSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2,
   ownerId: z2.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema,
-  usage: AgentUsageSchema.optional()
+  fencingToken: AgentRecordVersionSchema2.optional(),
+  assistant: AgentMessageSchema2,
+  usage: AgentUsageSchema2.optional()
 });
-var RecordRunOperationSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
+var RecordRunOperationSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2,
   ownerId: z2.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  operation: AgentRunOperationSchema
+  fencingToken: AgentRecordVersionSchema2.optional(),
+  operation: AgentRunOperationSchema2
 });
-var CommitRunTerminalSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
+var CommitRunTerminalSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2,
   ownerId: z2.string().min(1),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema,
-  reason: AgentTerminalReasonSchema,
+  fencingToken: AgentRecordVersionSchema2.optional(),
+  assistant: AgentMessageSchema2,
+  reason: AgentTerminalReasonSchema2,
   policyName: z2.string().min(1).optional(),
-  usage: AgentUsageSchema.optional(),
+  usage: AgentUsageSchema2.optional(),
   absorb: z2.array(z2.object({
-    runId: AgentRecordIdSchema,
-    inputMessageIds: z2.array(AgentRecordIdSchema).min(1)
+    runId: AgentRecordIdSchema2,
+    inputMessageIds: z2.array(AgentRecordIdSchema2).min(1)
   })).min(1).optional()
 });
-var RequestRunInterruptSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema
+var RequestRunInterruptSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2
 });
-var RecoverAgentRunSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  expectedRevision: AgentRecordVersionSchema,
+var RecoverAgentRunSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  expectedRevision: AgentRecordVersionSchema2,
   action: z2.enum(["requeue", "abandon"]),
   replaySafe: z2.boolean().optional()
 });
-var ReplaceCompactedRangeSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
-  summary: AgentMessageSchema
+var ReplaceCompactedRangeSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  expectedVersion: AgentRecordVersionSchema2,
+  replacedMessageIds: z2.array(AgentRecordIdSchema2).min(1),
+  summary: AgentMessageSchema2
 });
-var SeedConversationInputSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
+var SeedConversationInputSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
   seedKey: z2.string().min(1),
-  inputs: z2.array(AgentMessageSchema).min(1)
+  inputs: z2.array(AgentMessageSchema2).min(1)
 });
-var AgentRecoverableDescriptorSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  run: AgentRunSchema
+var AgentRecoverableDescriptorSchema2 = z2.object({
+  conversationId: AgentRecordIdSchema2,
+  run: AgentRunSchema2
 });
-var AgentRecoverablePageSchema = z2.object({
-  items: z2.array(AgentRecoverableDescriptorSchema),
+var AgentRecoverablePageSchema2 = z2.object({
+  items: z2.array(AgentRecoverableDescriptorSchema2),
   nextCursor: z2.string().min(1).optional()
 });
 
 // src/agent-runtime/store-events.ts
 import { randomUUID } from "node:crypto";
 import { z as z3 } from "zod";
-var AgentStoreTransitionSchema = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("accept"), input: AcceptInputAndAssignRunSchema }).strict(),
-  z3.object({ type: z3.literal("acquire"), input: AcquireAgentRunSchema }).strict(),
-  z3.object({ type: z3.literal("checkpoint"), input: CheckpointRunAssistantSchema }).strict(),
-  z3.object({ type: z3.literal("operation"), input: RecordRunOperationSchema }).strict(),
-  z3.object({ type: z3.literal("interrupt"), input: RequestRunInterruptSchema }).strict(),
-  z3.object({ type: z3.literal("recover"), input: RecoverAgentRunSchema }).strict(),
-  z3.object({ type: z3.literal("terminal"), input: CommitRunTerminalSchema }).strict(),
-  z3.object({ type: z3.literal("compact"), input: ReplaceCompactedRangeSchema }).strict(),
-  z3.object({ type: z3.literal("seed"), input: SeedConversationInputSchema }).strict()
+var AgentStoreTransitionSchema2 = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("accept"), input: AcceptInputAndAssignRunSchema2 }).strict(),
+  z3.object({ type: z3.literal("acquire"), input: AcquireAgentRunSchema2 }).strict(),
+  z3.object({ type: z3.literal("checkpoint"), input: CheckpointRunAssistantSchema2 }).strict(),
+  z3.object({ type: z3.literal("operation"), input: RecordRunOperationSchema2 }).strict(),
+  z3.object({ type: z3.literal("interrupt"), input: RequestRunInterruptSchema2 }).strict(),
+  z3.object({ type: z3.literal("recover"), input: RecoverAgentRunSchema2 }).strict(),
+  z3.object({ type: z3.literal("terminal"), input: CommitRunTerminalSchema2 }).strict(),
+  z3.object({ type: z3.literal("compact"), input: ReplaceCompactedRangeSchema2 }).strict(),
+  z3.object({ type: z3.literal("seed"), input: SeedConversationInputSchema2 }).strict()
 ]);
 var CURRENT_EVENT_SCHEMA_VERSION = 1;
-function decodeAgentStoreEvent(value) {
-  const envelope = AgentStoreEventEnvelopeSchema.parse(value);
+function decodeAgentStoreEvent2(value) {
+  const envelope = AgentStoreEventEnvelopeSchema2.parse(value);
   const knownVersion = envelope.schemaVersion === CURRENT_EVENT_SCHEMA_VERSION;
-  const knownKind = AgentStoreEventKindSchema.safeParse(envelope.kind).success;
+  const knownKind = AgentStoreEventKindSchema2.safeParse(envelope.kind).success;
   if (knownVersion && knownKind)
     return { outcome: "accepted", event: envelope };
   if (!envelope.ignorable) {
@@ -213,7 +213,7 @@ function decodeAgentStoreEvent(value) {
   };
 }
 function agentStoreEventDraft(input) {
-  const parsed = AppendAgentStoreEventSchema.parse(input);
+  const parsed = AppendAgentStoreEventSchema2.parse(input);
   return {
     schemaVersion: CURRENT_EVENT_SCHEMA_VERSION,
     eventId: randomUUID(),
@@ -224,24 +224,24 @@ function agentStoreEventDraft(input) {
     ...parsed.ignorable && { ignorable: true }
   };
 }
-function canonicalAgentJson(value) {
+function canonicalAgentJson2(value) {
   return serializeCanonicalJson(z3.json().parse(value));
 }
-var AgentConversationArchiveSchema = z3.object({
+var AgentConversationArchiveSchema2 = z3.object({
   format: z3.literal("stitchkit.agent-conversation"),
   formatVersion: z3.literal(1),
   conversationId: z3.string().min(1),
-  events: z3.array(AgentStoreEventEnvelopeSchema),
+  events: z3.array(AgentStoreEventEnvelopeSchema2),
   projections: z3.array(z3.json()).default([]),
   spills: z3.array(z3.json()).default([])
 }).strict();
-function encodeAgentConversationArchive(archive) {
-  const parsed = AgentConversationArchiveSchema.parse(archive);
-  return new TextEncoder().encode(canonicalAgentJson(parsed));
+function encodeAgentConversationArchive2(archive) {
+  const parsed = AgentConversationArchiveSchema2.parse(archive);
+  return new TextEncoder().encode(canonicalAgentJson2(parsed));
 }
-function decodeAgentConversationArchive(bytes) {
+function decodeAgentConversationArchive2(bytes) {
   const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-  const archive = AgentConversationArchiveSchema.parse(value);
+  const archive = AgentConversationArchiveSchema2.parse(value);
   let previous = 0;
   const ids = new Set;
   for (const event of archive.events) {
@@ -252,7 +252,7 @@ function decodeAgentConversationArchive(bytes) {
       throw new TypeError("Conversation archive event sequence is not increasing");
     if (ids.has(event.eventId))
       throw new TypeError("Conversation archive contains a duplicate event id");
-    decodeAgentStoreEvent(event);
+    decodeAgentStoreEvent2(event);
     previous = event.seq;
     ids.add(event.eventId);
   }
@@ -306,7 +306,7 @@ function canProjectToolChronology(state) {
 function isSpeakableAssistantStatus(status) {
   return status === "completed" || status === "interrupted" || status === "committed";
 }
-function isAssistantHistoryEvidence(status, policy) {
+function isAssistantHistoryEvidence2(status, policy) {
   return isSpeakableAssistantStatus(status) || status === "failed" && policy?.failedAssistant === "assistant-marked";
 }
 function isCompleteAgentHistoryTurn(messages, policy) {
@@ -316,7 +316,7 @@ function isCompleteAgentHistoryTurn(messages, policy) {
   let assistantCount = 0;
   for (const message of messages) {
     if (message.role === "assistant") {
-      if (!isAssistantHistoryEvidence(message.status, policy))
+      if (!isAssistantHistoryEvidence2(message.status, policy))
         return false;
       assistantCount += 1;
     }
@@ -341,4 +341,4 @@ function assistantStatus(reason) {
   return "failed";
 }
 
-export { AgentStoreEventKindSchema, AgentStoreEventEnvelopeSchema, AppendAgentStoreEventSchema, ReadAgentStoreEventsSchema, AgentStoreEventPageSchema, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, RecordRunOperationSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, SeedConversationInputSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentStoreTransitionSchema, decodeAgentStoreEvent, agentStoreEventDraft, canonicalAgentJson, AgentConversationArchiveSchema, encodeAgentConversationArchive, decodeAgentConversationArchive, createToolChronology, advanceToolChronology, canProjectToolChronology, isAssistantHistoryEvidence, isCompleteAgentHistoryTurn, assistantStatus };
+export { AgentStoreEventKindSchema2, AgentStoreEventEnvelopeSchema2, AppendAgentStoreEventSchema2, ReadAgentStoreEventsSchema2, AgentStoreEventPageSchema2, AgentStoreConflictSchema2, AgentStoreNotFoundSchema2, AgentStoreAppliedSchema2, AgentStoreDuplicateSchema2, AgentStoreMutationResultSchema2, AgentRunViewSchema2, AcceptInputAndAssignRunSchema2, AcquireAgentRunSchema2, CheckpointRunAssistantSchema2, RecordRunOperationSchema2, CommitRunTerminalSchema2, RequestRunInterruptSchema2, RecoverAgentRunSchema2, ReplaceCompactedRangeSchema2, SeedConversationInputSchema2, AgentRecoverableDescriptorSchema2, AgentRecoverablePageSchema2, AgentStoreTransitionSchema2, decodeAgentStoreEvent2, agentStoreEventDraft, canonicalAgentJson2, AgentConversationArchiveSchema2, encodeAgentConversationArchive2, decodeAgentConversationArchive2, createToolChronology, advanceToolChronology, canProjectToolChronology, isAssistantHistoryEvidence2, isCompleteAgentHistoryTurn, assistantStatus };

package/dist/{index-0b1ess5e.js → index-r7a7r7ha.js}

@@ -1,6 +1,6 @@
 import {
   serializeCanonicalJson
-} from "./index-k5hsfc3j.js";
+} from "./index-zsvzhjtk.js";
 
 // src/internal/stable-digest.ts
 function mix128(input) {