@google/adk 0.4.0 → 0.6.0

package/dist/esm/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/esm/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/esm/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/esm/runner/runner.js

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
 import { createPartFromText } from "@google/genai";
 import { context, trace } from "@opentelemetry/api";
 import {
@@ -24,12 +25,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;
@@ -89,7 +96,7 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a;
+          var _a2;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
@@ -134,7 +141,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) {
@@ -210,8 +217,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++) {
@@ -244,7 +251,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;
@@ -292,12 +299,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) {
@@ -318,5 +325,6 @@ function findEventByLastFunctionResponseId(events) {
   return null;
 }
 export {
-  Runner
+  Runner,
+  isRunner
 };

package/dist/esm/sessions/database_session_service.js

@@ -38,7 +38,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.");
@@ -53,6 +53,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/esm/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: ${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/esm/sessions/state.js

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

package/dist/esm/tools/agent_tool.js

@@ -63,7 +63,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;
     }
@@ -82,13 +82,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;
@@ -102,7 +103,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       }
       lastEvent = event;
     }
-    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/esm/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: ${this.name}`);
+    }
     llmRequest.toolsDict[this.name] = this;
     const tool = findToolWithFunctionDeclarations(llmRequest);
     if (tool) {

package/dist/esm/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/esm/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/esm/tools/load_artifacts_tool.js

@@ -0,0 +1,159 @@
+/**
+ * @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: ${artifactName}, type: ${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 {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${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.
+
+NOTE: 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:
+  ${JSON.stringify(
+        artifactNames
+      )}
+
+  When the user asks questions about any of the artifacts, you should call the
+  \`load_artifacts\` function to load the artifact. Always call load_artifacts
+  before answering questions related to the artifacts, regardless of whether the
+  artifacts have been loaded before. Do not depend on prior answers about the
+  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:${artifactName}`;
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn(`Artifact "${artifactName}" not found, skipping`);
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+export {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+};

package/dist/esm/tools/load_memory_tool.js

@@ -0,0 +1,78 @@
+/**
+ * @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
+you 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/esm/tools/mcp/mcp_toolset.js

@@ -8,8 +8,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 +19,13 @@ class MCPToolset extends BaseToolset {
     for (const tool of listResult.tools) {
       logger.debug(`tool: ${tool.name}`);
     }
-    return listResult.tools.map(
-      (tool) => new MCPTool(tool, this.mcpSessionManager)
-    );
+    return listResult.tools.map((tool) => {
+      const toolWithPrefix = {
+        ...tool,
+        name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
+      };
+      return new MCPTool(toolWithPrefix, this.mcpSessionManager);
+    });
   }
   async close() {
   }