stitchkit 0.67.0 → 0.68.1

package/dist/{index-1pgeyyee.js → index-cszjsxy5.js}

@@ -1,100 +1,37 @@
+import {
+  contractToolMountable,
+  createToolRunner,
+  formatToolError
+} from "./index-7etq650s.js";
 import {
   coerceJsonArgs,
-  executeToolMethod,
   toolResultFromError
-} from "./index-wrhf06ak.js";
+} from "./index-cz32amcb.js";
 import {
   isWithinDir
 } from "./index-sbdmyz75.js";
 import {
-  assertToolExtensionCompatible,
   assertUniqueToolName,
   buildToolPresentationSchema,
   projectRuntimeTool,
   projectToolSurface
 } from "./index-vkk06pv1.js";
 import {
-  mergeSchemas,
-  objectShapeKeys,
-  rebuildObject
+  objectShapeKeys
 } from "./index-6djpbnda.js";
 import {
   jsonSchemaFields
 } from "./index-cby4ar3v.js";
 import {
   formatZodError,
-  validateDeclaredOutput
-} from "./index-tvwcrx2d.js";
-import {
   isUnsafeKey,
-  safeJsonParse
-} from "./index-wd8g8z6e.js";
+  safeJsonParse,
+  validateDeclaredOutput
+} from "./index-9ky9hhg3.js";
 import {
   isRecord
 } from "./index-smpbdg6k.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 };
