@google/adk 1.4.0 → 1.5.0

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

@@ -0,0 +1,114 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../../models/llm_request.js";
+import { logger } from "../../utils/logger.js";
+import {
+  BaseTool
+} from "../base_tool.js";
+class LoadMcpResourceTool extends BaseTool {
+  constructor(mcpToolset) {
+    super({
+      name: "load_mcp_resource",
+      description: `Loads resources from the MCP server.
+
+NOTE: Call when you need access to resources.`
+    });
+    this.mcpToolset = mcpToolset;
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          resource_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the MCP resources to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const resourceNames = args["resource_names"] || [];
+    return {
+      resource_names: resourceNames,
+      status: "resource contents temporarily inserted and removed. to access these resources, call load_mcp_resource tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendResourcesToLlmRequest(request.llmRequest);
+  }
+  async appendResourcesToLlmRequest(llmRequest) {
+    var _a, _b;
+    try {
+      const availableResourceNames = await this.mcpToolset.listResources();
+      if (availableResourceNames.length > 0) {
+        appendInstructions(llmRequest, [
+          `You have a list of MCP resources:
+${JSON.stringify(
+            availableResourceNames
+          )}
+
+When the user asks questions about any of the resources, you should call the
+\`load_mcp_resource\` function to load the resource. Always call load_mcp_resource
+before answering questions related to the resources.`
+        ]);
+      }
+    } catch (e) {
+      logger.warn(`Failed to list MCP resources: ${e}`);
+    }
+    const lastContent = llmRequest.contents.at(-1);
+    const functionResponse = (_b = (_a = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a[0]) == null ? void 0 : _b.functionResponse;
+    if (!functionResponse || functionResponse.name !== this.name) {
+      return;
+    }
+    const response = functionResponse.response || {};
+    const requestedResourceNames = response["resource_names"] || [];
+    for (const resourceName of requestedResourceNames) {
+      try {
+        const resourceContents = await this.mcpToolset.readResource(resourceName);
+        for (const content of resourceContents) {
+          llmRequest.contents.push({
+            role: "user",
+            parts: [
+              { text: `Resource ${resourceName} is:` },
+              this.mcpContentToPart(content, resourceName)
+            ]
+          });
+        }
+      } catch (e) {
+        logger.warn(`Failed to read MCP resource '${resourceName}': ${e}`);
+      }
+    }
+  }
+  mcpContentToPart(content, resourceName) {
+    var _a;
+    if ("text" in content) {
+      return { text: content.text };
+    }
+    if ("blob" in content) {
+      return {
+        inlineData: {
+          data: content.blob,
+          mimeType: (_a = content.mimeType) != null ? _a : "application/octet-stream"
+        }
+      };
+    }
+    return { text: `[Unknown content type for ${resourceName}]` };
+  }
+}
+export {
+  LoadMcpResourceTool
+};

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

@@ -48,6 +48,69 @@ class MCPToolset extends BaseToolset {
     );
     return tools;
   }
+  /**
+   * Lists the names of the resources advertised by the MCP server.
+   *
+   * @return The resource names available on the server.
+   */
+  async listResources() {
+    const session = await this.mcpSessionManager.createSession();
+    try {
+      const result = await session.listResources();
+      return result.resources.map((resource) => resource.name);
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+  }
+  /**
+   * Returns metadata for the resource whose name matches `name`.
+   *
+   * @param name The advertised name of the resource.
+   * @return The matching MCP `Resource`.
+   * @throws If no resource with the given name is advertised by the server.
+   */
+  async getResourceInfo(name) {
+    const session = await this.mcpSessionManager.createSession();
+    let result;
+    try {
+      result = await session.listResources();
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+    const resource = result.resources.find(
+      (candidate) => candidate.name === name
+    );
+    if (!resource) {
+      throw new Error(`Resource with name '${name}' not found.`);
+    }
+    return resource;
+  }
+  /**
+   * Reads the contents of the named resource from the MCP server.
+   *
+   * The resource name is resolved to a URI via {@link getResourceInfo} before
+   * reading. Binary contents are returned base64-encoded, exactly as provided
+   * by the server (never decoded and re-encoded).
+   *
+   * @param name The advertised name of the resource to read.
+   * @return The resource contents (text and/or base64-encoded binary).
+   * @throws If the resource is unknown or has no URI.
+   */
+  async readResource(name) {
+    const resourceInfo = await this.getResourceInfo(name);
+    if (!resourceInfo.uri) {
+      throw new Error(`Resource '${name}' has no URI.`);
+    }
+    const session = await this.mcpSessionManager.createSession();
+    try {
+      const result = await session.readResource({
+        uri: resourceInfo.uri
+      });
+      return result.contents;
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
+  }
   async close() {
     const sessions = this.mcpSessionManager.getActiveSessions();
     await Promise.allSettled(

package/dist/esm/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js

@@ -62,19 +62,22 @@ let ToolAuthHandler = class {
       rawAuthCredential: this.authCredential,
       credentialKey: this.credentialKey || "default_openapi_key"
     };
-    const credential = this.context.getAuthResponse(authConfig);
-    if (credential) {
-      const exchanger = new AutoAuthCredentialExchanger();
-      const result = await exchanger.exchange({
-        authScheme: this.authScheme,
-        authCredential: credential
-      });
+    const authResponseCredential = this.context.getAuthResponse(authConfig);
+    const credential = authResponseCredential != null ? authResponseCredential : this.authCredential;
+    if (!credential) {
+      this.context.requestCredential(authConfig);
+      return { state: "pending" };
+    }
+    const exchanger = new AutoAuthCredentialExchanger();
+    const result = await exchanger.exchange({
+      authScheme: this.authScheme,
+      authCredential: credential
+    });
+    if (authResponseCredential || result.wasExchanged) {
       const key = store.getCredentialKey(this.authScheme);
       store.storeCredential(key, result.credential);
-      return { state: "done", authCredential: result.credential };
     }
-    this.context.requestCredential(authConfig);
-    return { state: "pending" };
+    return { state: "done", authCredential: result.credential };
   }
 };
 __decorateClass([

package/dist/esm/tools/skill/run_skill_inline_script_tool.js

@@ -21,6 +21,15 @@ import { CodeExecutionLanguage } from "../../code_executors/code_execution_utils
 import { experimental } from "../../utils/experimental.js";
 import { materializeFiles } from "../../utils/file_utils.js";
 import { BaseTool } from "../base_tool.js";
+var RunSkillInlineScriptErrorCode = /* @__PURE__ */ ((RunSkillInlineScriptErrorCode2) => {
+  RunSkillInlineScriptErrorCode2["MISSING_SCRIPT_CONTENT"] = "MISSING_SCRIPT_CONTENT";
+  RunSkillInlineScriptErrorCode2["MISSING_LANGUAGE"] = "MISSING_LANGUAGE";
+  RunSkillInlineScriptErrorCode2["NO_CODE_EXECUTOR"] = "NO_CODE_EXECUTOR";
+  RunSkillInlineScriptErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
+  RunSkillInlineScriptErrorCode2["CONFIRMATION_REJECTED"] = "CONFIRMATION_REJECTED";
+  return RunSkillInlineScriptErrorCode2;
+})(RunSkillInlineScriptErrorCode || {});
+const REQUIRE_CONFIRMATION_MESSAGE = "This tool call needs external confirmation before completion.";
 let RunSkillInlineScriptTool = class extends BaseTool {
   constructor(toolset) {
     super({
@@ -70,13 +79,13 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     if (!inlineScriptContent) {
       return {
         error: "Script content is required.",
-        errorCode: "MISSING_SCRIPT_CONTENT"
+        errorCode: "MISSING_SCRIPT_CONTENT" /* MISSING_SCRIPT_CONTENT */
       };
     }
     if (!language) {
       return {
         error: "Language is required.",
-        errorCode: "MISSING_LANGUAGE"
+        errorCode: "MISSING_LANGUAGE" /* MISSING_LANGUAGE */
       };
     }
     let codeExecutor = (_a = this.toolset) == null ? void 0 : _a.codeExecutor;
@@ -89,9 +98,17 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     if (!codeExecutor) {
       return {
         error: "No code executor configured.",
-        errorCode: "NO_CODE_EXECUTOR"
+        errorCode: "NO_CODE_EXECUTOR" /* NO_CODE_EXECUTOR */
       };
     }
+    const confirmationResult = this.enforceConfirmation(
+      toolContext,
+      inlineScriptContent,
+      language
+    );
+    if (confirmationResult) {
+      return confirmationResult;
+    }
     try {
       const result = await codeExecutor.executeCode({
         invocationContext: toolContext.invocationContext,
@@ -107,14 +124,46 @@ let RunSkillInlineScriptTool = class extends BaseTool {
     } catch (e) {
       return {
         error: `Failed to execute inline script: ${e.message}`,
-        errorCode: "EXECUTION_ERROR"
+        errorCode: "EXECUTION_ERROR" /* EXECUTION_ERROR */
+      };
+    }
+  }
+  /**
+   * Enforces a human-in-the-loop confirmation gate before executing an inline
+   * script, using the repo's standard tool-confirmation mechanism.
+   *
+   * - When no confirmation has been provided yet, a confirmation is requested
+   *   (surfacing the language and script that would run) and an intermediate
+   *   result is returned so the tool call pauses until the client responds.
+   * - When a confirmation exists but was not confirmed, a rejection error is
+   *   returned and execution is refused.
+   * - When the confirmation is confirmed, `undefined` is returned to allow the
+   *   caller to proceed with execution.
+   */
+  enforceConfirmation(toolContext, scriptContent, language) {
+    const confirmation = toolContext.toolConfirmation;
+    if (!confirmation) {
+      toolContext.requestConfirmation({
+        hint: `Confirmation is required before executing an inline skill script. The agent requested to run the following ${language} script in the code executor. Only approve if you trust its contents:
+
+` + scriptContent,
+        payload: { language, scriptContent }
+      });
+      return { partial: REQUIRE_CONFIRMATION_MESSAGE };
+    }
+    if (!confirmation.confirmed) {
+      return {
+        error: "Inline script execution was not confirmed and was rejected.",
+        errorCode: "CONFIRMATION_REJECTED" /* CONFIRMATION_REJECTED */
       };
     }
+    return void 0;
   }
 };
 RunSkillInlineScriptTool = __decorateClass([
   experimental
 ], RunSkillInlineScriptTool);
 export {
+  RunSkillInlineScriptErrorCode,
   RunSkillInlineScriptTool
 };

package/dist/esm/tools/skill/skill_toolset.js

@@ -55,9 +55,11 @@ let SkillToolset = class extends BaseToolset {
       new ListSkillsTool(this),
       new LoadSkillTool(this),
       new LoadSkillResourceTool(this),
-      new RunSkillScriptTool(this),
-      new RunSkillInlineScriptTool(this)
+      new RunSkillScriptTool(this)
     ];
+    if (options.allowInlineScripts) {
+      this.tools.push(new RunSkillInlineScriptTool(this));
+    }
     if (this.registry) {
       this.tools.push(new SearchSkillsTool(this));
     }

package/dist/esm/utils/branch_trie.js

@@ -0,0 +1,13 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isSegmentPrefix(currentBranch, targetBranch) {
+  return !targetBranch || targetBranch === currentBranch || !!currentBranch && currentBranch.startsWith(`${targetBranch}.`);
+}
+export {
+  isSegmentPrefix
+};

package/dist/esm/utils/streaming_utils.js

@@ -9,7 +9,7 @@ import {
   FinishReason
 } from "@google/genai";
 import { JSONPath } from "jsonpath-plus";
-import { generateClientFunctionCallId } from "../agents/functions.js";
+import { generateClientFunctionCallId } from "../events/event.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);

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.4.0";
+const version = "1.5.0";
 export {
   version
 };

package/dist/types/a2a/a2a_remote_agent.d.ts

@@ -68,8 +68,12 @@ export interface RemoteA2AAgentConfig extends BaseAgentConfig {
 }
 /**
  * RemoteA2AAgent delegates execution to a remote agent using the A2A protocol.
+ *
+ * @remarks
+ * A cloned `RemoteA2AAgent` (via {@link BaseAgent.clone}) is a fresh,
+ * uninitialized instance that re-resolves its client and card on first use.
  */
-export declare class RemoteA2AAgent extends BaseAgent {
+export declare class RemoteA2AAgent extends BaseAgent<RemoteA2AAgentConfig> {
     private readonly a2aConfig;
     private client?;
     private card?;

package/dist/types/a2a/agent_to_a2a.d.ts

@@ -4,12 +4,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AgentCard } from '@a2a-js/sdk';
+import { UserBuilder } from '@a2a-js/sdk/server/express';
 import express from 'express';
 import { BaseAgent } from '../agents/base_agent.js';
 import { BaseArtifactService } from '../artifacts/base_artifact_service.js';
 import { BaseMemoryService } from '../memory/base_memory_service.js';
 import { Runner } from '../runner/runner.js';
 import { BaseSessionService } from '../sessions/base_session_service.js';
+/**
+ * A request authenticator for the A2A surface.
+ *
+ * This is the `UserBuilder` hook from `@a2a-js/sdk`: an async function that
+ * receives the incoming Express request, validates its credentials (for
+ * example a bearer token or an OIDC ID token) and resolves to the
+ * authenticated `User`. Implementations should reject unauthenticated
+ * requests by throwing (or by resolving to a user whose `isAuthenticated` is
+ * `false`), which prevents the underlying agent and its tools from being
+ * invoked by anonymous callers.
+ */
+export type A2aUserBuilder = UserBuilder;
 /**
  * Options for the `toA2a` function.
  */
@@ -34,6 +47,31 @@ export interface ToA2aOptions {
     artifactService?: BaseArtifactService;
     /** Optional existing express application */
     app?: express.Application;
+    /**
+     * Authenticator used to validate incoming A2A requests.
+     *
+     * A2A is the production-intended inter-agent surface: any network-reachable
+     * caller that can reach it can invoke the agent and its tools with arbitrary
+     * input and read the output. Provide a `UserBuilder` (from
+     * `@a2a-js/sdk/server/express`) that validates the request's credentials —
+     * for example a bearer token or an OIDC ID token — and it will be wired into
+     * both the REST and JSON-RPC handlers.
+     *
+     * When omitted, `toA2a` fails closed and throws unless
+     * {@link ToA2aOptions.allowUnauthenticated} is explicitly set to `true`.
+     */
+    authentication?: A2aUserBuilder;
+    /**
+     * Explicit escape hatch to mount the A2A surface WITHOUT authentication.
+     *
+     * This is intentionally insecure and must only be used for local, trusted
+     * development where the surface is not network reachable. When set to
+     * `true` (and no {@link ToA2aOptions.authentication} is provided), a loud
+     * warning is logged and the handlers are mounted with no authentication.
+     *
+     * Defaults to `false`, which makes `toA2a` fail closed.
+     */
+    allowUnauthenticated?: boolean;
 }
 /**
  * Converts an ADK agent to an Express application with A2A handlers.

package/dist/types/agents/base_agent.d.ts

@@ -45,12 +45,25 @@ declare const BASE_AGENT_SIGNATURE_SYMBOL: unique symbol;
 export declare function isBaseAgent(obj: unknown): obj is BaseAgent;
 /**
  * Base class for all agents in Agent Development Kit.
+ *
+ * The class is generic over its config type so that {@link clone} can be typed
+ * per subclass (e.g. `LlmAgent.clone({instruction})`). The default keeps bare
+ * `BaseAgent` references valid as `BaseAgent<BaseAgentConfig>`.
  */
-export declare abstract class BaseAgent {
+export declare abstract class BaseAgent<TConfig extends BaseAgentConfig = BaseAgentConfig> {
     /**
      * A unique symbol to identify ADK agent classes.
      */
     readonly [BASE_AGENT_SIGNATURE_SYMBOL] = true;
+    /**
+     * The config this agent was constructed from.
+     *
+     * Stored so {@link clone} can rebuild the agent by re-running the concrete
+     * constructor with overrides applied, which re-derives all state correctly
+     * instead of copying an already-mutated instance. Shallow-copied so later
+     * external mutation of the caller's object does not leak into clones.
+     */
+    protected readonly config: TConfig;
     /**
      * The agent's name.
      * Agent name must be a JS identifier and unique within the agent tree.
@@ -112,6 +125,21 @@ export declare abstract class BaseAgent {
      */
     readonly afterAgentCallback: SingleAgentCallback[];
     constructor(config: BaseAgentConfig);
+    /**
+     * Creates a copy of this agent with the given config fields overridden.
+     *
+     * Mirrors adk-python's `BaseAgent.clone(update=...)`. The clone is a detached
+     * root: its `parentAgent` is always `undefined`. Sub-agents are recursively
+     * cloned (and re-parented to the clone) unless `subAgents` is overridden.
+     * Rebuilding via the concrete constructor re-derives all state, so a cloned
+     * `LlmAgent` gets a fresh `requestProcessors` array rather than sharing the
+     * original's. See google/adk-js#534.
+     *
+     * @param overrides Config fields to override on the clone. Overriding
+     *     `parentAgent` is rejected, matching adk-python.
+     * @returns A new detached agent instance of the same concrete class.
+     */
+    clone(overrides?: Partial<TConfig>): this;
     /**
      * Entry method to run an agent via text-based conversation.
      *

package/dist/types/agents/functions.d.ts

@@ -9,7 +9,7 @@ import { Event } from '../events/event.js';
 import { BaseTool } from '../tools/base_tool.js';
 import { ToolConfirmation } from '../tools/tool_confirmation.js';
 import { SingleAfterToolCallback, SingleBeforeToolCallback } from './llm_agent.js';
-export declare const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+export { AF_FUNCTION_CALL_ID_PREFIX, generateClientFunctionCallId, populateClientFunctionCallId, } from '../events/event.js';
 export declare const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 export declare const functionsExportedForTestingOnly: {
@@ -17,14 +17,6 @@ export declare const functionsExportedForTestingOnly: {
     generateAuthEvent: typeof generateAuthEvent;
     generateRequestConfirmationEvent: typeof generateRequestConfirmationEvent;
 };
-export declare function generateClientFunctionCallId(): string;
-/**
- * Populates client-side function call IDs.
- *
- * It iterates through all function calls in the event and assigns a
- * unique client-side ID to each one that doesn't already have an ID.
- */
-export declare function populateClientFunctionCallId(modelResponseEvent: Event): void;
 /**
  * Returns a set of function call ids of the long running tools.
  */

package/dist/types/agents/llm_agent.d.ts

@@ -130,6 +130,8 @@ export interface LlmAgentConfig extends BaseAgentConfig {
      *
      * For example: use globalInstruction to make all agents have a stable
      * identity or personality.
+     *
+     * @deprecated Use GlobalInstructionPlugin instead.
      */
     globalInstruction?: string | InstructionProvider;
     /** Tools available to this agent. */
@@ -224,11 +226,12 @@ export declare function isLlmAgent(obj: unknown): obj is LlmAgent;
 /**
  * An agent that uses a large language model to generate responses.
  */
-export declare class LlmAgent extends BaseAgent {
+export declare class LlmAgent extends BaseAgent<LlmAgentConfig> {
     /** A unique symbol to identify ADK LLM agent class. */
     readonly [LLM_AGENT_SIGNATURE_SYMBOL] = true;
     model?: string | BaseLlm;
     instruction: string | InstructionProvider;
+    /** @deprecated Use GlobalInstructionPlugin instead. */
     globalInstruction: string | InstructionProvider;
     tools: ToolUnion[];
     generateContentConfig?: GenerateContentConfig;
@@ -270,6 +273,7 @@ export declare class LlmAgent extends BaseAgent {
      * This method is only for use by Agent Development Kit.
      * @param context The context to retrieve the session state.
      * @returns The resolved globalInstruction field.
+     * @deprecated Use GlobalInstructionPlugin instead.
      */
     canonicalGlobalInstruction(context: ReadonlyContext): Promise<{
         instruction: string;

package/dist/types/agents/loop_agent.d.ts

@@ -34,7 +34,7 @@ export declare function isLoopAgent(obj: unknown): obj is LoopAgent;
  * When sub-agent generates an event with escalate or max_iterations are
  * reached, the loop agent will stop.
  */
-export declare class LoopAgent extends BaseAgent {
+export declare class LoopAgent extends BaseAgent<LoopAgentConfig> {
     /**
      * A unique symbol to identify ADK loop agent class.
      */
@@ -42,6 +42,6 @@ export declare class LoopAgent extends BaseAgent {
     readonly maxIterations: number;
     constructor(config: LoopAgentConfig);
     protected runAsyncImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
-    protected runLiveImpl(_context: InvocationContext): AsyncGenerator<Event, void, void>;
+    protected runLiveImpl(context: InvocationContext): AsyncGenerator<Event, void, void>;
 }
 export {};

package/dist/types/agents/routed_agent.d.ts

@@ -41,12 +41,35 @@ export interface RoutedAgentConfig extends BaseAgentConfig {
 /**
  * A BaseAgent implementation that delegates to one of multiple agents based on a router function.
  * Routing is strictly limited to the agents passed in the config.
+ *
+ * @remarks
+ * Cloning is supported: {@link RoutedAgent.clone} deep-clones the routing
+ * targets from `config.agents` and re-parents the fresh copies onto the clone,
+ * so the clone is a detached root that routes identically to the original while
+ * leaving the original agent tree untouched.
  */
-export declare class RoutedAgent extends BaseAgent {
+export declare class RoutedAgent extends BaseAgent<RoutedAgentConfig> {
     readonly [ROUTED_AGENT_SIGNATURE_SYMBOL] = true;
     private readonly agents;
     private readonly router;
     constructor(config: RoutedAgentConfig);
+    /**
+     * 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?: Partial<RoutedAgentConfig>): this;
     /**
      * Runs the selected agent via text-based conversation.
      */

package/dist/types/agents/run_config.d.ts

@@ -94,6 +94,7 @@ export interface RunConfig {
  * @throws {Error} When `params.maxLlmCalls` exceeds `Number.MAX_SAFE_INTEGER`.
  */
 export declare function createRunConfig(params?: Partial<RunConfig>): {
+    maxLlmCalls: number;
     speechConfig?: SpeechConfig | undefined;
     responseModalities?: Modality[] | undefined;
     saveInputBlobsAsArtifacts: boolean;
@@ -104,6 +105,5 @@ export declare function createRunConfig(params?: Partial<RunConfig>): {
     enableAffectiveDialog: boolean;
     proactivity?: ProactivityConfig | undefined;
     realtimeInputConfig?: RealtimeInputConfig | undefined;
-    maxLlmCalls: number;
     pauseOnToolCalls: boolean;
 };

package/dist/types/common.d.ts

@@ -58,6 +58,8 @@ export type { ExecuteCodeParams } from './code_executors/base_code_executor.js';
 export { BuiltInCodeExecutor } from './code_executors/built_in_code_executor.js';
 export { CodeExecutionLanguage, FileContentEncoding, type CodeExecutionInput, type CodeExecutionResult, type File, } from './code_executors/code_execution_utils.js';
 export { AgentControlledContextCompactor } from './context/agent_controlled_context_compactor.js';
+export { AnchoredContextCompactor } from './context/anchored_context_compactor.js';
+export type { AnchoredContextCompactorOptions } from './context/anchored_context_compactor.js';
 export type { BaseContextCompactor } from './context/base_context_compactor.js';
 export type { BaseSummarizer } from './context/summarizers/base_summarizer.js';
 export { LlmSummarizer } from './context/summarizers/llm_summarizer.js';
@@ -68,9 +70,9 @@ export { TrajectoryThoughtPruningCompactor } from './context/trajectory_thought_
 export type { TrajectoryThoughtPruningCompactorOptions } from './context/trajectory_thought_pruning_compactor.js';
 export { TruncatingContextCompactor } from './context/truncating_context_compactor.js';
 export type { TruncatingContextCompactorOptions } from './context/truncating_context_compactor.js';
-export { isCompactedEvent } from './events/compacted_event.js';
+export { isCompactedEvent, isScratchpadEvent } from './events/compacted_event.js';
 export type { CompactedEvent } from './events/compacted_event.js';
-export { createEvent, getFunctionCalls, getFunctionResponses, hasTrailingCodeExecutionResult, isFinalResponse, stringifyContent, } from './events/event.js';
+export { createEvent, generateClientFunctionCallId, getFunctionCalls, getFunctionResponses, hasThoughts, hasTrailingCodeExecutionResult, isFinalResponse, populateClientFunctionCallId, pruneThoughts, stringifyContent, } from './events/event.js';
 export type { Event } from './events/event.js';
 export { createEventActions } from './events/event_actions.js';
 export type { EventActions } from './events/event_actions.js';
@@ -96,6 +98,7 @@ export type { BaseLlmType } from './models/registry.js';
 export { RoutedLlm } from './models/routed_llm.js';
 export type { LlmRouter } from './models/routed_llm.js';
 export { BasePlugin, ContextCompactionTrigger } from './plugins/base_plugin.js';
+export { GlobalInstructionPlugin } from './plugins/global_instruction_plugin.js';
 export { LoggingPlugin } from './plugins/logging_plugin.js';
 export { PluginManager } from './plugins/plugin_manager.js';
 export { InMemoryPolicyEngine, PolicyOutcome, REQUEST_CONFIRMATION_FUNCTION_CALL_NAME, SecurityPlugin, getAskUserConfirmationFunctionCalls, } from './plugins/security_plugin.js';
@@ -116,6 +119,8 @@ export type { BaseToolParams, RunAsyncToolRequest, ToolProcessLlmRequest, } from
 export { BaseToolset, isBaseToolset } from './tools/base_toolset.js';
 export type { ToolPredicate } from './tools/base_toolset.js';
 export { ConsolidateContextTool } from './tools/consolidate_context_tool.js';
+export { ENTERPRISE_WEB_SEARCH, EnterpriseWebSearchTool, } from './tools/enterprise_web_search_tool.js';
+export { ExampleTool } from './tools/example_tool.js';
 export { EXIT_LOOP, ExitLoopTool } from './tools/exit_loop_tool.js';
 export { FunctionTool, isFunctionTool } from './tools/function_tool.js';
 export type { ToolExecuteArgument, ToolExecuteFunction, ToolInputParameters, ToolOptions, } from './tools/function_tool.js';
@@ -123,6 +128,8 @@ export { GOOGLE_MAPS_GROUNDING, GoogleMapsGroundingTool, } from './tools/google_
 export { GOOGLE_SEARCH, GoogleSearchTool } from './tools/google_search_tool.js';
 export { LOAD_ARTIFACTS, LoadArtifactsTool, } from './tools/load_artifacts_tool.js';
 export { LOAD_MEMORY, LoadMemoryTool } from './tools/load_memory_tool.js';
+export { LOAD_WEB_PAGE, loadWebPage } from './tools/load_web_page.js';
+export type { LoadWebPageOptions } from './tools/load_web_page.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';