stitchkit 0.93.0 → 0.94.1

package/dist/index-yn8remb1.js

@@ -1,290 +0,0 @@
-import {
-  getRequestContext,
-  runWithRequestContext
-} from "./index-tmwcrptx.js";
-import {
-  formatZodError,
-  normalizeError,
-  validateDeclaredOutput
-} from "./index-e0znv5gn.js";
-import {
-  coerceJsonArgs
-} from "./index-7zbps32p.js";
-import {
-  objectShapeKeys
-} from "./index-h9etkkyk.js";
-import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isRetryableStatus,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
-import {
-  isRecord
-} from "./index-77fekveh.js";
-
-// src/tools/execute.ts
-class ToolExecutionControlError extends Error {
-  reason;
-  constructor(reason) {
-    super(`Agent tool execution stopped: ${reason}`);
-    this.name = "ToolExecutionControlError";
-    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;
-}
-var normalizedToolErrors = new WeakMap;
-function parseToolCallArguments(method, callArgs, coerceJson) {
-  const paramKeys = new Set(objectShapeKeys(method.paramsSchema));
-  let paramArgs = {};
-  let inputArgs = {};
-  for (const [key, value] of Object.entries(callArgs)) {
-    if (isUnsafeKey(key))
-      continue;
-    if (paramKeys.has(key))
-      paramArgs[key] = value;
-    else
-      inputArgs[key] = value;
-  }
-  if (coerceJson) {
-    paramArgs = coerceJsonArgs(paramArgs, method.paramsSchema);
-    inputArgs = coerceJsonArgs(inputArgs, method.inputSchema);
-  }
-  let params;
-  if (method.paramsSchema) {
-    let result;
-    try {
-      result = method.paramsSchema.safeParse(paramArgs);
-    } catch (err) {
-      return { ok: false, message: "Invalid params", thrown: err };
-    }
-    if (!result.success) {
-      return { ok: false, message: `Invalid params: ${formatZodError(result.error)}` };
-    }
-    params = result.data;
-  }
-  let input;
-  if (method.inputSchema) {
-    let result;
-    try {
-      result = method.inputSchema.safeParse(inputArgs);
-    } catch (err) {
-      return { ok: false, message: "Invalid input", thrown: err };
-    }
-    if (!result.success) {
-      return { ok: false, message: `Invalid input: ${formatZodError(result.error)}` };
-    }
-    input = result.data;
-  }
-  return { ok: true, params, input };
-}
-var noProgress = async () => {
-  return;
-};
-function toolResultFromError(err) {
-  const appErr = normalizeError(err);
-  const result = {
-    ok: false,
-    code: appErr.code,
-    details: appErr.details ?? { message: appErr.message },
-    ...appErr.hint && { hint: appErr.hint },
-    retryable: appErr.retryable ?? isRetryableStatus(appErr.status)
-  };
-  normalizedToolErrors.set(result, { normalized: appErr, cause: err });
-  return result;
-}
-function toolErrorFromResult(result) {
-  const retained = normalizedToolErrors.get(result);
-  if (retained)
-    return retained.normalized;
-  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, undefined, result.retryable);
-}
-function toolCauseFromResult(result) {
-  return normalizedToolErrors.get(result)?.cause;
-}
-async function executeToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson = false, onOutputStrip, extension, finalizeOutput) {
-  return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson, onOutputStrip, extension, finalizeOutput));
-}
-function inToolCallContext(call, body) {
-  const parent = getRequestContext();
-  if (!parent)
-    return body();
-  return runWithRequestContext({
-    ...parent,
-    trace: parent.trace,
-    dimensions: parent.dimensions ? { ...parent.dimensions } : undefined,
-    error: undefined,
-    source: call.source,
-    method: "TOOL",
-    path: `/${call.source}/${call.toolName}`,
-    serviceName: call.method.serviceName,
-    action: call.method.key
-  }, body);
-}
-async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson, onOutputStrip, extension, finalizeOutput) {
-  const startedAt = Date.now();
-  let hookContext = context;
-  const finish = async (result, thrown) => {
-    try {
-      await hooks?.afterToolCall?.({
-        toolName,
-        args: rawArgs,
-        result,
-        durationMs: Date.now() - startedAt,
-        context: hookContext,
-        endpoint: method,
-        ...thrown !== undefined && { error: thrown },
-        ...rewrittenArgsApplied && rewrittenArgs !== undefined && { effectiveArgs: rewrittenArgs }
-      });
-    } catch (hookError) {
-      try {
-        console.error("[stitchkit] afterToolCall hook failed:", hookError);
-      } catch {}
-    }
-    return result;
-  };
-  let beforeRan = false;
-  let rewrittenArgs;
-  let rewrittenArgsApplied = false;
-  const runBefore = async () => {
-    if (beforeRan || !hooks?.beforeToolCall)
-      return null;
-    beforeRan = true;
-    let returned;
-    try {
-      returned = await hooks.beforeToolCall({
-        toolName,
-        args: rawArgs,
-        context: hookContext,
-        endpoint: method
-      });
-    } catch (err) {
-      return { kind: "failure", result: await finish(toolResultFromError(err)) };
-    }
-    if (!isPlainObject(returned))
-      return null;
-    rewrittenArgs = returned;
-    return { kind: "args" };
-  };
-  const finishThrown = async (err) => {
-    const before2 = await runBefore();
-    if (before2?.kind === "failure")
-      return before2.result;
-    if (hooks?.onToolError) {
-      try {
-        await hooks.onToolError({
-          toolName,
-          error: err,
-          context: hookContext,
-          endpoint: method
-        });
-      } catch (hookErr) {
-        try {
-          console.error("[stitchkit] onToolError hook failed:", hookErr);
-        } catch {}
-      }
-    }
-    return finish(toolResultFromError(err), err);
-  };
-  let callArgs = rawArgs;
-  let callContext = context;
-  let extensionKeys;
-  if (extension) {
-    const keys = new Set(Object.keys(extension.schema.shape));
-    extensionKeys = keys;
-    const extensionArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => keys.has(key)));
-    let parsed2;
-    try {
-      parsed2 = extension.schema.safeParse(extensionArgs);
-    } catch (err) {
-      return finishThrown(err);
-    }
-    if (!parsed2.success) {
-      const before2 = await runBefore();
-      if (before2?.kind === "failure")
-        return before2.result;
-      return finish({
-        ok: false,
-        code: "VALIDATION_ERROR",
-        details: { message: `Invalid tool extension: ${formatZodError(parsed2.error)}` }
-      });
-    }
-    try {
-      const resolved = await extension.resolve({ ...rawArgs, ...parsed2.data });
-      callContext = {
-        ...context,
-        ...resolved,
-        source: context.source,
-        ...context.mcp !== undefined && { mcp: context.mcp },
-        ...context.toolCallId !== undefined && { toolCallId: context.toolCallId }
-      };
-      hookContext = callContext;
-      callArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !keys.has(key)));
-    } catch (err) {
-      return finishThrown(err);
-    }
-  }
-  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 parsed = parseToolCallArguments(method, callArgs, coerceJson);
-  if (!parsed.ok) {
-    return parsed.thrown !== undefined ? finishThrown(parsed.thrown) : finish({ ok: false, code: "VALIDATION_ERROR", details: { message: parsed.message } });
-  }
-  const { params, input } = parsed;
-  try {
-    const ctx = {
-      reportProgress: noProgress,
-      ...callContext,
-      params,
-      input,
-      source: context.source
-    };
-    if (lifecycle?.beforeHandle) {
-      await lifecycle.beforeHandle(ctx, method);
-    }
-    let data = await method.handler(ctx);
-    if (lifecycle?.afterHandle) {
-      const transformed = await lifecycle.afterHandle(ctx, data, method);
-      if (transformed !== undefined)
-        data = transformed;
-    }
-    const checked = validateDeclaredOutput(method.outputSchema, data, onOutputStrip);
-    if (!checked.ok) {
-      return finish({
-        ok: false,
-        code: "INTERNAL_SERVER_ERROR",
-        details: { message: checked.message }
-      });
-    }
-    data = checked.data;
-    if (finalizeOutput)
-      data = await finalizeOutput(data);
-    const output = (data === undefined || data === null) && !method.outputSchema ? { status: "ok" } : data;
-    return finish({ ok: true, data: output });
-  } catch (err) {
-    if (isToolExecutionControlError(err))
-      throw err;
-    return finishThrown(err);
-  }
-}
-
-export { ToolExecutionControlError, isToolExecutionControlError, parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, executeToolMethod };

