stitchkit 0.90.7 → 0.91.0

package/dist/index-kw9t5ayn.js

@@ -0,0 +1,507 @@
+// src/agent-runtime/durability-contract.ts
+import { z } from "zod";
+var DURABILITY_STEP_EVENT_KIND = "durability/step";
+var DURABILITY_PARK_EVENT_KIND = "durability/park";
+var DURABILITY_EVENT_EVENT_KIND = "durability/event";
+var StepEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  stepName: z.string().min(1),
+  encoded: z.string()
+});
+var SleepParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("sleep"),
+  name: z.string().min(1),
+  deadline: z.number()
+});
+var WaitParkSchema = z.object({
+  runId: z.string().min(1),
+  kind: z.literal("wait"),
+  event: z.string().min(1),
+  id: z.string().min(1)
+});
+var ParkEventPayloadSchema = z.discriminatedUnion("kind", [
+  SleepParkSchema,
+  WaitParkSchema
+]);
+var DeliveredEventPayloadSchema = z.object({
+  runId: z.string().min(1),
+  event: z.string().min(1),
+  id: z.string().min(1),
+  encoded: z.string()
+});
+
+class StepResultDecodeError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "StepResultDecodeError";
+  }
+}
+
+class StepResultNotSerializableError extends Error {
+  constructor(stepName, cause) {
+    super(`Step "${stepName}" returned a value that is not JSON-serializable`, {
+      cause
+    });
+    this.name = "StepResultNotSerializableError";
+  }
+}
+
+class StepAbortedError extends Error {
+  constructor(stepName) {
+    super(`Step "${stepName}" was aborted before it started`);
+    this.name = "StepAbortedError";
+  }
+}
+
+class ParkRecordDecodeError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ParkRecordDecodeError";
+  }
+}
+
+class ParkAbortedError extends Error {
+  constructor(park) {
+    super(`Park "${park}" was aborted before it was satisfied`);
+    this.name = "ParkAbortedError";
+  }
+}
+
+// src/agent-runtime/durability-json.ts
+import { z as z2 } from "zod";
+function losslessJson(value, ancestors = new Set, depth = 0) {
+  if (depth > 100)
+    return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value) && !Object.is(value, -0);
+  if (typeof value !== "object" || ancestors.has(value))
+    return false;
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+    return false;
+  ancestors.add(value);
+  try {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    if (array && keys.length !== value.length + 1)
+      return false;
+    for (const key of keys) {
+      if (array && key === "length")
+        continue;
+      if (typeof key !== "string")
+        return false;
+      if (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length))
+        return false;
+      const descriptor = descriptors[key];
+      if (!descriptor?.enumerable || !("value" in descriptor))
+        return false;
+      if (!losslessJson(descriptor.value, ancestors, depth + 1))
+        return false;
+    }
+    return true;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var DurableJsonSchema = z2.custom((value) => losslessJson(value), "Expected lossless JSON data (finite numbers, plain objects and dense arrays; no accessors)");
+
+// src/agent-runtime/durability-ledger.ts
+function stepKey(conversationId, runId, stepName) {
+  return JSON.stringify([conversationId, runId, stepName]);
+}
+function sleepParkKey(conversationId, runId, name) {
+  return JSON.stringify([conversationId, runId, "sleep", name]);
+}
+function waitParkKey(conversationId, runId, event, id) {
+  return JSON.stringify([conversationId, runId, "wait", event, id]);
+}
+function parkEventKey(conversationId, payload) {
+  return payload.kind === "sleep" ? sleepParkKey(conversationId, payload.runId, payload.name) : waitParkKey(conversationId, payload.runId, payload.event, payload.id);
+}
+function encodeStepResult(stepName, value) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(DurableJsonSchema.parse(value));
+  } catch (cause) {
+    throw new StepResultNotSerializableError(stepName, cause);
+  }
+  if (encoded === undefined) {
+    throw new StepResultNotSerializableError(stepName, value);
+  }
+  return encoded;
+}
+function encodeDeliveredPayload(event, id, payload) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(DurableJsonSchema.parse(payload === undefined ? null : payload));
+  } catch (cause) {
+    throw new TypeError(`Delivered event "${event}#${id}" payload is not JSON-serializable`, {
+      cause
+    });
+  }
+  if (encoded === undefined) {
+    throw new TypeError(`Delivered event "${event}#${id}" payload is not JSON-serializable`);
+  }
+  return encoded;
+}
+function decodeStepPayload(event) {
+  const parsed = StepEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new StepResultDecodeError(`Recorded step event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeRecordedResult(payload, event) {
+  try {
+    return DurableJsonSchema.parse(JSON.parse(payload.encoded));
+  } catch (cause) {
+    throw new StepResultDecodeError(`Recorded result for step "${payload.stepName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+  }
+}
+function decodeParkPayload(event) {
+  const parsed = ParkEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new ParkRecordDecodeError(`Recorded park event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeDeliveredPayload(event) {
+  const parsed = DeliveredEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new ParkRecordDecodeError(`Delivered event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+function decodeDeliveredResult(payload, event) {
+  try {
+    return JSON.parse(payload.encoded);
+  } catch (cause) {
+    throw new ParkRecordDecodeError(`Delivered payload for "${payload.event}#${payload.id}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+  }
+}
+async function readDurabilityLedger(store, conversationId, view) {
+  const { steps, parks, deliveries } = view;
+  let fromSeq = view.nextSeq;
+  for (;; ) {
+    const page = await store.readEvents({
+      conversationId,
+      ...fromSeq !== undefined && { fromSeq },
+      limit: 1e4
+    });
+    for (const event of page.items) {
+      if (event.kind === DURABILITY_STEP_EVENT_KIND) {
+        const payload = decodeStepPayload(event);
+        steps.set(stepKey(event.conversationId, payload.runId, payload.stepName), decodeRecordedResult(payload, event));
+      } else if (event.kind === DURABILITY_PARK_EVENT_KIND) {
+        const payload = decodeParkPayload(event);
+        parks.set(parkEventKey(event.conversationId, payload), payload);
+      } else if (event.kind === DURABILITY_EVENT_EVENT_KIND) {
+        const payload = decodeDeliveredPayload(event);
+        const key = waitParkKey(event.conversationId, payload.runId, payload.event, payload.id);
+        if (!deliveries.has(key))
+          deliveries.set(key, decodeDeliveredResult(payload, event));
+      }
+    }
+    const last = page.items.at(-1);
+    if (last)
+      view.nextSeq = last.seq + 1;
+    if (page.nextSeq === undefined)
+      break;
+    fromSeq = page.nextSeq;
+  }
+  return view;
+}
+
+// src/agent-runtime/durability-scheduler.ts
+var systemClock = {
+  now: () => Date.now(),
+  schedule(callback, delayMs) {
+    const timer = setTimeout(callback, Math.min(delayMs, 2147483647));
+    timer.unref();
+    return { cancel: () => clearTimeout(timer) };
+  }
+};
+var stores = new WeakMap;
+function notifyWaiters(parkWaiters, key) {
+  const waiters = parkWaiters.get(key);
+  if (!waiters)
+    return;
+  for (const wake of [...waiters])
+    wake();
+}
+function waitForTimer(clock, delayMs, signal) {
+  return new Promise((resolve) => {
+    let timer;
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      timer?.cancel();
+      signal?.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    const onAbort = () => finish("aborted");
+    timer = clock.schedule(() => finish("elapsed"), delayMs);
+    if (signal) {
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+async function waitForDeadline(clock, deadline, park, signal) {
+  for (;; ) {
+    if (signal?.aborted)
+      throw new ParkAbortedError(park);
+    const remaining = deadline - clock.now();
+    if (remaining <= 0)
+      return;
+    const outcome = await waitForTimer(clock, remaining, signal);
+    if (outcome === "aborted")
+      throw new ParkAbortedError(park);
+  }
+}
+function createParkWaiter(parkWaiters, key, signal) {
+  const waiters = parkWaiters.get(key) ?? new Set;
+  parkWaiters.set(key, waiters);
+  let settle;
+  const outcome = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let settled = false;
+  const cleanup = () => {
+    waiters.delete(onWake);
+    if (waiters.size === 0)
+      parkWaiters.delete(key);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  const finish = (result) => {
+    if (settled)
+      return;
+    settled = true;
+    cleanup();
+    settle(result);
+  };
+  const onWake = () => finish("woke");
+  const onAbort = () => finish("aborted");
+  waiters.add(onWake);
+  if (signal) {
+    if (signal.aborted)
+      onAbort();
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return { outcome, cancel: cleanup };
+}
+
+// src/agent-runtime/durability.ts
+function releaseSettled(registry, key, pending) {
+  const release = () => {
+    if (registry.get(key) === pending)
+      registry.delete(key);
+  };
+  pending.then(release, release);
+}
+function detachedResult(pending) {
+  return pending.then((value) => JSON.parse(JSON.stringify(value)));
+}
+function createLocalStepDurability(options) {
+  const { store, conversationId, runId } = options;
+  const inFlight = stores.get(store) ?? {
+    steps: new Map,
+    parks: new Map,
+    waiters: new Map
+  };
+  stores.set(store, inFlight);
+  const { steps: inFlightSteps, parks: inFlightParks, waiters: parkWaiters } = inFlight;
+  const clock = options.clock ?? systemClock;
+  const view = {
+    steps: new Map,
+    parks: new Map,
+    deliveries: new Map,
+    nextSeq: 1
+  };
+  let reading = Promise.resolve(view);
+  const readLedger = () => {
+    reading = reading.catch(() => view).then(() => readDurabilityLedger(store, conversationId, view));
+    return reading;
+  };
+  const readRecordedStep = async (name) => {
+    const key = stepKey(conversationId, runId, name);
+    const records = await readLedger();
+    const value = records.steps.get(key);
+    return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  };
+  const execute = async (name, body, runOptions) => {
+    const recorded = await readRecordedStep(name);
+    if (recorded !== undefined) {
+      return recorded;
+    }
+    if (runOptions?.signal?.aborted || options.signal?.aborted)
+      throw new StepAbortedError(name);
+    const value = await body();
+    const encoded = encodeStepResult(name, value);
+    await store.appendEvent({
+      conversationId,
+      kind: DURABILITY_STEP_EVENT_KIND,
+      payload: { runId, stepName: name, encoded }
+    });
+    return JSON.parse(encoded);
+  };
+  const step = (name, body, runOptions) => {
+    const key = stepKey(conversationId, runId, name);
+    const existing = inFlightSteps.get(key);
+    if (existing) {
+      return detachedResult(existing);
+    }
+    const pending = execute(name, body, runOptions);
+    inFlightSteps.set(key, pending);
+    releaseSettled(inFlightSteps, key, pending);
+    return detachedResult(pending);
+  };
+  const executeSleep = async (name, seconds, runOptions) => {
+    const key = sleepParkKey(conversationId, runId, name);
+    const signal = options.signal && runOptions?.signal ? AbortSignal.any([options.signal, runOptions.signal]) : runOptions?.signal ?? options.signal;
+    const ledger = await readLedger();
+    const existing = ledger.parks.get(key);
+    let deadline;
+    if (existing) {
+      if (existing.kind !== "sleep") {
+        throw new ParkRecordDecodeError(`Recorded park "${name}" is not a sleep record`);
+      }
+      deadline = existing.deadline;
+    } else {
+      deadline = clock.now() + seconds * 1000;
+      if (!Number.isSafeInteger(Math.ceil(deadline)))
+        throw new TypeError("Sleep deadline exceeds the supported clock range");
+      await store.appendEvent({
+        conversationId,
+        kind: DURABILITY_PARK_EVENT_KIND,
+        payload: { runId, kind: "sleep", name, deadline }
+      });
+    }
+    if (signal?.aborted)
+      throw new ParkAbortedError(name);
+    await waitForDeadline(clock, deadline, name, signal);
+  };
+  const sleep = (input, runOptions) => {
+    const { seconds } = input;
+    if (!Number.isFinite(seconds) || seconds < 0) {
+      throw new TypeError(`sleep seconds must be a non-negative finite number, got ${String(seconds)}`);
+    }
+    const name = input.name ?? `sleep:${seconds}`;
+    const key = sleepParkKey(conversationId, runId, name);
+    const existing = inFlightParks.get(key);
+    if (existing) {
+      return existing;
+    }
+    const pending = executeSleep(name, seconds, runOptions);
+    inFlightParks.set(key, pending);
+    releaseSettled(inFlightParks, key, pending);
+    return pending;
+  };
+  const executeWait = async (eventName, id, runOptions) => {
+    const key = waitParkKey(conversationId, runId, eventName, id);
+    const park = `${eventName}#${id}`;
+    const signal = options.signal && runOptions?.signal ? AbortSignal.any([options.signal, runOptions.signal]) : runOptions?.signal ?? options.signal;
+    for (;; ) {
+      if (signal?.aborted)
+        throw new ParkAbortedError(park);
+      const waiter = createParkWaiter(parkWaiters, key, signal);
+      let unsubscribe;
+      try {
+        unsubscribe = options.subscribe?.(() => notifyWaiters(parkWaiters, key));
+        const ledger = await readLedger();
+        if (ledger.deliveries.has(key)) {
+          return JSON.parse(JSON.stringify(ledger.deliveries.get(key)));
+        }
+        if (!ledger.parks.has(key)) {
+          await store.appendEvent({
+            conversationId,
+            kind: DURABILITY_PARK_EVENT_KIND,
+            payload: { runId, kind: "wait", event: eventName, id }
+          });
+        }
+        const outcome = await waiter.outcome;
+        if (outcome === "aborted")
+          throw new ParkAbortedError(park);
+      } finally {
+        waiter.cancel();
+        unsubscribe?.();
+      }
+    }
+  };
+  const waitFor = (input, runOptions) => {
+    const key = waitParkKey(conversationId, runId, input.event, input.id);
+    const existing = inFlightParks.get(key);
+    if (existing) {
+      return detachedResult(existing);
+    }
+    const pending = executeWait(input.event, input.id, runOptions);
+    inFlightParks.set(key, pending);
+    releaseSettled(inFlightParks, key, pending);
+    return detachedResult(pending);
+  };
+  const deliver = async (input) => {
+    const key = waitParkKey(conversationId, runId, input.event, input.id);
+    const ledger = await readLedger();
+    if (!ledger.deliveries.has(key)) {
+      const encoded = encodeDeliveredPayload(input.event, input.id, input.payload);
+      await store.appendEvent({
+        conversationId,
+        kind: DURABILITY_EVENT_EVENT_KIND,
+        payload: { runId, event: input.event, id: input.id, encoded }
+      });
+    }
+    notifyWaiters(parkWaiters, key);
+  };
+  return {
+    step,
+    readRecordedStep,
+    hasRecordedStep: async (name) => await readRecordedStep(name) !== undefined,
+    sleep,
+    waitFor,
+    deliver
+  };
+}
+
+// src/tools/agent-tool-error.ts
+var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
+
+class AgentToolError extends Error {
+  output;
+  constructor(output, cause) {
+    let message = "Tool execution failed";
+    try {
+      message = JSON.stringify(output);
+    } catch {}
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "AgentToolError";
+    this.output = output;
+    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
+  }
+}
+function isAgentToolError(value) {
+  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
+}
+
+// src/tools/durability-context.ts
+var contexts = new WeakMap;
+function createToolDurabilityContext(factory) {
+  const context = {};
+  contexts.set(context, factory);
+  return context;
+}
+function resolveToolDurability(context, callId, signal) {
+  if (typeof context !== "object" || context === null)
+    return;
+  return contexts.get(context)?.(callId, signal);
+}
+
+export { DURABILITY_STEP_EVENT_KIND, StepResultDecodeError, StepResultNotSerializableError, StepAbortedError, ParkRecordDecodeError, ParkAbortedError, createLocalStepDurability, AgentToolError, isAgentToolError, createToolDurabilityContext, resolveToolDurability };

package/dist/{index-8pjqv3zh.js → index-mqhjmadk.js}

@@ -6,7 +6,7 @@ import {
   formatZodError,
   normalizeError,
   validateDeclaredOutput
-} from "./index-2hryh65w.js";
+} from "./index-13cjtmrw.js";
 import {
   coerceJsonArgs
 } from "./index-7zbps32p.js";
@@ -16,8 +16,9 @@ import {
 import {
   AppError,
   STITCH_ERROR_STATUS,
+  isRetryableStatus,
   isStitchErrorCode
-} from "./index-scs3f1eg.js";
+} from "./index-2vtcmrj9.js";
 import {
   isUnsafeKey
 } from "./index-kzfs85xp.js";
@@ -34,6 +35,12 @@ class ToolExecutionControlError extends Error {
     this.reason = reason;
   }
 }
+function isPlainObject(value) {
+  if (!isRecord(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
 function isToolExecutionControlError(value) {
   return value instanceof ToolExecutionControlError;
 }
@@ -44,7 +51,8 @@ function toolResultFromError(err) {
     ok: false,
     code: appErr.code,
     details: appErr.details ?? { message: appErr.message },
-    ...appErr.hint && { hint: appErr.hint }
+    ...appErr.hint && { hint: appErr.hint },
+    retryable: appErr.retryable ?? isRetryableStatus(appErr.status)
   };
   normalizedToolErrors.set(result, { normalized: appErr, cause: err });
   return result;
@@ -56,7 +64,7 @@ function toolErrorFromResult(result) {
   const details = isRecord(result.details) ? result.details : undefined;
   const message = typeof details?.message === "string" ? details.message : result.code;
   const status = isStitchErrorCode(result.code) ? STITCH_ERROR_STATUS[result.code] : 500;
-  return new AppError(result.code, message, status, details, result.hint);
+  return new AppError(result.code, message, status, details, result.hint, undefined, result.retryable);
 }
 function toolCauseFromResult(result) {
   return normalizedToolErrors.get(result)?.cause;
@@ -92,7 +100,8 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
         durationMs: Date.now() - startedAt,
         context: hookContext,
         endpoint: method,
-        ...thrown !== undefined && { error: thrown }
+        ...thrown !== undefined && { error: thrown },
+        ...rewrittenArgsApplied && rewrittenArgs !== undefined && { effectiveArgs: rewrittenArgs }
       });
     } catch (hookError) {
       try {
@@ -102,26 +111,32 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
     return result;
   };
   let beforeRan = false;
+  let rewrittenArgs;
+  let rewrittenArgsApplied = false;
   const runBefore = async () => {
     if (beforeRan || !hooks?.beforeToolCall)
       return null;
     beforeRan = true;
+    let returned;
     try {
-      await hooks.beforeToolCall({
+      returned = await hooks.beforeToolCall({
         toolName,
         args: rawArgs,
         context: hookContext,
         endpoint: method
       });
-      return null;
     } catch (err) {
-      return finish(toolResultFromError(err));
+      return { kind: "failure", result: await finish(toolResultFromError(err)) };
     }
+    if (!isPlainObject(returned))
+      return null;
+    rewrittenArgs = returned;
+    return { kind: "args" };
   };
   const finishThrown = async (err) => {
-    const beforeFailure2 = await runBefore();
-    if (beforeFailure2)
-      return beforeFailure2;
+    const before2 = await runBefore();
+    if (before2?.kind === "failure")
+      return before2.result;
     if (hooks?.onToolError) {
       try {
         await hooks.onToolError({
@@ -140,9 +155,11 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
   };
   let callArgs = rawArgs;
   let callContext = context;
+  let extensionKeys;
   if (extension) {
-    const extensionKeys = new Set(Object.keys(extension.schema.shape));
-    const extensionArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => extensionKeys.has(key)));
+    const keys = new Set(Object.keys(extension.schema.shape));
+    extensionKeys = keys;
+    const extensionArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => keys.has(key)));
     let parsed;
     try {
       parsed = extension.schema.safeParse(extensionArgs);
@@ -150,9 +167,9 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
       return finishThrown(err);
     }
     if (!parsed.success) {
-      const beforeFailure2 = await runBefore();
-      if (beforeFailure2)
-        return beforeFailure2;
+      const before2 = await runBefore();
+      if (before2?.kind === "failure")
+        return before2.result;
       return finish({
         ok: false,
         code: "VALIDATION_ERROR",
@@ -165,17 +182,22 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
         ...context,
         ...resolved,
         source: context.source,
-        ...context.mcp !== undefined && { mcp: context.mcp }
+        ...context.mcp !== undefined && { mcp: context.mcp },
+        ...context.toolCallId !== undefined && { toolCallId: context.toolCallId }
       };
       hookContext = callContext;
-      callArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !extensionKeys.has(key)));
+      callArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !keys.has(key)));
     } catch (err) {
       return finishThrown(err);
     }
   }
-  const beforeFailure = await runBefore();
-  if (beforeFailure)
-    return beforeFailure;
+  const before = await runBefore();
+  if (before?.kind === "failure")
+    return before.result;
+  if (before?.kind === "args" && rewrittenArgs) {
+    callArgs = extensionKeys ? Object.fromEntries(Object.entries(rewrittenArgs).filter(([key]) => !extensionKeys.has(key))) : rewrittenArgs;
+    rewrittenArgsApplied = true;
+  }
   const paramKeys = new Set(objectShapeKeys(method.paramsSchema));
   let paramArgs = {};
   let inputArgs = {};

package/dist/{index-3yqgj323.js → index-qjeyx5t2.js}

@@ -17,14 +17,14 @@ import {
   missingSandboxRestrictions,
   probeAgentProcessSandbox,
   refuseMissingCodingPath
-} from "./index-gte38nbm.js";
+} from "./index-qmy6zq75.js";
 import {
   defineRuntimeTool
 } from "./index-8z9we758.js";
 import {
   conflict,
   forbidden
-} from "./index-scs3f1eg.js";
+} from "./index-2vtcmrj9.js";
 
 // src/agent-runtime/coding-tool-contract.ts
 import { z } from "zod";

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

@@ -1,7 +1,7 @@
 import {
   AppError,
   STITCH_ERROR_STATUS
-} from "./index-scs3f1eg.js";
+} from "./index-2vtcmrj9.js";
 
 // src/agent-runtime/sandbox.ts
 import { z } from "zod";

package/dist/{index-zsdgd1tz.js → index-qrbdq8jk.js}

@@ -1,6 +1,6 @@
 import {
   contractToolMountable
-} from "./index-1bnkzq95.js";
+} from "./index-1qvdwnp2.js";
 import {
   runtimeToolMountable
 } from "./index-8z9we758.js";