stitchkit 0.90.7 → 0.91.0

package/dist/{index-s208wab5.js → index-bx6yq2m4.js}

@@ -30,13 +30,14 @@ import {
   createBoundedSinkManager
 } from "./index-wnfk50r0.js";
 import {
+  createLocalStepDurability,
   createToolDurabilityContext,
   isAgentToolError
-} from "./index-7rkhw9ec.js";
+} from "./index-kw9t5ayn.js";
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-8pjqv3zh.js";
+} from "./index-mqhjmadk.js";
 import {
   isRecord,
   transportResult
@@ -316,479 +317,6 @@ function createAgentSessionCoordinator() {
   };
 }
 
-// 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/agent-runtime/events.ts
 function createAgentRuntimeEventSink(config) {
   const manager = createBoundedSinkManager({
@@ -1104,9 +632,9 @@ function createAgentToolFenceLifecycle(config) {
 }
 
 // src/agent-runtime/prompt.ts
-import { z as z3 } from "zod";
-var AgentTokenCountSchema = z3.object({
-  value: z3.int().nonnegative().optional(),
+import { z } from "zod";
+var AgentTokenCountSchema = z.object({
+  value: z.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -1226,7 +754,7 @@ function knownValue(value) {
 }
 function composeAgentPrompt(sections) {
   return async (options) => {
-    const event = z3.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
+    const event = z.enum(["session.started", "turn.started"]).parse(options.event ?? "turn.started");
     const rendered = [];
     let systemTotal = 0;
     let userTotal = 0;
@@ -1429,7 +957,7 @@ async function recordAgentRetryDecision(input) {
 }
 
 // src/agent-runtime/state-slots.ts
-import { z as z4 } from "zod";
+import { z as z2 } from "zod";
 function defineStateSlot(input) {
   if (input.name.length === 0)
     throw new TypeError("State slot name must not be empty");
@@ -1444,11 +972,11 @@ function defineStateSlot(input) {
     ...input.description && { description: input.description }
   };
 }
-var StateSetPayloadSchema = z4.object({
-  name: z4.string().min(1),
-  version: z4.int().positive(),
-  value: z4.json(),
-  actor: z4.enum(["agent", "human", "system"])
+var StateSetPayloadSchema = z2.object({
+  name: z2.string().min(1),
+  version: z2.int().positive(),
+  value: z2.json(),
+  actor: z2.enum(["agent", "human", "system"])
 }).strict();
 function slotRegistry(definitions) {
   const result = new Map;
@@ -1530,18 +1058,18 @@ function renderAgentStateSlots(values) {
 var agentGoalStateSlot = defineStateSlot({
   name: "goal",
   description: "The durable objective and lifecycle of this conversation.",
-  schema: z4.object({
-    objective: z4.string().min(1),
-    status: z4.enum(["active", "complete", "blocked"])
+  schema: z2.object({
+    objective: z2.string().min(1),
+    status: z2.enum(["active", "complete", "blocked"])
   }).strict()
 });
 var agentTodoStateSlot = defineStateSlot({
   name: "todo",
   description: "The durable ordered work plan for this conversation.",
-  schema: z4.object({
-    items: z4.array(z4.object({
-      step: z4.string().min(1),
-      status: z4.enum(["pending", "in_progress", "completed"])
+  schema: z2.object({
+    items: z2.array(z2.object({
+      step: z2.string().min(1),
+      status: z2.enum(["pending", "in_progress", "completed"])
     }).strict())
   }).strict()
 });
@@ -1751,7 +1279,7 @@ function createRunMutationQueue() {
 import { wrapLanguageModel } from "ai";
 
 // src/agent-runtime/runtime-internals.ts
-import { z as z5 } from "zod";
+import { z as z3 } from "zod";
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1759,7 +1287,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z5.json().safeParse(value);
+  const parsed = z3.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -3813,4 +3341,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, DURABILITY_STEP_EVENT_KIND, StepResultDecodeError, StepResultNotSerializableError, StepAbortedError, ParkRecordDecodeError, ParkAbortedError, createLocalStepDurability, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };
+export { AgentRuntimeConflictError, normalizeSdkUsage, AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentProviderStreamCutError, classifyProviderFailure, isToolResultFailure, recordAgentRetryDecision, defineStateSlot, createAgentStateSlotStore, renderAgentStateSlots, agentGoalStateSlot, agentTodoStateSlot, createAgentRuntime };

package/dist/{index-83fafqw8.js → index-f4p4b8f6.js}

@@ -1,19 +1,19 @@
 import {
   AgentToolError,
   resolveToolDurability
-} from "./index-7rkhw9ec.js";
+} from "./index-kw9t5ayn.js";
 import {
   collectToolSurface
-} from "./index-zsdgd1tz.js";
+} from "./index-qrbdq8jk.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-1bnkzq95.js";
+} from "./index-1qvdwnp2.js";
 import {
   isToolExecutionControlError,
   toolCauseFromResult,
   toolResultFromError
-} from "./index-8pjqv3zh.js";
+} from "./index-mqhjmadk.js";
 import {
   isRecord
 } from "./index-77fekveh.js";
@@ -49,15 +49,16 @@ function mountAgent(services, config = {}) {
     });
     const execute = async (rawArgs, options) => {
       const args = isRecord(rawArgs) ? rawArgs : {};
-      const durability = resolveToolDurability(options.context, options.toolCallId, options.abortSignal);
+      const durability = resolveToolDurability(options.context, options.toolCallId, options.abortSignal) ?? config.durability?.(options.toolCallId, options.abortSignal);
+      const callContext = { signal: options.abortSignal, toolCallId: options.toolCallId };
       const executeTool = durability ? createToolRunner({
         source: "agent",
         extend: config.extend,
         context: {
           ...config.context,
-          step: durability.step,
-          sleep: durability.sleep,
-          waitFor: durability.waitFor
+          step: durability.step.bind(durability),
+          sleep: durability.sleep.bind(durability),
+          waitFor: durability.waitFor.bind(durability)
         },
         hooks: config.hooks,
         lifecycle: config.lifecycle,
@@ -65,9 +66,7 @@ function mountAgent(services, config = {}) {
         coerceJsonArgs: config.coerceJsonArgs,
         onOutputStrip: config.onOutputStrip
       }) : runTool;
-      const result = await executeTool(mountable, args, {
-        signal: options.abortSignal
-      }).catch((err) => {
+      const result = await executeTool(mountable, args, callContext).catch((err) => {
         if (isToolExecutionControlError(err))
           throw err;
         throw new AgentToolError(formatToolError(toolResultFromError(err), mountable.name, config.errorHint), err);