package/dist/index-ywd0y6m1.js

@@ -1,394 +0,0 @@
-import {
-  createBoundedChannel
-} from "./index-7gnkny4z.js";
-
-// src/browser/live-state.ts
-import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var LiveStatePhaseSchema = z.enum([
-  "idle",
-  "opening",
-  "live",
-  "resync-required",
-  "unavailable",
-  "closed"
-]);
-var LiveStateStopReasonSchema = z.enum([
-  "gap",
-  "buffer-overflow",
-  "source-unavailable",
-  "source-error",
-  "controller-error",
-  "controller-capacity"
-]);
-var LiveStateControllerStatusSchema = z.object({
-  phase: LiveStatePhaseSchema,
-  generation: z.number().int().nonnegative(),
-  hasValue: z.boolean(),
-  bufferedEvents: z.number().int().nonnegative(),
-  bufferedBytes: z.number().int().nonnegative(),
-  receivedEvents: z.number().int().nonnegative(),
-  appliedEvents: z.number().int().nonnegative(),
-  duplicateEvents: z.number().int().nonnegative(),
-  gapEvents: z.number().int().nonnegative(),
-  refusedEvents: z.number().int().nonnegative(),
-  reason: LiveStateStopReasonSchema.optional()
-}).strict().readonly();
-function createLiveStateController(config) {
-  const maxBufferedEvents = PositiveSafeIntegerSchema.parse(config.maxBufferedEvents);
-  const maxBufferedBytes = PositiveSafeIntegerSchema.parse(config.maxBufferedBytes);
-  const subscribers = new Set;
-  let phase = "idle";
-  let reason;
-  let generation = 0;
-  let stored = { hasValue: false };
-  let receivedEvents = 0;
-  let appliedEvents = 0;
-  let duplicateEvents = 0;
-  let gapEvents = 0;
-  let refusedEvents = 0;
-  let current;
-  let opening;
-  let unsettledSourceOpens = 0;
-  let unsettledSourceCloses = 0;
-  let publishDepth = 0;
-  let controllerErrorObserverEnabled = true;
-  let subscriberErrorObserverEnabled = true;
-  const isPromiseLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null && ("then" in value) && typeof value.then === "function";
-  const status = () => {
-    const buffered = current?.buffer.getSnapshot();
-    return LiveStateControllerStatusSchema.parse({
-      phase,
-      generation,
-      hasValue: stored.hasValue,
-      bufferedEvents: buffered?.queuedItems ?? 0,
-      bufferedBytes: buffered?.queuedBytes ?? 0,
-      receivedEvents,
-      appliedEvents,
-      duplicateEvents,
-      gapEvents,
-      refusedEvents,
-      ...reason && { reason }
-    });
-  };
-  const buildSnapshot = () => {
-    const metadata = status();
-    return stored.hasValue ? Object.freeze({ ...metadata, value: stored.value }) : metadata;
-  };
-  let published = buildSnapshot();
-  const reportControllerError = (error, at, atGeneration) => {
-    if (!config.onControllerError || !controllerErrorObserverEnabled)
-      return;
-    try {
-      const returned = config.onControllerError({
-        error,
-        generation: atGeneration,
-        phase: at
-      });
-      if (isPromiseLike(returned)) {
-        controllerErrorObserverEnabled = false;
-        Promise.resolve(returned).catch(() => {
-          return;
-        });
-      }
-    } catch {}
-  };
-  const reportSubscriberError = (error, snapshot) => {
-    if (!config.onSubscriberError || !subscriberErrorObserverEnabled)
-      return;
-    try {
-      const returned = config.onSubscriberError({ error, snapshot });
-      if (isPromiseLike(returned)) {
-        subscriberErrorObserverEnabled = false;
-        Promise.resolve(returned).catch(() => {
-          return;
-        });
-      }
-    } catch {}
-  };
-  const publish = () => {
-    const snapshot = buildSnapshot();
-    published = snapshot;
-    publishDepth += 1;
-    try {
-      for (const listener of subscribers) {
-        try {
-          const returned = listener(snapshot);
-          if (isPromiseLike(returned)) {
-            subscribers.delete(listener);
-            reportSubscriberError(new TypeError("Live-state subscribers must settle synchronously"), snapshot);
-            Promise.resolve(returned).catch(() => {
-              return;
-            });
-          }
-        } catch (error) {
-          reportSubscriberError(error, snapshot);
-        }
-      }
-    } finally {
-      publishDepth -= 1;
-    }
-    return published;
-  };
-  const publishAvailableCapacity = () => {
-    if (phase !== "unavailable" || reason !== "controller-capacity" || unsettledSourceOpens + unsettledSourceCloses >= 2)
-      return;
-    phase = "resync-required";
-    publish();
-  };
-  const closeSource = (active) => {
-    if (active.closePromise)
-      return active.closePromise;
-    if (!active.closeSource)
-      return Promise.resolve();
-    const at = phase;
-    unsettledSourceCloses += 1;
-    active.closePromise = Promise.resolve().then(() => active.closeSource?.()).then(() => {
-      return;
-    }).catch((error) => {
-      reportControllerError(error, at, active.id);
-    }).finally(() => {
-      unsettledSourceCloses -= 1;
-      publishAvailableCapacity();
-    });
-    return active.closePromise;
-  };
-  const retire = (active) => {
-    if (!active.retired) {
-      active.retired = true;
-      active.settleRetired();
-      active.abort.abort();
-      active.buffer.close({ mode: "discard" });
-    }
-    return closeSource(active);
-  };
-  const stopGeneration = (active, nextPhase, nextReason) => {
-    if (current !== active || active.retired || phase === "closed")
-      return;
-    phase = nextPhase;
-    reason = nextReason;
-    retire(active);
-    publish();
-  };
-  const apply = (active, event) => {
-    if (current !== active || active.retired || !stored.hasValue || phase !== "opening" && phase !== "live")
-      return;
-    let decision;
-    try {
-      decision = config.applyEvent(stored.value, event);
-    } catch (error) {
-      reportControllerError(error, phase, active.id);
-      stopGeneration(active, "unavailable", "controller-error");
-      return;
-    }
-    if (current !== active || active.retired || phase !== "opening" && phase !== "live")
-      return;
-    if (!decision || !["applied", "duplicate", "gap"].includes(decision.outcome) || decision.outcome === "applied" && !("state" in decision)) {
-      reportControllerError(new Error("applyEvent returned an invalid decision"), phase, active.id);
-      stopGeneration(active, "unavailable", "controller-error");
-      return;
-    }
-    if (decision.outcome === "duplicate") {
-      duplicateEvents += 1;
-      publish();
-      return;
-    }
-    if (decision.outcome === "gap") {
-      gapEvents += 1;
-      stopGeneration(active, "resync-required", "gap");
-      return;
-    }
-    stored = { hasValue: true, value: decision.state };
-    appliedEvents += 1;
-    publish();
-  };
-  const onEvent = (active, event) => {
-    if (current !== active || active.retired || phase === "closed")
-      return;
-    receivedEvents += 1;
-    if (phase === "opening") {
-      try {
-        const offered = active.buffer.offer(event);
-        if (offered.outcome === "refused") {
-          refusedEvents += 1;
-          stopGeneration(active, "resync-required", "buffer-overflow");
-        } else {
-          publish();
-        }
-      } catch (error) {
-        refusedEvents += 1;
-        reportControllerError(error, phase, active.id);
-        stopGeneration(active, "unavailable", "controller-error");
-      }
-      return;
-    }
-    if (phase === "live")
-      apply(active, event);
-  };
-  const openGeneration = async (active) => {
-    try {
-      if (active.retired || current !== active || phase === "closed")
-        return published;
-      unsettledSourceOpens += 1;
-      let sourceOpening;
-      try {
-        sourceOpening = config.source.open({
-          signal: active.abort.signal,
-          onEvent: (event) => onEvent(active, event),
-          onUnavailable: () => stopGeneration(active, "unavailable", "source-unavailable")
-        });
-      } catch (error) {
-        unsettledSourceOpens -= 1;
-        publishAvailableCapacity();
-        throw error;
-      }
-      sourceOpening = sourceOpening.then((opened2) => {
-        active.closeSource = () => opened2.close();
-        unsettledSourceOpens -= 1;
-        if (active.retired || current !== active || phase === "closed") {
-          closeSource(active);
-        }
-        publishAvailableCapacity();
-        return opened2;
-      }, (error) => {
-        unsettledSourceOpens -= 1;
-        publishAvailableCapacity();
-        throw error;
-      });
-      const outcome = await Promise.race([
-        sourceOpening.then((opened2) => ({ outcome: "opened", opened: opened2 })),
-        active.retiredPromise.then(() => ({ outcome: "retired" }))
-      ]);
-      if (outcome.outcome === "retired") {
-        return published;
-      }
-      const { opened } = outcome;
-      if (current !== active || active.retired || phase !== "opening") {
-        closeSource(active);
-        return published;
-      }
-      stored = { hasValue: true, value: opened.snapshot };
-      publish();
-      while (current === active && !active.retired && phase === "opening") {
-        if (active.buffer.getSnapshot().queuedItems === 0) {
-          active.buffer.close({ mode: "discard" });
-          phase = "live";
-          reason = undefined;
-          return publish();
-        }
-        const next = await active.buffer.next();
-        if (next.done)
-          break;
-        apply(active, next.value);
-      }
-      if (current && current !== active && opening)
-        return opening;
-      return published;
-    } catch (error) {
-      if (current === active && !active.retired && phase !== "closed") {
-        reportControllerError(error, phase, active.id);
-        stopGeneration(active, "unavailable", "source-error");
-      }
-      publishAvailableCapacity();
-      return published;
-    }
-  };
-  const begin = (startedByResync) => {
-    generation += 1;
-    phase = "opening";
-    reason = undefined;
-    let settleRetired = () => {
-      return;
-    };
-    const retiredPromise = new Promise((resolve) => {
-      settleRetired = resolve;
-    });
-    const active = {
-      id: generation,
-      startedByResync,
-      abort: new AbortController,
-      buffer: createBoundedChannel({
-        policy: "ordered",
-        maxItems: maxBufferedEvents,
-        maxBytes: maxBufferedBytes,
-        sizeOf: config.sizeOfEvent
-      }),
-      retiredPromise,
-      settleRetired,
-      retired: false,
-      sourceOpenStarted: false
-    };
-    current = active;
-    publish();
-    if (current !== active || active.retired || phase !== "opening") {
-      return opening ?? Promise.resolve(published);
-    }
-    active.sourceOpenStarted = true;
-    const operation = openGeneration(active);
-    opening = operation;
-    operation.finally(() => {
-      if (opening === operation)
-        opening = undefined;
-    });
-    return operation;
-  };
-  const close = () => {
-    if (phase === "closed")
-      return Promise.resolve(published);
-    const active = current;
-    current = undefined;
-    phase = "closed";
-    reason = undefined;
-    const snapshot = publish();
-    if (active)
-      retire(active);
-    config.signal?.removeEventListener("abort", abortFromConfig);
-    subscribers.clear();
-    return Promise.resolve(snapshot);
-  };
-  function abortFromConfig() {
-    close();
-  }
-  if (config.signal?.aborted) {
-    phase = "closed";
-    published = buildSnapshot();
-  } else {
-    config.signal?.addEventListener("abort", abortFromConfig, { once: true });
-  }
-  return {
-    start() {
-      if (phase === "idle")
-        return begin(false);
-      return opening ?? Promise.resolve(published);
-    },
-    resync() {
-      if (phase === "closed")
-        return Promise.resolve(published);
-      const active = current;
-      if (active?.startedByResync && !active.sourceOpenStarted && phase === "opening" && publishDepth > 0) {
-        return opening ?? Promise.resolve(published);
-      }
-      if (active) {
-        retire(active);
-        if (unsettledSourceOpens + unsettledSourceCloses >= 2) {
-          phase = "unavailable";
-          reason = "controller-capacity";
-          return Promise.resolve(publish());
-        }
-      }
-      return begin(true);
-    },
-    getSnapshot: () => published,
-    subscribe(listener) {
-      if (phase === "closed")
-        return () => {
-          return;
-        };
-      subscribers.add(listener);
-      return () => subscribers.delete(listener);
-    },
-    close
-  };
-}
-
-export { LiveStatePhaseSchema, LiveStateStopReasonSchema, LiveStateControllerStatusSchema, createLiveStateController };