stitchkit 0.100.2 → 0.100.3

package/dist/{index-ham5sz8m.js → index-aaj97r4y.js}

@@ -1,26 +1,26 @@
 import {
-  inputIsQuery
-} from "./index-48ffdxgk.js";
-import {
-  ContractStreamFrameSchema,
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
-} from "./index-wqgjfstn.js";
-import {
-  ApiError,
   RequestCancellationError,
   createRequestCancellation,
-  parseApiErrorBody,
+  responseTraceId,
+  ApiError2,
   refuseLocally,
-  responseTraceId
-} from "./index-v260df89.js";
+  parseApiErrorBody
+} from "./index-qjeggp8w.js";
 import {
   parseTrailingWildcard
-} from "./index-4gcnakhx.js";
+} from "./index-m38ej7e5.js";
+import {
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES2,
+  ContractStreamFrameSchema2
+} from "./index-r5c4fedv.js";
+import {
+  inputIsQuery
+} from "./index-xhzq2qvj.js";
 import {
+  typedEntries,
   isRecord,
-  mapObject,
-  typedEntries
-} from "./index-hffjpmq9.js";
+  mapObject
+} from "./index-9jfdm5tg.js";
 
 // src/internal/bounded-lines.ts
 var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
@@ -89,7 +89,7 @@ function parseFailure(raw, error, onParseError) {
     throw failure;
   onParseError(raw, failure);
 }
-async function* parseNDJSON(response, options) {
+async function* parseNDJSON2(response, options) {
   try {
     for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES, options?.finalLine === "require-newline")) {
       const line = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).trim();
@@ -105,7 +105,7 @@ async function* parseNDJSON(response, options) {
     parseFailure("", error, options?.onParseError);
   }
 }
