stitchkit 0.93.0 → 0.94.1

package/dist/index-55hkhm67.js

@@ -0,0 +1,343 @@
+import {
+  getRequestContext,
+  runWithRequestContext
+} from "./index-zfrhfn82.js";
+import {
+  coerceJsonArgs
+} from "./index-1zbbzgfh.js";
+import {
+  applyToolViewDefaults,
+  objectShapeKeys,
+  projectToolView
+} from "./index-np4m8hd3.js";
+import {
+  normalizeError,
+  validateDeclaredOutput
+} from "./index-znfs20ss.js";
+import {
+  formatZodError
+} from "./index-p5r7qpdd.js";
+import {
+  AppError,
+  STITCH_ERROR_STATUS,
+  isRetryableStatus,
+  isStitchErrorCode
+} from "./index-2vtcmrj9.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/tools/execute-args.ts
+function parseToolCallArguments(method, callArgs, {
+  coerceJson = false,
+  toolSurface = false
+} = {}) {
+  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);
+  }
+  if (toolSurface)
+    inputArgs = applyToolViewDefaults(inputArgs, method.toolView?.defaults);
+  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 };
+}
+
+// src/tools/execute-result.ts
+var normalizedToolErrors = new WeakMap;
+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;
+}
+
+// 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 noProgress = async () => {
+  return;
+};
+async function executeToolMethod(method, call, options = {}) {
+  const { toolName, context } = call;
+  return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, call, options));
+}
+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 invokeToolHandler(method, ctx, input, source, {
+  lifecycle,
+  onOutputStrip,
+  finalizeOutput,
+  toolSurface
+}) {
+  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 {
+      ok: false,
+      code: "INTERNAL_SERVER_ERROR",
+      details: { message: checked.message }
+    };
+  }
+  data = checked.data;
+  if (toolSurface && method.toolView && method.outputSchema) {
+    const viewed = projectToolView({
+      view: method.toolView,
+      fullSchema: method.outputSchema,
+      full: data,
+      call: { input, source },
+      operation: `${method.serviceName}.${method.key}`,
+      onStripped: onOutputStrip
+    });
+    if (!viewed.ok) {
+      return {
+        ok: false,
+        code: "INTERNAL_SERVER_ERROR",
+        details: { message: viewed.message }
+      };
+    }
+    data = viewed.data;
+  }
+  if (finalizeOutput)
+    data = await finalizeOutput(data);
+  const output = (data === undefined || data === null) && !method.outputSchema ? { status: "ok" } : data;
+  return { ok: true, data: output };
+}
+async function resolveToolExtension(extension, keys, rawArgs, context) {
+  const extensionArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => keys.has(key)));
+  let parsed;
+  try {
+    parsed = extension.schema.safeParse(extensionArgs);
+  } catch (err) {
+    return { thrown: err };
+  }
+  if (!parsed.success)
+    return { invalid: formatZodError(parsed.error) };
+  try {
+    const resolved = await extension.resolve({ ...rawArgs, ...parsed.data });
+    return {
+      context: {
+        ...context,
+        ...resolved,
+        source: context.source,
+        ...context.mcp !== undefined && { mcp: context.mcp },
+        ...context.toolCallId !== undefined && { toolCallId: context.toolCallId }
+      },
+      args: Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !keys.has(key)))
+    };
+  } catch (err) {
+    return { thrown: err };
+  }
+}
+async function observed(hook, call) {
+  try {
+    await call();
+  } catch (hookError) {
+    try {
+      console.error(`[stitchkit] ${hook} hook failed:`, hookError);
+    } catch {}
+  }
+}
+async function runToolMethod(method, { toolName, rawArgs, context }, {
+  hooks,
+  lifecycle,
+  coerceJson = false,
+  onOutputStrip,
+  extension,
+  finalizeOutput,
+  toolSurface = false
+}) {
+  const startedAt = Date.now();
+  let hookContext = context;
+  const finish = async (result, thrown) => {
+    await observed("afterToolCall", () => hooks?.afterToolCall?.({
+      toolName,
+      args: rawArgs,
+      result,
+      durationMs: Date.now() - startedAt,
+      context: hookContext,
+      endpoint: method,
+      ...thrown !== undefined && { error: thrown },
+      ...rewrittenArgsApplied && rewrittenArgs !== undefined && { effectiveArgs: rewrittenArgs }
+    }));
+    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;
+    await observed("onToolError", () => hooks?.onToolError?.({ toolName, error: err, context: hookContext, endpoint: method }));
+    return finish(toolResultFromError(err), err);
+  };
+  let callArgs = rawArgs;
+  let callContext = context;
+  let extensionKeys;
+  if (extension) {
+    extensionKeys = new Set(Object.keys(extension.schema.shape));
+    const resolved = await resolveToolExtension(extension, extensionKeys, rawArgs, context);
+    if ("thrown" in resolved)
+      return finishThrown(resolved.thrown);
+    if ("invalid" in resolved) {
+      const before2 = await runBefore();
+      if (before2?.kind === "failure")
+        return before2.result;
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { message: `Invalid tool extension: ${resolved.invalid}` }
+      });
+    }
+    callContext = resolved.context;
+    hookContext = callContext;
+    callArgs = resolved.args;
+  }
+  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, toolSurface });
+  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
+    };
+    return finish(await invokeToolHandler(method, ctx, input, context.source, {
+      lifecycle,
+      onOutputStrip,
+      finalizeOutput,
+      toolSurface
+    }));
+  } catch (err) {
+    if (isToolExecutionControlError(err))
+      throw err;
+    return finishThrown(err);
+  }
+}
+
+export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError, isToolExecutionControlError, executeToolMethod };