-  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;
-}
-
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {
   if (definition.transports?.length === 0) {
@@ -177,7 +114,7 @@ function runtimeToolMountable(definition, assertName = true) {
 }
 
 // src/tools/cli-args.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 var NUMERIC_VALUE = /^-(\d+\.?\d*|\.\d+)$/;
 var BOOL_OPTIONS = new Set(["json", "wait", "quiet", "dry-run", "help"]);
 var VALUE_OPTIONS = new Set(["wait-timeout", "output-dir"]);
@@ -286,27 +223,27 @@ class CliArgumentError extends Error {
   name = "CliArgumentError";
 }
 function unwrap(field) {
-  if (field instanceof z2.ZodOptional || field instanceof z2.ZodNullable || field instanceof z2.ZodDefault) {
+  if (field instanceof z.ZodOptional || field instanceof z.ZodNullable || field instanceof z.ZodDefault) {
     return unwrap(field.unwrap());
   }
   return field;
 }
 function classify(field) {
-  if (field instanceof z2.ZodBoolean)
+  if (field instanceof z.ZodBoolean)
     return "boolean";
-  if (field instanceof z2.ZodNumber)
+  if (field instanceof z.ZodNumber)
     return "number";
-  if (field instanceof z2.ZodBigInt)
+  if (field instanceof z.ZodBigInt)
     return "bigint";
-  if (field instanceof z2.ZodDate)
+  if (field instanceof z.ZodDate)
     return "date";
-  if (field instanceof z2.ZodEnum)
+  if (field instanceof z.ZodEnum)
     return "enum";
-  if (field instanceof z2.ZodArray)
+  if (field instanceof z.ZodArray)
     return "array";
-  if (field instanceof z2.ZodObject)
+  if (field instanceof z.ZodObject)
     return "object";
-  if (field instanceof z2.ZodString || field instanceof z2.ZodLiteral)
+  if (field instanceof z.ZodString || field instanceof z.ZodLiteral)
     return "string";
   return "other";
 }
@@ -326,11 +263,11 @@ function mergeField(fields, name, info) {
 }
 function collectSchemaFields(schema, fields) {
   const base = unwrap(schema);
-  if (base instanceof z2.ZodObject) {
+  if (base instanceof z.ZodObject) {
     for (const [name, raw] of Object.entries(base.shape)) {
       const fieldBase = unwrap(raw);
       const kind = classify(fieldBase);
-      if (kind === "array" && fieldBase instanceof z2.ZodArray) {
+      if (kind === "array" && fieldBase instanceof z.ZodArray) {
         mergeField(fields, name, { kind, elementKind: classify(unwrap(fieldBase.element)) });
       } else {
         mergeField(fields, name, { kind });
@@ -338,12 +275,12 @@ function collectSchemaFields(schema, fields) {
     }
     return;
   }
-  if (base instanceof z2.ZodUnion) {
+  if (base instanceof z.ZodUnion) {
     for (const option of base.def.options)
       collectSchemaFields(option, fields);
     return;
   }
-  if (base instanceof z2.ZodIntersection) {
+  if (base instanceof z.ZodIntersection) {
     collectSchemaFields(base.def.left, fields);
     collectSchemaFields(base.def.right, fields);
     return;
@@ -1737,4 +1674,4 @@ async function createCli(config) {
   return exit(downloadsOk ? exitCode : 1);
 }
 
-export { collectTools, createToolRunner, formatToolError, defineRuntimeTool, createRuntimeToolFactory, collectToolSurface, WaitTimeoutError, runWaitOperation, fetchGuarded, fetchPinnedDocument, readCapped, parseCliArgs, defineCliCommand, DEFAULT_EXIT_CODES, emitResult, pollUntilDone, createCli };
+export { defineRuntimeTool, createRuntimeToolFactory, collectToolSurface, WaitTimeoutError, runWaitOperation, fetchGuarded, fetchPinnedDocument, readCapped, parseCliArgs, defineCliCommand, DEFAULT_EXIT_CODES, emitResult, pollUntilDone, createCli };

package/dist/{index-wrhf06ak.js → index-cz32amcb.js}

@@ -1,17 +1,17 @@
+import {
+  getRequestContext,
+  runWithRequestContext
+} from "./index-69m2278y.js";
 import {
   objectShapeKeys
 } from "./index-6djpbnda.js";
 import {
   formatZodError,
-  getRequestContext,
+  isUnsafeKey,
   normalizeError,
-  runWithRequestContext,
+  safeJsonParse,
   validateDeclaredOutput
-} from "./index-tvwcrx2d.js";
-import {
-  isUnsafeKey,
-  safeJsonParse
-} from "./index-wd8g8z6e.js";
+} from "./index-9ky9hhg3.js";
 import {
   isRecord
 } from "./index-smpbdg6k.js";
@@ -19,7 +19,7 @@ import {
   AppError,
   STITCH_ERROR_STATUS,
   isStitchErrorCode
-} from "./index-xxye8j3k.js";
+} from "./index-0w9abg87.js";
 
 // src/tools/coerce.ts
 import { z } from "zod";

package/dist/{index-6taryy00.js → index-dafax5md.js}

@@ -1,6 +1,6 @@
 import {
   isUnsafeKey
-} from "./index-wd8g8z6e.js";
+} from "./index-9ky9hhg3.js";
 import {
   isRecord
 } from "./index-smpbdg6k.js";

package/dist/index-g2j2m6vv.js

@@ -0,0 +1,63 @@
+import {
+  collectTools,
+  createToolRunner
+} from "./index-7etq650s.js";
+import {
+  toolErrorFromResult
+} from "./index-cz32amcb.js";
+import {
+  assertUniqueToolName
+} from "./index-vkk06pv1.js";
+import {
+  AppError
+} from "./index-0w9abg87.js";
+
+// src/tools/invoker.ts
+function createToolInvoker(services, config) {
+  const serviceList = Array.isArray(services) ? services : [services];
+  const tools = new Map;
+  for (const service of serviceList) {
+    for (const tool of collectTools(service, config.transport, {
+      extend: config.extend,
+      flattenUnionInput: config.flattenUnionInput
+    })) {
+      assertUniqueToolName(tool.name, tools.has(tool.name), "in-process tool name");
+      tools.set(tool.name, tool);
+    }
+  }
+  const names = Object.freeze([...tools.keys()].sort());
+  const operation = (name) => {
+    const tool = tools.get(name);
+    if (tool)
+      return tool;
+    throw new AppError("NOT_FOUND", `Unknown tool: ${name}`, 404, {
+      available: names
+    });
+  };
+  const run = (name, args, options = {}) => {
+    const runTool = createToolRunner({
+      source: options.source ?? "internal",
+      context: options.context,
+      hooks: options.hooks,
+      lifecycle: options.lifecycle,
+      extend: config.extend,
+      coerceJsonArgs: config.coerceJsonArgs,
+      onOutputStrip: options.onOutputStrip
+    });
+    return runTool(operation(name), args);
+  };
+  return Object.freeze({
+    names,
+    invoke(name, args, options) {
+      return run(name, args, options);
+    },
+    async invokeOrThrow(name, args, options) {
+      const result = await run(name, args, options);
+      if (!result.ok)
+        throw toolErrorFromResult(result);
+      return result.data;
+    }
+  });
+}
+
+export { createToolInvoker };