@google/adk 1.4.0 → 1.6.0

package/dist/web/a2a/event_converter_utils.js

@@ -62,32 +62,34 @@ function toA2AMessage(event, {
     metadata: getA2AEventMetadata(event, { appName, userId, sessionId })
   };
 }
-function toAdkEvent(event, invocationId, agentName) {
+function toAdkEvent(event, invocationId, agentName, branch) {
   if (isMessage(event)) {
-    return messageToAdkEvent(event, invocationId, agentName);
+    return messageToAdkEvent(event, invocationId, agentName, branch);
   }
   if (isTask(event)) {
-    return taskToAdkEvent(event, invocationId, agentName);
+    return taskToAdkEvent(event, invocationId, agentName, branch);
   }
   if (isTaskArtifactUpdateEvent(event)) {
-    return artifactUpdateToAdkEvent(event, invocationId, agentName);
+    return artifactUpdateToAdkEvent(event, invocationId, agentName, branch);
   }
   if (isTaskStatusUpdateEvent(event)) {
-    return event.final ? finalTaskStatusUpdateToAdkEvent(event, invocationId, agentName) : taskStatusUpdateToAdkEvent(event, invocationId, agentName);
+    return event.final ? finalTaskStatusUpdateToAdkEvent(event, invocationId, agentName, branch) : taskStatusUpdateToAdkEvent(event, invocationId, agentName, branch);
   }
   return void 0;
 }
-function messageToAdkEvent(msg, invocationId, agentName, parentEvent) {
+function messageToAdkEvent(msg, invocationId, agentName, branch) {
   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),
+    branch,
+    content,
     turnComplete: true,
     partial: false
   });
 }
-function artifactUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+function artifactUpdateToAdkEvent(a2aEvent, invocationId, agentName, branch) {
   var _a;
   const partsToConvert = ((_a = a2aEvent.artifact) == null ? void 0 : _a.parts) || [];
   if (partsToConvert.length === 0) {
@@ -97,12 +99,13 @@ function artifactUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
   return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
     invocationId,
     author: agentName,
+    branch,
     content: createModelContent(toGenAIParts(partsToConvert)),
     longRunningToolIds: getLongRunningToolIDs(partsToConvert),
     partial
   });
 }
-function finalTaskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+function finalTaskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName, branch) {
   var _a;
   const partsToConvert = ((_a = a2aEvent.status.message) == null ? void 0 : _a.parts) || [];
   if (partsToConvert.length === 0) {
@@ -114,27 +117,32 @@ function finalTaskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
   return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
     invocationId,
     author: agentName,
+    branch,
     errorMessage: isFailedTask ? getFailedTaskStatusUpdateEventError(a2aEvent) : void 0,
     content: hasContent ? createModelContent(parts) : void 0,
     longRunningToolIds: getLongRunningToolIDs(partsToConvert),
     turnComplete: true
   });
 }
-function taskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+function taskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName, branch) {
   const msg = a2aEvent.status.message;
   if (!msg) {
     return void 0;
   }
   const parts = toGenAIParts(msg.parts);
+  if (parts.length === 0) {
+    return void 0;
+  }
   return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
     invocationId,
     author: agentName,
+    branch,
     content: createModelContent(parts),
     turnComplete: false,
     partial: true
   });
 }
-function taskToAdkEvent(a2aTask, invocationId, agentName) {
+function taskToAdkEvent(a2aTask, invocationId, agentName, branch) {
   var _a, _b;
   const parts = [];
   const longRunningToolIds = [];
@@ -155,22 +163,32 @@ 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)), {
     invocationId,
     author: agentName,
+    branch,
     content: isFailed ? void 0 : createModelContent(parts),
     errorMessage: isFailed ? getFailedTaskStatusUpdateEventError(a2aTask) : void 0,
     longRunningToolIds,
     turnComplete: isTerminal
   });
 }
