stitchkit 0.93.0 → 0.94.1

package/dist/index-kw9t5ayn.js

@@ -1,507 +0,0 @@
-// 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-mzvgxp0n.js

@@ -1,80 +0,0 @@
-import {
-  executeToolMethod,
-  toolErrorFromResult
-} from "./index-yn8remb1.js";
-import {
-  assertToolExtensionCompatible,
-  mergeSchemas,
-  projectToolSurface,
-  rebuildObject
-} from "./index-h9etkkyk.js";
-import {
-  isRetryableStatus
-} from "./index-2vtcmrj9.js";
-
-// src/tools/mount.ts
-import { z } from "zod";
-function applyExtend(base, extra) {
-  if (base instanceof z.ZodObject) {
-    assertToolExtensionCompatible(base, extra);
-    return rebuildObject(base, { ...extra, ...base.shape });
-  }
-  return z.intersection(z.object(extra), base);
-}
-function contractToolMountable(projected, extend) {
-  const method = projected.source;
-  const baseArgumentSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
-  const argumentSchema = projected.shouldExtend && extend ? applyExtend(baseArgumentSchema, extend.schema) : baseArgumentSchema;
-  return {
-    method,
-    name: projected.name,
-    argumentSchema,
-    presentationSchema: projected.presentationSchema,
-    shouldExtend: projected.shouldExtend
-  };
-}
-function collectTools(service, transport, config = {}) {
-  const { extend, flattenUnionInput = false, assertNames = true } = config;
-  const tools = [];
-  for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
-    extend,
-    flattenUnionInput,
-    assertNames,
-    assertUniqueNames: false
-  })) {
-    if (projected.kind !== "contract")
-      continue;
-    tools.push(contractToolMountable(projected, extend));
-  }
-  return tools;
-}
-function createToolRunner(config) {
-  const extension = config.extend ? {
-    schema: z.object(config.extend.schema),
-    resolve: config.extend.resolve
-  } : undefined;
-  return async function runOneToolCall(tool, rawArgs, context) {
-    return executeToolMethod(tool.method, tool.name, rawArgs, { ...config.context, ...context, source: config.source }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(tool.name, paths) : undefined, tool.shouldExtend ? extension : undefined);
-  };
-}
-function formatToolError(result, toolName, errorHint) {
-  const err = {
-    error: result.code,
-    retryable: result.retryable ?? isRetryableStatus(toolErrorFromResult(result).status)
-  };
-  if (result.details)
-    err.details = result.details;
-  const hints = [];
-  if (result.hint)
-    hints.push(result.hint);
-  if (errorHint && toolName) {
-    const global = errorHint(toolName, result.code);
-    if (global)
-      hints.push(global);
-  }
-  if (hints.length > 0)
-    err._hint = hints.join(" ");
-  return err;
-}
-
-export { contractToolMountable, collectTools, createToolRunner, formatToolError };