toolwire 0.1.1

package/dist/index.cjs

@@ -0,0 +1,719 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+
+// src/schema.ts
+function resolveJsonSchema(schema) {
+  const hit = cache.get(schema);
+  if (hit !== void 0) return hit;
+  const result = compute(schema);
+  cache.set(schema, result);
+  return result;
+}
+function compute(schema) {
+  const toJSONSchemaV4 = zodNs["toJSONSchema"];
+  if (typeof toJSONSchemaV4 === "function") {
+    const { $schema: _$schema, ...clean } = toJSONSchemaV4(schema);
+    return clean;
+  }
+  try {
+    const pkg = _require("zod-to-json-schema");
+    const { $schema: _$schema, ...clean } = pkg.zodToJsonSchema(schema, {
+      $refStrategy: "none"
+    });
+    return clean;
+  } catch {
+    throw new Error(
+      "toolwire: Cannot convert Zod schema to JSON Schema.\n  \u2022 Zod v4: ensure zod@^4.0.0 is installed.\n  \u2022 Zod v3: run `npm install zod-to-json-schema`.\n  \u2022 Or supply a pre-computed schema via the `_jsonSchema` option in tool()."
+    );
+  }
+}
+var import_node_module, zodNs, _require, cache;
+var init_schema = __esm({
+  "src/schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_module = require("module");
+    zodNs = __toESM(require("zod"), 1);
+    _require = (0, import_node_module.createRequire)(importMetaUrl);
+    cache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/tool.ts
+function tool(config) {
+  if (!NAME_RE.test(config.name)) {
+    throw new Error(
+      `toolwire: Invalid tool name "${config.name}". Names must be 1\u201364 characters containing only letters, digits, underscores, or hyphens.`
+    );
+  }
+  const inputSchema = config._jsonSchema ?? resolveJsonSchema(config.input);
+  const outputSchema = config.output ? resolveJsonSchema(config.output) : void 0;
+  const def = {
+    name: config.name,
+    description: config.description,
+    input: config.input,
+    output: config.output,
+    handler: config.handler,
+    timeout: config.timeout ?? DEFAULTS.timeout,
+    retries: config.retries ?? DEFAULTS.retries,
+    annotations: config.annotations ?? {},
+    inputSchema,
+    outputSchema
+  };
+  return Object.freeze(def);
+}
+var NAME_RE, DEFAULTS;
+var init_tool = __esm({
+  "src/tool.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_schema();
+    NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+    DEFAULTS = {
+      timeout: 3e4,
+      retries: 0
+    };
+  }
+});
+
+// src/errors.ts
+function err(code, toolName, message, llmMessage, retryable, extras) {
+  return { code, toolName, message, llmMessage, retryable, ...extras };
+}
+function makeNotFoundError(toolName, available) {
+  const list = available.length > 0 ? `Available tools: ${available.join(", ")}.` : "No tools are currently registered.";
+  return err(
+    "NOT_FOUND",
+    toolName,
+    `Tool "${toolName}" is not registered`,
+    `The tool "${toolName}" does not exist. ${list} Please use one of the available tools.`,
+    true
+  );
+}
+function makeDisabledError(toolName) {
+  return err(
+    "DISABLED",
+    toolName,
+    `Tool "${toolName}" is currently disabled`,
+    `The tool "${toolName}" is currently disabled and cannot be called. Please try a different approach or wait until it is re-enabled.`,
+    false
+  );
+}
+function makeValidationInputError(toolName, issues) {
+  const lines = issues.map((i) => `  - ${i.path.length > 0 ? i.path.join(".") : "(root)"}: ${i.message}`).join("\n");
+  return err(
+    "VALIDATION_INPUT",
+    toolName,
+    `Invalid input for tool "${toolName}"`,
+    `Your call to "${toolName}" had invalid arguments:
+${lines}
+
+Please fix these and try again.`,
+    true,
+    { issues }
+  );
+}
+function makeValidationOutputError(toolName, issues) {
+  return err(
+    "VALIDATION_OUTPUT",
+    toolName,
+    `Tool "${toolName}" returned an invalid response format`,
+    `The tool "${toolName}" returned an unexpected response and could not be used. This is a bug in the tool implementation, not in your call. Please try a different approach.`,
+    false,
+    { issues }
+  );
+}
+function makeTimeoutError(toolName, timeoutMs) {
+  return err(
+    "TIMEOUT",
+    toolName,
+    `Tool "${toolName}" timed out after ${timeoutMs}ms`,
+    `The tool "${toolName}" timed out after ${timeoutMs}ms. This may be a temporary issue \u2014 please wait a moment before retrying.`,
+    true,
+    { retryAfterMs: Math.min(timeoutMs, 5e3) }
+  );
+}
+function makeExecutionError(toolName, cause, attempts) {
+  const msg = cause instanceof Error ? cause.message : String(cause);
+  const attemptStr = attempts > 1 ? ` after ${attempts} attempt(s)` : "";
+  return err(
+    "EXECUTION",
+    toolName,
+    `Tool "${toolName}" failed${attemptStr}: ${msg}`,
+    `The tool "${toolName}" encountered an error${attemptStr}: ${msg}. All retries have been exhausted \u2014 please try a different approach.`,
+    false,
+    { cause }
+  );
+}
+function makeFailure(toolName, error, durationMs) {
+  return { success: false, toolName, error, durationMs };
+}
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/middleware.ts
+async function runBefore(middleware, toolName, args) {
+  let current = args;
+  for (const mw of middleware) {
+    if (mw.beforeCall) {
+      const next = await mw.beforeCall(toolName, current);
+      if (next !== void 0) current = next;
+    }
+  }
+  return current;
+}
+async function runAfter(middleware, toolName, args, result) {
+  let current = result;
+  for (let i = middleware.length - 1; i >= 0; i--) {
+    const mw = middleware[i];
+    if (mw?.afterCall) {
+      const next = await mw.afterCall(toolName, args, current);
+      if (next !== void 0) current = next;
+    }
+  }
+  return current;
+}
+async function runOnError(middleware, toolName, args, failure) {
+  for (const mw of middleware) {
+    if (mw.onError) {
+      const recovery = await mw.onError(toolName, args, failure);
+      if (recovery !== void 0) return recovery;
+    }
+  }
+  return failure;
+}
+var init_middleware = __esm({
+  "src/middleware.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/adapters/anthropic.ts
+function toAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema
+  }));
+}
+var init_anthropic = __esm({
+  "src/adapters/anthropic.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/adapters/gemini.ts
+function toGemini(tools) {
+  return {
+    functionDeclarations: tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parametersJsonSchema: t.inputSchema
+    }))
+  };
+}
+var init_gemini = __esm({
+  "src/adapters/gemini.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/adapters/openai.ts
+function toOpenAI(tools, options) {
+  return tools.map((t) => {
+    const fn = {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    };
+    if (options?.strict !== void 0) {
+      fn.strict = options.strict;
+    }
+    return { type: "function", function: fn };
+  });
+}
+var init_openai = __esm({
+  "src/adapters/openai.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/adapters/vercel-ai.ts
+function toVercelAI(tools) {
+  return Object.fromEntries(
+    tools.map((t) => [
+      t.name,
+      {
+        description: t.description,
+        parameters: t.input
+      }
+    ])
+  );
+}
+var init_vercel_ai = __esm({
+  "src/adapters/vercel-ai.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/discovery.ts
+var discovery_exports = {};
+__export(discovery_exports, {
+  fromDir: () => fromDir,
+  fromManifest: () => fromManifest
+});
+async function fromDir(dirPath) {
+  const absPath = (0, import_node_path.resolve)(dirPath);
+  let files;
+  try {
+    files = await (0, import_promises.readdir)(absPath);
+  } catch (err2) {
+    throw new Error(
+      `toolwire: Cannot read directory "${absPath}": ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+  }
+  const toolFiles = files.filter((f) => /\.(js|mjs|cjs)$/.test(f));
+  const discovered = [];
+  for (const file of toolFiles) {
+    const fileUrl = (0, import_node_url.pathToFileURL)((0, import_node_path.join)(absPath, file)).href;
+    try {
+      const mod = await import(fileUrl);
+      discovered.push(...extractTools(mod));
+    } catch (err2) {
+      console.warn(
+        `toolwire: Skipping "${file}" (failed to import):`,
+        err2 instanceof Error ? err2.message : err2
+      );
+    }
+  }
+  return new ToolRegistry(discovered);
+}
+async function fromManifest(url) {
+  let manifest;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
+    }
+    manifest = await response.json();
+  } catch (err2) {
+    throw new Error(
+      `toolwire: Failed to fetch manifest from "${url}": ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+  }
+  if (manifest.version !== "1.0" || !Array.isArray(manifest.tools)) {
+    throw new Error(
+      'toolwire: Invalid manifest. Expected { version: "1.0", tools: [...] }'
+    );
+  }
+  const { z } = await import("zod");
+  const tools = manifest.tools.map(
+    (entry) => tool({
+      name: entry.name,
+      description: entry.description,
+      input: z.record(z.string(), z.unknown()),
+      _jsonSchema: entry.inputSchema,
+      handler: async (input) => {
+        const res = await fetch(entry.endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        return res.json();
+      }
+    })
+  );
+  return new ToolRegistry(tools);
+}
+function isToolDefinition(value) {
+  return typeof value === "object" && value !== null && typeof value["name"] === "string" && typeof value["description"] === "string" && typeof value["handler"] === "function";
+}
+function extractTools(mod) {
+  if (isToolDefinition(mod["default"])) {
+    return [mod["default"]];
+  }
+  if (Array.isArray(mod["tools"])) {
+    const found = mod["tools"].filter(isToolDefinition);
+    if (found.length > 0) return found;
+  }
+  return Object.entries(mod).filter(([key]) => key !== "default" && key !== "tools").map(([, value]) => value).filter(isToolDefinition);
+}
+var import_promises, import_node_path, import_node_url;
+var init_discovery = __esm({
+  "src/discovery.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises = require("fs/promises");
+    import_node_path = require("path");
+    import_node_url = require("url");
+    init_registry();
+    init_tool();
+  }
+});
+
+// src/registry.ts
+function registry(tools = [], options = {}) {
+  return new ToolRegistry(tools, options);
+}
+async function withTimeout(fn, ms, toolName) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(
+      new DOMException(`Tool "${toolName}" timed out after ${ms}ms`, "AbortError")
+    );
+  }, ms);
+  const execution = Promise.resolve().then(() => fn(controller.signal));
+  const timeoutRace = new Promise((_, reject) => {
+    controller.signal.addEventListener("abort", () => reject(controller.signal.reason), {
+      once: true
+    });
+  });
+  try {
+    return await Promise.race([execution, timeoutRace]);
+  } finally {
+    clearTimeout(timer);
+    execution.catch(() => void 0);
+  }
+}
+function isAbortError(err2) {
+  return err2 instanceof Error && (err2.name === "AbortError" || err2 instanceof DOMException && err2.name === "AbortError");
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var ToolRegistry;
+var init_registry = __esm({
+  "src/registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors();
+    init_middleware();
+    init_anthropic();
+    init_gemini();
+    init_openai();
+    init_vercel_ai();
+    ToolRegistry = class {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tools = /* @__PURE__ */ new Map();
+      disabledTools = /* @__PURE__ */ new Set();
+      _middleware = [];
+      options;
+      constructor(tools = [], options = {}) {
+        this.options = options;
+        for (const t of tools) {
+          this.tools.set(t.name, t);
+        }
+      }
+      // ---------------------------------------------------------------------------
+      // Tool management
+      // ---------------------------------------------------------------------------
+      /** Add one or more tools. Returns `this` for chaining. */
+      register(tools) {
+        const list = Array.isArray(tools) ? tools : [tools];
+        for (const t of list) this.tools.set(t.name, t);
+        return this;
+      }
+      /**
+       * Replace a registered tool in-place (hot-swap).
+       * Useful for swapping slow tools with cached versions mid-run.
+       */
+      swap(name, newTool) {
+        if (!this.tools.has(name)) {
+          throw new Error(`toolwire: Cannot swap "${name}" \u2014 it is not registered.`);
+        }
+        this.tools.set(name, newTool);
+        return this;
+      }
+      /** Temporarily prevent a tool from being called. */
+      disable(name) {
+        if (!this.tools.has(name)) {
+          throw new Error(`toolwire: Cannot disable "${name}" \u2014 it is not registered.`);
+        }
+        this.disabledTools.add(name);
+        return this;
+      }
+      /** Re-enable a previously disabled tool. */
+      enable(name) {
+        if (!this.tools.has(name)) {
+          throw new Error(`toolwire: Cannot enable "${name}" \u2014 it is not registered.`);
+        }
+        this.disabledTools.delete(name);
+        return this;
+      }
+      /** Add middleware. Returns `this` for chaining. */
+      use(middleware) {
+        const list = Array.isArray(middleware) ? middleware : [middleware];
+        this._middleware.push(...list);
+        return this;
+      }
+      /** Return the names of all registered tools (including disabled ones). */
+      list() {
+        return [...this.tools.keys()];
+      }
+      /** Return a tool definition by name, or undefined if not found. */
+      get(name) {
+        return this.tools.get(name);
+      }
+      /**
+       * Return a human-readable list of enabled tools.
+       * Handy for injecting into a system prompt.
+       */
+      describe() {
+        const enabled = [...this.tools.values()].filter(
+          (t) => !this.disabledTools.has(t.name)
+        );
+        if (enabled.length === 0) return "No tools are currently available.";
+        return enabled.map((t) => `- ${t.name}: ${t.description}`).join("\n");
+      }
+      // ---------------------------------------------------------------------------
+      // Execution
+      // ---------------------------------------------------------------------------
+      /**
+       * Execute a tool call from an LLM.
+       * Always resolves (never throws) — check `result.success` to distinguish outcomes.
+       */
+      async call(request) {
+        const start = Date.now();
+        const { name: toolName, arguments: rawArgs } = request;
+        const toolDef = this.tools.get(toolName);
+        if (!toolDef) {
+          return runOnError(
+            this._middleware,
+            toolName,
+            rawArgs,
+            makeFailure(toolName, makeNotFoundError(toolName, this.list()), Date.now() - start)
+          );
+        }
+        if (this.disabledTools.has(toolName)) {
+          return runOnError(
+            this._middleware,
+            toolName,
+            rawArgs,
+            makeFailure(toolName, makeDisabledError(toolName), Date.now() - start)
+          );
+        }
+        const parsed = toolDef.input.safeParse(rawArgs);
+        if (!parsed.success) {
+          return runOnError(
+            this._middleware,
+            toolName,
+            rawArgs,
+            makeFailure(
+              toolName,
+              makeValidationInputError(toolName, parsed.error.issues),
+              Date.now() - start
+            )
+          );
+        }
+        let args = parsed.data;
+        try {
+          args = await runBefore(this._middleware, toolName, args);
+        } catch (err2) {
+          return runOnError(
+            this._middleware,
+            toolName,
+            rawArgs,
+            makeFailure(toolName, makeExecutionError(toolName, err2, 1), Date.now() - start)
+          );
+        }
+        const timeout = toolDef.timeout ?? this.options.defaultTimeout ?? 3e4;
+        const maxAttempts = toolDef.retries + 1;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          try {
+            const data = await withTimeout(
+              (signal) => toolDef.handler(args, { signal, attempt }),
+              timeout,
+              toolName
+            );
+            let output = data;
+            if (toolDef.output) {
+              const outParsed = toolDef.output.safeParse(data);
+              if (!outParsed.success) {
+                return runOnError(
+                  this._middleware,
+                  toolName,
+                  rawArgs,
+                  makeFailure(
+                    toolName,
+                    makeValidationOutputError(toolName, outParsed.error.issues),
+                    Date.now() - start
+                  )
+                );
+              }
+              output = outParsed.data;
+            }
+            const raw = {
+              success: true,
+              data: output,
+              toolName,
+              durationMs: Date.now() - start
+            };
+            return await runAfter(this._middleware, toolName, rawArgs, raw);
+          } catch (err2) {
+            lastError = err2;
+            if (isAbortError(err2)) {
+              return runOnError(
+                this._middleware,
+                toolName,
+                rawArgs,
+                makeFailure(toolName, makeTimeoutError(toolName, timeout), Date.now() - start)
+              );
+            }
+            if (attempt < maxAttempts - 1) {
+              await sleep(100 * 2 ** attempt);
+            }
+          }
+        }
+        return runOnError(
+          this._middleware,
+          toolName,
+          rawArgs,
+          makeFailure(
+            toolName,
+            makeExecutionError(toolName, lastError, maxAttempts),
+            Date.now() - start
+          )
+        );
+      }
+      // ---------------------------------------------------------------------------
+      // Provider adapters
+      // ---------------------------------------------------------------------------
+      /** Export tool schemas in OpenAI function-calling format. */
+      toOpenAI(options) {
+        return toOpenAI(this.enabledTools(), options);
+      }
+      /** Export tool schemas in Anthropic tool-use format. */
+      toAnthropic() {
+        return toAnthropic(this.enabledTools());
+      }
+      /** Export tool schemas in Google Gemini format. */
+      toGemini() {
+        return toGemini(this.enabledTools());
+      }
+      /** Export tool schemas in Vercel AI SDK format (passes Zod schemas directly). */
+      toVercelAI() {
+        return toVercelAI(this.enabledTools());
+      }
+      // ---------------------------------------------------------------------------
+      // Static factory methods
+      // ---------------------------------------------------------------------------
+      /** Load tools from a directory of compiled JS/MJS files. */
+      static async fromDir(dirPath) {
+        const { fromDir: fromDir2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+        return fromDir2(dirPath);
+      }
+      /** Load tools from a remote JSON manifest. */
+      static async fromManifest(url) {
+        const { fromManifest: fromManifest2 } = await Promise.resolve().then(() => (init_discovery(), discovery_exports));
+        return fromManifest2(url);
+      }
+      // ---------------------------------------------------------------------------
+      // Private helpers
+      // ---------------------------------------------------------------------------
+      enabledTools() {
+        return [...this.tools.values()].filter((t) => !this.disabledTools.has(t.name));
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ToolRegistry: () => ToolRegistry,
+  fromDir: () => fromDir,
+  fromManifest: () => fromManifest,
+  makeDisabledError: () => makeDisabledError,
+  makeExecutionError: () => makeExecutionError,
+  makeFailure: () => makeFailure,
+  makeNotFoundError: () => makeNotFoundError,
+  makeTimeoutError: () => makeTimeoutError,
+  makeValidationInputError: () => makeValidationInputError,
+  makeValidationOutputError: () => makeValidationOutputError,
+  registry: () => registry,
+  toAnthropic: () => toAnthropic,
+  toGemini: () => toGemini,
+  toOpenAI: () => toOpenAI,
+  toVercelAI: () => toVercelAI,
+  tool: () => tool
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+init_tool();
+init_registry();
+init_openai();
+init_anthropic();
+init_gemini();
+init_vercel_ai();
+init_discovery();
+init_errors();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolRegistry,
+  fromDir,
+  fromManifest,
+  makeDisabledError,
+  makeExecutionError,
+  makeFailure,
+  makeNotFoundError,
+  makeTimeoutError,
+  makeValidationInputError,
+  makeValidationOutputError,
+  registry,
+  toAnthropic,
+  toGemini,
+  toOpenAI,
+  toVercelAI,
+  tool
+});
+//# sourceMappingURL=index.cjs.map