stitchkit 0.93.0 → 0.94.1

package/dist/index-79z7m7dt.js

@@ -0,0 +1,675 @@
+// src/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 DURABILITY_EFFECT_EVENT_KIND = "durability/effect";
+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()
+});
+var EffectIdentity = { runId: z.string().min(1), effectName: z.string().min(1) };
+var EffectEventPayloadSchema = z.discriminatedUnion("phase", [
+  z.object({ ...EffectIdentity, phase: z.literal("intent") }),
+  z.object({
+    ...EffectIdentity,
+    phase: z.literal("accepted"),
+    encoded: z.string(),
+    via: z.enum(["run", "reconcile"])
+  }),
+  z.object({ ...EffectIdentity, phase: z.literal("uncertain") })
+]);
+
+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 EffectUnresolvedError extends Error {
+  effectName;
+  reason;
+  constructor(effectName, reason, options) {
+    super(`Effect "${effectName}" is unresolved (${reason}); its intent stands`, options);
+    this.effectName = effectName;
+    this.reason = reason;
+    this.name = "EffectUnresolvedError";
+  }
+}
+
+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/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/durability/ledger.ts
+function stepKey(conversationId, runId, stepName) {
+  return JSON.stringify([conversationId, runId, stepName]);
+}
+function effectKey(conversationId, runId, effectName) {
+  return JSON.stringify([conversationId, runId, "effect", effectName]);
+}
+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 });
+  }
+}
+function decodeEffect(event) {
+  const parsed = EffectEventPayloadSchema.safeParse(event.payload);
+  if (!parsed.success) {
+    throw new StepResultDecodeError(`Recorded effect event ${event.eventId} in conversation ${event.conversationId} is malformed`, { cause: parsed.error });
+  }
+  const payload = parsed.data;
+  if (payload.phase === "intent")
+    return { payload, record: { outcome: undefined } };
+  if (payload.phase === "uncertain")
+    return { payload, record: { outcome: "uncertain" } };
+  try {
+    const proof = DurableJsonSchema.parse(JSON.parse(payload.encoded));
+    return { payload, record: { outcome: "accepted", proof } };
+  } catch (cause) {
+    throw new StepResultDecodeError(`Recorded proof for effect "${payload.effectName}" (run ${payload.runId}, ` + `event ${event.eventId}) is not decodable JSON`, { cause });
+  }
+}
+async function readDurabilityLedger(store, conversationId, view) {
+  const { steps, effects, 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_EFFECT_EVENT_KIND) {
+        const { payload, record } = decodeEffect(event);
+        const key = effectKey(event.conversationId, payload.runId, payload.effectName);
+        if (effects.get(key)?.outcome === undefined)
+          effects.set(key, record);
+      } 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/durability/effect.ts
+var DEFAULT_RECONCILE_TIMEOUT_MS = 30000;
+var MAX_PROOF_BYTES = 64 * 1024;
+function encodeProof(name, proof) {
+  let encoded;
+  try {
+    encoded = encodeStepResult(name, proof);
+  } catch (cause) {
+    throw new EffectUnresolvedError(name, "proof-rejected", { cause });
+  }
+  const bytes = new TextEncoder().encode(encoded).byteLength;
+  if (bytes > MAX_PROOF_BYTES) {
+    throw new EffectUnresolvedError(name, "proof-rejected", {
+      cause: new RangeError(`the proof is ${bytes} bytes; at most ${MAX_PROOF_BYTES} are kept`)
+    });
+  }
+  return encoded;
+}
+function outcomeOf(encoded) {
+  return { outcome: "accepted", proof: JSON.parse(encoded) };
+}
+async function append(context, payload, name) {
+  await context.store.appendEvent({
+    conversationId: context.conversationId,
+    kind: DURABILITY_EFFECT_EVENT_KIND,
+    payload: { runId: context.runId, effectName: name, ...payload }
+  });
+}
+async function reconcile(context, name, handlers, timeoutMs) {
+  const controller = new AbortController;
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort(new Error(`reconcile did not finish within ${timeoutMs} ms`));
+      resolve("timeout");
+    }, timeoutMs);
+  });
+  let found;
+  try {
+    found = await Promise.race([
+      Promise.resolve().then(() => handlers.reconcile(controller.signal)),
+      deadline
+    ]);
+  } catch (cause) {
+    throw new EffectUnresolvedError(name, "reconcile-failed", { cause });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (found === "timeout") {
+    throw new EffectUnresolvedError(name, "reconcile-timeout", {
+      cause: controller.signal.reason
+    });
+  }
+  if (found === null) {
+    await append(context, { phase: "uncertain" }, name);
+    return { outcome: "uncertain" };
+  }
+  const encoded = encodeProof(name, found);
+  await append(context, { phase: "accepted", encoded, via: "reconcile" }, name);
+  return outcomeOf(encoded);
+}
+async function executeEffect(context, name, handlers, options) {
+  const timeoutMs = options?.reconcileTimeoutMs ?? DEFAULT_RECONCILE_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new TypeError(`reconcileTimeoutMs must be a positive finite number, got ${timeoutMs}`);
+  }
+  const key = effectKey(context.conversationId, context.runId, name);
+  const recorded = (await context.readLedger()).effects.get(key);
+  if (recorded?.outcome === "uncertain")
+    return { outcome: "uncertain" };
+  if (recorded?.outcome === "accepted") {
+    return outcomeOf(JSON.stringify(recorded.proof));
+  }
+  if (options?.signal?.aborted || context.signal?.aborted)
+    throw new StepAbortedError(name);
+  if (recorded)
+    return reconcile(context, name, handlers, timeoutMs);
+  await append(context, { phase: "intent" }, name);
+  let proof;
+  try {
+    proof = await handlers.run();
+  } catch (cause) {
+    throw new EffectUnresolvedError(name, "run-failed", { cause });
+  }
+  const encoded = encodeProof(name, proof);
+  await append(context, { phase: "accepted", encoded, via: "run" }, name);
+  return outcomeOf(encoded);
+}
+
+// src/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/durability/parks.ts
+async function executeSleep(park, name, seconds, runOptions) {
+  const key = sleepParkKey(park.conversationId, park.runId, name);
+  const signal = park.signal && runOptions?.signal ? AbortSignal.any([park.signal, runOptions.signal]) : runOptions?.signal ?? park.signal;
+  const ledger = await park.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 = park.clock.now() + seconds * 1000;
+    if (!Number.isSafeInteger(Math.ceil(deadline)))
+      throw new TypeError("Sleep deadline exceeds the supported clock range");
+    await park.store.appendEvent({
+      conversationId: park.conversationId,
+      kind: DURABILITY_PARK_EVENT_KIND,
+      payload: { runId: park.runId, kind: "sleep", name, deadline }
+    });
+  }
+  if (signal?.aborted)
+    throw new ParkAbortedError(name);
+  await waitForDeadline(park.clock, deadline, name, signal);
+}
+async function executeWait(park, eventName, id, runOptions) {
+  const key = waitParkKey(park.conversationId, park.runId, eventName, id);
+  const label = `${eventName}#${id}`;
+  const signal = park.signal && runOptions?.signal ? AbortSignal.any([park.signal, runOptions.signal]) : runOptions?.signal ?? park.signal;
+  for (;; ) {
+    if (signal?.aborted)
+      throw new ParkAbortedError(label);
+    const waiter = createParkWaiter(park.waiters, key, signal);
+    let unsubscribe;
+    try {
+      unsubscribe = park.subscribe?.(() => notifyWaiters(park.waiters, key));
+      const ledger = await park.readLedger();
+      if (ledger.deliveries.has(key)) {
+        return JSON.parse(JSON.stringify(ledger.deliveries.get(key)));
+      }
+      if (!ledger.parks.has(key)) {
+        await park.store.appendEvent({
+          conversationId: park.conversationId,
+          kind: DURABILITY_PARK_EVENT_KIND,
+          payload: { runId: park.runId, kind: "wait", event: eventName, id }
+        });
+      }
+      const outcome = await waiter.outcome;
+      if (outcome === "aborted")
+        throw new ParkAbortedError(label);
+    } finally {
+      waiter.cancel();
+      unsubscribe?.();
+    }
+  }
+}
+
+// src/durability/engine.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,
+    effects: new Map,
+    parks: new Map,
+    waiters: new Map
+  };
+  stores.set(store, inFlight);
+  const {
+    steps: inFlightSteps,
+    effects: inFlightEffects,
+    parks: inFlightParks,
+    waiters: parkWaiters
+  } = inFlight;
+  const clock = options.clock ?? systemClock;
+  const view = {
+    steps: new Map,
+    effects: 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 park = {
+    store,
+    conversationId,
+    runId,
+    signal: options.signal,
+    subscribe: options.subscribe,
+    clock,
+    waiters: parkWaiters,
+    readLedger
+  };
+  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 effect = (name, handlers, runOptions) => {
+    const key = effectKey(conversationId, runId, name);
+    const existing = inFlightEffects.get(key);
+    if (existing) {
+      return detachedResult(existing);
+    }
+    const pending = executeEffect({ store, conversationId, runId, signal: options.signal, readLedger }, name, handlers, runOptions);
+    inFlightEffects.set(key, pending);
+    releaseSettled(inFlightEffects, key, pending);
+    return detachedResult(pending);
+  };
+  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(park, name, seconds, runOptions);
+    inFlightParks.set(key, pending);
+    releaseSettled(inFlightParks, key, pending);
+    return pending;
+  };
+  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(park, 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,
+    effect
+  };
+}
+
+// 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, EffectUnresolvedError, ParkRecordDecodeError, ParkAbortedError, createLocalStepDurability, AgentToolError, isAgentToolError, createToolDurabilityContext, resolveToolDurability };