@yak-io/rest 0.1.2 → 0.2.0

package/dist/adapters.d.ts

@@ -1,10 +1,17 @@
 import type { RESTRequest, ToolAdapter } from "@yak-io/javascript";
+/** An OpenAPI spec as an object or a JSON string. */
+type RESTSpec = Record<string, unknown> | string;
 /** Config for {@link createRESTToolAdapter}. */
 export type RESTToolAdapterConfig = {
     /** Spec name — the tool is exposed to the LLM as `rest_<name>`. */
     name: string;
-    /** OpenAPI spec (object or string). Embedded in the tool description so the LLM can author requests. */
-    spec: Record<string, unknown> | string;
+    /**
+     * OpenAPI spec as an object or JSON string, or a resolver that returns it (sync or async). Use a
+     * resolver to fetch the spec lazily: it runs once on first `getTools()` and the result is cached,
+     * so the fetch is paid lazily, not at construction. A literal spec is embedded eagerly. Embedded
+     * in the tool description so the LLM can author requests.
+     */
+    spec: RESTSpec | (() => RESTSpec | Promise<RESTSpec>);
     /**
      * Execute the LLM-authored REST request with YOUR client. Yak builds the tool and the request
      * shape (method / path / query / body) but never makes the call itself — your client owns the
@@ -33,6 +40,18 @@ export type RESTToolAdapterConfig = {
  *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // Lazy: fetch the OpenAPI spec once, on first use. The factory stays synchronous — the fetch
+ * // is paid when the toolset first materializes its tools, then cached.
+ * const billing = createRESTToolAdapter({
+ *   name: "billing",
+ *   spec: async () => (await fetch("/openapi.json")).json(),
+ *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),
+ * });
+ * ```
  */
 export declare function createRESTToolAdapter(config: RESTToolAdapterConfig): ToolAdapter;
+export {};
 //# sourceMappingURL=adapters.d.ts.map

package/dist/adapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,WAAW,EAAE,WAAW,EAAkB,MAAM,oBAAoB,CAAC;AAE/F,gDAAgD;AAChD,MAAM,MAAM,qBAAqB,GAAG;IAClC,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,wGAAwG;IACxG,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;IACvC;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AA2BF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,WAAW,CA6BhF"}
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,WAAW,EAAE,WAAW,EAAkB,MAAM,oBAAoB,CAAC;AAE/F,qDAAqD;AACrD,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;AAEjD,gDAAgD;AAChD,MAAM,MAAM,qBAAqB,GAAG;IAClC,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtD;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AA2BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,WAAW,CAoDhF"}

package/dist/index.cjs

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRESTToolAdapter: () => createRESTToolAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters.ts
+var REST_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    method: {
+      type: "string",
+      enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+      description: "HTTP method for the request."
+    },
+    path: { type: "string", description: "API path (e.g., '/users/123')." },
+    query: {
+      type: "object",
+      description: "Query parameters as key-value pairs.",
+      additionalProperties: { type: "string" }
+    },
+    body: { description: "Request body for POST/PUT/PATCH requests." }
+  },
+  required: ["method", "path"],
+  additionalProperties: false
+};
+function createRESTToolAdapter(config) {
+  const toolName = `rest_${config.name}`;
+  const buildTool = (spec) => {
+    const specStr = typeof spec === "string" ? spec : JSON.stringify(spec);
+    return {
+      name: toolName,
+      description: `Make a REST API call to the ${config.name} API. Based on the OpenAPI spec below, generate the appropriate request with method, path, query params, and body.
+
+OpenAPI spec:
+\`\`\`json
+${specStr}
+\`\`\``,
+      inputSchema: REST_INPUT_SCHEMA
+    };
+  };
+  const eager = typeof config.spec === "function" ? void 0 : [buildTool(config.spec)];
+  let pending;
+  return {
+    id: config.id ?? toolName,
+    getTools: () => {
+      if (eager) return eager;
+      if (!pending) {
+        const resolve = config.spec;
+        pending = Promise.resolve().then(resolve).then((spec) => [buildTool(spec)]);
+        pending.catch(() => {
+          pending = void 0;
+        });
+      }
+      return pending;
+    },
+    ownsTool: (name) => name === toolName,
+    execute: async (_name, args) => {
+      const request = args ?? {};
+      return config.execute({
+        method: request.method,
+        path: request.path,
+        query: request.query,
+        body: request.body
+      });
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/adapters.ts"],
+  "sourcesContent": ["// REST/OpenAPI tool adapter for the yak client toolset\nexport { createRESTToolAdapter } from \"./adapters.js\";\nexport type { RESTToolAdapterConfig } from \"./adapters.js\";\n\n// Shared types from core\nexport type { RESTRequest, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n", "import type { JSONSchema, RESTRequest, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n\n/** An OpenAPI spec as an object or a JSON string. */\ntype RESTSpec = Record<string, unknown> | string;\n\n/** Config for {@link createRESTToolAdapter}. */\nexport type RESTToolAdapterConfig = {\n  /** Spec name \u2014 the tool is exposed to the LLM as `rest_<name>`. */\n  name: string;\n  /**\n   * OpenAPI spec as an object or JSON string, or a resolver that returns it (sync or async). Use a\n   * resolver to fetch the spec lazily: it runs once on first `getTools()` and the result is cached,\n   * so the fetch is paid lazily, not at construction. A literal spec is embedded eagerly. Embedded\n   * in the tool description so the LLM can author requests.\n   */\n  spec: RESTSpec | (() => RESTSpec | Promise<RESTSpec>);\n  /**\n   * Execute the LLM-authored REST request with YOUR client. Yak builds the tool and the request\n   * shape (method / path / query / body) but never makes the call itself \u2014 your client owns the\n   * base URL, auth, transport, and error handling. Use whatever you already have (a configured\n   * `fetch` wrapper, axios, your app's API client, \u2026). Return the result the assistant should\n   * see; throw to surface an error to the model.\n   */\n  execute: (request: RESTRequest) => unknown | Promise<unknown>;\n  /** Stable id for diagnostics. Defaults to the tool name. */\n  id?: string;\n};\n\n/**\n * Generic input schema for a REST tool. The LLM authors method/path/query/body;\n * the adapter hands them to your `execute` client. Do NOT inject `_reason` here \u2014 the\n * chat-ui / voice runtimes inject it when registering the tool with the model.\n */\nconst REST_INPUT_SCHEMA: JSONSchema = {\n  type: \"object\",\n  properties: {\n    method: {\n      type: \"string\",\n      enum: [\"GET\", \"POST\", \"PUT\", \"PATCH\", \"DELETE\"],\n      description: \"HTTP method for the request.\",\n    },\n    path: { type: \"string\", description: \"API path (e.g., '/users/123').\" },\n    query: {\n      type: \"object\",\n      description: \"Query parameters as key-value pairs.\",\n      additionalProperties: { type: \"string\" },\n    },\n    body: { description: \"Request body for POST/PUT/PATCH requests.\" },\n  },\n  required: [\"method\", \"path\"],\n  additionalProperties: false,\n};\n\n/**\n * Create a REST {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the generated\n * `rest_<name>` tool joins the single merged manifest + `onToolCall` funnel (and therefore\n * surfaces through `onToolCallComplete` / `useYakToolEvent`).\n *\n * The model authors a request from the OpenAPI spec you provide; the adapter hands it to your\n * `execute` callback, which runs it with whatever client you already use. Yak never constructs\n * the HTTP call \u2014 your client owns the base URL, auth, and transport.\n *\n * @example\n * ```ts\n * const billing = createRESTToolAdapter({\n *   name: \"billing\",\n *   spec: openapiSpec,\n *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Lazy: fetch the OpenAPI spec once, on first use. The factory stays synchronous \u2014 the fetch\n * // is paid when the toolset first materializes its tools, then cached.\n * const billing = createRESTToolAdapter({\n *   name: \"billing\",\n *   spec: async () => (await fetch(\"/openapi.json\")).json(),\n *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),\n * });\n * ```\n */\nexport function createRESTToolAdapter(config: RESTToolAdapterConfig): ToolAdapter {\n  const toolName = `rest_${config.name}`;\n\n  const buildTool = (spec: RESTSpec): ToolDefinition => {\n    // Minified, not pretty-printed: the model reads compact JSON identically, and the\n    // spec is embedded verbatim in the tool description sent to the LLM on every turn \u2014\n    // dropping the indentation/newlines is a free token saving for large specs.\n    const specStr = typeof spec === \"string\" ? spec : JSON.stringify(spec);\n    return {\n      name: toolName,\n      description:\n        `Make a REST API call to the ${config.name} API. Based on the OpenAPI spec below, ` +\n        \"generate the appropriate request with method, path, query params, and body.\" +\n        `\\n\\nOpenAPI spec:\\n\\`\\`\\`json\\n${specStr}\\n\\`\\`\\``,\n      inputSchema: REST_INPUT_SCHEMA,\n    };\n  };\n\n  // A literal spec (object or string) builds the tool eagerly. A resolver runs once on first\n  // getTools() and the [tool] result is cached; a rejection is NOT cached, so a later getTools()\n  // can retry \u2014 a transient spec-fetch failure doesn't wedge the toolset.\n  const eager = typeof config.spec === \"function\" ? undefined : [buildTool(config.spec)];\n  let pending: Promise<ToolDefinition[]> | undefined;\n\n  return {\n    id: config.id ?? toolName,\n    getTools: () => {\n      if (eager) return eager;\n      if (!pending) {\n        const resolve = config.spec as () => RESTSpec | Promise<RESTSpec>;\n        // Promise.resolve().then(resolve) so a synchronous throw also surfaces as a rejection.\n        pending = Promise.resolve()\n          .then(resolve)\n          .then((spec) => [buildTool(spec)]);\n        pending.catch(() => {\n          pending = undefined; // don't cache failures \u2014 allow retry on the next getTools()\n        });\n      }\n      return pending;\n    },\n    ownsTool: (name) => name === toolName,\n    execute: async (_name, args) => {\n      const request = (args ?? {}) as RESTRequest;\n      // Hand a clean request to the caller's client \u2014 never forward the runtime-injected `_reason`.\n      return config.execute({\n        method: request.method,\n        path: request.path,\n        query: request.query,\n        body: request.body,\n      });\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiCA,IAAM,oBAAgC;AAAA,EACpC,MAAM;AAAA,EACN,YAAY;AAAA,IACV,QAAQ;AAAA,MACN,MAAM;AAAA,MACN,MAAM,CAAC,OAAO,QAAQ,OAAO,SAAS,QAAQ;AAAA,MAC9C,aAAa;AAAA,IACf;AAAA,IACA,MAAM,EAAE,MAAM,UAAU,aAAa,iCAAiC;AAAA,IACtE,OAAO;AAAA,MACL,MAAM;AAAA,MACN,aAAa;AAAA,MACb,sBAAsB,EAAE,MAAM,SAAS;AAAA,IACzC;AAAA,IACA,MAAM,EAAE,aAAa,4CAA4C;AAAA,EACnE;AAAA,EACA,UAAU,CAAC,UAAU,MAAM;AAAA,EAC3B,sBAAsB;AACxB;AA+BO,SAAS,sBAAsB,QAA4C;AAChF,QAAM,WAAW,QAAQ,OAAO,IAAI;AAEpC,QAAM,YAAY,CAAC,SAAmC;AAIpD,UAAM,UAAU,OAAO,SAAS,WAAW,OAAO,KAAK,UAAU,IAAI;AACrE,WAAO;AAAA,MACL,MAAM;AAAA,MACN,aACE,+BAA+B,OAAO,IAAI;AAAA;AAAA;AAAA;AAAA,EAER,OAAO;AAAA;AAAA,MAC3C,aAAa;AAAA,IACf;AAAA,EACF;AAKA,QAAM,QAAQ,OAAO,OAAO,SAAS,aAAa,SAAY,CAAC,UAAU,OAAO,IAAI,CAAC;AACrF,MAAI;AAEJ,SAAO;AAAA,IACL,IAAI,OAAO,MAAM;AAAA,IACjB,UAAU,MAAM;AACd,UAAI,MAAO,QAAO;AAClB,UAAI,CAAC,SAAS;AACZ,cAAM,UAAU,OAAO;AAEvB,kBAAU,QAAQ,QAAQ,EACvB,KAAK,OAAO,EACZ,KAAK,CAAC,SAAS,CAAC,UAAU,IAAI,CAAC,CAAC;AACnC,gBAAQ,MAAM,MAAM;AAClB,oBAAU;AAAA,QACZ,CAAC;AAAA,MACH;AACA,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,SAAS,SAAS;AAAA,IAC7B,SAAS,OAAO,OAAO,SAAS;AAC9B,YAAM,UAAW,QAAQ,CAAC;AAE1B,aAAO,OAAO,QAAQ;AAAA,QACpB,QAAQ,QAAQ;AAAA,QAChB,MAAM,QAAQ;AAAA,QACd,OAAO,QAAQ;AAAA,QACf,MAAM,QAAQ;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/index.js

@@ -1,2 +1,66 @@
-// REST/OpenAPI tool adapter for the yak client toolset
-export { createRESTToolAdapter } from "./adapters.js";
+// src/adapters.ts
+var REST_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    method: {
+      type: "string",
+      enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+      description: "HTTP method for the request."
+    },
+    path: { type: "string", description: "API path (e.g., '/users/123')." },
+    query: {
+      type: "object",
+      description: "Query parameters as key-value pairs.",
+      additionalProperties: { type: "string" }
+    },
+    body: { description: "Request body for POST/PUT/PATCH requests." }
+  },
+  required: ["method", "path"],
+  additionalProperties: false
+};
+function createRESTToolAdapter(config) {
+  const toolName = `rest_${config.name}`;
+  const buildTool = (spec) => {
+    const specStr = typeof spec === "string" ? spec : JSON.stringify(spec);
+    return {
+      name: toolName,
+      description: `Make a REST API call to the ${config.name} API. Based on the OpenAPI spec below, generate the appropriate request with method, path, query params, and body.
+
+OpenAPI spec:
+\`\`\`json
+${specStr}
+\`\`\``,
+      inputSchema: REST_INPUT_SCHEMA
+    };
+  };
+  const eager = typeof config.spec === "function" ? void 0 : [buildTool(config.spec)];
+  let pending;
+  return {
+    id: config.id ?? toolName,
+    getTools: () => {
+      if (eager) return eager;
+      if (!pending) {
+        const resolve = config.spec;
+        pending = Promise.resolve().then(resolve).then((spec) => [buildTool(spec)]);
+        pending.catch(() => {
+          pending = void 0;
+        });
+      }
+      return pending;
+    },
+    ownsTool: (name) => name === toolName,
+    execute: async (_name, args) => {
+      const request = args ?? {};
+      return config.execute({
+        method: request.method,
+        path: request.path,
+        query: request.query,
+        body: request.body
+      });
+    }
+  };
+}
+export {
+  createRESTToolAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/adapters.ts"],
+  "sourcesContent": ["import type { JSONSchema, RESTRequest, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n\n/** An OpenAPI spec as an object or a JSON string. */\ntype RESTSpec = Record<string, unknown> | string;\n\n/** Config for {@link createRESTToolAdapter}. */\nexport type RESTToolAdapterConfig = {\n  /** Spec name \u2014 the tool is exposed to the LLM as `rest_<name>`. */\n  name: string;\n  /**\n   * OpenAPI spec as an object or JSON string, or a resolver that returns it (sync or async). Use a\n   * resolver to fetch the spec lazily: it runs once on first `getTools()` and the result is cached,\n   * so the fetch is paid lazily, not at construction. A literal spec is embedded eagerly. Embedded\n   * in the tool description so the LLM can author requests.\n   */\n  spec: RESTSpec | (() => RESTSpec | Promise<RESTSpec>);\n  /**\n   * Execute the LLM-authored REST request with YOUR client. Yak builds the tool and the request\n   * shape (method / path / query / body) but never makes the call itself \u2014 your client owns the\n   * base URL, auth, transport, and error handling. Use whatever you already have (a configured\n   * `fetch` wrapper, axios, your app's API client, \u2026). Return the result the assistant should\n   * see; throw to surface an error to the model.\n   */\n  execute: (request: RESTRequest) => unknown | Promise<unknown>;\n  /** Stable id for diagnostics. Defaults to the tool name. */\n  id?: string;\n};\n\n/**\n * Generic input schema for a REST tool. The LLM authors method/path/query/body;\n * the adapter hands them to your `execute` client. Do NOT inject `_reason` here \u2014 the\n * chat-ui / voice runtimes inject it when registering the tool with the model.\n */\nconst REST_INPUT_SCHEMA: JSONSchema = {\n  type: \"object\",\n  properties: {\n    method: {\n      type: \"string\",\n      enum: [\"GET\", \"POST\", \"PUT\", \"PATCH\", \"DELETE\"],\n      description: \"HTTP method for the request.\",\n    },\n    path: { type: \"string\", description: \"API path (e.g., '/users/123').\" },\n    query: {\n      type: \"object\",\n      description: \"Query parameters as key-value pairs.\",\n      additionalProperties: { type: \"string\" },\n    },\n    body: { description: \"Request body for POST/PUT/PATCH requests.\" },\n  },\n  required: [\"method\", \"path\"],\n  additionalProperties: false,\n};\n\n/**\n * Create a REST {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the generated\n * `rest_<name>` tool joins the single merged manifest + `onToolCall` funnel (and therefore\n * surfaces through `onToolCallComplete` / `useYakToolEvent`).\n *\n * The model authors a request from the OpenAPI spec you provide; the adapter hands it to your\n * `execute` callback, which runs it with whatever client you already use. Yak never constructs\n * the HTTP call \u2014 your client owns the base URL, auth, and transport.\n *\n * @example\n * ```ts\n * const billing = createRESTToolAdapter({\n *   name: \"billing\",\n *   spec: openapiSpec,\n *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Lazy: fetch the OpenAPI spec once, on first use. The factory stays synchronous \u2014 the fetch\n * // is paid when the toolset first materializes its tools, then cached.\n * const billing = createRESTToolAdapter({\n *   name: \"billing\",\n *   spec: async () => (await fetch(\"/openapi.json\")).json(),\n *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),\n * });\n * ```\n */\nexport function createRESTToolAdapter(config: RESTToolAdapterConfig): ToolAdapter {\n  const toolName = `rest_${config.name}`;\n\n  const buildTool = (spec: RESTSpec): ToolDefinition => {\n    // Minified, not pretty-printed: the model reads compact JSON identically, and the\n    // spec is embedded verbatim in the tool description sent to the LLM on every turn \u2014\n    // dropping the indentation/newlines is a free token saving for large specs.\n    const specStr = typeof spec === \"string\" ? spec : JSON.stringify(spec);\n    return {\n      name: toolName,\n      description:\n        `Make a REST API call to the ${config.name} API. Based on the OpenAPI spec below, ` +\n        \"generate the appropriate request with method, path, query params, and body.\" +\n        `\\n\\nOpenAPI spec:\\n\\`\\`\\`json\\n${specStr}\\n\\`\\`\\``,\n      inputSchema: REST_INPUT_SCHEMA,\n    };\n  };\n\n  // A literal spec (object or string) builds the tool eagerly. A resolver runs once on first\n  // getTools() and the [tool] result is cached; a rejection is NOT cached, so a later getTools()\n  // can retry \u2014 a transient spec-fetch failure doesn't wedge the toolset.\n  const eager = typeof config.spec === \"function\" ? undefined : [buildTool(config.spec)];\n  let pending: Promise<ToolDefinition[]> | undefined;\n\n  return {\n    id: config.id ?? toolName,\n    getTools: () => {\n      if (eager) return eager;\n      if (!pending) {\n        const resolve = config.spec as () => RESTSpec | Promise<RESTSpec>;\n        // Promise.resolve().then(resolve) so a synchronous throw also surfaces as a rejection.\n        pending = Promise.resolve()\n          .then(resolve)\n          .then((spec) => [buildTool(spec)]);\n        pending.catch(() => {\n          pending = undefined; // don't cache failures \u2014 allow retry on the next getTools()\n        });\n      }\n      return pending;\n    },\n    ownsTool: (name) => name === toolName,\n    execute: async (_name, args) => {\n      const request = (args ?? {}) as RESTRequest;\n      // Hand a clean request to the caller's client \u2014 never forward the runtime-injected `_reason`.\n      return config.execute({\n        method: request.method,\n        path: request.path,\n        query: request.query,\n        body: request.body,\n      });\n    },\n  };\n}\n"],
+  "mappings": ";AAiCA,IAAM,oBAAgC;AAAA,EACpC,MAAM;AAAA,EACN,YAAY;AAAA,IACV,QAAQ;AAAA,MACN,MAAM;AAAA,MACN,MAAM,CAAC,OAAO,QAAQ,OAAO,SAAS,QAAQ;AAAA,MAC9C,aAAa;AAAA,IACf;AAAA,IACA,MAAM,EAAE,MAAM,UAAU,aAAa,iCAAiC;AAAA,IACtE,OAAO;AAAA,MACL,MAAM;AAAA,MACN,aAAa;AAAA,MACb,sBAAsB,EAAE,MAAM,SAAS;AAAA,IACzC;AAAA,IACA,MAAM,EAAE,aAAa,4CAA4C;AAAA,EACnE;AAAA,EACA,UAAU,CAAC,UAAU,MAAM;AAAA,EAC3B,sBAAsB;AACxB;AA+BO,SAAS,sBAAsB,QAA4C;AAChF,QAAM,WAAW,QAAQ,OAAO,IAAI;AAEpC,QAAM,YAAY,CAAC,SAAmC;AAIpD,UAAM,UAAU,OAAO,SAAS,WAAW,OAAO,KAAK,UAAU,IAAI;AACrE,WAAO;AAAA,MACL,MAAM;AAAA,MACN,aACE,+BAA+B,OAAO,IAAI;AAAA;AAAA;AAAA;AAAA,EAER,OAAO;AAAA;AAAA,MAC3C,aAAa;AAAA,IACf;AAAA,EACF;AAKA,QAAM,QAAQ,OAAO,OAAO,SAAS,aAAa,SAAY,CAAC,UAAU,OAAO,IAAI,CAAC;AACrF,MAAI;AAEJ,SAAO;AAAA,IACL,IAAI,OAAO,MAAM;AAAA,IACjB,UAAU,MAAM;AACd,UAAI,MAAO,QAAO;AAClB,UAAI,CAAC,SAAS;AACZ,cAAM,UAAU,OAAO;AAEvB,kBAAU,QAAQ,QAAQ,EACvB,KAAK,OAAO,EACZ,KAAK,CAAC,SAAS,CAAC,UAAU,IAAI,CAAC,CAAC;AACnC,gBAAQ,MAAM,MAAM;AAClB,oBAAU;AAAA,QACZ,CAAC;AAAA,MACH;AACA,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,SAAS,SAAS;AAAA,IAC7B,SAAS,OAAO,OAAO,SAAS;AAC9B,YAAM,UAAW,QAAQ,CAAC;AAE1B,aAAO,OAAO,QAAQ;AAAA,QACpB,QAAQ,QAAQ;AAAA,QAChB,MAAM,QAAQ;AAAA,QACd,OAAO,QAAQ;AAAA,QACf,MAAM,QAAQ;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yak-io/rest",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "REST/OpenAPI adapter for yak chatbot - exposes a REST API as a chatbot tool",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -30,19 +30,20 @@
     "LICENSE"
   ],
   "sideEffects": false,
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@yak-io/javascript": "0.10.0"
+    "@yak-io/javascript": "0.11.0"
   },
   "devDependencies": {
     "@types/node": "^24.12.4",
@@ -51,7 +52,7 @@
   },
   "homepage": "https://docs.yak.io/docs/tool-adapters/rest",
   "scripts": {
-    "build": "tsc",
+    "build": "node ../../scripts/build-package.mjs && tsc --emitDeclarationOnly",
     "check-types": "tsc --noEmit",
     "test": "vitest run",
     "lint": "biome lint ./src --fix",

package/dist/adapters.js

@@ -1,68 +0,0 @@
-/**
- * Generic input schema for a REST tool. The LLM authors method/path/query/body;
- * the adapter hands them to your `execute` client. Do NOT inject `_reason` here — the
- * chat-ui / voice runtimes inject it when registering the tool with the model.
- */
-const REST_INPUT_SCHEMA = {
-    type: "object",
-    properties: {
-        method: {
-            type: "string",
-            enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
-            description: "HTTP method for the request.",
-        },
-        path: { type: "string", description: "API path (e.g., '/users/123')." },
-        query: {
-            type: "object",
-            description: "Query parameters as key-value pairs.",
-            additionalProperties: { type: "string" },
-        },
-        body: { description: "Request body for POST/PUT/PATCH requests." },
-    },
-    required: ["method", "path"],
-    additionalProperties: false,
-};
-/**
- * Create a REST {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the generated
- * `rest_<name>` tool joins the single merged manifest + `onToolCall` funnel (and therefore
- * surfaces through `onToolCallComplete` / `useYakToolEvent`).
- *
- * The model authors a request from the OpenAPI spec you provide; the adapter hands it to your
- * `execute` callback, which runs it with whatever client you already use. Yak never constructs
- * the HTTP call — your client owns the base URL, auth, and transport.
- *
- * @example
- * ```ts
- * const billing = createRESTToolAdapter({
- *   name: "billing",
- *   spec: openapiSpec,
- *   execute: (req) => myApiClient(req.method, req.path, { query: req.query, body: req.body }),
- * });
- * ```
- */
-export function createRESTToolAdapter(config) {
-    const toolName = `rest_${config.name}`;
-    const specStr = typeof config.spec === "string" ? config.spec : JSON.stringify(config.spec, null, 2);
-    const tool = {
-        name: toolName,
-        description: `Make a REST API call to the ${config.name} API. Based on the OpenAPI spec below, ` +
-            "generate the appropriate request with method, path, query params, and body." +
-            `\n\nOpenAPI spec:\n\`\`\`json\n${specStr}\n\`\`\``,
-        inputSchema: REST_INPUT_SCHEMA,
-    };
-    return {
-        id: config.id ?? toolName,
-        getTools: () => [tool],
-        ownsTool: (name) => name === toolName,
-        execute: async (_name, args) => {
-            const request = (args ?? {});
-            // Hand a clean request to the caller's client — never forward the runtime-injected `_reason`.
-            return config.execute({
-                method: request.method,
-                path: request.path,
-                query: request.query,
-                body: request.body,
-            });
-        },
-    };
-}