stitchkit 0.98.2 → 0.100.0

package/dist/{index-wsm5w4ee.js → index-0b1cnze2.js}

@@ -19,7 +19,7 @@ import {
   canonicalAgentJson,
   decodeAgentConversationArchive,
   encodeAgentConversationArchive
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema,
@@ -427,6 +427,37 @@ async function importConversation(driver, bytes) {
   });
 }
 
+// src/agent-runtime/store-event-once.ts
+import { createHash } from "node:crypto";
+function appendEventOnce(driver, input, key) {
+  const parsed = AppendAgentStoreEventSchema.parse(input);
+  if (!key)
+    throw new TypeError("Event admission key must not be empty");
+  const eventId = createHash("sha256").update(JSON.stringify([parsed.conversationId, parsed.kind, key])).digest("hex");
+  return driver.transaction(async (transaction) => {
+    if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+      throw new AgentConversationPurgedError;
+    }
+    let fromSeq;
+    do {
+      const page = await driver.events.list(transaction, {
+        conversationId: parsed.conversationId,
+        fromSeq,
+        limit: 1e4
+      });
+      const previous = page.items.find((event2) => event2.eventId === eventId);
+      if (previous)
+        return { outcome: "duplicate", event: previous };
+      fromSeq = page.nextSeq;
+    } while (fromSeq !== undefined);
+    const event = await driver.events.append(transaction, {
+      ...agentStoreEventDraft(parsed),
+      eventId
+    });
+    return { outcome: "applied", event };
+  });
+}
+
 // src/agent-runtime/store-mutate.ts
 import { z as z4 } from "zod";
 
