stitchkit 0.94.0 → 0.94.1

package/dist/index-4gcnakhx.js

@@ -0,0 +1,82 @@
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
+
+// src/internal/route-pattern.ts
+import { z } from "zod";
+var PARAM_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function joinRoutePath(...parts) {
+  const joined = parts.filter((part) => Boolean(part)).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
+function parseRoutePattern(path) {
+  const segments = path.split("/").filter(Boolean);
+  const parameters = [];
+  const names = new Set;
+  for (const [segmentIndex, segment] of segments.entries()) {
+    const marker = segment.at(0);
+    if (marker !== ":" && marker !== "*") {
+      if (segment.includes("*")) {
+        throw new Error(`Wildcard must occupy its own segment in path "${path}"`);
+      }
+      continue;
+    }
+    const name = segment.slice(1);
+    if (marker === "*" && name === "") {
+      throw new Error(`Trailing wildcard in path "${path}" must be named, for example "/*filePath"`);
+    }
+    if (!PARAM_IDENTIFIER.test(name) || isUnsafeKey(name)) {
+      const label = marker === "*" ? "wildcard" : "route parameter";
+      throw new Error(`Invalid ${label} name "${name}" in path "${path}"`);
+    }
+    if (names.has(name)) {
+      throw new Error(`Duplicate route parameter name "${name}" in path "${path}"`);
+    }
+    if (marker === "*" && segmentIndex !== segments.length - 1) {
+      throw new Error(`Wildcard "*${name}" must be the final segment in path "${path}"`);
+    }
+    names.add(name);
+    parameters.push({
+      name,
+      kind: marker === "*" ? "wildcard" : "segment",
+      segmentIndex
+    });
+  }
+  return parameters;
+}
+function resolveRouteParamsSchema(path, schema) {
+  const parameters = parseRoutePattern(path);
+  if (parameters.length === 0)
+    return schema;
+  if (!schema) {
+    const shape = {};
+    for (const parameter of parameters)
+      shape[parameter.name] = z.string();
+    return z.object(shape);
+  }
+  const jsonSchema = z.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
+  const properties = jsonSchema.properties;
+  if (!properties) {
+    throw new Error(`Route params schema for path "${path}" must be an object schema with a property per path field`);
+  }
+  for (const parameter of parameters) {
+    if (!(parameter.name in properties)) {
+      const kind = parameter.kind === "wildcard" ? "wildcard" : "path";
+      throw new Error(`Route params schema for path "${path}" is missing ${kind} field "${parameter.name}"`);
+    }
+  }
+  const names = new Set(parameters.map((parameter) => parameter.name));
+  const required = Array.isArray(jsonSchema.required) ? jsonSchema.required : [];
+  for (const field of required) {
+    if (typeof field === "string" && !names.has(field)) {
+      throw new Error(`Route params schema for path "${path}" requires field "${field}" that the path does not carry`);
+    }
+  }
+  return schema;
+}
+function parseTrailingWildcard(path) {
+  const wildcard = parseRoutePattern(path).find((parameter) => parameter.kind === "wildcard");
+  return wildcard ? { name: wildcard.name, segmentIndex: wildcard.segmentIndex } : null;
+}
+
+export { joinRoutePath, resolveRouteParamsSchema, parseTrailingWildcard };

package/dist/{index-j05z5gn4.js → index-55hkhm67.js}

@@ -9,7 +9,7 @@ import {
   applyToolViewDefaults,
   objectShapeKeys,
   projectToolView
-} from "./index-dydjcp8z.js";
+} from "./index-np4m8hd3.js";
 import {
   normalizeError,
   validateDeclaredOutput
@@ -30,25 +30,7 @@ import {
   isRecord
 } from "./index-hffjpmq9.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;
+// src/tools/execute-args.ts
 function parseToolCallArguments(method, callArgs, {
   coerceJson = false,
   toolSurface = false
@@ -98,9 +80,9 @@ function parseToolCallArguments(method, callArgs, {
   }
   return { ok: true, params, input };
 }
-var noProgress = async () => {
-  return;
-};
+
+// src/tools/execute-result.ts
+var normalizedToolErrors = new WeakMap;
 function toolResultFromError(err) {
   const appErr = normalizeError(err);
   const result = {
@@ -125,6 +107,28 @@ function toolErrorFromResult(result) {
 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));
@@ -145,6 +149,88 @@ function inToolCallContext(call, body) {
     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,
@@ -157,22 +243,16 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
   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 {}
-    }
+    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;
@@ -202,59 +282,30 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
     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 {}
-      }
-    }
+    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) {
-    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) {
+    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: ${formatZodError(parsed2.error)}` }
+        details: { message: `Invalid tool extension: ${resolved.invalid}` }
       });
     }
-    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);
-    }
+    callContext = resolved.context;
+    hookContext = callContext;
+    callArgs = resolved.args;
   }
   const before = await runBefore();
   if (before?.kind === "failure")
@@ -276,46 +327,12 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
       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 (toolSurface && method.toolView && method.outputSchema) {
-      const viewed = projectToolView({
-        view: method.toolView,
-        fullSchema: method.outputSchema,
-        full: data,
-        call: { input, source: context.source },
-        operation: `${method.serviceName}.${method.key}`,
-        onStripped: onOutputStrip
-      });
-      if (!viewed.ok) {
-        return finish({
-          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 finish({ ok: true, data: output });
+    return finish(await invokeToolHandler(method, ctx, input, context.source, {
+      lifecycle,
+      onOutputStrip,
+      finalizeOutput,
+      toolSurface
+    }));
   } catch (err) {
     if (isToolExecutionControlError(err))
       throw err;
@@ -323,4 +340,4 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
   }
 }
 
-export { ToolExecutionControlError, isToolExecutionControlError, parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, executeToolMethod };
+export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError, isToolExecutionControlError, executeToolMethod };