@drupalmcp/adk 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# @drupalmcp/adk
+
+Use a Drupal site from a [Google ADK](https://adk.dev) agent: OAuth
+credentials, the site's tools, and the refusals that keep an agent honest.
+
+```bash
+npm install @drupalmcp/adk @google/adk
+```
+
+```ts
+import { LlmAgent } from '@google/adk';
+import { DrupalOAuth, drupalTools } from '@drupalmcp/adk';
+
+export const rootAgent = new LlmAgent({
+  name: 'site_editor',
+  model: 'gemini-flash-latest',
+  instruction: 'Help with the Drupal site.',
+  tools: [drupalTools({ auth: DrupalOAuth.fromEnv() })],
+});
+```
+
+`DrupalOAuth.fromEnv()` reads `DRUPAL_BASE_URL`, `DRUPAL_CLIENT_ID`,
+`DRUPAL_CLIENT_SECRET` and the optional `DRUPAL_SCOPES`. The site prints the
+first three when you run `drush mcp:setup`.
+
+## What it does for you
+
+**Keeps the token fresh.** Drupal's access tokens last five minutes by
+default. The bearer is attached per request, so a token expiring in the
+middle of a conversation is replaced without the agent noticing.
+
+**Makes the tool schemas readable.** Drupal describes an optional parameter
+as `oneOf: [{type: 'string'}, {type: 'null'}]`, and an entity parameter with
+no type at all. Gemini understands neither, so those parameters arrive
+untyped and the model cannot fill them in: the whole write path is
+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.
+
+## Agents defined in Drupal
+
+If the site has the [MCP Agents](https://www.drupal.org/project/mcp) module,
+an agent's instructions can live in Drupal rather than in this file:
+
+```ts
+import { DrupalOAuth, drupalAgent } from '@drupalmcp/adk';
+
+export const rootAgent = await drupalAgent({
+  auth: DrupalOAuth.fromEnv(),
+  id: 'site_editor',
+});
+```
+
+The definition is read again on every turn, so editing the prompt at
+Configuration → AI → Tools and automation → Agents changes the next answer
+with nothing restarted. If the site also runs the Context Control Center,
+whatever context it selects for that agent is appended under a heading, which
+is how a tone-of-voice rule reaches an agent running outside Drupal.
+
+`listAgents(auth)` returns what the site publishes. `cacheMs` controls how
+long a definition is reused; it defaults to ten seconds and zero re-reads
+every turn.
+
+## Choosing what the agent can reach
+
+```ts
+drupalTools({ auth, only: ['tool_api__tool_belt_entity_list'] });
+```
+
+`only` narrows the tool list. It is a convenience, not a boundary: what the
+agent may actually do is decided by the credential's scopes on the server.
+
+Apache-2.0. Part of [drupalmcp-ts](https://github.com/Omedia/drupalmcp-ts).

package/dist/index.d.ts

@@ -0,0 +1,208 @@
+import { MCPToolset } from '@google/adk/tools/mcp';
+import { LlmAgent } from '@google/adk';
+
+/**
+ * OAuth 2 client credentials against a Drupal site running drupal/mcp.
+ *
+ * An agent runs unattended, so it authenticates as itself rather than as a
+ * person: the site's `agent-draft` and `agent-publish` clients each hold a
+ * fixed set of scopes, and what the agent may do is decided by which one you
+ * hand it. See https://drupalmcp.io/connecting-a-client/.
+ */
+interface DrupalOAuthOptions {
+    /** Site root, with or without a trailing slash: `https://example.com`. */
+    baseUrl: string;
+    clientId: string;
+    clientSecret: string;
+    /**
+     * Scopes to request. Omit to take everything the client is granted, which
+     * is the usual case: the client is the credential, and its scopes are the
+     * boundary.
+     */
+    scopes?: string[];
+    /** Replace for tests, proxies, or a custom agent. Defaults to global fetch. */
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Mints and caches one access token.
+ *
+ * A token lasts five minutes by default, so it is refreshed rather than held:
+ * every call goes through {@link token}, which returns the cached one until it
+ * is nearly expired. Concurrent callers share a single in-flight request.
+ */
+declare class DrupalOAuth {
+    readonly baseUrl: string;
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly scopes;
+    private readonly fetchImpl;
+    private accessToken;
+    private expiresAt;
+    private granted;
+    private inFlight;
+    constructor(options: DrupalOAuthOptions);
+    /**
+     * Reads the four standard variables, so an agent file stays free of secrets.
+     *
+     * `DRUPAL_BASE_URL`, `DRUPAL_CLIENT_ID`, `DRUPAL_CLIENT_SECRET` and the
+     * optional `DRUPAL_SCOPES` (space or comma separated).
+     */
+    static fromEnv(env?: NodeJS.ProcessEnv): DrupalOAuth;
+    /** The scopes the site granted, known only after the first token. */
+    get grantedScopes(): string[];
+    /** A valid access token, minted or from cache. */
+    token(): Promise<string>;
+    /** Drops the cached token so the next call mints a fresh one. */
+    forget(): void;
+    private mint;
+}
+
+/**
+ * The Drupal site's MCP tools, ready to hand to an ADK agent.
+ */
+
+interface DrupalToolsOptions {
+    /** Site root. Defaults to the auth client's own base URL. */
+    baseUrl?: string;
+    /** The credential. Build one with `DrupalOAuth.fromEnv()`. */
+    auth: DrupalOAuth;
+    /**
+     * Restrict the agent to these MCP tool names, for example
+     * `['tool_api__tool_belt_entity_list']`. Omit to expose everything the
+     * site publishes; the credential's scopes still decide what may run.
+     */
+    only?: string[];
+    /** Prefix added to every tool name, for telling two sites apart. */
+    prefix?: string;
+}
+/**
+ * Connects to `{baseUrl}/mcp` and returns the tools it publishes.
+ *
+ * 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}.
+ */
+declare function drupalTools(options: DrupalToolsOptions): MCPToolset;
+
+/**
+ * Agents defined in Drupal, running in ADK.
+ *
+ * The site holds the definition: what the agent is for, how it should behave,
+ * and whatever context the Context Control Center attaches to it. This module
+ * reads that definition and re-reads it every turn, so editing the prompt in
+ * the Drupal admin changes the next answer without restarting anything.
+ *
+ * Drupal never calls a model. It holds the definition; ADK runs it.
+ */
+
+interface AgentDefinition {
+    id: string;
+    label: string;
+    description: string;
+    /** What the agent should do, as typed into the Drupal admin. */
+    instruction: string;
+    /** Context selected for this agent, or an empty string if there is none. */
+    context: string;
+    /** Changes whenever the instruction or the context does. */
+    version: string;
+}
+interface AgentSummary {
+    id: string;
+    label: string;
+    description: string;
+    has_context: boolean;
+}
+interface DrupalAgentOptions {
+    /** Site root. Defaults to the auth client's own base URL. */
+    baseUrl?: string;
+    auth: DrupalOAuth;
+    /** The agent's machine name in Drupal, for example `site_editor`. */
+    id: string;
+    /** Any ADK model. Defaults to `gemini-flash-latest`. */
+    model?: string;
+    /** Restrict the tools handed to this agent. See `drupalTools`. */
+    only?: string[];
+    /** How long to reuse a definition, in milliseconds. Zero re-reads always. */
+    cacheMs?: number;
+}
+/**
+ * Builds an ADK agent from a definition held in Drupal.
+ *
+ * The instruction is a provider rather than a string, so it is fetched again
+ * on every turn. A short cache keeps a burst of turns from hammering the
+ * site while still picking an edit up within seconds, which is what makes
+ * "change it in Drupal, ask again" work in front of an audience.
+ */
+declare function drupalAgent(options: DrupalAgentOptions): Promise<LlmAgent>;
+/**
+ * Every agent the site publishes.
+ */
+declare function listAgents(auth: DrupalOAuth, baseUrl?: string): Promise<AgentSummary[]>;
+/**
+ * The instruction and the context, as one prompt.
+ *
+ * The context is fenced and labelled so the model can tell the two apart: the
+ * instruction is what the agent is, the context is what the site wants it to
+ * keep in mind today.
+ */
+declare function promptFrom(definition: AgentDefinition): string;
+
+/**
+ * Makes Drupal's tool schemas legible to Gemini.
+ *
+ * Drupal's Tool API describes an optional parameter as a choice between a type
+ * and null: `{oneOf: [{type: 'string'}, {type: 'null'}]}`. That is correct
+ * JSON Schema, but ADK's converter only understands `type` and `anyOf`, so a
+ * `oneOf` property arrives at the model with no type at all and the model
+ * cannot fill it in. `anyOf` says exactly the same thing in a dialect both
+ * sides read, and ADK then folds the null branch into `nullable: true`.
+ *
+ * The second problem is a property with no type at all. Drupal emits one for
+ * every entity parameter, because its typed-data system has no JSON Schema for
+ * an entity and says so in a `$comment`. On the wire that parameter is a
+ * string: the handle (`handle:<uuid>`) that `entity_stub` and
+ * `entity_load_by_id` hand back. Without a type the model cannot fill it, so
+ * the whole write path is unreachable. Where ADK's own inference gives up, a
+ * string is both the safe default and, here, the right answer.
+ *
+ * Nothing else is touched: this is a translation, not a repair.
+ */
+/** A JSON Schema fragment, as loose as the wire allows. */
+type JsonSchema = Record<string, unknown>;
+/**
+ * Rewrites a tool's input schema into the dialect ADK reads.
+ *
+ * Returns a new object; the input is never mutated. A schema that already has
+ * `anyOf` keeps it and its `oneOf` branches are appended, which cannot happen
+ * with anything Drupal emits but would otherwise lose information.
+ */
+declare function normaliseSchema<T>(schema: T): T;
+
+/**
+ * Turns the site's refusals into sentences an agent can repeat truthfully.
+ *
+ * When a credential lacks the scope a tool needs, drupal/mcp answers HTTP 403
+ * with JSON-RPC code -32002, the message `insufficient_scope`, and a
+ * `WWW-Authenticate` header naming the scope that was missing. Left raw, a
+ * model tends to either retry forever or tell the user it published something.
+ * Rewritten, it says what happened and stops.
+ */
+/** JSON-RPC code drupal/mcp uses for a scope refusal. */
+declare const INSUFFICIENT_SCOPE_CODE = -32002;
+/** JSON-RPC code drupal/mcp uses when no usable credential was presented. */
+declare const AUTHENTICATION_REQUIRED_CODE = -32001;
+/** Pulls `scope="mcp:publish"` out of a WWW-Authenticate challenge. */
+declare function scopeFromChallenge(challenge: string | null | undefined): string | null;
+/**
+ * Describes a refusal in plain words, or returns null if this is not one.
+ *
+ * @param error
+ *   Anything thrown or returned by a tool call.
+ */
+declare function describeRefusal(error: unknown): string | null;
+
+/** Kept in step with package.json; sent as the user agent. */
+declare const VERSION = "0.1.0";
+
+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

@@ -0,0 +1,371 @@
+// src/auth.ts
+var REFRESH_SKEW_SECONDS = 30;
+var DEFAULT_LIFETIME_SECONDS = 300;
+var DrupalOAuth = class _DrupalOAuth {
+  baseUrl;
+  clientId;
+  clientSecret;
+  scopes;
+  fetchImpl;
+  accessToken = null;
+  expiresAt = 0;
+  granted = [];
+  inFlight = null;
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("DrupalOAuth needs a baseUrl, for example https://example.com");
+    }
+    if (!options.clientId || !options.clientSecret) {
+      throw new Error(
+        "DrupalOAuth needs a clientId and clientSecret. Run `drush mcp:setup --rotate-secrets` on the site to get a fresh pair."
+      );
+    }
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+    this.scopes = options.scopes;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+  }
+  /**
+   * Reads the four standard variables, so an agent file stays free of secrets.
+   *
+   * `DRUPAL_BASE_URL`, `DRUPAL_CLIENT_ID`, `DRUPAL_CLIENT_SECRET` and the
+   * optional `DRUPAL_SCOPES` (space or comma separated).
+   */
+  static fromEnv(env = process.env) {
+    const scopes = env.DRUPAL_SCOPES?.split(/[\s,]+/).filter(Boolean);
+    return new _DrupalOAuth({
+      baseUrl: env.DRUPAL_BASE_URL ?? "",
+      clientId: env.DRUPAL_CLIENT_ID ?? "",
+      clientSecret: env.DRUPAL_CLIENT_SECRET ?? "",
+      ...scopes?.length ? { scopes } : {}
+    });
+  }
+  /** The scopes the site granted, known only after the first token. */
+  get grantedScopes() {
+    return [...this.granted];
+  }
+  /** A valid access token, minted or from cache. */
+  async token() {
+    const now = Date.now() / 1e3;
+    if (this.accessToken && now < this.expiresAt - REFRESH_SKEW_SECONDS) {
+      return this.accessToken;
+    }
+    this.inFlight ??= this.mint().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  /** Drops the cached token so the next call mints a fresh one. */
+  forget() {
+    this.accessToken = null;
+    this.expiresAt = 0;
+  }
+  async mint() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.clientId,
+      client_secret: this.clientSecret
+    });
+    if (this.scopes?.length) {
+      body.set("scope", this.scopes.join(" "));
+    }
+    const response = await this.fetchImpl(`${this.baseUrl}/oauth/token`, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(
+        `Drupal refused the client credentials (HTTP ${response.status}): ${text.slice(0, 300)}`
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(
+        `The token endpoint answered with something that is not JSON. Check that ${this.baseUrl} is the site root: ${text.slice(0, 200)}`
+      );
+    }
+    if (!data.access_token) {
+      throw new Error(`The token endpoint returned no access_token: ${text.slice(0, 200)}`);
+    }
+    this.accessToken = data.access_token;
+    this.expiresAt = Date.now() / 1e3 + (data.expires_in ?? DEFAULT_LIFETIME_SECONDS);
+    this.granted = data.scope ? data.scope.split(/\s+/).filter(Boolean) : [];
+    return this.accessToken;
+  }
+};
+
+// src/toolset.ts
+import { MCPToolset } from "@google/adk/tools/mcp";
+
+// src/errors.ts
+var INSUFFICIENT_SCOPE_CODE = -32002;
+var AUTHENTICATION_REQUIRED_CODE = -32001;
+function scopeFromChallenge(challenge) {
+  if (!challenge) {
+    return null;
+  }
+  const match = /scope="([^"]+)"/.exec(challenge);
+  return match?.[1] ?? null;
+}
+function describeRefusal(error) {
+  const text = messageOf(error);
+  if (!text) {
+    return null;
+  }
+  if (text.includes("insufficient_scope") || text.includes(String(INSUFFICIENT_SCOPE_CODE))) {
+    const scope = scopeFromChallenge(text) ?? scopeFromText(text);
+    return scope ? `The site refused: this credential does not hold the ${scope} scope. Say so plainly and do not try again; a different credential is needed.` : "The site refused: this credential is not allowed to do that. Say so plainly and do not try again.";
+  }
+  if (text.includes("authentication_required") || text.includes("-32001")) {
+    return "The site refused: no valid credential was presented. Check the client id and secret.";
+  }
+  return null;
+}
+function scopeFromText(text) {
+  const match = /\bmcp:[a-z]+/.exec(text);
+  return match?.[0] ?? null;
+}
+function messageOf(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return `${error.message}`;
+  }
+  if (error && typeof error === "object") {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+
+// src/schema.ts
+var SCHEMA_VALUED_KEYS = ["items", "additionalProperties", "not", "if", "then", "else"];
+var SCHEMA_MAP_KEYS = ["properties", "patternProperties", "definitions", "$defs"];
+var SCHEMA_LIST_KEYS = ["anyOf", "allOf", "oneOf", "prefixItems"];
+var TYPE_BEARING_KEYS = ["type", "properties", "$ref", "items", "enum", "const", "anyOf", "oneOf"];
+function normaliseSchema(schema) {
+  return walk(schema, false);
+}
+function walk(node, isProperty) {
+  if (Array.isArray(node)) {
+    return node.map((item) => walk(item, false));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const source = node;
+  const result = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "oneOf") {
+      continue;
+    }
+    if (SCHEMA_MAP_KEYS.includes(key) && value && typeof value === "object" && !Array.isArray(value)) {
+      const mapped = {};
+      const namesAreProperties = key === "properties" || key === "patternProperties";
+      for (const [name, child] of Object.entries(value)) {
+        mapped[name] = walk(child, namesAreProperties);
+      }
+      result[key] = mapped;
+    } else if (SCHEMA_LIST_KEYS.includes(key) && Array.isArray(value)) {
+      result[key] = value.map((item) => walk(item, false));
+    } else if (SCHEMA_VALUED_KEYS.includes(key)) {
+      result[key] = walk(value, false);
+    } else {
+      result[key] = value;
+    }
+  }
+  if (Array.isArray(source.oneOf)) {
+    const branches = source.oneOf.map((item) => walk(item, false));
+    result.anyOf = Array.isArray(result.anyOf) ? [...result.anyOf, ...branches] : branches;
+  }
+  if (isProperty && !TYPE_BEARING_KEYS.some((key) => key in source)) {
+    result.type = "string";
+  }
+  return result;
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/toolset.ts
+function drupalTools(options) {
+  const { auth, only, 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;
+        }
+      }
+    },
+    only,
+    prefix
+  );
+  return prepareTools(toolset, lastChallenge);
+}
+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);
+      }
+      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);
+        }
+      };
+    }
+    return tools;
+  };
+  return toolset;
+}
+function withScope(message, scope) {
+  return message.replace("is not allowed to do that", `does not hold the ${scope} scope`);
+}
+
+// src/agents.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { LlmAgent } from "@google/adk";
+var LIST_URI = "drupal://agents";
+var DEFAULT_CACHE_MS = 1e4;
+async function drupalAgent(options) {
+  const { auth, id, only } = options;
+  const baseUrl = (options.baseUrl ?? auth.baseUrl).replace(/\/+$/, "");
+  const cacheMs = options.cacheMs ?? DEFAULT_CACHE_MS;
+  const reader = new DefinitionReader(baseUrl, auth);
+  const definition = await reader.read(id);
+  let cached = definition;
+  let fetchedAt = Date.now();
+  const instruction = async () => {
+    if (cacheMs === 0 || Date.now() - fetchedAt > cacheMs) {
+      try {
+        cached = await reader.read(id);
+        fetchedAt = Date.now();
+      } catch {
+      }
+    }
+    return promptFrom(cached);
+  };
+  return new LlmAgent({
+    name: definition.id,
+    model: options.model ?? "gemini-flash-latest",
+    description: definition.description || definition.label,
+    instruction,
+    tools: [drupalTools({ baseUrl, auth, ...only ? { only } : {} })]
+  });
+}
+async function listAgents(auth, baseUrl) {
+  const root = (baseUrl ?? auth.baseUrl).replace(/\/+$/, "");
+  const payload = await new DefinitionReader(root, auth).readUri(LIST_URI);
+  return payload.agents ?? [];
+}
+function promptFrom(definition) {
+  if (!definition.context) {
+    return definition.instruction;
+  }
+  return [
+    definition.instruction,
+    "",
+    "Site context. Apply it where it is relevant; it does not override what",
+    "the person in front of you is asking for.",
+    "",
+    definition.context
+  ].join("\n");
+}
+var DefinitionReader = class {
+  constructor(baseUrl, auth) {
+    this.baseUrl = baseUrl;
+    this.auth = auth;
+  }
+  baseUrl;
+  auth;
+  /** One agent's definition. */
+  async read(id) {
+    if (!/^[a-z0-9_]+$/.test(id)) {
+      throw new Error(`"${id}" is not a Drupal agent id; expected lowercase letters, digits and underscores.`);
+    }
+    return this.readUri(`${LIST_URI}/${id}`);
+  }
+  /** Whatever the site publishes at this resource URI, parsed as JSON. */
+  async readUri(uri) {
+    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}`);
+        return globalThis.fetch(input, { ...init, headers });
+      }
+    });
+    try {
+      await client.connect(transport);
+      const result = await client.readResource({ uri });
+      const first = result.contents?.[0];
+      const text = first && "text" in first ? first.text : void 0;
+      if (typeof text !== "string") {
+        throw new Error(`The site returned no text for ${uri}.`);
+      }
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(explain(uri, error));
+    } finally {
+      await client.close().catch(() => void 0);
+    }
+  }
+};
+function explain(uri, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("Resource not found")) {
+    return `The site has no agent at ${uri}. Check the machine name at Configuration \u2192 AI \u2192 Tools and automation \u2192 Agents, and that the MCP Agents module is installed.`;
+  }
+  return `Could not read ${uri} from Drupal: ${message}`;
+}
+export {
+  AUTHENTICATION_REQUIRED_CODE,
+  DrupalOAuth,
+  INSUFFICIENT_SCOPE_CODE,
+  VERSION,
+  describeRefusal,
+  drupalAgent,
+  drupalTools,
+  listAgents,
+  normaliseSchema,
+  promptFrom,
+  scopeFromChallenge
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@drupalmcp/adk",
+  "version": "0.1.0",
+  "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",
+  "engines": {
+    "node": ">=24.13.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Omedia/drupalmcp-ts.git",
+    "directory": "packages/adk"
+  },
+  "homepage": "https://drupalmcp.io",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "drupal",
+    "mcp",
+    "adk",
+    "agent",
+    "ai",
+    "model-context-protocol"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:live": "DRUPALMCP_LIVE=1 vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0"
+  },
+  "peerDependencies": {
+    "@google/adk": "^2.0.0"
+  },
+  "devDependencies": {
+    "@google/adk": "^2.1.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}