+const PEER_SETTABLE_ACTION_FIELDS = /* @__PURE__ */ new Set(["escalate"]);
 function createAdkEventFromMetadata(a2aEvent) {
   const metadata = a2aEvent.metadata || {};
   return createEvent({
-    branch: metadata[A2AMetadataKeys.BRANCH],
+    // `branch` is intentionally NOT restored from peer metadata here (unlike
+    // the other fields below): it is the mechanism getContents() (see
+    // content_processor_utils.ts) uses to keep sibling sub-agent branches'
+    // conversation contexts isolated from each other. A remote A2A peer that
+    // controls its own outgoing metadata could otherwise forge `adk_branch`
+    // (set it to a shared ancestor branch, or omit it) to leak its content
+    // into an unrelated sibling agent's LLM context. Every caller of the
+    // `*ToAdkEvent` functions in this file force-sets `branch` from its own
+    // local `InvocationContext` instead, the same way `author` is handled.
     author: metadata[A2AMetadataKeys.AUTHOR],
     partial: metadata[A2AMetadataKeys.PARTIAL],
     errorCode: metadata[A2AMetadataKeys.ERROR_CODE],
@@ -179,10 +197,21 @@ function createAdkEventFromMetadata(a2aEvent) {
     groundingMetadata: metadata[A2AMetadataKeys.GROUNDING_METADATA],
     usageMetadata: metadata[A2AMetadataKeys.USAGE_METADATA],
     customMetadata: metadata[A2AMetadataKeys.CUSTOM_METADATA],
-    actions: createEventActions({
-      escalate: !!metadata[A2AMetadataKeys.ESCALATE],
-      transferToAgent: metadata[A2AMetadataKeys.TRANSFER_TO_AGENT]
-    })
+    // Only fields in PEER_SETTABLE_ACTION_FIELDS may be restored from
+    // metadata a remote A2A peer controls. Every other action field either
+    // mutates the caller's own session or drives the caller's own control
+    // flow (e.g. `transferToAgent`, see llm_agent.ts), so it must never be
+    // rebuilt from peer-supplied data. Filtering through an allowlist here
+    // (rather than just omitting the unsafe field) means a future action
+    // field is unsafe-by-default: adding it to `candidateActions` alone
+    // does nothing until it's also added to the allowlist.
+    actions: createEventActions(
+      Object.fromEntries(
+        Object.entries({
+          escalate: !!metadata[A2AMetadataKeys.ESCALATE]
+        }).filter(([key]) => PEER_SETTABLE_ACTION_FIELDS.has(key))
+      )
+    )
   });
 }
 function getLongRunningToolIDs(parts) {

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) {
@@ -195,6 +185,18 @@ async function handleFunctionCallsAsync({
     toolConfirmationDict
   });
 }
+function normalizeCallbackResponse(response) {
+  if (response == null) {
+    return void 0;
+  }
+  if (typeof response !== "object") {
+    return { result: response };
+  }
+  if (Array.isArray(response)) {
+    return { results: response };
+  }
+  return response;
+}
 async function handleFunctionCallList({
   invocationContext,
   functionCalls,
@@ -241,6 +243,7 @@ async function handleFunctionCallList({
         }
       }
     }
+    functionResponse = normalizeCallbackResponse(functionResponse);
     if (functionResponse == null) {
       try {
         functionResponse = await callToolAsync(tool, functionArgs, toolContext);
@@ -252,8 +255,8 @@ async function handleFunctionCallList({
             toolContext,
             error: e
           });
-          if (onToolErrorResponse) {
-            functionResponse = onToolErrorResponse;
+          if (onToolErrorResponse != null) {
+            functionResponse = normalizeCallbackResponse(onToolErrorResponse);
           } else {
             functionResponseError = e.message;
           }
@@ -282,17 +285,17 @@ async function handleFunctionCallList({
       }
     }
     if (alteredFunctionResponse != null) {
-      functionResponse = alteredFunctionResponse;
+      functionResponse = normalizeCallbackResponse(alteredFunctionResponse);
     }
-    if (tool.isLongRunning && !functionResponse) {
+    if (tool.isLongRunning && functionResponse == null) {
       continue;
     }
     if (functionResponseError) {
       functionResponse = { error: functionResponseError };
-    } else if (typeof functionResponse !== "object" || functionResponse == null) {
+    } else if (functionResponse == null) {
       functionResponse = { result: functionResponse };
-    } else if (Array.isArray(functionResponse)) {
-      functionResponse = { results: functionResponse };
+    } else {
+      functionResponse = normalizeCallbackResponse(functionResponse);
     }
     const functionResponseEvent = createEvent({
       invocationId: invocationContext.invocationId,
@@ -420,7 +423,7 @@ export {
   findMatchingFunctionCall,
   functionsExportedForTestingOnly,
   generateAuthEvent,
-  generateClientFunctionCallId,
+  generateClientFunctionCallId2 as generateClientFunctionCallId,
   generateRequestConfirmationEvent,
   getLongRunningFunctionCalls,
   handleFunctionCallList,

package/dist/web/agents/llm_agent.js

@@ -77,12 +77,14 @@ import {
   createNewEventId,
   getFunctionCalls,
   getFunctionResponses,
-  isFinalResponse
+  isFinalResponse,
+  populateClientFunctionCallId
 } from "../events/event.js";
 import { isBaseLlm } from "../models/base_llm.js";
 import { LLMRegistry } from "../models/registry.js";
 import { isBaseTool } from "../tools/base_tool.js";
 import { logger } from "../utils/logger.js";
+import { canUseOutputSchemaWithTools } from "../utils/output_schema_utils.js";
 import { Context } from "./context.js";
 import {
   runAsyncGeneratorWithOtelContext,
@@ -95,8 +97,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 +248,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") {
@@ -498,7 +500,7 @@ class LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNATURE_SYMBOL, _b) {
         }
       }
       const allTools = [...this.tools];
-      if (this.outputSchema && allTools.length > 0) {
+      if (this.outputSchema && allTools.length > 0 && !canUseOutputSchemaWithTools(this.canonicalModel.model)) {
         const setModelResponseTool = new FunctionTool({
           name: "set_model_response",
           description: "Call this tool to submit your final response conforming to the output schema. Use this tool only when you have collected all the information and are ready to return the final answer.",

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/basic_llm_request_processor.js

@@ -38,6 +38,7 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { setOutputSchema } from "../../models/llm_request.js";
+import { canUseOutputSchemaWithTools } from "../../utils/output_schema_utils.js";
 import { isLlmAgent } from "../llm_agent.js";
 import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
 class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
@@ -51,14 +52,14 @@ class BasicLlmRequestProcessor extends BaseLlmRequestProcessor {
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {
-      var _a;
+      var _a, _b;
       const agent = invocationContext.agent;
       if (!isLlmAgent(agent)) {
         return;
       }
       llmRequest.model = agent.canonicalModel.model;
       llmRequest.config = __spreadValues({}, (_a = agent.generateContentConfig) != null ? _a : {});
-      if (agent.outputSchema && (!agent.tools || agent.tools.length === 0)) {
+      if (agent.outputSchema && (!((_b = agent.tools) == null ? void 0 : _b.length) || canUseOutputSchemaWithTools(agent.canonicalModel.model))) {
         setOutputSchema(llmRequest, agent.outputSchema);
       }
       if (invocationContext.runConfig) {

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/processors/content_request_processor.js

@@ -21,7 +21,7 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { isCompactedEvent } from "../../events/compacted_event.js";
+import { getActiveEvents } from "../../context/compaction_utils.js";
 import { isLlmAgent } from "../llm_agent.js";
 import {
   getContents,
@@ -42,26 +42,7 @@ class ContentRequestProcessor {
       if (!agent || !isLlmAgent(agent)) {
         return;
       }
-      let events = invocationContext.session.events;
-      const compactedEvents = events.filter(isCompactedEvent);
-      const latestCompactedEvent = compactedEvents.length > 0 ? compactedEvents.reduce(
-        (latest, current) => current.endTime > latest.endTime ? current : latest
-      ) : void 0;
-      if (latestCompactedEvent) {
-        const remainingEvents = events.filter((event) => {
-          if (event === latestCompactedEvent) {
-            return false;
-          }
-          if (isCompactedEvent(event)) {
-            return false;
-          }
-          if (event.timestamp <= latestCompactedEvent.endTime) {
-            return false;
-          }
-          return true;
-        });
-        events = [latestCompactedEvent, ...remainingEvents];
-      }
+      const events = getActiveEvents(invocationContext.session.events);
       if (agent.includeContents === "default") {
         llmRequest.contents = getContents(
           events,

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

@@ -22,6 +22,7 @@ var __asyncGenerator = (__this, __arguments, generator) => {
  * SPDX-License-Identifier: Apache-2.0
  */
 import { appendInstructions } from "../../models/llm_request.js";
+import { canUseOutputSchemaWithTools } from "../../utils/output_schema_utils.js";
 import { injectSessionState } from "../instructions.js";
 import { isLlmAgent } from "../llm_agent.js";
 import { ReadonlyContext } from "../readonly_context.js";
@@ -33,6 +34,7 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
   // eslint-disable-next-line require-yield
   runAsync(invocationContext, llmRequest) {
     return __asyncGenerator(this, null, function* () {
+      var _a;
       const agent = invocationContext.agent;
       if (!isLlmAgent(agent)) {
         return;
@@ -64,7 +66,7 @@ class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
         }
         appendInstructions(llmRequest, [instructionWithState]);
       }
-      if (agent.outputSchema && agent.tools && agent.tools.length > 0) {
+      if (agent.outputSchema && ((_a = agent.tools) == null ? void 0 : _a.length) && !canUseOutputSchemaWithTools(agent.canonicalModel.model)) {
         appendInstructions(llmRequest, [
           'To output the final result, you must call the "set_model_response" function with the appropriate values. Do not output anything else.'
         ]);

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({
@@ -63,16 +70,14 @@ class InMemoryArtifactService {
     userId,
     sessionId
   }) {
-    const sessionPrefix = "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/");
-    const usernamespacePrefix = "".concat(appName, "/").concat(userId, "/user/");
+    const sessionPrefix = artifactPrefix("session", appName, userId, sessionId);
+    const userPrefix = artifactPrefix("user", appName, userId);
     const filenames = [];
     for (const path in this.artifacts) {
       if (path.startsWith(sessionPrefix)) {
-        const filename = path.replace(sessionPrefix, "");
-        filenames.push(filename);
-      } else if (path.startsWith(usernamespacePrefix)) {
-        const filename = path.replace(usernamespacePrefix, "");
-        filenames.push(filename);
+        filenames.push(decodeURIComponent(path.slice(sessionPrefix.length)));
+      } else if (path.startsWith(userPrefix)) {
+        filenames.push(decodeURIComponent(path.slice(userPrefix.length)));
       }
     }
     return Promise.resolve(filenames.sort());
@@ -143,9 +148,12 @@ class InMemoryArtifactService {
 }
 function artifactPath(appName, userId, sessionId, filename) {
   if (fileHasUserNamespace(filename)) {
-    return "".concat(appName, "/").concat(userId, "/user/").concat(filename);
+    return "".concat(artifactPrefix("user", appName, userId)).concat(encodeURIComponent(filename));
   }
-  return "".concat(appName, "/").concat(userId, "/").concat(sessionId, "/").concat(filename);
+  return "".concat(artifactPrefix("session", appName, userId, sessionId)).concat(encodeURIComponent(filename));
+}
+function artifactPrefix(scope, ...parts) {
+  return "".concat([scope, ...parts].map(encodeURIComponent).join("/"), "/");
 }
 function fileHasUserNamespace(filename) {
   return filename.startsWith("user:");