stitchkit 0.56.0 → 0.56.2

package/dist/index-sa2mbwa7.js

@@ -0,0 +1,336 @@
+import {
+  objectShapeKeys
+} from "./index-6djpbnda.js";
+import {
+  formatZodError,
+  getRequestContext,
+  normalizeError,
+  runWithRequestContext,
+  validateDeclaredOutput
+} from "./index-7c0gkyvj.js";
+import {
+  AppError,
+  STITCH_ERROR_STATUS,
+  isStitchErrorCode,
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-ps5pxp3h.js";
+import {
+  isRecord
+} from "./index-smpbdg6k.js";
+
+// src/tools/coerce.ts
+import { z } from "zod";
+function needsJsonCoercion(schema) {
+  if (schema instanceof z.ZodArray || schema instanceof z.ZodObject || schema instanceof z.ZodRecord || schema instanceof z.ZodTuple || schema instanceof z.ZodUnion) {
+    return true;
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return needsJsonCoercion(schema.unwrap());
+  }
+  return false;
+}
+function acceptsRawString(schema) {
+  const type = schema._zod.def.type;
+  if (type === "string" || type === "template_literal")
+    return true;
+  if (schema instanceof z.ZodLiteral) {
+    return schema.def.values.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodEnum) {
+    return schema.options.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return acceptsRawString(schema.unwrap());
+  }
+  if (schema instanceof z.ZodUnion) {
+    return schema.def.options.some((option) => acceptsRawString(option));
+  }
+  return false;
+}
+function matchingVariant(union, value) {
+  const disc = union.def.discriminator;
+  const tag = value[disc];
+  for (const option of union.def.options) {
+    if (!(option instanceof z.ZodObject))
+      continue;
+    const field = option.shape[disc];
+    if (field instanceof z.ZodLiteral && field.def.values.some((v) => v === tag))
+      return option;
+    if (field instanceof z.ZodEnum && field.options.some((v) => v === tag))
+      return option;
+  }
+  return;
+}
+function coerceValue(value, schema) {
+  if (!schema)
+    return value;
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return coerceValue(value, schema.unwrap());
+  }
+  let current = value;
+  if (typeof current === "string" && needsJsonCoercion(schema)) {
+    if (acceptsRawString(schema))
+      return current;
+    try {
+      current = safeJsonParse(current);
+    } catch {
+      return value;
+    }
+  }
+  if (schema instanceof z.ZodObject && isRecord(current)) {
+    const shape = schema.shape;
+    const out = {};
+    for (const [key, item] of Object.entries(current)) {
+      out[key] = coerceValue(item, shape[key]);
+    }
+    return out;
+  }
+  if (schema instanceof z.ZodArray && Array.isArray(current)) {
+    return current.map((item) => coerceValue(item, schema.element));
+  }
+  if (schema instanceof z.ZodDiscriminatedUnion && isRecord(current)) {
+    const variant = matchingVariant(schema, current);
+    return variant ? coerceValue(current, variant) : current;
+  }
+  return current;
+}
+function coerceJsonArgs(args, schema) {
+  const coerced = coerceValue(args, schema);
+  return isRecord(coerced) ? coerced : args;
+}
+
+// src/tools/execute.ts
+class ToolExecutionControlError extends Error {
+  reason;
+  constructor(reason) {
+    super(`Agent tool execution stopped: ${reason}`);
+    this.name = "ToolExecutionControlError";
+    this.reason = reason;
+  }
+}
+function isToolExecutionControlError(value) {
+  return value instanceof ToolExecutionControlError;
+}
+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 }
+  };
+  normalizedToolErrors.set(result, appErr);
+  return result;
+}
+function toolErrorFromResult(result) {
+  const retained = normalizedToolErrors.get(result);
+  if (retained)
+    return retained;
+  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);
+}
+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 }
+      });
+    } catch (hookError) {
+      try {
+        console.error("[stitchkit] afterToolCall hook failed:", hookError);
+      } catch {}
+    }
+    return result;
+  };
+  let beforeRan = false;
+  const runBefore = async () => {
+    if (beforeRan || !hooks?.beforeToolCall)
+      return null;
+    beforeRan = true;
+    try {
+      await hooks.beforeToolCall({
+        toolName,
+        args: rawArgs,
+        context: hookContext,
+        endpoint: method
+      });
+      return null;
+    } catch (err) {
+      return finish(toolResultFromError(err));
+    }
+  };
+  const finishThrown = async (err) => {
+    const beforeFailure2 = await runBefore();
+    if (beforeFailure2)
+      return beforeFailure2;
+    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;
+  if (extension) {
+    const extensionKeys = new Set(Object.keys(extension.schema.shape));
+    const extensionArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => extensionKeys.has(key)));
+    let parsed;
+    try {
+      parsed = extension.schema.safeParse(extensionArgs);
+    } catch (err) {
+      return finishThrown(err);
+    }
+    if (!parsed.success) {
+      const beforeFailure2 = await runBefore();
+      if (beforeFailure2)
+        return beforeFailure2;
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { message: `Invalid tool extension: ${formatZodError(parsed.error)}` }
+      });
+    }
+    try {
+      const resolved = await extension.resolve({ ...rawArgs, ...parsed.data });
+      callContext = {
+        ...context,
+        ...resolved,
+        source: context.source,
+        ...context.mcp !== undefined && { mcp: context.mcp }
+      };
+      hookContext = callContext;
+      callArgs = Object.fromEntries(Object.entries(rawArgs).filter(([key]) => !extensionKeys.has(key)));
+    } catch (err) {
+      return finishThrown(err);
+    }
+  }
+  const beforeFailure = await runBefore();
+  if (beforeFailure)
+    return beforeFailure;
+  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 finishThrown(err);
+    }
+    if (!result.success) {
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { 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 finishThrown(err);
+    }
+    if (!result.success) {
+      return finish({
+        ok: false,
+        code: "VALIDATION_ERROR",
+        details: { message: `Invalid input: ${formatZodError(result.error)}` }
+      });
+    }
+    input = result.data;
+  }
+  try {
+    const ctx = {
+      ...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 { coerceJsonArgs, ToolExecutionControlError, isToolExecutionControlError, toolResultFromError, toolErrorFromResult, executeToolMethod };

package/dist/index-smpbdg6k.js

@@ -0,0 +1,27 @@
+// src/internal/typed.ts
+function typedEntries(value) {
+  return Object.entries(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function callRuntimeHandler(handler, context) {
+  if (typeof handler !== "function") {
+    throw new TypeError("Runtime handler must be a function");
+  }
+  return Reflect.apply(handler, undefined, [context]);
+}
+function transportResult(value) {
+  return value;
+}
+function mapObject(source, mapper) {
+  const result = {};
+  for (const [key, value] of typedEntries(source)) {
+    const mapped = mapper(key, value);
+    if (mapped !== undefined)
+      result[key] = mapped;
+  }
+  return result;
+}
+
+export { typedEntries, isRecord, callRuntimeHandler, transportResult, mapObject };

package/dist/{index-7eq9va6e.js → index-y2rb7dwx.js}

@@ -120,30 +120,4 @@ function parseTrailingWildcard(path) {
   return wildcard;
 }
 
-// src/internal/typed.ts
-function typedEntries(value) {
-  return Object.entries(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function callRuntimeHandler(handler, context) {
-  if (typeof handler !== "function") {
-    throw new TypeError("Runtime handler must be a function");
-  }
-  return Reflect.apply(handler, undefined, [context]);
-}
-function transportResult(value) {
-  return value;
-}
-function mapObject(source, mapper) {
-  const result = {};
-  for (const [key, value] of typedEntries(source)) {
-    const mapped = mapper(key, value);
-    if (mapped !== undefined)
-      result[key] = mapped;
-  }
-  return result;
-}
-
-export { parseTrailingWildcard, typedEntries, isRecord, callRuntimeHandler, transportResult, mapObject, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };
+export { parseTrailingWildcard, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };