@google/adk 1.4.0 → 1.5.0

package/dist/web/agents/loop_agent.js

@@ -75,10 +75,34 @@ class LoopAgent extends (_b = BaseAgent, _a = LOOP_AGENT_SIGNATURE_SYMBOL, _b) {
       return;
     });
   }
-  // eslint-disable-next-line require-yield
-  runLiveImpl(_context) {
+  runLiveImpl(context) {
     return __asyncGenerator(this, null, function* () {
-      throw new Error("This is not supported yet for LoopAgent.");
+      var _a2, _b2;
+      for (let iteration = 0; iteration < this.maxIterations; iteration++) {
+        for (const subAgent of this.subAgents) {
+          try {
+            for (var iter = __forAwait(subAgent.runLive(context)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const event = temp.value;
+              if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+                return;
+              }
+              yield event;
+              if ((_b2 = event.actions) == null ? void 0 : _b2.escalate) {
+                return;
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        }
+      }
     });
   }
 }

package/dist/web/agents/processors/content_processor_utils.js

@@ -34,6 +34,7 @@ import {
   getFunctionCalls,
   getFunctionResponses
 } from "../../events/event.js";
+import { isSegmentPrefix } from "../../utils/branch_trie.js";
 import {
   AF_FUNCTION_CALL_ID_PREFIX,
   REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
@@ -61,7 +62,7 @@ function getContents(events, agentName, currentBranch) {
     if (!((_a = event.content) == null ? void 0 : _a.role) || ((_c = (_b = event.content.parts) == null ? void 0 : _b[0]) == null ? void 0 : _c.text) === "") {
       continue;
     }
-    if (currentBranch && event.branch && !currentBranch.startsWith(event.branch)) {
+    if (currentBranch && event.branch && !isSegmentPrefix(currentBranch, event.branch)) {
       continue;
     }
     if (isAuthEvent(event)) {

package/dist/web/agents/routed_agent.js

@@ -102,6 +102,29 @@ let RoutedAgent = class extends (_b = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYM
     }
     this.router = config.router;
   }
+  /**
+   * Creates a detached copy of this routed agent.
+   *
+   * The inherited {@link BaseAgent.clone} only deep-clones `subAgents`, but a
+   * `RoutedAgent` derives its routing targets from `config.agents`. Rebuilding
+   * through the base clone alone would re-read the already-parented original
+   * agents and throw "already has a parent agent". This override deep-clones the
+   * routing targets (unless the caller overrides `agents`) so the rebuilt
+   * constructor re-parents fresh, detached copies. The array-vs-record shape
+   * and, for records, the keys are preserved so the router keeps selecting the
+   * same targets.
+   *
+   * @param overrides Config fields to override on the clone. Overriding
+   *     `parentAgent` is rejected by the base implementation.
+   * @returns A new detached `RoutedAgent` of the same concrete class.
+   */
+  clone(overrides) {
+    const nextOverrides = __spreadValues({}, overrides);
+    if (!("agents" in nextOverrides)) {
+      nextOverrides.agents = cloneRoutingTargets(this.config.agents);
+    }
+    return super.clone(nextOverrides);
+  }
   /**
    * Runs the selected agent via text-based conversation.
    */
@@ -132,6 +155,14 @@ let RoutedAgent = class extends (_b = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYM
 RoutedAgent = __decorateClass([
   experimental
 ], RoutedAgent);
+function cloneRoutingTargets(agents) {
+  if (Array.isArray(agents)) {
+    return agents.map((agent) => agent.clone());
+  }
+  return Object.fromEntries(
+    Object.entries(agents).map(([key, agent]) => [key, agent.clone()])
+  );
+}
 export {
   RoutedAgent,
   isRoutedAgent

package/dist/web/agents/run_config.js

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
 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;
@@ -16,6 +18,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -29,14 +32,16 @@ var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
   return StreamingMode2;
 })(StreamingMode || {});
 function createRunConfig(params = {}) {
-  return __spreadValues({
+  var _a;
+  return __spreadProps(__spreadValues({
     saveInputBlobsAsArtifacts: false,
     supportCfc: false,
     enableAffectiveDialog: false,
     streamingMode: "none" /* NONE */,
-    maxLlmCalls: validateMaxLlmCalls(params.maxLlmCalls || 500),
     pauseOnToolCalls: false
-  }, params);
+  }, params), {
+    maxLlmCalls: validateMaxLlmCalls((_a = params.maxLlmCalls) != null ? _a : 500)
+  });
 }
 function validateMaxLlmCalls(value) {
   if (value > Number.MAX_SAFE_INTEGER) {

package/dist/web/artifacts/in_memory_artifact_service.js

@@ -5,6 +5,7 @@ const require = topLevelCreateRequire(import.meta.url);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { logger } from "../utils/logger.js";
 function isInMemoryConnectionString(uri) {
   return uri === "memory://";
 }
@@ -56,6 +57,12 @@ class InMemoryArtifactService {
     if (version === void 0) {
       version = versions.length - 1;
     }
+    if (!versions[version]) {
+      logger.warn(
+        "[InMemoryArtifactService] loadArtifact: Artifact ".concat(filename, " version ").concat(version, " not found")
+      );
+      return Promise.resolve(void 0);
+    }
     return Promise.resolve(versions[version].part);
   }
   listArtifactKeys({

package/dist/web/common.js

@@ -56,17 +56,22 @@ import {
   FileContentEncoding
 } from "./code_executors/code_execution_utils.js";
 import { AgentControlledContextCompactor } from "./context/agent_controlled_context_compactor.js";
+import { AnchoredContextCompactor } from "./context/anchored_context_compactor.js";
 import { LlmSummarizer } from "./context/summarizers/llm_summarizer.js";
 import { TokenBasedContextCompactor } from "./context/token_based_context_compactor.js";
 import { TrajectoryThoughtPruningCompactor } from "./context/trajectory_thought_pruning_compactor.js";
 import { TruncatingContextCompactor } from "./context/truncating_context_compactor.js";
-import { isCompactedEvent } from "./events/compacted_event.js";
+import { isCompactedEvent, isScratchpadEvent } from "./events/compacted_event.js";
 import {
   createEvent,
+  generateClientFunctionCallId,
   getFunctionCalls,
   getFunctionResponses,
+  hasThoughts,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
+  populateClientFunctionCallId,
+  pruneThoughts,
   stringifyContent
 } from "./events/event.js";
 import { createEventActions } from "./events/event_actions.js";
@@ -83,6 +88,7 @@ import { Gemini, geminiInitParams } from "./models/google_llm.js";
 import { LLMRegistry } from "./models/registry.js";
 import { RoutedLlm } from "./models/routed_llm.js";
 import { BasePlugin, ContextCompactionTrigger } from "./plugins/base_plugin.js";
+import { GlobalInstructionPlugin } from "./plugins/global_instruction_plugin.js";
 import { LoggingPlugin } from "./plugins/logging_plugin.js";
 import { PluginManager } from "./plugins/plugin_manager.js";
 import {
@@ -108,6 +114,11 @@ import { AgentTool, isAgentTool } from "./tools/agent_tool.js";
 import { BaseTool, isBaseTool } from "./tools/base_tool.js";
 import { BaseToolset, isBaseToolset } from "./tools/base_toolset.js";
 import { ConsolidateContextTool } from "./tools/consolidate_context_tool.js";
+import {
+  ENTERPRISE_WEB_SEARCH,
+  EnterpriseWebSearchTool
+} from "./tools/enterprise_web_search_tool.js";
+import { ExampleTool } from "./tools/example_tool.js";
 import { EXIT_LOOP, ExitLoopTool } from "./tools/exit_loop_tool.js";
 import { FunctionTool, isFunctionTool } from "./tools/function_tool.js";
 import {
@@ -120,6 +131,7 @@ import {
   LoadArtifactsTool
 } from "./tools/load_artifacts_tool.js";
 import { LOAD_MEMORY, LoadMemoryTool } from "./tools/load_memory_tool.js";
+import { LOAD_WEB_PAGE, loadWebPage } from "./tools/load_web_page.js";
 import { LongRunningFunctionTool } from "./tools/long_running_tool.js";
 import {
   PRELOAD_MEMORY,
@@ -174,6 +186,7 @@ export {
   AgentControlledContextCompactor,
   AgentTool,
   AgentTransferLlmRequestProcessor,
+  AnchoredContextCompactor,
   ApigeeLlm,
   AuthCredentialTypes,
   AuthHandler,
@@ -199,8 +212,11 @@ export {
   ContextCompactorRequestProcessor,
   CredentialExchangeError,
   CredentialRefresherRegistry,
+  ENTERPRISE_WEB_SEARCH,
   EXIT_LOOP,
+  EnterpriseWebSearchTool,
   EventType,
+  ExampleTool,
   ExitLoopTool,
   FileContentEncoding,
   FunctionTool,
@@ -208,6 +224,7 @@ export {
   GOOGLE_MAPS_GROUNDING,
   GOOGLE_SEARCH,
   Gemini,
+  GlobalInstructionPlugin,
   GoogleLLMVariant,
   GoogleMapsGroundingTool,
   GoogleSearchTool,
@@ -223,6 +240,7 @@ export {
   LLMRegistry,
   LOAD_ARTIFACTS,
   LOAD_MEMORY,
+  LOAD_WEB_PAGE,
   ListSkillsTool,
   LiveRequestQueue,
   LlmAgent2 as LlmAgent,
@@ -281,11 +299,13 @@ export {
   findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   geminiInitParams,
+  generateClientFunctionCallId,
   getAskUserConfirmationFunctionCalls,
   getClientLabels,
   getFunctionCalls,
   getFunctionResponses,
   getLogger,
+  hasThoughts,
   hasTrailingCodeExecutionResult,
   isAgentTool,
   isBaseAgent,
@@ -304,10 +324,14 @@ export {
   isRoutableLlmAgent,
   isRoutedAgent,
   isRunner,
+  isScratchpadEvent,
   isSequentialAgent,
   loadAllSkillsInDir,
   loadSkillFromDir,
   loadSkillFromZipBuffer,
+  loadWebPage,
+  populateClientFunctionCallId,
+  pruneThoughts,
   runWithClientLabel,
   setLogLevel,
   setLogger,

package/dist/web/context/anchored_context_compactor.js

@@ -0,0 +1,117 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+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 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isScratchpadEvent } from "../events/compacted_event.js";
+import { getEventTokens } from "../events/event.js";
+import { calculateRetainStartIndex } from "./compaction_utils.js";
+class AnchoredContextCompactor {
+  constructor(options) {
+    this.tokenThreshold = options.tokenThreshold;
+    this.eventRetentionSize = options.eventRetentionSize;
+    this.summarizer = options.summarizer;
+  }
+  getActiveEvents(events) {
+    let latestScratchpad = void 0;
+    for (let i = events.length - 1; i >= 0; i--) {
+      const e = events[i];
+      if (isScratchpadEvent(e)) {
+        latestScratchpad = e;
+        break;
+      }
+    }
+    if (!latestScratchpad) {
+      return events;
+    }
+    const activeRawEvents = events.filter(
+      (e) => e.timestamp > latestScratchpad.endTime && !isScratchpadEvent(e)
+    );
+    return [latestScratchpad, ...activeRawEvents];
+  }
+  shouldCompact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
+    const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return false;
+    }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return false;
+    }
+    const totalTokens = activeEvents.reduce(
+      (sum, event) => sum + getEventTokens(event),
+      0
+    );
+    return totalTokens > this.tokenThreshold;
+  }
+  async compact(invocationContext) {
+    const events = invocationContext.session.events;
+    const activeEvents = this.getActiveEvents(events);
+    const hasScratchpad = activeEvents.length > 0 && isScratchpadEvent(activeEvents[0]);
+    const rawEvents = hasScratchpad ? activeEvents.slice(1) : activeEvents;
+    if (rawEvents.length <= this.eventRetentionSize) {
+      return;
+    }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return;
+    }
+    const rawEventsToCompact = rawEvents.slice(0, retainStartIndex);
+    let scratchpadEvent;
+    if (hasScratchpad) {
+      const existingScratchpad = activeEvents[0];
+      scratchpadEvent = await this.summarizer.summarize([
+        existingScratchpad,
+        ...rawEventsToCompact
+      ]);
+    } else {
+      scratchpadEvent = await this.summarizer.summarize(rawEventsToCompact);
+    }
+    const updatedScratchpad = __spreadProps(__spreadValues({}, scratchpadEvent), {
+      isScratchpad: true,
+      author: "system"
+    });
+    const inactiveEvents = events.slice(0, events.indexOf(activeEvents[0]));
+    const retainedRawEvents = rawEvents.slice(retainStartIndex);
+    const newEventsList = [
+      ...inactiveEvents,
+      updatedScratchpad,
+      ...retainedRawEvents
+    ];
+    events.length = 0;
+    events.push(...newEventsList);
+  }
+}
+export {
+  AnchoredContextCompactor
+};

package/dist/web/context/compaction_utils.js

@@ -0,0 +1,27 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  getFunctionCalls,
+  getFunctionResponses
+} from "../events/event.js";
+function calculateRetainStartIndex(rawEvents, eventRetentionSize) {
+  let retainStartIndex = Math.max(0, rawEvents.length - eventRetentionSize);
+  while (retainStartIndex > 0) {
+    const eventToRetain = rawEvents[retainStartIndex];
+    const previousEvent = rawEvents[retainStartIndex - 1];
+    if (getFunctionResponses(eventToRetain).length > 0 && getFunctionCalls(previousEvent).length > 0) {
+      retainStartIndex--;
+    } else {
+      break;
+    }
+  }
+  return retainStartIndex;
+}
+export {
+  calculateRetainStartIndex
+};

package/dist/web/context/token_based_context_compactor.js

@@ -7,6 +7,7 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import { getContents } from "../agents/processors/content_processor_utils.js";
 import { isCompactedEvent } from "../events/compacted_event.js";
+import { calculateRetainStartIndex } from "./compaction_utils.js";
 const CHARS_PER_TOKEN = 4;
 class TokenBasedContextCompactor {
   constructor(options) {
@@ -39,6 +40,13 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return false;
     }
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
+    );
+    if (retainStartIndex === 0) {
+      return false;
+    }
     const promptTokenCount = latestPromptTokenCount(
       activeEvents,
       invocationContext
@@ -55,19 +63,10 @@ class TokenBasedContextCompactor {
     if (rawEvents.length <= this.eventRetentionSize) {
       return;
     }
-    let retainStartIndex = Math.max(
-      0,
-      rawEvents.length - this.eventRetentionSize
+    const retainStartIndex = calculateRetainStartIndex(
+      rawEvents,
+      this.eventRetentionSize
     );
-    while (retainStartIndex > 0) {
-      const eventToRetain = rawEvents[retainStartIndex];
-      const previousEvent = rawEvents[retainStartIndex - 1];
-      if (hasFunctionResponse(eventToRetain) && hasFunctionCall(previousEvent)) {
-        retainStartIndex--;
-      } else {
-        break;
-      }
-    }
     if (retainStartIndex === 0) {
       return;
     }
@@ -122,18 +121,6 @@ function estimatePromptTokenCount(activeEvents, invocationContext) {
   }
   return Math.ceil(totalChars / CHARS_PER_TOKEN);
 }
-function hasFunctionCall(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionCall !== void 0
-  ));
-}
-function hasFunctionResponse(event) {
-  var _a, _b;
-  return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some(
-    (part) => part.functionResponse !== void 0
-  ));
-}
 export {
   TokenBasedContextCompactor
 };

package/dist/web/events/compacted_event.js

@@ -28,15 +28,20 @@ import { createEvent } from "./event.js";
 function isCompactedEvent(event) {
   return "isCompacted" in event && event.isCompacted === true;
 }
+function isScratchpadEvent(event) {
+  return isCompactedEvent(event) && event.isScratchpad === true;
+}
 function createCompactedEvent(params = {}) {
   return __spreadProps(__spreadValues({}, createEvent(params)), {
     isCompacted: params.isCompacted || true,
     startTime: params.startTime,
     endTime: params.endTime,
-    compactedContent: params.compactedContent
+    compactedContent: params.compactedContent,
+    isScratchpad: params.isScratchpad
   });
 }
 export {
   createCompactedEvent,
-  isCompactedEvent
+  isCompactedEvent,
+  isScratchpadEvent
 };

package/dist/web/events/event.js

@@ -24,6 +24,7 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { randomUUID } from "../utils/env_aware_utils.js";
 import { toCamelCase, toSnakeCase } from "../utils/object_notation_utils.js";
 import { createEventActions } from "./event_actions.js";
 function createEvent(params = {}) {
@@ -54,6 +55,17 @@ function getFunctionCalls(event) {
   }
   return funcCalls;
 }
+const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+function generateClientFunctionCallId() {
+  return "".concat(AF_FUNCTION_CALL_ID_PREFIX).concat(randomUUID());
+}
+function populateClientFunctionCallId(modelResponseEvent) {
+  for (const functionCall of getFunctionCalls(modelResponseEvent)) {
+    if (!functionCall.id) {
+      functionCall.id = generateClientFunctionCallId();
+    }
+  }
+}
 function getFunctionResponses(event) {
   const funcResponses = [];
   if (event.content && event.content.parts) {
@@ -83,6 +95,14 @@ function stringifyContent(event) {
     return (_a2 = part.text) != null ? _a2 : "";
   }).join("");
 }
+function getEventTokens(event) {
+  var _a;
+  if (((_a = event.usageMetadata) == null ? void 0 : _a.promptTokenCount) !== void 0) {
+    return event.usageMetadata.promptTokenCount;
+  }
+  const contentStr = stringifyContent(event);
+  return Math.ceil(contentStr.length / 4);
+}
 function hasThoughts(event) {
   var _a, _b;
   return !!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.some((part) => part.thought === true));
@@ -136,13 +156,17 @@ function transformToSnakeCaseEvent(event) {
   return toSnakeCase(event, PRESERVE_KEYS_CAMEL_CASE);
 }
 export {
+  AF_FUNCTION_CALL_ID_PREFIX,
   createEvent,
   createNewEventId,
+  generateClientFunctionCallId,
+  getEventTokens,
   getFunctionCalls,
   getFunctionResponses,
   hasThoughts,
   hasTrailingCodeExecutionResult,
   isFinalResponse,
+  populateClientFunctionCallId,
   pruneThoughts,
   stringifyContent,
   transformToCamelCaseEvent,

package/dist/web/index.js

@@ -29,11 +29,15 @@ import {
   loadSkillFromDir,
   validateSkillDir
 } from "./skills/loader.js";
-import { RunSkillInlineScriptTool } from "./tools/skill/run_skill_inline_script_tool.js";
+import {
+  RunSkillInlineScriptErrorCode,
+  RunSkillInlineScriptTool
+} from "./tools/skill/run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./tools/skill/run_skill_script_tool.js";
 export * from "./integrations/agent_registry/agent_registry.js";
 export * from "./telemetry/google_cloud.js";
 export * from "./telemetry/setup.js";
+export * from "./tools/mcp/load_mcp_resource_tool.js";
 export * from "./tools/mcp/mcp_session_manager.js";
 export * from "./tools/mcp/mcp_tool.js";
 export * from "./tools/mcp/mcp_toolset.js";
@@ -47,6 +51,7 @@ export {
   GcsArtifactService,
   InvocationContext,
   RemoteA2AAgent,
+  RunSkillInlineScriptErrorCode,
   RunSkillInlineScriptTool,
   RunSkillScriptTool,
   UnsafeLocalCodeExecutor,

package/dist/web/integrations/agent_registry/agent_registry_mcp_toolset.js

@@ -29,6 +29,7 @@ import {
   MCPSessionManager
 } from "../../tools/mcp/mcp_session_manager.js";
 import { MCPTool } from "../../tools/mcp/mcp_tool.js";
+import { logger } from "../../utils/logger.js";
 import { GCP_MCP_SERVER_DESTINATION_ID } from "./types.js";
 class AgentRegistrySingleMCPToolset extends BaseToolset {
   /**
@@ -78,7 +79,14 @@ class AgentRegistrySingleMCPToolset extends BaseToolset {
     });
     const sessionManager = new MCPSessionManager(connectionParamsCopy);
     const session = await sessionManager.createSession();
-    const listResult = await session.listTools();
+    let listResult;
+    try {
+      listResult = await session.listTools();
+    } finally {
+      await sessionManager.closeSession(session).catch((e) => {
+        logger.warn("Failed to close MCP discovery session", e);
+      });
+    }
     const tools = listResult.tools.map((tool) => {
       const prefixedName = this.prefix ? "".concat(this.prefix, "_").concat(tool.name) : tool.name;
       const mcpTool = new MCPTool(

package/dist/web/plugins/global_instruction_plugin.js

@@ -0,0 +1,67 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { injectSessionState } from "../agents/instructions.js";
+import { ReadonlyContext } from "../agents/readonly_context.js";
+import { BasePlugin } from "./base_plugin.js";
+class GlobalInstructionPlugin extends BasePlugin {
+  /**
+   * Initializes the GlobalInstructionPlugin.
+   *
+   * @param globalInstruction The instruction to apply globally. Can be a string
+   *     or an InstructionProvider function that takes ReadonlyContext and
+   *     returns a string (sync or async).
+   * @param name The name of the plugin (defaults to 'global_instruction').
+   */
+  constructor(globalInstruction, name = "global_instruction") {
+    super(name);
+    this.globalInstruction = globalInstruction;
+  }
+  async beforeModelCallback(params) {
+    if (!this.globalInstruction) {
+      return;
+    }
+    const readonlyContext = new ReadonlyContext(
+      params.callbackContext.invocationContext
+    );
+    const finalGlobalInstruction = await this.resolveGlobalInstruction(readonlyContext);
+    if (!finalGlobalInstruction) {
+      return;
+    }
+    if (!params.llmRequest.config) {
+      params.llmRequest.config = {};
+    }
+    const existingInstruction = params.llmRequest.config.systemInstruction;
+    if (!existingInstruction || Array.isArray(existingInstruction) && existingInstruction.length === 0) {
+      params.llmRequest.config.systemInstruction = finalGlobalInstruction;
+      return;
+    }
+    if (typeof existingInstruction === "string") {
+      params.llmRequest.config.systemInstruction = "".concat(finalGlobalInstruction, "\n\n").concat(existingInstruction);
+    } else if (Array.isArray(existingInstruction)) {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        ...existingInstruction
+      ];
+    } else {
+      params.llmRequest.config.systemInstruction = [
+        finalGlobalInstruction,
+        existingInstruction
+      ];
+    }
+    return;
+  }
+  async resolveGlobalInstruction(readonlyContext) {
+    if (typeof this.globalInstruction === "string") {
+      return await injectSessionState(this.globalInstruction, readonlyContext);
+    }
+    return await this.globalInstruction(readonlyContext);
+  }
+}
+export {
+  GlobalInstructionPlugin
+};