@google/adk 1.0.0 → 1.1.0

package/dist/esm/tools/agent_tool.js

@@ -88,7 +88,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
-    const session = await runner.sessionService.createSession({
+    const session = await runner.sessionService.getOrCreateSession({
       appName: this.agent.name,
       userId: toolContext.invocationContext.userId,
       sessionId: toolContext.invocationContext.session.id,

package/dist/esm/tools/mcp/mcp_tool.js

@@ -8,10 +8,11 @@ const require = topLevelCreateRequire(import.meta.url);
 import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
 import { BaseTool } from "../base_tool.js";
 class MCPTool extends BaseTool {
-  constructor(mcpTool, mcpSessionManager) {
+  constructor(mcpTool, mcpSessionManager, originalName) {
     super({ name: mcpTool.name, description: mcpTool.description || "" });
     this.mcpTool = mcpTool;
     this.mcpSessionManager = mcpSessionManager;
+    this.originalName = originalName || mcpTool.name;
   }
   _getDeclaration() {
     return {
@@ -26,7 +27,7 @@ class MCPTool extends BaseTool {
   async runAsync(request) {
     const session = await this.mcpSessionManager.createSession();
     const callRequest = {};
-    callRequest.params = { name: this.mcpTool.name, arguments: request.args };
+    callRequest.params = { name: this.originalName, arguments: request.args };
     const result = await session.callTool(callRequest.params, void 0, {
       signal: request.toolContext.abortSignal
     });

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

@@ -26,7 +26,7 @@ class MCPToolset extends BaseToolset {
         ...tool,
         name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
       };
-      return new MCPTool(toolWithPrefix, this.mcpSessionManager);
+      return new MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
   }
   async close() {

package/dist/esm/tools/url_context_tool.js

@@ -0,0 +1,44 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini2OrAbove, isGeminiModel } from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+class UrlContextTool extends BaseTool {
+  constructor() {
+    super({ name: "url_context", description: "URL Context Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    if (!isGeminiModel(llmRequest.model)) {
+      throw new Error(
+        `URL context tool is not supported for model ${llmRequest.model}`
+      );
+    }
+    if (!isGemini2OrAbove(llmRequest.model)) {
+      throw new Error(
+        `URL context tool requires Gemini 2 or above, but got ${llmRequest.model}`
+      );
+    }
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      urlContext: {}
+    });
+  }
+}
+const URL_CONTEXT = new UrlContextTool();
+export {
+  URL_CONTEXT,
+  UrlContextTool
+};

package/dist/esm/tools/vertex_ai_search_tool.js

@@ -0,0 +1,103 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getLogger } from "../utils/logger.js";
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+const logger = getLogger();
+class VertexAiSearchTool extends BaseTool {
+  constructor(params) {
+    super({ name: "vertex_ai_search", description: "vertex_ai_search" });
+    const {
+      dataStoreId,
+      dataStoreSpecs,
+      searchEngineId,
+      filter,
+      maxResults,
+      bypassMultiToolsLimit = false
+    } = params;
+    if (dataStoreId === void 0 && searchEngineId === void 0 || dataStoreId !== void 0 && searchEngineId !== void 0) {
+      throw new Error(
+        "Either dataStoreId or searchEngineId must be specified."
+      );
+    }
+    if (dataStoreSpecs !== void 0 && searchEngineId === void 0) {
+      throw new Error(
+        "searchEngineId must be specified if dataStoreSpecs is specified."
+      );
+    }
+    this.dataStoreId = dataStoreId;
+    this.dataStoreSpecs = dataStoreSpecs;
+    this.searchEngineId = searchEngineId;
+    this.filter = filter;
+    this.maxResults = maxResults;
+    this.bypassMultiToolsLimit = bypassMultiToolsLimit;
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  /**
+   * Builds the VertexAISearch configuration.
+   *
+   * Override this method in a subclass to dynamically customize the search
+   * configuration based on the context (e.g., set filter based on session
+   * state).
+   */
+  buildVertexAiSearchConfig(_readonlyContext) {
+    return {
+      datastore: this.dataStoreId,
+      dataStoreSpecs: this.dataStoreSpecs,
+      engine: this.searchEngineId,
+      filter: this.filter,
+      maxResults: this.maxResults
+    };
+  }
+  async processLlmRequest({
+    toolContext,
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    if (!isGeminiModel(llmRequest.model) && !modelCheckDisabled) {
+      throw new Error(
+        `Vertex AI search tool is not supported for model ${llmRequest.model}`
+      );
+    }
+    if (isGemini1Model(llmRequest.model) && llmRequest.config.tools.length > 0 && !this.bypassMultiToolsLimit) {
+      throw new Error(
+        "Vertex AI search tool cannot be used with other tools in Gemini 1.x."
+      );
+    }
+    const vertexAiSearchConfig = this.buildVertexAiSearchConfig(toolContext);
+    let specsInfo;
+    if (vertexAiSearchConfig.dataStoreSpecs) {
+      const specIds = vertexAiSearchConfig.dataStoreSpecs.map(
+        (spec) => spec.dataStore ? spec.dataStore.split("/").pop() : "unnamed"
+      );
+      specsInfo = `${vertexAiSearchConfig.dataStoreSpecs.length} spec(s): [${specIds.join(", ")}]`;
+    }
+    logger.debug(
+      `Adding Vertex AI Search tool config to LLM request: datastore=${vertexAiSearchConfig.datastore}, engine=${vertexAiSearchConfig.engine}, filter=${vertexAiSearchConfig.filter}, maxResults=${vertexAiSearchConfig.maxResults}, dataStoreSpecs=${specsInfo}`
+    );
+    llmRequest.config.tools.push({
+      retrieval: {
+        vertexAiSearch: vertexAiSearchConfig
+      }
+    });
+  }
+}
+export {
+  VertexAiSearchTool
+};

package/dist/esm/utils/model_name.js

@@ -5,6 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { getBooleanEnvVar } from "./env_aware_utils.js";
 const MODEL_NAME_PATTERN = "^projects/[^/]+/locations/[^/]+/publishers/[^/]+/models/(.+)$";
 function extractModelName(modelString) {
   const match = modelString.match(MODEL_NAME_PATTERN);
@@ -45,9 +46,13 @@ function isGemini2OrAbove(modelString) {
   const parsedVersion = parseVersion(versionString);
   return parsedVersion.valid && parsedVersion.major >= 2;
 }
+function isGeminiModelIdCheckDisabled() {
+  return getBooleanEnvVar("ADK_DISABLE_GEMINI_MODEL_ID_CHECK");
+}
 export {
   extractModelName,
   isGemini1Model,
   isGemini2OrAbove,
-  isGeminiModel
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
 };

package/dist/esm/version.js

@@ -5,7 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "1.0.0";
+const version = "1.1.0";
 export {
   version
 };

package/dist/types/common.d.ts

@@ -114,6 +114,9 @@ export { LOAD_MEMORY, LoadMemoryTool } from './tools/load_memory_tool.js';
 export { LongRunningFunctionTool } from './tools/long_running_tool.js';
 export { PRELOAD_MEMORY, PreloadMemoryTool, } from './tools/preload_memory_tool.js';
 export { ToolConfirmation } from './tools/tool_confirmation.js';
+export { URL_CONTEXT, UrlContextTool } from './tools/url_context_tool.js';
+export { VertexAiSearchTool } from './tools/vertex_ai_search_tool.js';
+export type { DataStoreParams, SearchEngineParams, VertexAISearchConfig, VertexAISearchDataStoreSpec, VertexAiSearchToolParams, } from './tools/vertex_ai_search_tool.js';
 export { LogLevel, getLogger, setLogLevel, setLogger } from './utils/logger.js';
 export type { Logger } from './utils/logger.js';
 export { isGemini2OrAbove } from './utils/model_name.js';

package/dist/types/tools/mcp/mcp_tool.d.ts

@@ -20,11 +20,17 @@ import { MCPSessionManager } from './mcp_session_manager.js';
  * invoked, which in turn establishes an MCP session, sends a `callTool`
  * request with the provided arguments, and returns the result from the
  * remote tool.
+ *
+ * The originalName parameter allows the tool to track the native tool name
+ * exposed by the MCP server. This is critical when the toolset applies a
+ * prefix to tool names (e.g., for LLM namespace disambiguation), ensuring
+ * the correct original name is used when executing on the server.
  */
 export declare class MCPTool extends BaseTool {
     private readonly mcpTool;
     private readonly mcpSessionManager;
-    constructor(mcpTool: Tool, mcpSessionManager: MCPSessionManager);
+    private readonly originalName;
+    constructor(mcpTool: Tool, mcpSessionManager: MCPSessionManager, originalName?: string);
     _getDeclaration(): FunctionDeclaration;
     runAsync(request: RunAsyncToolRequest): Promise<unknown>;
 }

package/dist/types/tools/mcp/mcp_toolset.d.ts

@@ -17,6 +17,11 @@ import { MCPConnectionParams } from './mcp_session_manager.js';
  * The toolset can be configured with a filter to selectively expose a subset
  * of the tools provided by the MCP server.
  *
+ * It can also be configured with a prefix. If provided, all tools discovered
+ * from the MCP server will have their names prefixed with `${prefix}_`. When the
+ * LLM invokes the prefixed tool, this toolset transparently strips the prefix
+ * before sending the request to the underlying MCP server.
+ *
  * Usage:
  *   import { MCPToolset } from '@google/adk';
  *   import { StreamableHTTPConnectionParamsSchema } from '@google/adk';

package/dist/types/tools/url_context_tool.d.ts

@@ -0,0 +1,17 @@
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A built-in tool that allows Gemini 2+ models to retrieve content from URLs
+ * provided in the conversation.
+ *
+ * This tool operates internally within the model and does not require or
+ * perform local code execution.
+ */
+export declare class UrlContextTool extends BaseTool {
+    constructor();
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link UrlContextTool}.
+ */
+export declare const URL_CONTEXT: UrlContextTool;

package/dist/types/tools/vertex_ai_search_tool.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+export interface VertexAISearchDataStoreSpec {
+    dataStore?: string;
+}
+export interface VertexAISearchConfig {
+    datastore?: string;
+    dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+    engine?: string;
+    filter?: string;
+    maxResults?: number;
+}
+export interface BaseVertexAiSearchToolParams {
+    filter?: string;
+    maxResults?: number;
+    bypassMultiToolsLimit?: boolean;
+}
+export interface DataStoreParams extends BaseVertexAiSearchToolParams {
+    dataStoreId: string;
+    searchEngineId?: never;
+    dataStoreSpecs?: never;
+}
+export interface SearchEngineParams extends BaseVertexAiSearchToolParams {
+    searchEngineId: string;
+    dataStoreId?: never;
+    dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+}
+export type VertexAiSearchToolParams = DataStoreParams | SearchEngineParams;
+/**
+ * A built-in tool using Vertex AI Search.
+ */
+export declare class VertexAiSearchTool extends BaseTool {
+    readonly dataStoreId?: string;
+    readonly dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+    readonly searchEngineId?: string;
+    readonly filter?: string;
+    readonly maxResults?: number;
+    readonly bypassMultiToolsLimit: boolean;
+    constructor(params: VertexAiSearchToolParams);
+    runAsync(): Promise<unknown>;
+    /**
+     * Builds the VertexAISearch configuration.
+     *
+     * Override this method in a subclass to dynamically customize the search
+     * configuration based on the context (e.g., set filter based on session
+     * state).
+     */
+    protected buildVertexAiSearchConfig(_readonlyContext: ReadonlyContext): VertexAISearchConfig;
+    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}

package/dist/types/utils/model_name.d.ts

@@ -32,3 +32,7 @@ export declare function isGemini1Model(modelString: string): boolean;
  * @return true if it's a Gemini 2.x model, false otherwise.
  */
 export declare function isGemini2OrAbove(modelString: string): boolean;
+/**
+ * Returns True when Gemini model-id validation should be bypassed.
+ */
+export declare function isGeminiModelIdCheckDisabled(): boolean;

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "1.0.0";
+export declare const version = "1.1.0";

package/dist/web/common.js

@@ -102,6 +102,8 @@ import {
   PreloadMemoryTool
 } from "./tools/preload_memory_tool.js";
 import { ToolConfirmation } from "./tools/tool_confirmation.js";
+import { URL_CONTEXT, UrlContextTool } from "./tools/url_context_tool.js";
+import { VertexAiSearchTool } from "./tools/vertex_ai_search_tool.js";
 import { LogLevel, getLogger, setLogLevel, setLogger } from "./utils/logger.js";
 import { isGemini2OrAbove } from "./utils/model_name.js";
 import { zodObjectToSchema } from "./utils/simple_zod_to_json.js";
@@ -197,6 +199,9 @@ export {
   TokenBasedContextCompactor,
   ToolConfirmation,
   TruncatingContextCompactor,
+  URL_CONTEXT,
+  UrlContextTool,
+  VertexAiSearchTool,
   createEvent,
   createEventActions,
   createSession,