@google/adk 0.4.0 → 0.6.0

package/dist/web/memory/in_memory_memory_service.js

@@ -58,7 +58,7 @@ function getUserKey(appName, userId) {
 }
 function extractWordsLower(text) {
   return new Set(
-    [...text.matchAll(/[A-Za-z]+/)].map((match) => match[0].toLowerCase())
+    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
   );
 }
 function formatTimestamp(timestamp) {

package/dist/web/models/llm_response.js

@@ -12,6 +12,7 @@ function createLlmResponse(response) {
       return {
         content: candidate.content,
         groundingMetadata: candidate.groundingMetadata,
+        citationMetadata: candidate.citationMetadata,
         usageMetadata,
         finishReason: candidate.finishReason
       };
@@ -20,6 +21,7 @@ function createLlmResponse(response) {
       errorCode: candidate.finishReason,
       errorMessage: candidate.finishMessage,
       usageMetadata,
+      citationMetadata: candidate.citationMetadata,
       finishReason: candidate.finishReason
     };
   }

package/dist/web/plugins/base_plugin.js

@@ -198,7 +198,7 @@ class BasePlugin {
      * Callback executed when a tool call encounters an error.
       tool: BaseTool;
       toolArgs: Record<string, unknown>;
-      toolContext: ToolContext;
+      toolContext: Context;
       result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined> {
       return;

package/dist/web/runner/runner.js

@@ -51,6 +51,7 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import { createPartFromText } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import {
@@ -72,12 +73,18 @@ import {
 } from "../telemetry/tracing.js";
 import { logger } from "../utils/logger.js";
 import { isGemini2OrAbove } from "../utils/model_name.js";
+const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+function isRunner(obj) {
+  return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
+}
+_a = RUNNER_SIGNATURE_SYMBOL;
 class Runner {
   constructor(input) {
-    var _a;
+    this[_a] = true;
+    var _a2;
     this.appName = input.appName;
     this.agent = input.agent;
-    this.pluginManager = new PluginManager((_a = input.plugins) != null ? _a : []);
+    this.pluginManager = new PluginManager((_a2 = input.plugins) != null ? _a2 : []);
     this.artifactService = input.artifactService;
     this.sessionService = input.sessionService;
     this.memoryService = input.memoryService;
@@ -141,7 +148,7 @@ class Runner {
           this,
           function() {
             return __asyncGenerator(this, null, function* () {
-              var _a;
+              var _a2;
               const session = yield new __await(this.sessionService.getSession({
                 appName: this.appName,
                 userId,
@@ -186,7 +193,7 @@ class Runner {
                 newMessage = pluginUserMessage;
               }
               if (newMessage) {
-                if (!((_a = newMessage.parts) == null ? void 0 : _a.length)) {
+                if (!((_a2 = newMessage.parts) == null ? void 0 : _a2.length)) {
                   throw new Error("No parts in the newMessage.");
                 }
                 if (runConfig.saveInputBlobsAsArtifacts) {
@@ -276,8 +283,8 @@ class Runner {
    * @param message The message containing parts to process.
    */
   async saveArtifacts(invocationId, userId, sessionId, message) {
-    var _a;
-    if (!this.artifactService || !((_a = message.parts) == null ? void 0 : _a.length)) {
+    var _a2;
+    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return;
     }
     for (let i = 0; i < message.parts.length; i++) {
@@ -310,7 +317,7 @@ class Runner {
       return rootAgent.findAgent(event.author) || rootAgent;
     }
     for (let i = session.events.length - 1; i >= 0; i--) {
-      logger.info("event: ", JSON.stringify(session.events[i]));
+      logger.info("event:", JSON.stringify(session.events[i]));
       const event2 = session.events[i];
       if (event2.author === "user" || !event2.author) {
         continue;
@@ -358,12 +365,12 @@ class Runner {
   // TODO - b/425992518: Implement runLive and related methods.
 }
 function findEventByLastFunctionResponseId(events) {
-  var _a, _b, _c, _d;
+  var _a2, _b, _c, _d;
   if (!events.length) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find(
+  const functionCallId = (_d = (_c = (_b = (_a2 = lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.find(
     (part) => part.functionResponse
   )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
   if (!functionCallId) {
@@ -384,5 +391,6 @@ function findEventByLastFunctionResponseId(events) {
   return null;
 }
 export {
-  Runner
+  Runner,
+  isRunner
 };

package/dist/web/sessions/database_session_service.js

@@ -57,7 +57,7 @@ class DatabaseSessionService extends BaseSessionService {
     super();
     this.initialized = false;
     if (typeof connectionStringOrOptions === "string") {
-      this.options = getConnectionOptionsFromUri(connectionStringOrOptions);
+      this.connectionString = connectionStringOrOptions;
     } else {
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
@@ -71,6 +71,9 @@ class DatabaseSessionService extends BaseSessionService {
     if (this.initialized) {
       return;
     }
+    if (this.connectionString && (!this.options || !this.options.driver)) {
+      this.options = await getConnectionOptionsFromUri(this.connectionString);
+    }
     this.orm = await MikroORM.init(this.options);
     await ensureDatabaseCreated(this.orm);
     await validateDatabaseSchemaVersion(this.orm);

package/dist/web/sessions/db/operations.js

@@ -1,31 +1,52 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { MikroORM } from "@mikro-orm/core";
-import { MariaDbDriver } from "@mikro-orm/mariadb";
-import { MsSqlDriver } from "@mikro-orm/mssql";
-import { MySqlDriver } from "@mikro-orm/mysql";
-import { PostgreSqlDriver } from "@mikro-orm/postgresql";
-import { SqliteDriver } from "@mikro-orm/sqlite";
 import {
   ENTITIES,
   SCHEMA_VERSION_1_JSON,
   SCHEMA_VERSION_KEY,
   StorageMetadata
 } from "./schema.js";
-function getConnectionOptionsFromUri(uri) {
+async function getConnectionOptionsFromUri(uri) {
   let driver;
   if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
+    const { PostgreSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1));
     driver = PostgreSqlDriver;
   } else if (uri.startsWith("mysql://")) {
+    const { MySqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1));
     driver = MySqlDriver;
   } else if (uri.startsWith("mariadb://")) {
+    const { MariaDbDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1));
     driver = MariaDbDriver;
   } else if (uri.startsWith("sqlite://")) {
+    const { SqliteDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1));
     driver = SqliteDriver;
   } else if (uri.startsWith("mssql://")) {
+    const { MsSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1));
     driver = MsSqlDriver;
   } else {
     throw new Error("Unsupported database URI: ".concat(uri));
@@ -39,9 +60,10 @@ function getConnectionOptionsFromUri(uri) {
   }
   const { host, port, username, password, pathname } = new URL(uri);
   const hostName = host.split(":")[0];
+  const dbName = uri.startsWith("sqlite://") ? uri.substring("sqlite://".length) : pathname.slice(1);
   return {
     entities: ENTITIES,
-    dbName: pathname.slice(1),
+    dbName,
     host: hostName,
     port: port ? parseInt(port) : void 0,
     user: username,
@@ -49,17 +71,9 @@ function getConnectionOptionsFromUri(uri) {
     driver
   };
 }
-async function ensureDatabaseCreated(ormOrUrlOrOptions) {
-  let orm;
-  if (ormOrUrlOrOptions instanceof MikroORM) {
-    orm = ormOrUrlOrOptions;
-  } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
-  } else {
-    orm = await MikroORM.init(ormOrUrlOrOptions);
-  }
+async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema();
+  await orm.schema.updateSchema({ safe: true });
 }
 async function validateDatabaseSchemaVersion(orm) {
   const em = orm.em.fork();

package/dist/web/sessions/state.js

@@ -69,8 +69,8 @@ class State {
    * @param delta The delta to update the state with.
    */
   update(delta) {
-    this.delta = __spreadValues(__spreadValues({}, this.delta), delta);
-    this.value = __spreadValues(__spreadValues({}, this.value), delta);
+    Object.assign(this.delta, delta);
+    Object.assign(this.value, delta);
   }
   /**
    * Returns the state as a plain JSON object.

package/dist/web/tools/agent_tool.js

@@ -65,7 +65,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     args,
     toolContext
   }) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -84,13 +84,14 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       appName: this.agent.name,
       agent: this.agent,
       artifactService: new ForwardingArtifactService(toolContext),
-      sessionService: new InMemorySessionService(),
-      memoryService: new InMemoryMemoryService(),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
     const session = await runner.sessionService.createSession({
       appName: this.agent.name,
-      userId: "tmp_user",
+      userId: toolContext.invocationContext.userId,
+      sessionId: toolContext.invocationContext.session.id,
       state: toolContext.state.toRecord()
     });
     let lastEvent;
@@ -116,7 +117,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
           throw error[0];
       }
     }
-    if (!((_b2 = (_a2 = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
+    if (!((_d = (_c = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.length)) {
       return "";
     }
     const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;

package/dist/web/tools/base_tool.js

@@ -54,6 +54,9 @@ class BaseTool {
     if (!functionDeclaration) {
       return;
     }
+    if (this.name in llmRequest.toolsDict) {
+      throw new Error("Duplicate tool name: ".concat(this.name));
+    }
     llmRequest.toolsDict[this.name] = this;
     const tool = findToolWithFunctionDeclarations(llmRequest);
     if (tool) {

package/dist/web/tools/base_toolset.js

@@ -3,9 +3,17 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+function isBaseToolset(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
 class BaseToolset {
-  constructor(toolFilter) {
+  constructor(toolFilter, prefix) {
     this.toolFilter = toolFilter;
+    this.prefix = prefix;
+    this[_a] = true;
   }
   /**
    * Returns whether the tool should be exposed to LLM.
@@ -42,5 +50,6 @@ class BaseToolset {
   }
 }
 export {
-  BaseToolset
+  BaseToolset,
+  isBaseToolset
 };

package/dist/web/tools/exit_loop_tool.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool } from "./base_tool.js";
+class ExitLoopTool extends BaseTool {
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description
+    };
+  }
+  async runAsync({
+    toolContext
+  }) {
+    toolContext.actions.escalate = true;
+    toolContext.actions.skipSummarization = true;
+    return "";
+  }
+}
+const EXIT_LOOP = new ExitLoopTool();
+export {
+  EXIT_LOOP,
+  ExitLoopTool
+};

package/dist/web/tools/load_artifacts_tool.js

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import { getLogger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+const logger = getLogger();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: "[Artifact: ".concat(artifactName, ", type: ").concat(mimeType, ". No inline data was provided.]")
+    };
+  }
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+  const decodedBuffer = Buffer.from(data, "base64");
+  if (isTextLike) {
+    try {
+      const decoded = decodedBuffer.toString("utf8");
+      return { text: decoded };
+    } catch (e) {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: "[Binary artifact: ".concat(artifactName, ", type: ").concat(mimeType, ", size: ").concat(sizeKb.toFixed(1), " KB. Content cannot be displayed inline.]")
+  };
+}
+class LoadArtifactsTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: "Loads artifacts into the session for this request.\n\nNOTE: Call when you need access to artifacts (for example, uploads saved by the web UI)."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      "You have a list of artifacts:\n  ".concat(JSON.stringify(
+        artifactNames
+      ), "\n\n  When the user asks questions about any of the artifacts, you should call the\n  `load_artifacts` function to load the artifact. Always call load_artifacts\n  before answering questions related to the artifacts, regardless of whether the\n  artifacts have been loaded before. Do not depend on prior answers about the\n  artifacts.")
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = "user:".concat(artifactName);
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn('Artifact "'.concat(artifactName, '" not found, skipping'));
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: "Artifact ".concat(artifactName, " is:") }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+export {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+};

package/dist/web/tools/load_memory_tool.js

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class LoadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to load the memory for."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    try {
+      const query = args["query"];
+      if (!toolContext.invocationContext.memoryService) {
+        throw new Error("Memory service is not initialized.");
+      }
+      const searchMemoryResponse = await toolContext.searchMemory(query);
+      return {
+        memories: searchMemoryResponse.memories.map((m) => {
+          var _a, _b;
+          return {
+            // Join all text parts by a space, or empty string if no text parts
+            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
+              var _a2;
+              return (_a2 = p.text) != null ? _a2 : "";
+            }).join(" ")) != null ? _b : "",
+            author: m.author,
+            timestamp: m.timestamp
+          };
+        })
+      };
+    } catch (e) {
+      console.error("ERROR in LoadMemoryTool runAsync:", e);
+      throw e;
+    }
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    if (!request.toolContext.invocationContext.memoryService) {
+      return;
+    }
+    appendInstructions(request.llmRequest, [
+      "You have memory. You can use it to answer questions. If any questions need\nyou to look up the memory, you should call load_memory function with a query."
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+export {
+  LOAD_MEMORY,
+  LoadMemoryTool
+};

package/dist/web/tools/mcp/mcp_toolset.js

@@ -1,3 +1,22 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -8,8 +27,8 @@ import { BaseToolset } from "../base_toolset.js";
 import { MCPSessionManager } from "./mcp_session_manager.js";
 import { MCPTool } from "./mcp_tool.js";
 class MCPToolset extends BaseToolset {
-  constructor(connectionParams, toolFilter = []) {
-    super(toolFilter);
+  constructor(connectionParams, toolFilter = [], prefix) {
+    super(toolFilter, prefix);
     this.mcpSessionManager = new MCPSessionManager(connectionParams);
   }
   async getTools() {
@@ -19,9 +38,12 @@ class MCPToolset extends BaseToolset {
     for (const tool of listResult.tools) {
       logger.debug("tool: ".concat(tool.name));
     }
-    return listResult.tools.map(
-      (tool) => new MCPTool(tool, this.mcpSessionManager)
-    );
+    return listResult.tools.map((tool) => {
+      const toolWithPrefix = __spreadProps(__spreadValues({}, tool), {
+        name: this.prefix ? "".concat(this.prefix, "_").concat(tool.name) : tool.name
+      });
+      return new MCPTool(toolWithPrefix, this.mcpSessionManager);
+    });
   }
   async close() {
   }