@yak-io/graphql 0.1.2 → 0.2.0

package/dist/adapters.d.ts

@@ -3,8 +3,13 @@ import type { GraphQLRequest, ToolAdapter } from "@yak-io/javascript";
 export type GraphQLToolAdapterConfig = {
     /** Schema name — the tool is exposed to the LLM as `graphql_<name>`. */
     name: string;
-    /** GraphQL schema in SDL format. Embedded in the tool description so the LLM can author queries. */
-    schema: string;
+    /**
+     * GraphQL schema as SDL — either a literal string, or a resolver that returns it (sync or
+     * async). Use a resolver when your SDL comes from introspection or any other deferred source:
+     * it runs once on first `getTools()` and the resulting SDL is cached, so the network call is
+     * paid lazily, not at construction. A literal string is embedded eagerly with no async overhead.
+     */
+    schema: string | (() => string | Promise<string>);
     /**
      * Execute the LLM-authored GraphQL request with YOUR client. Yak builds the tool and the
      * request payload (query / variables / operationName) but never makes the call itself — your
@@ -33,6 +38,17 @@ export type GraphQLToolAdapterConfig = {
  *   execute: (req) => myGraphQLClient.request(req.query, req.variables),
  * });
  * ```
+ *
+ * @example
+ * ```ts
+ * // Lazy: resolve SDL from introspection once, on first use. The factory stays synchronous —
+ * // the network call is paid when the toolset first materializes its tools, then cached.
+ * const shop = createGraphQLToolAdapter({
+ *   name: "shop",
+ *   schema: async () => printSchema(buildClientSchema(await introspect(endpoint))),
+ *   execute: (req) => myGraphQLClient.request(req.query, req.variables),
+ * });
+ * ```
  */
 export declare function createGraphQLToolAdapter(config: GraphQLToolAdapterConfig): ToolAdapter;
 //# 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,EAAE,cAAc,EAAc,WAAW,EAAkB,MAAM,oBAAoB,CAAC;AAElG,mDAAmD;AACnD,MAAM,MAAM,wBAAwB,GAAG;IACrC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,oGAAoG;IACpG,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjE,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AA6BF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,WAAW,CA2BtF"}
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../src/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAc,WAAW,EAAkB,MAAM,oBAAoB,CAAC;AAElG,mDAAmD;AACnD,MAAM,MAAM,wBAAwB,GAAG;IACrC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAClD;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjE,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,WAAW,CA8CtF"}

package/dist/index.cjs

@@ -0,0 +1,86 @@
+"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, {
+  createGraphQLToolAdapter: () => createGraphQLToolAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters.ts
+var GRAPHQL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string",
+      description: "The GraphQL query or mutation string. Use $variableName syntax for all dynamic values."
+    },
+    variables: {
+      type: "object",
+      description: "Variables object with values for all $variableName references in the query.",
+      additionalProperties: true
+    },
+    operationName: {
+      type: "string",
+      description: "Optional operation name if the query contains multiple operations."
+    }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+function createGraphQLToolAdapter(config) {
+  const toolName = `graphql_${config.name}`;
+  const buildTool = (sdl) => ({
+    name: toolName,
+    description: `Execute a GraphQL query or mutation against the ${config.name} API. You MUST use GraphQL variables for all dynamic values \u2014 never hardcode values directly in the query string. Define variables with $variableName syntax and pass them in the variables object.
+
+Schema (SDL):
+\`\`\`graphql
+${sdl}
+\`\`\``,
+    inputSchema: GRAPHQL_INPUT_SCHEMA
+  });
+  const eager = typeof config.schema === "string" ? [buildTool(config.schema)] : void 0;
+  let pending;
+  return {
+    id: config.id ?? toolName,
+    getTools: () => {
+      if (eager) return eager;
+      if (!pending) {
+        const resolve = config.schema;
+        pending = Promise.resolve().then(resolve).then((sdl) => [buildTool(sdl)]);
+        pending.catch(() => {
+          pending = void 0;
+        });
+      }
+      return pending;
+    },
+    ownsTool: (name) => name === toolName,
+    execute: async (_name, args) => {
+      const request = args ?? {};
+      return config.execute({
+        query: request.query,
+        variables: request.variables,
+        operationName: request.operationName
+      });
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/adapters.ts"],
+  "sourcesContent": ["// GraphQL tool adapter for the yak client toolset\nexport { createGraphQLToolAdapter } from \"./adapters.js\";\nexport type { GraphQLToolAdapterConfig } from \"./adapters.js\";\n\n// Shared types from core\nexport type { GraphQLRequest, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n", "import type { GraphQLRequest, JSONSchema, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n\n/** Config for {@link createGraphQLToolAdapter}. */\nexport type GraphQLToolAdapterConfig = {\n  /** Schema name \u2014 the tool is exposed to the LLM as `graphql_<name>`. */\n  name: string;\n  /**\n   * GraphQL schema as SDL \u2014 either a literal string, or a resolver that returns it (sync or\n   * async). Use a resolver when your SDL comes from introspection or any other deferred source:\n   * it runs once on first `getTools()` and the resulting SDL is cached, so the network call is\n   * paid lazily, not at construction. A literal string is embedded eagerly with no async overhead.\n   */\n  schema: string | (() => string | Promise<string>);\n  /**\n   * Execute the LLM-authored GraphQL request with YOUR client. Yak builds the tool and the\n   * request payload (query / variables / operationName) but never makes the call itself \u2014 your\n   * client owns transport, auth, retries, and error handling. Use whatever you already have\n   * (Apollo, urql, graphql-request, a signed `fetch`, \u2026). Return the result the assistant should\n   * see (typically the `data` field); throw to surface an error to the model.\n   */\n  execute: (request: GraphQLRequest) => 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 GraphQL tool. The LLM authors the query + variables;\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 GRAPHQL_INPUT_SCHEMA: JSONSchema = {\n  type: \"object\",\n  properties: {\n    query: {\n      type: \"string\",\n      description:\n        \"The GraphQL query or mutation string. Use $variableName syntax for all dynamic values.\",\n    },\n    variables: {\n      type: \"object\",\n      description: \"Variables object with values for all $variableName references in the query.\",\n      additionalProperties: true,\n    },\n    operationName: {\n      type: \"string\",\n      description: \"Optional operation name if the query contains multiple operations.\",\n    },\n  },\n  required: [\"query\"],\n  additionalProperties: false,\n};\n\n/**\n * Create a GraphQL {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the\n * generated `graphql_<name>` tool joins the single merged manifest + `onToolCall` funnel\n * (and therefore surfaces through `onToolCallComplete` / `useYakToolEvent`).\n *\n * The model authors a query/mutation from the SDL you provide; the adapter hands the request\n * to your `execute` callback, which runs it with whatever client you already use. Yak never\n * constructs the HTTP call \u2014 your client owns the endpoint, auth, and transport.\n *\n * @example\n * ```ts\n * const shop = createGraphQLToolAdapter({\n *   name: \"shop\",\n *   schema: typeDefs,\n *   execute: (req) => myGraphQLClient.request(req.query, req.variables),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Lazy: resolve SDL from introspection once, on first use. The factory stays synchronous \u2014\n * // the network call is paid when the toolset first materializes its tools, then cached.\n * const shop = createGraphQLToolAdapter({\n *   name: \"shop\",\n *   schema: async () => printSchema(buildClientSchema(await introspect(endpoint))),\n *   execute: (req) => myGraphQLClient.request(req.query, req.variables),\n * });\n * ```\n */\nexport function createGraphQLToolAdapter(config: GraphQLToolAdapterConfig): ToolAdapter {\n  const toolName = `graphql_${config.name}`;\n\n  const buildTool = (sdl: string): ToolDefinition => ({\n    name: toolName,\n    description:\n      `Execute a GraphQL query or mutation against the ${config.name} API. ` +\n      \"You MUST use GraphQL variables for all dynamic values \u2014 never hardcode values directly in \" +\n      \"the query string. Define variables with $variableName syntax and pass them in the variables \" +\n      `object.\\n\\nSchema (SDL):\\n\\`\\`\\`graphql\\n${sdl}\\n\\`\\`\\``,\n    inputSchema: GRAPHQL_INPUT_SCHEMA,\n  });\n\n  // A literal SDL builds the tool eagerly (no async overhead, identical to before). A resolver\n  // runs once on first getTools() and the [tool] result is cached; a rejection is NOT cached, so\n  // a later getTools() can retry \u2014 a transient introspection failure doesn't wedge the toolset.\n  const eager = typeof config.schema === \"string\" ? [buildTool(config.schema)] : undefined;\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.schema as () => string | Promise<string>;\n        // Promise.resolve().then(resolve) so a synchronous throw also surfaces as a rejection.\n        pending = Promise.resolve()\n          .then(resolve)\n          .then((sdl) => [buildTool(sdl)]);\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 GraphQLRequest;\n      // Hand a clean request to the caller's client \u2014 never forward the runtime-injected `_reason`.\n      return config.execute({\n        query: request.query,\n        variables: request.variables,\n        operationName: request.operationName,\n      });\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;AC8BA,IAAM,uBAAmC;AAAA,EACvC,MAAM;AAAA,EACN,YAAY;AAAA,IACV,OAAO;AAAA,MACL,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,IACA,WAAW;AAAA,MACT,MAAM;AAAA,MACN,aAAa;AAAA,MACb,sBAAsB;AAAA,IACxB;AAAA,IACA,eAAe;AAAA,MACb,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,UAAU,CAAC,OAAO;AAAA,EAClB,sBAAsB;AACxB;AA+BO,SAAS,yBAAyB,QAA+C;AACtF,QAAM,WAAW,WAAW,OAAO,IAAI;AAEvC,QAAM,YAAY,CAAC,SAAiC;AAAA,IAClD,MAAM;AAAA,IACN,aACE,mDAAmD,OAAO,IAAI;AAAA;AAAA;AAAA;AAAA,EAGlB,GAAG;AAAA;AAAA,IACjD,aAAa;AAAA,EACf;AAKA,QAAM,QAAQ,OAAO,OAAO,WAAW,WAAW,CAAC,UAAU,OAAO,MAAM,CAAC,IAAI;AAC/E,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,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAC;AACjC,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,OAAO,QAAQ;AAAA,QACf,WAAW,QAAQ;AAAA,QACnB,eAAe,QAAQ;AAAA,MACzB,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/index.js

@@ -1,2 +1,63 @@
-// GraphQL tool adapter for the yak client toolset
-export { createGraphQLToolAdapter } from "./adapters.js";
+// src/adapters.ts
+var GRAPHQL_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    query: {
+      type: "string",
+      description: "The GraphQL query or mutation string. Use $variableName syntax for all dynamic values."
+    },
+    variables: {
+      type: "object",
+      description: "Variables object with values for all $variableName references in the query.",
+      additionalProperties: true
+    },
+    operationName: {
+      type: "string",
+      description: "Optional operation name if the query contains multiple operations."
+    }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+function createGraphQLToolAdapter(config) {
+  const toolName = `graphql_${config.name}`;
+  const buildTool = (sdl) => ({
+    name: toolName,
+    description: `Execute a GraphQL query or mutation against the ${config.name} API. You MUST use GraphQL variables for all dynamic values \u2014 never hardcode values directly in the query string. Define variables with $variableName syntax and pass them in the variables object.
+
+Schema (SDL):
+\`\`\`graphql
+${sdl}
+\`\`\``,
+    inputSchema: GRAPHQL_INPUT_SCHEMA
+  });
+  const eager = typeof config.schema === "string" ? [buildTool(config.schema)] : void 0;
+  let pending;
+  return {
+    id: config.id ?? toolName,
+    getTools: () => {
+      if (eager) return eager;
+      if (!pending) {
+        const resolve = config.schema;
+        pending = Promise.resolve().then(resolve).then((sdl) => [buildTool(sdl)]);
+        pending.catch(() => {
+          pending = void 0;
+        });
+      }
+      return pending;
+    },
+    ownsTool: (name) => name === toolName,
+    execute: async (_name, args) => {
+      const request = args ?? {};
+      return config.execute({
+        query: request.query,
+        variables: request.variables,
+        operationName: request.operationName
+      });
+    }
+  };
+}
+export {
+  createGraphQLToolAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/adapters.ts"],
+  "sourcesContent": ["import type { GraphQLRequest, JSONSchema, ToolAdapter, ToolDefinition } from \"@yak-io/javascript\";\n\n/** Config for {@link createGraphQLToolAdapter}. */\nexport type GraphQLToolAdapterConfig = {\n  /** Schema name \u2014 the tool is exposed to the LLM as `graphql_<name>`. */\n  name: string;\n  /**\n   * GraphQL schema as SDL \u2014 either a literal string, or a resolver that returns it (sync or\n   * async). Use a resolver when your SDL comes from introspection or any other deferred source:\n   * it runs once on first `getTools()` and the resulting SDL is cached, so the network call is\n   * paid lazily, not at construction. A literal string is embedded eagerly with no async overhead.\n   */\n  schema: string | (() => string | Promise<string>);\n  /**\n   * Execute the LLM-authored GraphQL request with YOUR client. Yak builds the tool and the\n   * request payload (query / variables / operationName) but never makes the call itself \u2014 your\n   * client owns transport, auth, retries, and error handling. Use whatever you already have\n   * (Apollo, urql, graphql-request, a signed `fetch`, \u2026). Return the result the assistant should\n   * see (typically the `data` field); throw to surface an error to the model.\n   */\n  execute: (request: GraphQLRequest) => 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 GraphQL tool. The LLM authors the query + variables;\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 GRAPHQL_INPUT_SCHEMA: JSONSchema = {\n  type: \"object\",\n  properties: {\n    query: {\n      type: \"string\",\n      description:\n        \"The GraphQL query or mutation string. Use $variableName syntax for all dynamic values.\",\n    },\n    variables: {\n      type: \"object\",\n      description: \"Variables object with values for all $variableName references in the query.\",\n      additionalProperties: true,\n    },\n    operationName: {\n      type: \"string\",\n      description: \"Optional operation name if the query contains multiple operations.\",\n    },\n  },\n  required: [\"query\"],\n  additionalProperties: false,\n};\n\n/**\n * Create a GraphQL {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the\n * generated `graphql_<name>` tool joins the single merged manifest + `onToolCall` funnel\n * (and therefore surfaces through `onToolCallComplete` / `useYakToolEvent`).\n *\n * The model authors a query/mutation from the SDL you provide; the adapter hands the request\n * to your `execute` callback, which runs it with whatever client you already use. Yak never\n * constructs the HTTP call \u2014 your client owns the endpoint, auth, and transport.\n *\n * @example\n * ```ts\n * const shop = createGraphQLToolAdapter({\n *   name: \"shop\",\n *   schema: typeDefs,\n *   execute: (req) => myGraphQLClient.request(req.query, req.variables),\n * });\n * ```\n *\n * @example\n * ```ts\n * // Lazy: resolve SDL from introspection once, on first use. The factory stays synchronous \u2014\n * // the network call is paid when the toolset first materializes its tools, then cached.\n * const shop = createGraphQLToolAdapter({\n *   name: \"shop\",\n *   schema: async () => printSchema(buildClientSchema(await introspect(endpoint))),\n *   execute: (req) => myGraphQLClient.request(req.query, req.variables),\n * });\n * ```\n */\nexport function createGraphQLToolAdapter(config: GraphQLToolAdapterConfig): ToolAdapter {\n  const toolName = `graphql_${config.name}`;\n\n  const buildTool = (sdl: string): ToolDefinition => ({\n    name: toolName,\n    description:\n      `Execute a GraphQL query or mutation against the ${config.name} API. ` +\n      \"You MUST use GraphQL variables for all dynamic values \u2014 never hardcode values directly in \" +\n      \"the query string. Define variables with $variableName syntax and pass them in the variables \" +\n      `object.\\n\\nSchema (SDL):\\n\\`\\`\\`graphql\\n${sdl}\\n\\`\\`\\``,\n    inputSchema: GRAPHQL_INPUT_SCHEMA,\n  });\n\n  // A literal SDL builds the tool eagerly (no async overhead, identical to before). A resolver\n  // runs once on first getTools() and the [tool] result is cached; a rejection is NOT cached, so\n  // a later getTools() can retry \u2014 a transient introspection failure doesn't wedge the toolset.\n  const eager = typeof config.schema === \"string\" ? [buildTool(config.schema)] : undefined;\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.schema as () => string | Promise<string>;\n        // Promise.resolve().then(resolve) so a synchronous throw also surfaces as a rejection.\n        pending = Promise.resolve()\n          .then(resolve)\n          .then((sdl) => [buildTool(sdl)]);\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 GraphQLRequest;\n      // Hand a clean request to the caller's client \u2014 never forward the runtime-injected `_reason`.\n      return config.execute({\n        query: request.query,\n        variables: request.variables,\n        operationName: request.operationName,\n      });\n    },\n  };\n}\n"],
+  "mappings": ";AA8BA,IAAM,uBAAmC;AAAA,EACvC,MAAM;AAAA,EACN,YAAY;AAAA,IACV,OAAO;AAAA,MACL,MAAM;AAAA,MACN,aACE;AAAA,IACJ;AAAA,IACA,WAAW;AAAA,MACT,MAAM;AAAA,MACN,aAAa;AAAA,MACb,sBAAsB;AAAA,IACxB;AAAA,IACA,eAAe;AAAA,MACb,MAAM;AAAA,MACN,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,UAAU,CAAC,OAAO;AAAA,EAClB,sBAAsB;AACxB;AA+BO,SAAS,yBAAyB,QAA+C;AACtF,QAAM,WAAW,WAAW,OAAO,IAAI;AAEvC,QAAM,YAAY,CAAC,SAAiC;AAAA,IAClD,MAAM;AAAA,IACN,aACE,mDAAmD,OAAO,IAAI;AAAA;AAAA;AAAA;AAAA,EAGlB,GAAG;AAAA;AAAA,IACjD,aAAa;AAAA,EACf;AAKA,QAAM,QAAQ,OAAO,OAAO,WAAW,WAAW,CAAC,UAAU,OAAO,MAAM,CAAC,IAAI;AAC/E,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,QAAQ,CAAC,UAAU,GAAG,CAAC,CAAC;AACjC,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,OAAO,QAAQ;AAAA,QACf,WAAW,QAAQ;AAAA,QACnB,eAAe,QAAQ;AAAA,MACzB,CAAC;AAAA,IACH;AAAA,EACF;AACF;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yak-io/graphql",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "GraphQL adapter for yak chatbot - exposes a GraphQL API as a chatbot tool",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -29,19 +29,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",
@@ -50,7 +51,7 @@
   },
   "homepage": "https://docs.yak.io/docs/tool-adapters/graphql",
   "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 GraphQL tool. The LLM authors the query + variables;
- * 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 GRAPHQL_INPUT_SCHEMA = {
-    type: "object",
-    properties: {
-        query: {
-            type: "string",
-            description: "The GraphQL query or mutation string. Use $variableName syntax for all dynamic values.",
-        },
-        variables: {
-            type: "object",
-            description: "Variables object with values for all $variableName references in the query.",
-            additionalProperties: true,
-        },
-        operationName: {
-            type: "string",
-            description: "Optional operation name if the query contains multiple operations.",
-        },
-    },
-    required: ["query"],
-    additionalProperties: false,
-};
-/**
- * Create a GraphQL {@link ToolAdapter}. Compose it into a {@link createYakToolset} so the
- * generated `graphql_<name>` tool joins the single merged manifest + `onToolCall` funnel
- * (and therefore surfaces through `onToolCallComplete` / `useYakToolEvent`).
- *
- * The model authors a query/mutation from the SDL you provide; the adapter hands the request
- * to your `execute` callback, which runs it with whatever client you already use. Yak never
- * constructs the HTTP call — your client owns the endpoint, auth, and transport.
- *
- * @example
- * ```ts
- * const shop = createGraphQLToolAdapter({
- *   name: "shop",
- *   schema: typeDefs,
- *   execute: (req) => myGraphQLClient.request(req.query, req.variables),
- * });
- * ```
- */
-export function createGraphQLToolAdapter(config) {
-    const toolName = `graphql_${config.name}`;
-    const tool = {
-        name: toolName,
-        description: `Execute a GraphQL query or mutation against the ${config.name} API. ` +
-            "You MUST use GraphQL variables for all dynamic values — never hardcode values directly in " +
-            "the query string. Define variables with $variableName syntax and pass them in the variables " +
-            `object.\n\nSchema (SDL):\n\`\`\`graphql\n${config.schema}\n\`\`\``,
-        inputSchema: GRAPHQL_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({
-                query: request.query,
-                variables: request.variables,
-                operationName: request.operationName,
-            });
-        },
-    };
-}