-async function* parseSSE(response, options) {
+async function* parseSSE2(response, options) {
   try {
     for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
       const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
@@ -343,10 +343,10 @@ function joinClientBaseUrl(baseUrl, relativeUrl) {
 // src/browser/contract-stream.ts
 function sourceFor(response, descriptor) {
   const options = {
-    maxLineBytes: descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
+    maxLineBytes: descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES2,
     finalLine: descriptor.finalLine
   };
-  return descriptor.format === "sse" ? parseSSE(response, options) : parseNDJSON(response, options);
+  return descriptor.format === "sse" ? parseSSE2(response, options) : parseNDJSON2(response, options);
 }
 async function* readContractStream(response, descriptor, abort) {
   let ended = false;
@@ -359,17 +359,17 @@ async function* readContractStream(response, descriptor, abort) {
         break;
       let candidate = next.value;
       if (descriptor.framing !== "item") {
-        const parsedFrame = ContractStreamFrameSchema.safeParse(candidate);
+        const parsedFrame = ContractStreamFrameSchema2.safeParse(candidate);
         if (!parsedFrame.success) {
-          throw new ApiError("STREAM_PROTOCOL_ERROR", 0, undefined, "Stream frame did not match the protocol envelope");
+          throw new ApiError2("STREAM_PROTOCOL_ERROR", 0, undefined, "Stream frame did not match the protocol envelope");
         }
         const frame = parsedFrame.data;
         if (frame.type === "error") {
-          throw new ApiError(frame.error.code, 0, frame.error.details, frame.error.message, frame.error.hint);
+          throw new ApiError2(frame.error.code, 0, frame.error.details, frame.error.message, frame.error.hint);
         }
         if (frame.type === "end") {
           if (!terminalSeen) {
-            throw new ApiError("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
+            throw new ApiError2("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
           }
           ended = true;
           return;
@@ -378,7 +378,7 @@ async function* readContractStream(response, descriptor, abort) {
       }
       const parsedItem = descriptor.item.safeParse(candidate);
       if (!parsedItem.success) {
-        throw new ApiError("STREAM_ITEM_INVALID", 0, undefined, "Stream item did not match its contract");
+        throw new ApiError2("STREAM_ITEM_INVALID", 0, undefined, "Stream item did not match its contract");
       }
       const item = parsedItem.data;
       const terminal = descriptor.terminal?.safeParse(item).success ?? false;
@@ -396,10 +396,10 @@ async function* readContractStream(response, descriptor, abort) {
     if (descriptor.framing === "item") {
       if (terminalSeen)
         return;
-      throw new ApiError("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
+      throw new ApiError2("STREAM_TERMINAL_MISSING", 0, undefined, "Stream completed before its declared terminal item");
     }
     if (!ended) {
-      throw new ApiError("STREAM_TRUNCATED", 0, undefined, "Stream ended without its protocol terminal frame");
+      throw new ApiError2("STREAM_TRUNCATED", 0, undefined, "Stream ended without its protocol terminal frame");
     }
   } finally {
     abort();
@@ -567,12 +567,12 @@ function createFetchExecutor(endpoint, prefix, config, contractConfig) {
       });
     } catch (error) {
       if (error instanceof RequestCancellationError) {
-        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
+        throw new ApiError2(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
       }
-      if (ApiError.is(error))
+      if (ApiError2.is(error))
         throw error;
       const message = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", 0, message ? { message } : undefined, message, undefined, undefined, { cause: error });
+      throw new ApiError2("UNKNOWN_ERROR", 0, message ? { message } : undefined, message, undefined, undefined, { cause: error });
     }
   };
 }
@@ -581,13 +581,13 @@ async function throwForErrorResponse(res, config, fallbackBody) {
   config.onError?.(res.status, body);
   const parsed = parseApiErrorBody(body);
   if (parsed) {
-    throw new ApiError(parsed.code, res.status, parsed.details, parsed.message, parsed.hint, responseTraceId(res));
+    throw new ApiError2(parsed.code, res.status, parsed.details, parsed.message, parsed.hint, responseTraceId(res));
   }
-  throw new ApiError("HTTP_ERROR", res.status, { body }, undefined, undefined, responseTraceId(res));
+  throw new ApiError2("HTTP_ERROR", res.status, { body }, undefined, undefined, responseTraceId(res));
 }
 
 // src/browser/client.ts
-function contractEndpointMatchers(contract, endpointNames, contractConfig) {
+function contractEndpointMatchers2(contract, endpointNames, contractConfig) {
   const selected = endpointNames ? new Set(endpointNames) : null;
   const matchers = [];
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
@@ -606,7 +606,7 @@ function contractEndpointMatchers(contract, endpointNames, contractConfig) {
   }
   return matchers;
 }
-function createClient(contract, configOrClient, contractConfig) {
+function createClient2(contract, configOrClient, contractConfig) {
   const client = {};
   const makeExecutor = isHttpAdapter(configOrClient) ? (endpoint) => createHttpExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchExecutor(endpoint, contract.meta.prefix, configOrClient, contractConfig);
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
@@ -616,8 +616,8 @@ function createClient(contract, configOrClient, contractConfig) {
   }
   return client;
 }
-function createClients(contracts, configOrClient, contractConfig) {
-  return mapObject(contracts, (_key, contract) => createClient(contract, configOrClient, contractConfig));
+function createClients2(contracts, configOrClient, contractConfig) {
+  return mapObject(contracts, (_key, contract) => createClient2(contract, configOrClient, contractConfig));
 }
 function buildScopedRegistry(contracts, scopeConfigs, surfaceName, build) {
   const registry = {};
@@ -644,8 +644,8 @@ function buildScopedRegistry(contracts, scopeConfigs, surfaceName, build) {
   }
   return registry;
 }
-function createScopedClients(contracts, configOrClient, scopeConfigs) {
-  return buildScopedRegistry(contracts, scopeConfigs, "client", (contract, config) => createClient(contract, configOrClient, config));
+function createScopedClients2(contracts, configOrClient, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "client", (contract, config) => createClient2(contract, configOrClient, config));
 }
 function isHttpAdapter(value) {
   return typeof value === "object" && "get" in value && typeof value.get === "function";
@@ -656,8 +656,8 @@ function setClientMethod(target, key, method) {
 function createEndpointMethod(endpoint, execute, contractConfig) {
   const hasScopedArguments = (contractConfig?.stripPrefixKeys?.length ?? 0) > 0;
   if (endpointHasArguments(endpoint) || hasScopedArguments) {
-    const method2 = (requestArgs) => settle(execute, readClientRequestArgs(requestArgs), undefined);
-    return Object.assign(method2, {
+    const method = (requestArgs) => settle(execute, readClientRequestArgs(requestArgs), undefined);
+    return Object.assign(method, {
       withOptions: (...args) => {
         refuseExtraWithOptionsArguments(endpoint, args.length, 2);
         return settle(execute, readClientRequestArgs(args[0]), readClientRequestOptions(args[1]));
@@ -708,7 +708,7 @@ function readClientRequestOptions(value) {
 function isAbortSignal(value) {
   return typeof value === "object" && value !== null && "aborted" in value && typeof value.aborted === "boolean" && "addEventListener" in value && typeof value.addEventListener === "function" && "removeEventListener" in value && typeof value.removeEventListener === "function";
 }
-function createUrlBuilder(contract, source, contractConfig) {
+function createUrlBuilder2(contract, source, contractConfig) {
   const builder = {};
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
     if (endpoint.expose && !endpoint.expose.includes("HTTP"))
@@ -724,11 +724,11 @@ function createUrlBuilder(contract, source, contractConfig) {
   }
   return builder;
 }
-function createUrlBuilders(contracts, source, contractConfig) {
-  return mapObject(contracts, (_key, contract) => createUrlBuilder(contract, source, contractConfig));
+function createUrlBuilders2(contracts, source, contractConfig) {
+  return mapObject(contracts, (_key, contract) => createUrlBuilder2(contract, source, contractConfig));
 }
-function createScopedUrlBuilders(contracts, source, scopeConfigs) {
-  return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
+function createScopedUrlBuilders2(contracts, source, scopeConfigs) {
+  return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder2(contract, source, config));
 }
 
-export { parseNDJSON, parseSSE, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };
+export { parseNDJSON2, parseSSE2, contractEndpointMatchers2, createClient2, createClients2, createScopedClients2, createUrlBuilder2, createUrlBuilders2, createScopedUrlBuilders2 };

package/dist/{index-s812ycat.js → index-aan6hqb9.js}

@@ -18,7 +18,7 @@ function stagingPath(target) {
 function bytesOf(data) {
   return typeof data === "string" ? new TextEncoder().encode(data) : data;
 }
-async function writeFileAtomic(target, data, options = {}) {
+async function writeFileAtomic2(target, data, options = {}) {
   const mode = options.mode ?? DEFAULT_MODE;
   const staged = stagingPath(target);
   const handle = await open(staged, "wx", mode);
@@ -38,7 +38,7 @@ async function writeFileAtomic(target, data, options = {}) {
     throw error;
   }
 }
-function writeFileAtomicSync(target, data, options = {}) {
+function writeFileAtomicSync2(target, data, options = {}) {
   const mode = options.mode ?? DEFAULT_MODE;
   const bytes = bytesOf(data);
   const staged = stagingPath(target);
@@ -62,4 +62,4 @@ function writeFileAtomicSync(target, data, options = {}) {
   }
 }
 
-export { writeFileAtomic, writeFileAtomicSync };
+export { writeFileAtomic2, writeFileAtomicSync2 };

package/dist/{index-10x2hbx0.js → index-adhgd4pe.js}

@@ -1,26 +1,26 @@
 import {
-  AgentAdmissionReceiptSchema,
-  AgentHistoryMutationSchema,
-  AgentRuntimeHeadSchema,
-  AgentSeedReceiptSchema,
-  AgentStoredRunSchema,
-  createAgentRuntimeStore,
-  isActiveRunState,
-  replaceMessage
-} from "./index-vqr7f7v8.js";
+  AgentStoreEventEnvelopeSchema2,
+  AgentStoreEventPageSchema2,
+  AgentRecoverablePageSchema2
+} from "./index-r5hsgkz5.js";
 import {
-  AgentRecoverablePageSchema,
-  AgentStoreEventEnvelopeSchema,
-  AgentStoreEventPageSchema
-} from "./index-cyktc4bp.js";
+  AgentRecordIdSchema2,
+  AgentMessageSchema2
+} from "./index-8kzct1d6.js";
 import {
-  AgentMessageSchema,
-  AgentRecordIdSchema
-} from "./index-gtj3zc53.js";
+  AgentRuntimeHeadSchema2,
+  AgentStoredRunSchema2,
+  AgentAdmissionReceiptSchema2,
+  AgentSeedReceiptSchema2,
+  AgentHistoryMutationSchema2,
+  isActiveRunState,
+  replaceMessage,
+  createAgentRuntimeStore2
+} from "./index-ssmd41kh.js";
 
 // src/agent-runtime/store-memory.ts
 import { z } from "zod";
-var RecoverableCursorSchema = z.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+var RecoverableCursorSchema = z.tuple([AgentRecordIdSchema2, AgentRecordIdSchema2]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -30,7 +30,7 @@ function parseRecoverableCursor(cursor) {
 function cloneHeadMap(source) {
   return new Map([...source].map(([key, value]) => [
     key,
-    AgentRuntimeHeadSchema.parse(structuredClone(value))
+    AgentRuntimeHeadSchema2.parse(structuredClone(value))
   ]));
 }
 function cloneNestedMap(source, clone) {
@@ -42,7 +42,7 @@ function cloneNestedMap(source, clone) {
 function cloneHistoryMap(source) {
   return new Map([...source].map(([key, value]) => [
     key,
-    value.map((message) => AgentMessageSchema.parse(structuredClone(message)))
+    value.map((message) => AgentMessageSchema2.parse(structuredClone(message)))
   ]));
 }
 var memoryConversations = {
@@ -62,7 +62,7 @@ var memoryConversations = {
 var memoryHead = {
   async load(transaction, conversationId) {
     const head = transaction.heads.get(conversationId);
-    return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
+    return head ? AgentRuntimeHeadSchema2.parse(structuredClone(head)) : undefined;
   },
   async compareAndSwap(transaction, input) {
     const current = transaction.heads.get(input.conversationId);
@@ -70,31 +70,31 @@ var memoryHead = {
     if (actualVersion !== input.expectedVersion) {
       return { outcome: "conflict", actualVersion };
     }
-    transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
+    transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema2.parse(structuredClone(input.next)));
     return { outcome: "applied" };
   }
 };
 var memoryRuns = {
   async load(transaction, input) {
     const record = transaction.runs.get(input.conversationId)?.get(input.runId);
-    return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+    return record ? AgentStoredRunSchema2.parse(structuredClone(record)) : undefined;
   },
   async loadByAssistantMessageId(transaction, input) {
     const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
-    return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+    return record ? AgentStoredRunSchema2.parse(structuredClone(record)) : undefined;
   },
   async loadMany(transaction, input) {
     const records = transaction.runs.get(input.conversationId);
     return input.runIds.flatMap((runId) => {
       const record = records?.get(runId);
-      return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
+      return record ? [AgentStoredRunSchema2.parse(structuredClone(record))] : [];
     });
   },
   async listActive(transaction, conversationId) {
-    return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => isActiveRunState(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
+    return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => isActiveRunState(record.run.state)).map((record) => AgentStoredRunSchema2.parse(structuredClone(record)));
   },
   async save(transaction, rawRecord) {
-    const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
+    const record = AgentStoredRunSchema2.parse(structuredClone(rawRecord));
     const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
     const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
     if (collision)
@@ -106,16 +106,16 @@ var memoryRuns = {
 var memoryAdmissions = {
   async load(transaction, input) {
     const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
-    return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+    return receipt ? AgentAdmissionReceiptSchema2.parse(structuredClone(receipt)) : undefined;
   },
   async loadByInputMessageId(transaction, input) {
     const receipt = [
       ...transaction.admissions.get(input.conversationId)?.values() ?? []
     ].find((candidate) => candidate.input.id === input.inputMessageId);
-    return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+    return receipt ? AgentAdmissionReceiptSchema2.parse(structuredClone(receipt)) : undefined;
   },
   async create(transaction, rawReceipt) {
-    const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
+    const receipt = AgentAdmissionReceiptSchema2.parse(structuredClone(rawReceipt));
     const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
     if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
       throw new TypeError("Admission identity is already reserved");
@@ -127,10 +127,10 @@ var memoryAdmissions = {
 var memorySeeds = {
   async load(transaction, input) {
     const receipt = transaction.seeds.get(input.conversationId)?.get(input.seedKey);
-    return receipt ? AgentSeedReceiptSchema.parse(structuredClone(receipt)) : undefined;
+    return receipt ? AgentSeedReceiptSchema2.parse(structuredClone(receipt)) : undefined;
   },
   async create(transaction, rawReceipt) {
-    const receipt = AgentSeedReceiptSchema.parse(structuredClone(rawReceipt));
+    const receipt = AgentSeedReceiptSchema2.parse(structuredClone(rawReceipt));
     const conversationSeeds = transaction.seeds.get(receipt.conversationId) ?? new Map;
     if (conversationSeeds.has(receipt.seedKey)) {
       throw new TypeError("Conversation seed identity is already reserved");
@@ -141,13 +141,13 @@ var memorySeeds = {
 };
 var memoryHistory = {
   async load(transaction, conversationId) {
-    return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
+    return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema2.parse(structuredClone(message)));
   },
   async hasMessage(transaction, input) {
     return (transaction.histories.get(input.conversationId) ?? []).some((message) => message.id === input.messageId);
   },
   async apply(transaction, rawMutation) {
-    const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+    const mutation = AgentHistoryMutationSchema2.parse(rawMutation);
     const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.type === "seed" ? mutation.message.conversationId : mutation.summary.conversationId;
     const current = transaction.histories.get(conversationId) ?? [];
     if (mutation.type === "admit") {
@@ -184,7 +184,7 @@ var memoryHistory = {
 var memoryEvents = {
   async append(transaction, draft) {
     const current = transaction.events.get(draft.conversationId) ?? [];
-    const event = AgentStoreEventEnvelopeSchema.parse({
+    const event = AgentStoreEventEnvelopeSchema2.parse({
       ...draft,
       seq: (current.at(-1)?.seq ?? 0) + 1
     });
@@ -198,7 +198,7 @@ var memoryEvents = {
     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({
+    return AgentStoreEventPageSchema2.parse({
       items,
       ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
     });
@@ -212,17 +212,17 @@ function scanMemoryRecoverable(runs, input) {
   const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
   const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId.localeCompare(cursorTuple[0]) > 0 || item.conversationId === cursorTuple[0] && item.run.id.localeCompare(cursorTuple[1]) > 0) : 0;
   if (start === -1) {
-    return AgentRecoverablePageSchema.parse({ items: [] });
+    return AgentRecoverablePageSchema2.parse({ items: [] });
   }
   const items = descriptors.slice(start, start + input.limit);
   const last = items.at(-1);
   const hasMore = start + items.length < descriptors.length;
-  return AgentRecoverablePageSchema.parse({
+  return AgentRecoverablePageSchema2.parse({
     items,
     ...hasMore && last && { nextCursor: recoverableCursor(last) }
   });
 }
-function createMemoryAgentRuntimeStore() {
+function createMemoryAgentRuntimeStore2() {
   let purged = new Set;
   let heads = new Map;
   let runs = new Map;
@@ -244,13 +244,13 @@ function createMemoryAgentRuntimeStore() {
       const transaction = {
         purged: new Set(purged),
         heads: cloneHeadMap(heads),
-        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
-        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
-        seeds: cloneNestedMap(seeds, (receipt) => AgentSeedReceiptSchema.parse(structuredClone(receipt))),
+        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema2.parse(structuredClone(record))),
+        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema2.parse(structuredClone(receipt))),
+        seeds: cloneNestedMap(seeds, (receipt) => AgentSeedReceiptSchema2.parse(structuredClone(receipt))),
         histories: cloneHistoryMap(histories),
         events: new Map([...events].map(([conversationId, stored]) => [
           conversationId,
-          stored.map((event) => AgentStoreEventEnvelopeSchema.parse(structuredClone(event)))
+          stored.map((event) => AgentStoreEventEnvelopeSchema2.parse(structuredClone(event)))
         ]))
       };
       try {
@@ -278,7 +278,7 @@ function createMemoryAgentRuntimeStore() {
       return scanMemoryRecoverable(runs, input);
     }
   };
-  return createAgentRuntimeStore(driver);
+  return createAgentRuntimeStore2(driver);
 }
 
-export { createMemoryAgentRuntimeStore };
+export { createMemoryAgentRuntimeStore2 };

package/dist/{index-2gxzjvyr.js → index-afjvjyck.js}

@@ -1,17 +1,17 @@
 import {
-  contractMethodFields
-} from "./index-2bxbyab0.js";
+  AppError2
+} from "./index-n53mswt3.js";
 import {
-  AppError
-} from "./index-2vtcmrj9.js";
+  contractMethodFields
+} from "./index-1bx1xv1k.js";
 import {
-  callRuntimeHandler,
-  typedEntries
-} from "./index-hffjpmq9.js";
+  typedEntries,
+  callRuntimeHandler
+} from "./index-9jfdm5tg.js";
 
 // src/server/middleware/cors.ts
-var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
-var DEFAULT_CORS_EXPOSE_HEADERS = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id, X-Build-Id";
+var DEFAULT_CORS_ALLOW_HEADERS2 = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";
+var DEFAULT_CORS_EXPOSE_HEADERS2 = "Content-Disposition, Content-Length, Content-Range, Accept-Ranges, ETag, Last-Modified, X-Request-Id, X-Build-Id";
 function assertCorsConfig(config) {
   if (config.credentials && (config.origin === undefined || config.origin === "*")) {
     throw new Error("[stitchkit] cors: `credentials: true` cannot be combined with a wildcard origin. " + "Set `origin` to an explicit string or list.");
@@ -46,13 +46,13 @@ function isOriginAllowed(config, requestOrigin) {
   const allowed = Array.isArray(config.origin) ? config.origin : [config.origin];
   return allowed.some((origin) => origin.toLowerCase() === lower);
 }
-function corsHeaders(config, requestOrigin) {
+function corsHeaders2(config, requestOrigin) {
   const allowOrigin = resolveOrigin(config, requestOrigin);
   const headers = {
     "Access-Control-Allow-Methods": config.methods ?? "GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": config.headers ?? DEFAULT_CORS_ALLOW_HEADERS
+    "Access-Control-Allow-Headers": config.headers ?? DEFAULT_CORS_ALLOW_HEADERS2
   };
-  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS;
+  const expose = Array.isArray(config.exposeHeaders) ? config.exposeHeaders.join(", ") : config.exposeHeaders ?? DEFAULT_CORS_EXPOSE_HEADERS2;
   if (expose !== "") {
     headers["Access-Control-Expose-Headers"] = expose;
   }
@@ -67,16 +67,16 @@ function corsHeaders(config, requestOrigin) {
   }
   return headers;
 }
-function corsPreflightResponse(config, req) {
+function corsPreflightResponse2(config, req) {
   return new Response(null, {
     status: 204,
-    headers: corsHeaders(config, req.headers.get("origin"))
+    headers: corsHeaders2(config, req.headers.get("origin"))
   });
 }
 function requestCorsHeaders(cors, req) {
   if (!cors)
     return {};
-  return corsHeaders(cors, req.headers.get("origin"));
+  return corsHeaders2(cors, req.headers.get("origin"));
 }
 function applyCors(res, cors, req) {
   const extra = requestCorsHeaders(cors, req);
@@ -116,7 +116,7 @@ function setCorsHeader(headers, key, value) {
 function isStreamingImplementation(value) {
   return typeof value === "object" && value !== null && "kind" in value && value.kind === "stitchkit.multipart.stream";
 }
-function defineMultipartStream(endpoint, config) {
+function defineMultipartStream2(endpoint, config) {
   return buildMultipartStream(endpoint, config.files, config.handler);
 }
 function buildMultipartStream(endpoint, files, handler) {
@@ -137,7 +137,7 @@ function buildMultipartStream(endpoint, files, handler) {
     }
   };
 }
-function createMultipartStream() {
+function createMultipartStream2() {
   return (endpoint, config) => buildMultipartStream(endpoint, config.files, config.handler);
 }
 function isStreamingEndpoint(endpoint) {
@@ -171,7 +171,7 @@ function contractOnlyService(contract) {
 }
 function stubHandler(label) {
   return () => {
-    throw new AppError("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
+    throw new AppError2("NOT_IMPLEMENTED", `[stitchkit] ${label} is declared by its contract and has no handler`, 501);
   };
 }
 function bindContract(contract, handlers, options) {
@@ -211,13 +211,13 @@ function bindContract(contract, handlers, options) {
     methods
   };
 }
-function implement(contract, handlers, options) {
+function implement2(contract, handlers, options) {
   return bindContract(contract, handlers, options);
 }
-function createImplement() {
-  return (contract, handlers, options) => implement(contract, handlers, options);
+function createImplement2() {
+  return (contract, handlers, options) => implement2(contract, handlers, options);
 }
-function createScopedImplement() {
+function createScopedImplement2() {
   const implementScoped = (contract, handlers, options) => bindContract(contract, handlers, options);
   const stream = (scope, endpoint, config) => {
     if (endpoint.scope !== undefined && endpoint.scope !== scope) {
@@ -263,4 +263,4 @@ function mediaTypeEssence(contentType) {
   return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
 }
 
-export { DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, requestCorsHeaders, applyCors, defineMultipartStream, createMultipartStream, contractOnlyService, bindContract, implement, createImplement, createScopedImplement, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };
+export { DEFAULT_CORS_ALLOW_HEADERS2, DEFAULT_CORS_EXPOSE_HEADERS2, assertCorsConfig, isOriginAllowed, corsHeaders2, corsPreflightResponse2, requestCorsHeaders, applyCors, defineMultipartStream2, createMultipartStream2, contractOnlyService, bindContract, implement2, createImplement2, createScopedImplement2, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };

package/dist/{index-qmy6zq75.js → index-ahvsksw5.js}

@@ -1,45 +1,45 @@
 import {
-  AppError,
-  STITCH_ERROR_STATUS
-} from "./index-2vtcmrj9.js";
+  AppError2,
+  STITCH_ERROR_STATUS2
+} from "./index-n53mswt3.js";
 
 // src/agent-runtime/sandbox.ts
 import { z } from "zod";
-var AgentSandboxRestrictionSchema = z.enum([
+var AgentSandboxRestrictionSchema2 = z.enum([
   "network-denied",
   "write-contained",
   "secrets-hidden",
   "process-contained"
 ]);
-var AgentSandboxGradeSchema = z.discriminatedUnion("grade", [
-  z.object({ grade: z.literal("full"), restrictions: z.array(AgentSandboxRestrictionSchema) }).strict(),
+var AgentSandboxGradeSchema2 = z.discriminatedUnion("grade", [
+  z.object({ grade: z.literal("full"), restrictions: z.array(AgentSandboxRestrictionSchema2) }).strict(),
   z.object({
     grade: z.literal("partial"),
-    restrictions: z.array(AgentSandboxRestrictionSchema),
-    gaps: z.array(AgentSandboxRestrictionSchema)
+    restrictions: z.array(AgentSandboxRestrictionSchema2),
+    gaps: z.array(AgentSandboxRestrictionSchema2)
   }).strict(),
   z.object({ grade: z.literal("unavailable"), reason: z.string().min(1) }).strict()
 ]);
 var probes = new WeakMap;
-function probeAgentProcessSandbox(sandbox, options = {}) {
+function probeAgentProcessSandbox2(sandbox, options = {}) {
   if (options.refresh)
     probes.delete(sandbox);
   const present = probes.get(sandbox);
   if (present)
     return present;
-  const pending = Promise.resolve(sandbox.probe()).then((grade) => AgentSandboxGradeSchema.parse(grade));
+  const pending = Promise.resolve(sandbox.probe()).then((grade) => AgentSandboxGradeSchema2.parse(grade));
   probes.set(sandbox, pending);
   return pending;
 }
-function missingSandboxRestrictions(grade, required) {
+function missingSandboxRestrictions2(grade, required) {
   if (grade.grade === "unavailable")
     return required;
   const present = new Set(grade.restrictions);
   return required.filter((restriction) => !present.has(restriction));
 }
-async function recordAgentSandboxProbe(input) {
-  const grade = await probeAgentProcessSandbox(input.sandbox);
-  const missing = missingSandboxRestrictions(grade, input.required);
+async function recordAgentSandboxProbe2(input) {
+  const grade = await probeAgentProcessSandbox2(input.sandbox);
+  const missing = missingSandboxRestrictions2(grade, input.required);
   await input.store.appendEvent({
     conversationId: input.conversationId,
     kind: "sandbox/probed",
@@ -54,7 +54,7 @@ async function recordAgentSandboxProbe(input) {
 
 // src/agent-runtime/coding-tool-refusals.ts
 function codingRefusal(code, message, options = {}) {
-  throw new AppError(code, message, STITCH_ERROR_STATUS[code], { message, ...options.details }, options.hint);
+  throw new AppError2(code, message, STITCH_ERROR_STATUS2[code], { message, ...options.details }, options.hint);
 }
 function codingPathRefusal(code, message, path, options = {}) {
   codingRefusal(code, message, {
@@ -98,4 +98,4 @@ function refuseUnknownSpillReference(reference) {
   });
 }
 
-export { AgentSandboxRestrictionSchema, AgentSandboxGradeSchema, probeAgentProcessSandbox, missingSandboxRestrictions, recordAgentSandboxProbe, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };
+export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };