@google/adk 1.4.0 → 1.5.0

package/dist/types/context/anchored_context_compactor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseContextCompactor } from './base_context_compactor.js';
+import { BaseSummarizer } from './summarizers/base_summarizer.js';
+export interface AnchoredContextCompactorOptions {
+    /** The maximum number of tokens to retain in the session history before compaction. */
+    tokenThreshold: number;
+    /**
+     * The minimum number of raw events to keep at the end of the session.
+     * Compaction will not affect these tail events (unless needed for tool splits).
+     */
+    eventRetentionSize: number;
+    /** The summarizer used to create the compacted event content. */
+    summarizer: BaseSummarizer;
+}
+/**
+ * A context compactor that maintains a single persistent 'Scratchpad' or
+ * 'State Tracker' event at the top of the context history.
+ *
+ * When compaction is triggered, it merges new raw events into the existing
+ * Scratchpad event and discards them from the active history view.
+ */
+export declare class AnchoredContextCompactor implements BaseContextCompactor {
+    private readonly tokenThreshold;
+    private readonly eventRetentionSize;
+    private readonly summarizer;
+    constructor(options: AnchoredContextCompactorOptions);
+    private getActiveEvents;
+    shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
+    compact(invocationContext: InvocationContext): Promise<void>;
+}

package/dist/types/context/compaction_utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../events/event.js';
+/**
+ * Determines the baseline index to retain from active raw events,
+ * ensuring we don't split between a function call and its response.
+ *
+ * @param rawEvents The active raw events to consider for compaction.
+ * @param eventRetentionSize The minimum number of raw events to keep at the end of the session.
+ * @returns The index in `rawEvents` at which to split. Events before this index will be compacted.
+ */
+export declare function calculateRetainStartIndex(rawEvents: Event[], eventRetentionSize: number): number;

package/dist/types/events/compacted_event.d.ts

@@ -25,9 +25,19 @@ export interface CompactedEvent extends Event {
      * The summarized content of the compacted events.
      */
     compactedContent: string;
+    /**
+     * Identifies this compacted event as the persistent context scratchpad.
+     */
+    isScratchpad?: boolean;
 }
 /**
  * Type guard to check if an event is a CompactedEvent.
  */
 export declare function isCompactedEvent(event: Event): event is CompactedEvent;
+/**
+ * Type guard to check if an event is a scratchpad CompactedEvent.
+ */
+export declare function isScratchpadEvent(event: Event): event is CompactedEvent & {
+    isScratchpad: true;
+};
 export declare function createCompactedEvent(params?: Partial<CompactedEvent>): CompactedEvent;

package/dist/types/events/event.d.ts

@@ -67,6 +67,15 @@ export declare function isFinalResponse(event: Event): boolean;
  * Returns the function calls in the event.
  */
 export declare function getFunctionCalls(event: Event): FunctionCall[];
+export declare const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+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 the function responses in the event.
  */
@@ -82,6 +91,10 @@ export declare function hasTrailingCodeExecutionResult(event: Event): boolean;
  * @returns A single string with the combined text.
  */
 export declare function stringifyContent(event: Event): string;
+/**
+ * Estimates the number of tokens in the event based on usage metadata or characters.
+ */
+export declare function getEventTokens(event: Event): number;
 /**
  * Returns whether the event contains any thought parts.
  */

package/dist/types/index.d.ts

@@ -9,7 +9,7 @@ export { getA2AAgentCard } from './a2a/agent_card.js';
 export { A2AAgentExecutor } from './a2a/agent_executor.js';
 export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './a2a/agent_executor.js';
 export { toA2a } from './a2a/agent_to_a2a.js';
-export type { ToA2aOptions } from './a2a/agent_to_a2a.js';
+export type { A2aUserBuilder, ToA2aOptions } from './a2a/agent_to_a2a.js';
 export type { ExecutorContext } from './a2a/executor_context.js';
 export { InvocationContext } from './agents/invocation_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
@@ -24,11 +24,12 @@ export { getSessionServiceFromUri } from './sessions/registry.js';
 export { VertexAiSessionService } from './sessions/vertex_ai_session_service.js';
 export type { VertexAiSessionServiceOptions } from './sessions/vertex_ai_session_service.js';
 export { loadAllSkillsInDir, loadSkillFromDir, validateSkillDir, } from './skills/loader.js';