@@ -453,7 +484,7 @@ function applied(current, input, effects) {
 }
 
 // src/agent-runtime/store-reducer.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // src/agent-runtime/store-reduce-history.ts
 function reduceAccept(current, input) {
@@ -737,7 +768,7 @@ function transitionRecord(operation) {
       assistant: {
         id: assistant.id,
         status: assistant.status,
-        sha256: createHash("sha256").update(body).digest("hex"),
+        sha256: createHash2("sha256").update(body).digest("hex"),
         parts: assistant.parts.length,
         bytes: Buffer.byteLength(body)
       }
@@ -979,6 +1010,7 @@ function createAgentRuntimeStore(driver) {
     loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
     loadRun: (input) => loadRun(driver, input),
     listActiveRuns: (conversationId) => listActiveRuns(driver, conversationId),
+    appendEventOnce: (input, key) => appendEventOnce(driver, input, key),
     appendEvent: (input) => appendEvent(driver, input),
     readEvents: (input) => readEvents(driver, input),
     exportConversation: (conversationId) => exportConversation(driver, conversationId),

package/dist/{index-np4m8hd3.js → index-0r0fbk7z.js}

@@ -271,12 +271,7 @@ function typeNames(schema) {
   return combinedBranchTypes(schema);
 }
 function typeSchema(type, nullable) {
-  const schema = { type: nullable ? [type, "null"] : type };
-  if (type === "array")
-    schema.items = {};
-  if (type === "object")
-    schema.additionalProperties = {};
-  return schema;
+  return { type: nullable ? [type, "null"] : type };
 }
 function commonBaseType(schemas) {
   const names = schemas.map(typeNames);
@@ -296,6 +291,13 @@ function commonBaseType(schemas) {
   }
   if (bases.size === 0)
     return nullable ? { type: "null" } : {};
+  if (bases.has("array") || bases.has("object")) {
+    const alternatives = new Map;
+    for (const schema of schemas)
+      alternatives.set(serializeCanonicalJson(schema), schema);
+    const ordered = [...alternatives].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, schema]) => schema);
+    return { anyOf: structuredClone(ordered) };
+  }
   if (bases.size === 1) {
     const [only] = bases;
     return only ? typeSchema(only, nullable) : {};
@@ -316,7 +318,7 @@ function mergePropertySchemas(properties) {
   } else {
     const values = schemas.map(stringValues);
     const allStrings = values.every((value) => value !== null);
-    merged = allStrings ? { type: "string", enum: [...new Set(values.flatMap((value) => value ?? []))] } : commonBaseType(schemas);
+    merged = allStrings ? { type: "string", enum: [...new Set(values.flatMap((value) => value ?? []))] } : commonBaseType(structural);
   }
   const descriptions = [
     ...new Set(schemas.map((schema) => schema.description).filter((value) => typeof value === "string"))

package/dist/{index-p9sh0xx4.js → index-5p2m7we1.js}

@@ -1,13 +1,13 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-khtgb21r.js";
+} from "./index-bm5rx7n6.js";
 import {
   toolErrorFromResult
-} from "./index-55hkhm67.js";
+} from "./index-8qt2m66q.js";
 import {
   assertUniqueToolName
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 import {
   AppError
 } from "./index-2vtcmrj9.js";

package/dist/{index-55hkhm67.js → index-8qt2m66q.js}

@@ -9,7 +9,7 @@ import {
   applyToolViewDefaults,
   objectShapeKeys,
   projectToolView
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 import {
   normalizeError,
   validateDeclaredOutput

package/dist/{index-hmp4800j.js → index-9t3dffv2.js}

@@ -1,12 +1,12 @@
 import {
   contractToolMountable
-} from "./index-khtgb21r.js";
+} from "./index-bm5rx7n6.js";
 import {
   runtimeToolMountable
-} from "./index-xw3s75nj.js";
+} from "./index-d8m8zpd8.js";
 import {
   projectToolSurface
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-khtgb21r.js → index-bm5rx7n6.js}

@@ -1,13 +1,13 @@
 import {
   executeToolMethod,
   toolErrorFromResult
-} from "./index-55hkhm67.js";
+} from "./index-8qt2m66q.js";
 import {
   assertToolExtensionCompatible,
   mergeSchemas,
   projectToolSurface,
   rebuildObject
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 import {
   isRetryableStatus
 } from "./index-2vtcmrj9.js";

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

@@ -17,6 +17,9 @@ import { z } from "zod";
 var AgentStoreEventKindSchema = z.enum([
   "runtime/baseline",
   "runtime/transition",
+  "invocation/started",
+  "invocation/finished",
+  "provider/payload",
   "provider/request",
   "provider/response",
   "provider/message",

package/dist/{index-xw3s75nj.js → index-d8m8zpd8.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {

package/dist/{index-px2gm2jp.js → index-fhwqwxe0.js}

@@ -1,21 +1,17 @@
+import {
+  loadDarwinBinding
+} from "./index-zjjyynm3.js";
+
 // src/agent-runtime/contained-scan.ts
-import path3 from "node:path";
+import path2 from "node:path";
 
 // src/agent-runtime/contained-files.ts
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readdir, realpath } from "node:fs/promises";
-import path2 from "node:path";
+import path from "node:path";
 
 // src/agent-runtime/contained-darwin.ts
-import {
-  close as closeDescriptor,
-  existsSync,
-  fstat,
-  read as readDescriptor
-} from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { close as closeDescriptor, fstat, read as readDescriptor } from "node:fs";
 var FILE_TYPE_MASK = 61440;
 var FILE_TYPE_DIRECTORY = 16384;
 var FILE_TYPE_REGULAR = 32768;
@@ -23,40 +19,6 @@ var FILE_TYPE_SYMLINK = 40960;
 function modeIs(mode, type) {
   return (mode & FILE_TYPE_MASK) === type;
 }
-function hasFunctions(value, names) {
-  return typeof value === "object" && value !== null && names.every((name) => typeof Reflect.get(value, name) === "function");
-}
-var darwinBinding;
-function loadDarwinBinding() {
-  if (darwinBinding)
-    return darwinBinding;
-  const directory = path.dirname(fileURLToPath(import.meta.url));
-  const binary = `darwin-${process.arch}.node`;
-  const candidates = [
-    path.resolve(directory, "../native", binary),
-    path.resolve(directory, "../../native", binary)
-  ];
-  const selected = candidates.find((candidate) => existsSync(candidate));
-  if (!selected) {
-    throw new Error(`Contained filesystem operations need the packaged Darwin ${process.arch} backend`);
-  }
-  const loaded = createRequire(import.meta.url)(selected);
-  const methods = [
-    "openDirectoryAt",
-    "openFileAt",
-    "createFileAt",
-    "createDirectoryAt",
-    "statAt",
-    "listAt",
-    "renameAt",
-    "unlinkAt"
-  ];
-  if (!hasFunctions(loaded, methods)) {
-    throw new Error("The packaged Darwin contained-files backend has an invalid surface");
-  }
-  darwinBinding = loaded;
-  return darwinBinding;
-}
 
 class NumericFileHandle {
   fd;
@@ -110,7 +72,7 @@ async function openPinnedDirectory(absolute) {
   }
 }
 function safeSegments(relative) {
-  if (path2.isAbsolute(relative))
+  if (path.isAbsolute(relative))
     throw new Error("Contained paths must be relative");
   const segments = relative.split(/[\\/]/u);
   if (segments.length === 0 || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
@@ -122,13 +84,13 @@ async function openDirectoryAt(directory, name) {
   if (process.platform === "darwin") {
     return new NumericFileHandle(loadDarwinBinding().openDirectoryAt(directory.fd, name));
   }
-  return open(path2.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
 }
 async function openFileAt(directory, name) {
   if (process.platform === "darwin") {
     return new NumericFileHandle(loadDarwinBinding().openFileAt(directory.fd, name));
   }
-  return open(path2.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_NOFOLLOW);
+  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_NOFOLLOW);
 }
 function entryMetadata(mode, size) {
   return {
@@ -144,7 +106,7 @@ async function statAt(directory, name) {
     const metadata = loadDarwinBinding().statAt(directory.fd, name);
     return metadata ? entryMetadata(metadata.mode, metadata.size) : null;
   }
-  return lstat(path2.join(descriptorPath(directory), name)).catch((error) => {
+  return lstat(path.join(descriptorPath(directory), name)).catch((error) => {
     if (error.code === "ENOENT")
       return null;
     throw error;
@@ -176,7 +138,7 @@ async function listContainedDirectory(root, relative, maxEntries, authorizePath)
     const admitted = [];
     const denied = [];
     for (const entry of raw) {
-      const entryPath = relative === "." ? entry.name : path2.join(relative, entry.name);
+      const entryPath = relative === "." ? entry.name : path.join(relative, entry.name);
       if (authorizePath && !await authorizePath(entryPath)) {
         denied.push({ name: entry.name, kind: containedEntryKind(entry) });
         continue;
@@ -217,7 +179,7 @@ async function createDirectoryAt(directory, name) {
     return loadDarwinBinding().createDirectoryAt(directory.fd, name, 511);
   }
   try {
-    await mkdir(path2.join(descriptorPath(directory), name));
+    await mkdir(path.join(descriptorPath(directory), name));
     return true;
   } catch (error) {
     if (error.code === "EEXIST")
@@ -235,7 +197,7 @@ async function missingContainedDirectories(root, relative) {
     for (const segment of segments) {
       walked = [...walked, segment];
       if (missing.length > 0) {
-        missing.push(walked.join(path2.sep));
+        missing.push(walked.join(path.sep));
         continue;
       }
       const next = await openDirectoryAt(current, segment).catch((error) => {
@@ -244,7 +206,7 @@ async function missingContainedDirectories(root, relative) {
         throw error;
       });
       if (!next) {
-        missing.push(walked.join(path2.sep));
+        missing.push(walked.join(path.sep));
         continue;
       }
       await current.close();
@@ -373,7 +335,7 @@ async function scanContainedFiles(input) {
     const entries = [...await listAt(directory)];
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
-      const relative = relativeDirectory ? path3.join(relativeDirectory, entry.name) : entry.name;
+      const relative = relativeDirectory ? path2.join(relativeDirectory, entry.name) : entry.name;
       const kind = entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : entry.isFile() ? "file" : "other";
       if (kind === "file" && input.includeFile && !input.includeFile(relative))
         continue;
@@ -445,4 +407,4 @@ async function scanContainedFiles(input) {
   return { files, truncated, skippedDirectories, skippedSymlinks, denied, deniedTruncated };
 }
 
-export { loadDarwinBinding, NumericFileHandle, descriptorPath, listContainedDirectory, missingContainedDirectories, openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };
+export { NumericFileHandle, descriptorPath, listContainedDirectory, missingContainedDirectories, openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };

package/dist/{index-het2he5g.js → index-gw8bmyaj.js}

@@ -5,14 +5,16 @@ import {
   containedEntryMetadata,
   descriptorPath,
   listContainedDirectory,
-  loadDarwinBinding,
   missingContainedDirectories,
   openContainedFile,
   openContainedParent,
   openContainedParentFile,
   readContainedUtf8Handle,
   scanContainedFiles
-} from "./index-px2gm2jp.js";
+} from "./index-fhwqwxe0.js";
+import {
+  loadDarwinBinding
+} from "./index-zjjyynm3.js";
 import {
   codingPathRefusal,
   codingRefusal,
@@ -22,7 +24,7 @@ import {
 } from "./index-qmy6zq75.js";
 import {
   defineRuntimeTool
-} from "./index-xw3s75nj.js";
+} from "./index-d8m8zpd8.js";
 import {
   conflict,
   forbidden

package/dist/{index-8p52kd5p.js → index-js7gqrb1.js}

@@ -1,3 +1,6 @@
+import {
+  loadDarwinBinding
+} from "./index-zjjyynm3.js";
 import {
   isRecord
 } from "./index-hffjpmq9.js";
@@ -6,6 +9,7 @@ import {
 import { constants } from "node:fs";
 import { lstat, open, unlink } from "node:fs/promises";
 import { hostname } from "node:os";
+import { z as z2 } from "zod";
 
 // src/internal/process-identity.ts
 import { execFile } from "node:child_process";
@@ -47,9 +51,9 @@ async function machineIdentity(declared) {
   detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
   return detectedIdentity;
 }
-async function probeLiveness(pid) {
+async function probeLiveness(pid, reach = (target) => process.kill(target, 0)) {
   try {
-    process.kill(pid, 0);
+    reach(pid);
   } catch (error) {
     return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
   }
@@ -73,7 +77,92 @@ async function isZombieProcess(pid, seam = {}) {
   }
 }
 
+// src/internal/process-instance.ts
+import { readFile as readFile2, readlink } from "node:fs/promises";
+import { platform as platform2 } from "node:os";
+import { z } from "zod";
+var ProcessInstanceSchema = z.object({
+  platform: z.enum(["linux", "darwin"]),
+  bootId: z.string().min(1),
+  namespace: z.string().min(1),
+  startId: z.string().regex(/^\d+$/)
+}).strict();
+function linuxProcessStart(stat, pid) {
+  if (!stat.startsWith(`${pid} (`))
+    return null;
+  const end = stat.lastIndexOf(")");
+  if (end < 0)
+    return null;
+  const start = stat.slice(end + 1).trim().split(/\s+/)[19];
+  return start !== undefined && /^\d+$/.test(start) ? start : null;
+}
+async function readProcessInstance(pid, procRoot = "/proc") {
+  try {
+    if (platform2() === "darwin") {
+      const result = ProcessInstanceSchema.safeParse(loadDarwinBinding().processIdentity(pid));
+      return result.success ? result.data : null;
+    }
+    if (platform2() !== "linux")
+      return null;
+    const [bootId, namespace, ownStatus, timeNamespace, ownStat, stat] = await Promise.all([
+      readFile2(`${procRoot}/sys/kernel/random/boot_id`, "utf8"),
+      readlink(`${procRoot}/self/ns/pid`),
+      readFile2(`${procRoot}/self/status`, "utf8"),
+      readlink(`${procRoot}/self/ns/time`),
+      readFile2(`${procRoot}/self/stat`, "utf8"),
+      readFile2(`${procRoot}/${pid}/stat`, "utf8")
+    ]);
+    const namespacePids = ownStatus.match(/^NStgid:[ \t]*(.*)$/m)?.[1]?.trim().split(/\s+/);
+    if (namespacePids?.length !== 1 || namespacePids[0] !== String(process.pid) || linuxProcessStart(ownStat, process.pid) === null)
+      return null;
+    const startId = linuxProcessStart(stat, pid);
+    if (startId === null || !bootId.trim())
+      return null;
+    return {
+      platform: "linux",
+      bootId: bootId.trim(),
+      namespace: `${namespace};${timeNamespace}`,
+      startId
+    };
+  } catch {
+    return null;
+  }
+}
+async function probeProcessOwner(pid, recorded, probes = { read: readProcessInstance, liveness: probeLiveness }) {
+  if (recorded === undefined)
+    return { liveness: await probes.liveness(pid), identity: "legacy" };
+  const unavailable = {
+    liveness: "not-probed",
+    identity: "unavailable"
+  };
+  if (recorded === null)
+    return unavailable;
+  const current = await probes.read(process.pid);
+  if (!current || recorded.platform !== current.platform)
+    return unavailable;
+  if (recorded.bootId !== current.bootId)
+    return { liveness: "gone", identity: "different-boot" };
+  if (recorded.namespace !== current.namespace)
+    return unavailable;
+  const liveness = await probes.liveness(pid);
+  if (liveness === "gone")
+    return { liveness, identity: "pid-gone" };
+  const observed = await probes.read(pid);
+  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+    return unavailable;
+  if (recorded.startId !== observed.startId)
+    return { liveness: "gone", identity: "reused-pid" };
+  return { liveness: "alive", identity: "matched" };
+}
+
 // src/internal/exclusive-lock.ts
+var ExclusiveLockOwnerSchema = z2.object({
+  pid: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  host: z2.string().min(1),
+  acquiredAt: z2.string(),
+  machine: z2.string().min(1).optional().catch(undefined),
+  process: ProcessInstanceSchema.nullable().optional().catch(null)
+});
 function isCode(error, code) {
   return isRecord(error) && error.code === code;
 }
@@ -84,17 +173,8 @@ function readOwner(text) {
   } catch {
     return;
   }
-  if (!isRecord(parsed))
-    return;
-  const { pid, host, acquiredAt, machine } = parsed;
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return;
-  if (typeof host !== "string" || host.length === 0)
-    return;
-  if (typeof acquiredAt !== "string")
-    return;
-  const identified = typeof machine === "string" && machine.length > 0 ? { machine } : {};
-  return { pid, host, acquiredAt, ...identified };
+  const owner = ExclusiveLockOwnerSchema.safeParse(parsed);
+  return owner.success ? owner.data : undefined;
 }
 function attribute(owner, identity) {
   if (identity !== null && owner.machine !== undefined) {
@@ -108,7 +188,7 @@ async function diagnose(owner, declaredIdentity) {
   const attribution = attribute(owner, await machineIdentity(declaredIdentity));
   if (attribution !== "this-machine")
     return { attribution, liveness: "not-probed", owner };
-  return { attribution, liveness: await probeLiveness(owner.pid), owner };
+  return { attribution, ...await probeProcessOwner(owner.pid, owner.process), owner };
 }
 async function readLockFile(path) {
   let handle;
@@ -140,9 +220,11 @@ async function unlinkIfSame(path, ino) {
 }
 async function createOwned(path, options, reclaimed) {
   const identity = await machineIdentity(options.machineIdentity);
+  const instance = await readProcessInstance(process.pid);
   const handle = await open(path, "wx", options.mode);
   const owner = {
     pid: process.pid,
+    process: instance,
     host: hostname(),
     acquiredAt: new Date().toISOString(),
     ...identity !== null && { machine: identity }

package/dist/{index-wt743f7f.js → index-k6gpggb9.js}

@@ -175,6 +175,7 @@ function deltaWins(delta, value) {
 import { z as z2 } from "zod";
 var WatchKeySchema = z2.object({
   service: z2.string().min(1),
+  instance: z2.string().min(1).max(128).optional(),
   action: z2.string().min(1),
   digest: z2.string().min(1)
 }).strict().readonly();
@@ -221,7 +222,7 @@ var watchContract = {
   }
 };
 function watchKeyString(key) {
-  return `${key.service}/${key.action}/${key.digest}`;
+  return `${key.service}/${key.action}/${key.digest}${key.instance === undefined ? "" : `/${encodeURIComponent(key.instance)}`}`;
 }
 
 export { WatchDeltaSchema, WatchArrayOpSchema, diff, apply, deltaWins, WatchKeySchema, WatchHaveSchema, WatchValueSchema, WatchStateSchema, WATCH_OPEN, WATCH_CLOSE, WATCH_VALUE, WATCH_STATE, watchContract, watchKeyString };

package/dist/index-q3pyb9n0.js

@@ -0,0 +1,22 @@
+// src/internal/mutation-queue.ts
+function createMutationQueue(maxPending = Number.POSITIVE_INFINITY) {
+  if (maxPending !== Number.POSITIVE_INFINITY && (!Number.isInteger(maxPending) || maxPending < 1)) {
+    throw new RangeError("maxPending must be a positive integer");
+  }
+  let tail = Promise.resolve();
+  let pending = 0;
+  return (mutation) => {
+    if (pending >= maxPending)
+      return Promise.reject(new Error("Mutation queue capacity exceeded"));
+    pending += 1;
+    const result = tail.then(mutation, mutation);
+    tail = result.then(() => {
+      pending -= 1;
+    }, () => {
+      pending -= 1;
+    });
+    return result;
+  };
+}
+
+export { createMutationQueue };

package/dist/{index-f1nb70ae.js → index-r066jx76.js}

@@ -3,15 +3,15 @@ import {
 } from "./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-hmp4800j.js";
+} from "./index-9t3dffv2.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-khtgb21r.js";
+} from "./index-bm5rx7n6.js";
 import {
   toolErrorFromResult,
   toolResultFromError
-} from "./index-55hkhm67.js";
+} from "./index-8qt2m66q.js";
 import {
   coerceJsonArgs
 } from "./index-1zbbzgfh.js";
@@ -19,7 +19,7 @@ import {
   assertUniqueToolName,
   buildToolPresentationSchema,
   objectShapeKeys
-} from "./index-np4m8hd3.js";
+} from "./index-0r0fbk7z.js";
 import {
   jsonSchemaFields
 } from "./index-eqqvgdb3.js";

package/dist/{index-sp1tzwnb.js → index-s84he4v7.js}

@@ -7,12 +7,12 @@ import {
   createAgentRuntimeStore,
   isActiveRunState,
   replaceMessage
-} from "./index-wsm5w4ee.js";
+} from "./index-0b1cnze2.js";
 import {
   AgentRecoverablePageSchema,
   AgentStoreEventEnvelopeSchema,
   AgentStoreEventPageSchema
-} from "./index-gxrt5h6v.js";
+} from "./index-cyktc4bp.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema

package/dist/{index-863ea9jb.js → index-sh3s86na.js}

@@ -4,16 +4,16 @@ import {
 } from "./index-79z7m7dt.js";
 import {
   collectToolSurface
-} from "./index-hmp4800j.js";
+} from "./index-9t3dffv2.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-khtgb21r.js";
+} from "./index-bm5rx7n6.js";
 import {
   isToolExecutionControlError,
   toolCauseFromResult,
   toolResultFromError
-} from "./index-55hkhm67.js";
+} from "./index-8qt2m66q.js";
 import {
   isRecord
 } from "./index-hffjpmq9.js";