@drupalmcp/adk 0.1.1 → 0.2.1

package/README.md

@@ -37,9 +37,16 @@ unreachable. `drupalTools()` rewrites both on the way through. You can use
 the rewrite on its own with `normaliseSchema()`.
 
 **Explains a refusal.** A call the credential may not make comes back as
-HTTP 403 with a challenge naming the missing scope. The MCP client drops
-that header, so the library keeps it and gives the model a sentence that
-says what happened and that retrying will not help.
+HTTP 403 with a challenge naming the missing scope. That header is dropped
+before the error reaches you, so the library keeps it and gives the model a
+sentence that says what happened and that retrying will not help.
+
+**Resolves its dependencies once, at import.** The tools are built on the
+protocol SDK directly rather than on the agent kit's own MCP toolset, which
+looks the SDK up lazily at the first tool call from whatever directory it
+happens to be running in. That lookup fails inside the dev server's temporary
+build folder, reporting a missing dependency that is sitting in
+`node_modules`. Importing at the top of the file cannot fail that way.
 
 ## Agents defined in Drupal
 
@@ -65,6 +72,11 @@ is how a tone-of-voice rule reaches an agent running outside Drupal.
 long a definition is reused; it defaults to ten seconds and zero re-reads
 every turn.
 
+If the site has no such agent, the call refuses and says where to look rather
+than failing obscurely. Keep these agents in their own folder: the ADK dev
+server loads every agent in the directory you point it at, and one that cannot
+reach its definition will report that at startup.
+
 ## Choosing what the agent can reach
 
 ```ts

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { MCPToolset } from '@google/adk/tools/mcp';
-import { LlmAgent } from '@google/adk';
+import { BaseToolset, ReadonlyContext, BaseTool, LlmAgent } from '@google/adk';
 
 /**
  * OAuth 2 client credentials against a Drupal site running drupal/mcp.
@@ -59,6 +58,14 @@ declare class DrupalOAuth {
 
 /**
  * The Drupal site's MCP tools, ready to hand to an ADK agent.
+ *
+ * These are built on the protocol SDK directly rather than on the agent kit's
+ * own MCP toolset. The kit resolves the SDK lazily at the moment of the first
+ * tool call, from whatever directory it happens to be running in, and when its
+ * dev server transpiles an agent into a temporary folder that lookup can fail
+ * with a message claiming the SDK is not installed. Importing it here, at the
+ * top of the file, means it is resolved once when this module loads, and
+ * bundled with the agent by anything that bundles.
  */
 
 interface DrupalToolsOptions {
@@ -86,10 +93,41 @@ interface DrupalToolsOptions {
  *
  * The bearer token is attached per request rather than frozen into the
  * transport, so a token expiring mid-conversation is replaced without the
- * agent noticing. Tool schemas are rewritten on the way through; see
- * {@link normaliseSchema}.
+ * agent noticing.
+ */
+declare function drupalTools(options: DrupalToolsOptions): DrupalToolset;
+/**
+ * An ADK toolset backed by one MCP session against a Drupal site.
  */
-declare function drupalTools(options: DrupalToolsOptions): MCPToolset;
+declare class DrupalToolset extends BaseToolset {
+    private readonly baseUrl;
+    private readonly auth;
+    private readonly only;
+    private readonly except;
+    private readonly namePrefix;
+    /** The last authentication challenge the site sent, if any. */
+    private challenge;
+    private client;
+    private connecting;
+    constructor(options: DrupalToolsOptions);
+    /**
+     * {@inheritdoc}
+     */
+    getTools(_context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * {@inheritdoc}
+     */
+    close(): Promise<void>;
+    /**
+     * Runs one tool, translating a refusal into something the model can use.
+     *
+     * @internal
+     */
+    call(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** The connected client, opening the session on first use. */
+    private connect;
+    private open;
+}
 
 /**
  * Agents defined in Drupal, running in ADK.
@@ -209,6 +247,6 @@ declare function scopeFromChallenge(challenge: string | null | undefined): strin
 declare function describeRefusal(error: unknown): string | null;
 
 /** Kept in step with package.json; sent as the user agent. */
-declare const VERSION = "0.1.1";
+declare const VERSION = "0.2.1";
 
 export { AUTHENTICATION_REQUIRED_CODE, type AgentDefinition, type AgentSummary, type DrupalAgentOptions, DrupalOAuth, type DrupalOAuthOptions, type DrupalToolsOptions, INSUFFICIENT_SCOPE_CODE, type JsonSchema, VERSION, describeRefusal, drupalAgent, drupalTools, listAgents, normaliseSchema, promptFrom, scopeFromChallenge };

package/dist/index.js

@@ -100,7 +100,9 @@ var DrupalOAuth = class _DrupalOAuth {
 };
 
 // src/toolset.ts
-import { MCPToolset } from "@google/adk/tools/mcp";
+import { BaseTool, BaseToolset } from "@google/adk";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/errors.ts
 var INSUFFICIENT_SCOPE_CODE = -32002;
@@ -147,6 +149,9 @@ function messageOf(error) {
   return "";
 }
 
+// src/gemini-schema.ts
+import { Type } from "@google/genai";
+
 // src/schema.ts
 var SCHEMA_VALUED_KEYS = ["items", "additionalProperties", "not", "if", "then", "else"];
 var SCHEMA_MAP_KEYS = ["properties", "patternProperties", "definitions", "$defs"];
@@ -193,79 +198,198 @@ function walk(node, isProperty) {
   return result;
 }
 
+// src/gemini-schema.ts
+var TYPES = {
+  string: Type.STRING,
+  number: Type.NUMBER,
+  integer: Type.INTEGER,
+  boolean: Type.BOOLEAN,
+  array: Type.ARRAY,
+  object: Type.OBJECT,
+  null: Type.NULL
+};
+function toGeminiSchema(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
+  }
+  return convert(normaliseSchema(input));
+}
+function convert(node) {
+  const branches = Array.isArray(node.anyOf) ? node.anyOf : null;
+  let source = node;
+  let nullable = false;
+  if (branches) {
+    const real = branches.filter((b) => b?.type !== "null");
+    nullable = real.length !== branches.length;
+    if (real.length === 1) {
+      const { anyOf: _drop, ...rest } = node;
+      source = { ...rest, ...real[0] };
+    }
+  }
+  const declared = typeof source.type === "string" ? source.type : inferType(source);
+  const schema = { type: TYPES[declared] ?? Type.STRING };
+  if (nullable || source.nullable === true) {
+    schema.nullable = true;
+  }
+  if (typeof source.description === "string") {
+    schema.description = source.description;
+  } else if (typeof source.title === "string") {
+    schema.description = source.title;
+  }
+  if (Array.isArray(source.enum) && source.enum.every((v) => typeof v === "string")) {
+    schema.enum = source.enum;
+  }
+  if (schema.type === Type.OBJECT) {
+    const properties = source.properties;
+    if (properties) {
+      schema.properties = Object.fromEntries(
+        Object.entries(properties).map(([name, value]) => [name, convert(value)])
+      );
+    }
+    const required = source.required?.filter(
+      (name) => !properties || name in properties
+    );
+    if (required?.length) {
+      schema.required = required;
+    }
+  }
+  if (schema.type === Type.ARRAY) {
+    schema.items = source.items ? convert(source.items) : { type: Type.STRING };
+  }
+  return schema;
+}
+function inferType(node) {
+  if (node.properties) return "object";
+  if (node.items) return "array";
+  if (Array.isArray(node.enum)) return "string";
+  return "string";
+}
+
 // src/version.ts
-var VERSION = "0.1.1";
+var VERSION = "0.2.1";
 
 // src/toolset.ts
 function drupalTools(options) {
-  const { auth, only, except, prefix } = options;
-  const baseUrl = (options.baseUrl ?? auth.baseUrl).replace(/\/+$/, "");
-  const lastChallenge = { value: null };
-  const toolset = new MCPToolset(
-    {
-      type: "StreamableHTTPConnectionParams",
-      url: `${baseUrl}/mcp`,
-      transportOptions: {
-        fetch: async (input, init) => {
-          const headers = new Headers(init?.headers);
-          headers.set("authorization", `Bearer ${await auth.token()}`);
-          headers.set("user-agent", `drupalmcp-adk/${VERSION}`);
-          const response = await globalThis.fetch(input, { ...init, headers });
-          const challenge = response.headers.get("www-authenticate");
-          if (challenge) {
-            lastChallenge.value = challenge;
-          }
-          return response;
-        }
-      }
-    },
-    toolFilter(only, except),
-    prefix
-  );
-  return prepareTools(toolset, lastChallenge);
+  return new DrupalToolset(options);
 }
-function prepareTools(toolset, lastChallenge) {
-  const listTools = toolset.getTools.bind(toolset);
-  toolset.getTools = async (...args) => {
-    const tools = await listTools(...args);
-    for (const tool of tools) {
-      const carrier = tool;
-      if (carrier.mcpTool?.inputSchema) {
-        carrier.mcpTool.inputSchema = normaliseSchema(carrier.mcpTool.inputSchema);
+var DrupalToolset = class extends BaseToolset {
+  baseUrl;
+  auth;
+  only;
+  except;
+  namePrefix;
+  /** The last authentication challenge the site sent, if any. */
+  challenge = null;
+  client = null;
+  connecting = null;
+  constructor(options) {
+    super(options.only ?? [], options.prefix);
+    this.auth = options.auth;
+    this.baseUrl = (options.baseUrl ?? options.auth.baseUrl).replace(/\/+$/, "");
+    this.only = options.only?.length ? new Set(options.only) : null;
+    this.except = new Set(options.except ?? []);
+    this.namePrefix = options.prefix ?? "";
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async getTools(_context) {
+    const client = await this.connect();
+    const listed = (await client.listTools()).tools;
+    return listed.filter((tool) => !this.except.has(tool.name) && (this.only === null || this.only.has(tool.name))).map((tool) => new DrupalTool(tool, this, this.namePrefix));
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async close() {
+    const client = this.client;
+    this.client = null;
+    this.connecting = null;
+    await client?.close().catch(() => void 0);
+  }
+  /**
+   * Runs one tool, translating a refusal into something the model can use.
+   *
+   * @internal
+   */
+  async call(name, args) {
+    const client = await this.connect();
+    try {
+      return await client.callTool({ name, arguments: args });
+    } catch (error) {
+      const explained = describeRefusal(error) ?? describeRefusal(this.challenge);
+      if (!explained) {
+        throw error;
       }
-      const run = carrier.runAsync.bind(carrier);
-      carrier.runAsync = async (request) => {
-        try {
-          return await run(request);
-        } catch (error) {
-          const explained = describeRefusal(error) ?? describeRefusal(lastChallenge.value);
-          if (!explained) {
-            throw error;
-          }
-          const scope = scopeFromChallenge(lastChallenge.value);
-          throw new Error(scope && !explained.includes(scope) ? withScope(explained, scope) : explained);
-        }
-      };
+      const scope = scopeFromChallenge(this.challenge);
+      throw new Error(
+        scope && !explained.includes(scope) ? explained.replace("is not allowed to do that", `does not hold the ${scope} scope`) : explained
+      );
     }
-    return tools;
-  };
-  return toolset;
-}
-function toolFilter(only, except) {
-  if (!except?.length) {
-    return only;
   }
-  const blocked = new Set(except);
-  const wanted = only ? new Set(only) : null;
-  return (tool) => !blocked.has(tool.name) && (wanted === null || wanted.has(tool.name));
-}
-function withScope(message, scope) {
-  return message.replace("is not allowed to do that", `does not hold the ${scope} scope`);
-}
+  /** The connected client, opening the session on first use. */
+  async connect() {
+    if (this.client) {
+      return this.client;
+    }
+    this.connecting ??= this.open().finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  async open() {
+    const client = new Client({ name: "drupalmcp-adk", version: VERSION }, { capabilities: {} });
+    const transport = new StreamableHTTPClientTransport(new URL(`${this.baseUrl}/mcp`), {
+      fetch: async (input, init) => {
+        const headers = new Headers(init?.headers);
+        headers.set("authorization", `Bearer ${await this.auth.token()}`);
+        headers.set("user-agent", `drupalmcp-adk/${VERSION}`);
+        const response = await globalThis.fetch(input, { ...init, headers });
+        const challenge = response.headers.get("www-authenticate");
+        if (challenge) {
+          this.challenge = challenge;
+        }
+        return response;
+      }
+    });
+    await client.connect(transport);
+    this.client = client;
+    return client;
+  }
+};
+var DrupalTool = class extends BaseTool {
+  constructor(definition, toolset, prefix) {
+    super({
+      name: prefix + definition.name,
+      description: definition.description ?? definition.name
+    });
+    this.definition = definition;
+    this.toolset = toolset;
+  }
+  definition;
+  toolset;
+  /**
+   * {@inheritdoc}
+   */
+  _getDeclaration() {
+    const parameters = toGeminiSchema(this.definition.inputSchema);
+    return {
+      name: this.name,
+      description: this.description,
+      ...parameters ? { parameters } : {}
+    };
+  }
+  /**
+   * {@inheritdoc}
+   */
+  async runAsync(request) {
+    return this.toolset.call(this.definition.name, request.args ?? {});
+  }
+};
 
 // src/agents.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { LlmAgent } from "@google/adk";
 var LIST_URI = "drupal://agents";
 var DEFAULT_CACHE_MS = 1e4;
@@ -329,11 +453,11 @@ var DefinitionReader = class {
   }
   /** Whatever the site publishes at this resource URI, parsed as JSON. */
   async readUri(uri) {
-    const client = new Client(
+    const client = new Client2(
       { name: "drupalmcp-adk", version: VERSION },
       { capabilities: {} }
     );
-    const transport = new StreamableHTTPClientTransport(new URL(`${this.baseUrl}/mcp`), {
+    const transport = new StreamableHTTPClientTransport2(new URL(`${this.baseUrl}/mcp`), {
       fetch: async (input, init) => {
         const headers = new Headers(init?.headers);
         headers.set("authorization", `Bearer ${await this.auth.token()}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drupalmcp/adk",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Use a Drupal site from a Google ADK agent: OAuth, scoped MCP tools, and agents defined in Drupal.",
   "license": "Apache-2.0",
   "type": "module",