-export { RunSkillInlineScriptTool } from './tools/skill/run_skill_inline_script_tool.js';
+export { RunSkillInlineScriptErrorCode, RunSkillInlineScriptTool, } from './tools/skill/run_skill_inline_script_tool.js';
 export { 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';

package/dist/types/plugins/global_instruction_plugin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../agents/context.js';
+import { InstructionProvider } from '../agents/llm_agent.js';
+import { LlmRequest } from '../models/llm_request.js';
+import { LlmResponse } from '../models/llm_response.js';
+import { BasePlugin } from './base_plugin.js';
+/**
+ * Plugin that provides global instructions functionality at the App level.
+ *
+ * This plugin replaces the deprecated globalInstruction field on LlmAgent.
+ * Global instructions are applied to all agents in the application, providing
+ * a consistent way to set application-wide instructions, identity, or
+ * personality.
+ *
+ * The plugin operates through the beforeModelCallback, allowing it to modify
+ * LLM requests before they are sent to the model.
+ */
+export declare class GlobalInstructionPlugin extends BasePlugin {
+    private readonly globalInstruction?;
+    /**
+     * 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?: string | InstructionProvider, name?: string);
+    beforeModelCallback(params: {
+        callbackContext: Context;
+        llmRequest: LlmRequest;
+    }): Promise<LlmResponse | undefined>;
+    private resolveGlobalInstruction;
+}

package/dist/types/runner/runner.d.ts

@@ -147,7 +147,7 @@ export declare class Runner {
     }): AsyncGenerator<Event, void, undefined>;
     /**
      * Saves artifacts from the message parts and replaces the inline data with
-     * a file name placeholder.
+     * a file name placeholder and optional file reference.
      *
      * @param invocationId The current invocation ID.
      * @param userId The user ID of the session.

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

@@ -0,0 +1,26 @@
+import { LlmRequest } from '../models/llm_request.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * Appends the Enterprise Web Search built-in tool to the LLM request when the
+ * target model supports it.
+ *
+ * NOTE: This is NOT Vertex AI Search (formerly "Enterprise Search"). See
+ * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+ */
+export declare function applyEnterpriseWebSearch(llmRequest: LlmRequest): void;
+/**
+ * A Gemini 2+ built-in tool that grounds responses on public web data via
+ * Vertex AI Search with Enterprise (Sec4) compliance.
+ *
+ * This tool operates internally within the model and does not require or
+ * perform local code execution.
+ */
+export declare class EnterpriseWebSearchTool extends BaseTool {
+    constructor();
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link EnterpriseWebSearchTool}.
+ */
+export declare const ENTERPRISE_WEB_SEARCH: EnterpriseWebSearchTool;

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseExampleProvider } from '../examples/base_example_provider.js';
+import { Example } from '../examples/example.js';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that adds (few-shot) examples to the LLM request.
+ *
+ * This tool is executed for each LLM request and is never called by the model;
+ * it only mutates the outgoing request by appending few-shot instructions built
+ * from the latest user query.
+ */
+export declare class ExampleTool extends BaseTool {
+    readonly examples: Example[] | BaseExampleProvider;
+    constructor(examples: Example[] | BaseExampleProvider);
+    runAsync(_request: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { FunctionTool } from './function_tool.js';
+/** Options for {@link loadWebPage}. */
+export interface LoadWebPageOptions {
+    /** Request timeout in milliseconds. Defaults to 30_000 (30s). */
+    timeoutMs?: number;
+}
+/**
+ * Fetches the content at `url` and returns its extracted, readable text.
+ *
+ * Hardened against SSRF: only `http`/`https` URLs are fetched, the host is
+ * resolved and rejected up front if it is `localhost`-style or resolves to a
+ * private / loopback / link-local / shared / reserved / multicast address, and
+ * redirects are never followed. Never throws for expected failures (bad scheme,
+ * blocked host, non-200, timeout, network error); returns
+ * `Failed to fetch url: <url>` instead.
+ *
+ * Known limitation: global `fetch` performs its own DNS resolution at connect
+ * time, so a residual time-of-check/time-of-use (DNS-rebinding) window exists
+ * between this pre-flight lookup and fetch's own lookup. Full connection
+ * IP-pinning (e.g. an `undici` Agent with a custom `lookup`) is a possible
+ * future hardening.
+ */
+export declare function loadWebPage(url: string, options?: LoadWebPageOptions): Promise<string>;
+/** A global {@link FunctionTool} exposing {@link loadWebPage} to the model. */
+export declare const LOAD_WEB_PAGE: FunctionTool<z.ZodObject<{
+    url: z.ZodString;
+}, z.core.$strip>>;

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

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from '../base_tool.js';
+import { MCPToolset } from './mcp_toolset.js';
+/**
+ * A tool that loads MCP server resources and adds them to the session.
+ *
+ * This mirrors the in-repo `LoadArtifactsTool` idiom: the model calls
+ * `load_mcp_resource` with the names of the resources it wants, and on the next
+ * turn {@link processLlmRequest} reads those resources over the MCP session and
+ * appends their contents (text and base64-encoded binary) to the request
+ * context.
+ */
+export declare class LoadMcpResourceTool extends BaseTool {
+    private readonly mcpToolset;
+    constructor(mcpToolset: MCPToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    private appendResourcesToLlmRequest;
+    private mcpContentToPart;
+}

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

@@ -3,6 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { BlobResourceContents, Resource, TextResourceContents } from '@modelcontextprotocol/sdk/types.js';
 import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset, ToolPredicate } from '../base_toolset.js';
@@ -40,5 +41,31 @@ export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;
     constructor(connectionParams: MCPConnectionParams, toolFilter?: ToolPredicate | string[], prefix?: string);
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Lists the names of the resources advertised by the MCP server.
+     *
+     * @return The resource names available on the server.
+     */
+    listResources(): Promise<string[]>;
+    /**
+     * 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.
+     */
+    getResourceInfo(name: string): Promise<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.
+     */
+    readResource(name: string): Promise<Array<TextResourceContents | BlobResourceContents>>;
     close(): Promise<void>;
 }

package/dist/types/tools/skill/run_skill_inline_script_tool.d.ts

@@ -6,9 +6,34 @@
 import { FunctionDeclaration } from '@google/genai';
 import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
 import { SkillToolset } from './skill_toolset.js';
+/**
+ * Error codes returned by {@link RunSkillInlineScriptTool} when a call cannot
+ * be completed. The string values are part of the tool's response contract and
+ * must remain stable.
+ */
+export declare enum RunSkillInlineScriptErrorCode {
+    MISSING_SCRIPT_CONTENT = "MISSING_SCRIPT_CONTENT",
+    MISSING_LANGUAGE = "MISSING_LANGUAGE",
+    NO_CODE_EXECUTOR = "NO_CODE_EXECUTOR",
+    EXECUTION_ERROR = "EXECUTION_ERROR",
+    CONFIRMATION_REJECTED = "CONFIRMATION_REJECTED"
+}
 export declare class RunSkillInlineScriptTool extends BaseTool {
     private toolset;
     constructor(toolset: SkillToolset);
     _getDeclaration(): FunctionDeclaration;
     runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * 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.
+     */
+    private enforceConfirmation;
 }

package/dist/types/tools/skill/skill_toolset.d.ts

@@ -23,6 +23,15 @@ export declare class SkillToolset extends BaseToolset {
         codeExecutor?: BaseCodeExecutor;
         additionalTools?: Array<BaseTool | BaseToolset>;
         registry?: SkillRegistry;
+        /**
+         * Whether to expose the `run_skill_inline_script` tool, which executes
+         * model-provided script content in the configured code executor. This is
+         * disabled by default because arbitrary inline-script execution is a
+         * sensitive capability; opt in explicitly by setting this to `true`.
+         * Execution additionally remains gated behind a human-in-the-loop
+         * confirmation.
+         */
+        allowInlineScripts?: boolean;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;

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

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Checks whether targetBranch is equal to or an ancestor of currentBranch
+ * by verifying segment-by-segment matching without substring false positives.
+ *
+ * @param currentBranch The branch being evaluated.
+ * @param targetBranch The candidate prefix or ancestor branch.
+ * @returns true if targetBranch equals currentBranch or is an ancestor of currentBranch.
+ */
+export declare function isSegmentPrefix(currentBranch: string, targetBranch: string): 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.4.0";
+export declare const version = "1.5.0";

package/dist/web/a2a/agent_to_a2a.js

@@ -16,10 +16,26 @@ import {
 import express from "express";
 import { StreamingMode } from "../agents/run_config.js";
 import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
+import { logger } from "../utils/logger.js";
 import { getA2AAgentCard, resolveAgentCard } from "./agent_card.js";
 import { A2AAgentExecutor } from "./agent_executor.js";
+function resolveA2aUserBuilder(options) {
+  if (options.authentication) {
+    return options.authentication;
+  }
+  if (options.allowUnauthenticated === true) {
+    logger.warn(
+      "SECURITY WARNING: Mounting the A2A server WITHOUT authentication because `allowUnauthenticated: true` was set. The agent and all of its tools are exposed to any network-reachable caller, which can invoke them with arbitrary input and read the output. Do NOT use this outside of local, trusted development."
+    );
+    return UserBuilder.noAuthentication;
+  }
+  throw new Error(
+    "toA2a: refusing to mount the A2A server without authentication. The A2A surface lets any network-reachable caller invoke this agent and its tools with arbitrary input and read the output, so it must be authenticated. Provide `authentication` (a UserBuilder that validates the request, e.g. a bearer token or OIDC credential) or, only for local/trusted development, explicitly set `allowUnauthenticated: true`."
+  );
+}
 async function toA2a(agent, options = {}) {
   var _a, _b, _c, _d;
+  const userBuilder = resolveA2aUserBuilder(options);
   const host = (_a = options.host) != null ? _a : "localhost";
   const port = (_b = options.port) != null ? _b : 8e3;
   const protocol = (_c = options.protocol) != null ? _c : "http";
@@ -65,14 +81,14 @@ async function toA2a(agent, options = {}) {
     "".concat(basePath, "/rest"),
     restHandler({
       requestHandler,
-      userBuilder: UserBuilder.noAuthentication
+      userBuilder
     })
   );
   app.use(
     "".concat(basePath, "/jsonrpc"),
     jsonRpcHandler({
       requestHandler,
-      userBuilder: UserBuilder.noAuthentication
+      userBuilder
     })
   );
   return app;

package/dist/web/a2a/event_converter_utils.js

@@ -77,12 +77,13 @@ function toAdkEvent(event, invocationId, agentName) {
   }
   return void 0;
 }
-function messageToAdkEvent(msg, invocationId, agentName, parentEvent) {
+function messageToAdkEvent(msg, invocationId, agentName) {
   const parts = toGenAIParts(msg.parts);
-  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(parentEvent || msg)), {
+  const content = parts.length === 0 ? void 0 : msg.role === MessageRole.USER ? createUserContent(parts) : createModelContent(parts);
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(msg)), {
     invocationId,
     author: msg.role === MessageRole.USER ? MessageRole.USER : agentName,
-    content: msg.role === MessageRole.USER ? createUserContent(parts) : createModelContent(parts),
+    content,
     turnComplete: true,
     partial: false
   });
@@ -126,6 +127,9 @@ function taskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
     return void 0;
   }
   const parts = toGenAIParts(msg.parts);
+  if (parts.length === 0) {
+    return void 0;
+  }
   return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
     invocationId,
     author: agentName,
@@ -155,7 +159,7 @@ function taskToAdkEvent(a2aTask, invocationId, agentName) {
   }
   const isTerminal = isTerminalTaskStatusUpdateEvent(a2aTask) || isInputRequiredTaskStatusUpdateEvent(a2aTask);
   const isFailed = isFailedTaskStatusUpdateEvent(a2aTask);
-  if (parts.length === 0 && !isTerminal) {
+  if (parts.length === 0 && !isFailed) {
     return void 0;
   }
   return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aTask)), {

package/dist/web/a2a/metadata_converter_utils.js

@@ -73,7 +73,7 @@ function getA2AEventMetadata(adkEvent, {
     [A2AMetadataKeys.INVOCATION_ID]: adkEvent.invocationId,
     [A2AMetadataKeys.AUTHOR]: adkEvent.author,
     [A2AMetadataKeys.BRANCH]: adkEvent.branch,
-    [A2AMetadataKeys.ERROR_CODE]: adkEvent.errorMessage,
+    [A2AMetadataKeys.ERROR_CODE]: adkEvent.errorCode,
     [A2AMetadataKeys.ERROR_MESSAGE]: adkEvent.errorMessage,
     [A2AMetadataKeys.CITATION_METADATA]: adkEvent.citationMetadata,
     [A2AMetadataKeys.GROUNDING_METADATA]: adkEvent.groundingMetadata,

package/dist/web/agents/base_agent.js

@@ -93,6 +93,7 @@ class BaseAgent {
      * A unique symbol to identify ADK agent classes.
      */
     this[_a] = true;
+    this.config = __spreadValues({}, config);
     this.name = validateAgentName(config.name);
     this.description = config.description;
     this.parentAgent = config.parentAgent;
@@ -110,6 +111,44 @@ class BaseAgent {
   get rootAgent() {
     return getRootAgent(this);
   }
+  /**
+   * 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) {
+    if (overrides && "parentAgent" in overrides) {
+      throw new Error(
+        "Cannot update `parentAgent` field in clone. Parent agent is set only when the parent agent is instantiated with the sub-agents."
+      );
+    }
+    const merged = __spreadValues(__spreadValues({}, this.config), overrides);
+    merged.parentAgent = void 0;
+    const mergedRecord = merged;
+    for (const key of Object.keys(mergedRecord)) {
+      if (key === "subAgents" || overrides && key in overrides) {
+        continue;
+      }
+      const value = mergedRecord[key];
+      if (Array.isArray(value)) {
+        mergedRecord[key] = value.slice();
+      }
+    }
+    if (!overrides || !("subAgents" in overrides)) {
+      merged.subAgents = this.subAgents.map((subAgent) => subAgent.clone());
+    }
+    const ctor = this.constructor;
+    return new ctor(merged);
+  }
   /**
    * Entry method to run an agent via text-based conversation.
    *

package/dist/web/agents/functions.js

@@ -9,11 +9,11 @@ import { createUserContent } from "@google/genai";
 import { isEmpty } from "lodash-es";
 import {
   createEvent,
+  generateClientFunctionCallId,
   getFunctionCalls,
   getFunctionResponses
 } from "../events/event.js";
 import { mergeEventActions } from "../events/event_actions.js";
-import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
 import { Context } from "./context.js";
 import {
@@ -21,7 +21,11 @@ import {
   tracer,
   traceToolCall
 } from "../telemetry/tracing.js";
-const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+import {
+  AF_FUNCTION_CALL_ID_PREFIX,
+  generateClientFunctionCallId as generateClientFunctionCallId2,
+  populateClientFunctionCallId
+} from "../events/event.js";
 const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
 const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 const functionsExportedForTestingOnly = {
@@ -29,20 +33,6 @@ const functionsExportedForTestingOnly = {
   generateAuthEvent,
   generateRequestConfirmationEvent
 };
-function generateClientFunctionCallId() {
-  return "".concat(AF_FUNCTION_CALL_ID_PREFIX).concat(randomUUID());
-}
-function populateClientFunctionCallId(modelResponseEvent) {
-  const functionCalls = getFunctionCalls(modelResponseEvent);
-  if (!functionCalls) {
-    return;
-  }
-  for (const functionCall of functionCalls) {
-    if (!functionCall.id) {
-      functionCall.id = generateClientFunctionCallId();
-    }
-  }
-}
 function getLongRunningFunctionCalls(functionCalls, toolsDict) {
   const longRunningToolIds = /* @__PURE__ */ new Set();
   for (const functionCall of functionCalls) {
@@ -420,7 +410,7 @@ export {
   findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   generateAuthEvent,
-  generateClientFunctionCallId,
+  generateClientFunctionCallId2 as generateClientFunctionCallId,
   generateRequestConfirmationEvent,
   getLongRunningFunctionCalls,
   handleFunctionCallList,

package/dist/web/agents/llm_agent.js

@@ -77,7 +77,8 @@ import {
   createNewEventId,
   getFunctionCalls,
   getFunctionResponses,
-  isFinalResponse
+  isFinalResponse,
+  populateClientFunctionCallId
 } from "../events/event.js";
 import { isBaseLlm } from "../models/base_llm.js";
 import { LLMRegistry } from "../models/registry.js";
@@ -95,8 +96,7 @@ import {
   generateAuthEvent,
   generateRequestConfirmationEvent,
   getLongRunningFunctionCalls,
-  handleFunctionCallsAsync,
-  populateClientFunctionCallId
+  handleFunctionCallsAsync
 } from "./functions.js";
 import { AUTH_PREPROCESSOR } from "../auth/auth_preprocessor.js";
 import { AGENT_TRANSFER_LLM_REQUEST_PROCESSOR } from "./processors/agent_transfer_llm_request_processor.js";
@@ -247,6 +247,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
    * 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.
    */
   async canonicalGlobalInstruction(context2) {
     if (typeof this.globalInstruction === "string") {