@google/adk 0.6.1 → 1.1.0

package/dist/cjs/agents/base_agent.js

@@ -83,19 +83,20 @@ class BaseAgent {
         ctx,
         this,
         async function* () {
+          var _a2, _b;
           const context2 = this.createInvocationContext(parentContext);
           const beforeAgentCallbackEvent = await this.handleBeforeAgentCallback(context2);
           if (beforeAgentCallbackEvent) {
             yield beforeAgentCallbackEvent;
           }
-          if (context2.endInvocation) {
+          if (context2.endInvocation || ((_a2 = parentContext.abortSignal) == null ? void 0 : _a2.aborted)) {
             return;
           }
           (0, import_tracing.traceAgentInvocation)({ agent: this, invocationContext: context2 });
           for await (const event of this.runAsyncImpl(context2)) {
             yield event;
           }
-          if (context2.endInvocation) {
+          if (context2.endInvocation || ((_b = parentContext.abortSignal) == null ? void 0 : _b.aborted)) {
             return;
           }
           const afterAgentCallbackEvent = await this.handleAfterAgentCallback(context2);
@@ -177,12 +178,16 @@ class BaseAgent {
    *     generated.
    */
   async handleBeforeAgentCallback(invocationContext) {
+    var _a2;
     if (this.beforeAgentCallback.length === 0) {
       return void 0;
     }
     const callbackContext = new import_context.Context({ invocationContext });
     for (const callback of this.beforeAgentCallback) {
       const content = await callback(callbackContext);
+      if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
       if (content) {
         invocationContext.endInvocation = true;
         return (0, import_event.createEvent)({
@@ -212,12 +217,16 @@ class BaseAgent {
    *     generated.
    */
   async handleAfterAgentCallback(invocationContext) {
+    var _a2;
     if (this.afterAgentCallback.length === 0) {
       return void 0;
     }
     const callbackContext = new import_context.Context({ invocationContext });
     for (const callback of this.afterAgentCallback) {
       const content = await callback(callbackContext);
+      if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
       if (content) {
         return (0, import_event.createEvent)({
           invocationId: invocationContext.invocationId,

package/dist/cjs/agents/context.js

@@ -59,6 +59,7 @@ class Context extends import_readonly_context.ReadonlyContext {
     );
     this.functionCallId = options.functionCallId;
     this.toolConfirmation = options.toolConfirmation;
+    this.abortSignal = options.invocationContext.abortSignal;
   }
   /**
    * The delta-aware state of the current session.

package/dist/cjs/agents/functions.js

@@ -415,6 +415,7 @@ function mergeParallelFunctionResponseEvents(functionResponseEvents) {
   );
   const mergedActions = (0, import_event_actions.mergeEventActions)(actionsList);
   return (0, import_event.createEvent)({
+    invocationId: baseEvent.invocationId,
     author: baseEvent.author,
     branch: baseEvent.branch,
     content: { role: "user", parts: mergedParts },

package/dist/cjs/agents/invocation_context.js

@@ -77,6 +77,7 @@ class InvocationContext {
     this.liveRequestQueue = params.liveRequestQueue;
     this.activeStreamingTools = params.activeStreamingTools;
     this.pluginManager = params.pluginManager;
+    this.abortSignal = params.abortSignal;
   }
   /**
    * The app name of the current session.

package/dist/cjs/agents/llm_agent.js

@@ -47,6 +47,7 @@ var import_context_compactor_request_processor = require("./processors/context_c
 var import_identity_llm_request_processor = require("./processors/identity_llm_request_processor.js");
 var import_instructions_llm_request_processor = require("./processors/instructions_llm_request_processor.js");
 var import_request_confirmation_llm_request_processor = require("./processors/request_confirmation_llm_request_processor.js");
+var import_tool_filter_request_processor = require("./processors/tool_filter_request_processor.js");
 var import_readonly_context = require("./readonly_context.js");
 var import_run_config = require("./run_config.js");
 /**
@@ -94,7 +95,8 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       import_instructions_llm_request_processor.INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
       import_request_confirmation_llm_request_processor.REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
       import_content_request_processor.CONTENT_REQUEST_PROCESSOR,
-      import_code_execution_request_processor.CODE_EXECUTION_REQUEST_PROCESSOR
+      import_code_execution_request_processor.CODE_EXECUTION_REQUEST_PROCESSOR,
+      import_tool_filter_request_processor.TOOL_FILTER_REQUEST_PROCESSOR
     ];
     if (!config.requestProcessors && config.contextCompactors && config.contextCompactors.length > 0) {
       const contentIndex = this.requestProcessors.indexOf(
@@ -314,9 +316,13 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     event.actions.stateDelta[this.outputKey] = result;
   }
   async *runAsyncImpl(context2) {
+    var _a2;
     while (true) {
       let lastEvent = void 0;
       for await (const event of this.runOneStepAsync(context2)) {
+        if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
         lastEvent = event;
         this.maybeSaveOutputToState(event);
         yield event;
@@ -331,7 +337,11 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     }
   }
   async *runLiveImpl(context2) {
+    var _a2;
     for await (const event of this.runLiveFlow(context2)) {
+      if ((_a2 = context2.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
       this.maybeSaveOutputToState(event);
       yield event;
     }
@@ -348,6 +358,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     throw new Error("LlmAgent.runLiveFlow not implemented");
   }
   async *runOneStepAsync(invocationContext) {
+    var _a2, _b2, _c;
     const llmRequest = {
       contents: [],
       toolsDict: {},
@@ -358,20 +369,28 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         invocationContext,
         llmRequest
       )) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
         yield event;
       }
     }
     for (const toolUnion of this.tools) {
       const toolContext = new import_context.Context({ invocationContext });
-      const tools = await convertToolUnionToTools(
+      const tools = (await convertToolUnionToTools(
         toolUnion,
         new import_readonly_context.ReadonlyContext(invocationContext)
-      );
+      )).filter((tool) => {
+        return !llmRequest.allowedTools || llmRequest.allowedTools.includes(tool.name);
+      });
       for (const tool of tools) {
         await tool.processLlmRequest({ toolContext, llmRequest });
+        if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
+          return;
+        }
       }
     }
-    if (invocationContext.endInvocation) {
+    if (invocationContext.endInvocation || ((_c = invocationContext.abortSignal) == null ? void 0 : _c.aborted)) {
       return;
     }
     const modelResponseEvent = (0, import_event.createEvent)({
@@ -386,17 +405,24 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       this,
       async function* () {
         const responsesGenerator = async function* () {
+          var _a3, _b3;
           for await (const llmResponse of this.callLlmAsync(
             invocationContext,
             llmRequest,
             modelResponseEvent
           )) {
+            if ((_a3 = invocationContext.abortSignal) == null ? void 0 : _a3.aborted) {
+              return;
+            }
             for await (const event of this.postprocess(
               invocationContext,
               llmRequest,
               llmResponse,
               modelResponseEvent
             )) {
+              if ((_b3 = invocationContext.abortSignal) == null ? void 0 : _b3.aborted) {
+                return;
+              }
               modelResponseEvent.id = (0, import_event.createNewEventId)();
               modelResponseEvent.timestamp = (/* @__PURE__ */ new Date()).getTime();
               yield event;
@@ -414,12 +440,15 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     span.end();
   }
   async *postprocess(invocationContext, llmRequest, llmResponse, modelResponseEvent) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d, _e;
     for (const processor of this.responseProcessors) {
       for await (const event of processor.runAsync(
         invocationContext,
         llmResponse
       )) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
         yield event;
       }
     }
@@ -440,10 +469,10 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       }
     }
     yield mergedEvent;
-    if (!((_a2 = (0, import_event.getFunctionCalls)(mergedEvent)) == null ? void 0 : _a2.length)) {
+    if (!((_b2 = (0, import_event.getFunctionCalls)(mergedEvent)) == null ? void 0 : _b2.length)) {
       return;
     }
-    if ((_b2 = invocationContext.runConfig) == null ? void 0 : _b2.pauseOnToolCalls) {
+    if ((_c = invocationContext.runConfig) == null ? void 0 : _c.pauseOnToolCalls) {
       invocationContext.endInvocation = true;
       return;
     }
@@ -454,7 +483,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       beforeToolCallbacks: this.canonicalBeforeToolCallbacks,
       afterToolCallbacks: this.canonicalAfterToolCallbacks
     });
-    if (!functionResponseEvent) {
+    if (!functionResponseEvent || ((_d = invocationContext.abortSignal) == null ? void 0 : _d.aborted)) {
       return;
     }
     const authEvent = (0, import_functions.generateAuthEvent)(
@@ -479,6 +508,9 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     if (nextAgentName) {
       const nextAgent = this.getAgentByName(invocationContext, nextAgentName);
       for await (const event of nextAgent.runAsync(invocationContext)) {
+        if ((_e = invocationContext.abortSignal) == null ? void 0 : _e.aborted) {
+          return;
+        }
         yield event;
       }
     }
@@ -504,30 +536,34 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     return agentToRun;
   }
   async *callLlmAsync(invocationContext, llmRequest, modelResponseEvent) {
-    var _a2, _b2, _c, _d, _e;
+    var _a2, _b2, _c, _d, _e, _f, _g, _h;
     const beforeModelResponse = await this.handleBeforeModelCallback(
       invocationContext,
       llmRequest,
       modelResponseEvent
     );
+    if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return;
+    }
     if (beforeModelResponse) {
       yield beforeModelResponse;
       return;
     }
-    (_a2 = llmRequest.config) != null ? _a2 : llmRequest.config = {};
-    (_c = (_b2 = llmRequest.config).labels) != null ? _c : _b2.labels = {};
+    (_b2 = llmRequest.config) != null ? _b2 : llmRequest.config = {};
+    (_d = (_c = llmRequest.config).labels) != null ? _d : _c.labels = {};
     if (!llmRequest.config.labels[ADK_AGENT_NAME_LABEL_KEY]) {
       llmRequest.config.labels[ADK_AGENT_NAME_LABEL_KEY] = this.name;
     }
     const llm = this.canonicalModel;
-    if ((_d = invocationContext.runConfig) == null ? void 0 : _d.supportCfc) {
+    if ((_e = invocationContext.runConfig) == null ? void 0 : _e.supportCfc) {
       throw new Error("CFC is not yet supported in callLlmAsync");
     } else {
       invocationContext.incrementLlmCallCount();
       const responsesGenerator = llm.generateContentAsync(
         llmRequest,
         /* stream= */
-        ((_e = invocationContext.runConfig) == null ? void 0 : _e.streamingMode) === import_run_config.StreamingMode.SSE
+        ((_f = invocationContext.runConfig) == null ? void 0 : _f.streamingMode) === import_run_config.StreamingMode.SSE,
+        invocationContext.abortSignal
       );
       for await (const llmResponse of responsesGenerator) {
         (0, import_tracing.traceCallLlm)({
@@ -536,16 +572,23 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
           llmRequest,
           llmResponse
         });
+        if ((_g = invocationContext.abortSignal) == null ? void 0 : _g.aborted) {
+          return;
+        }
         const alteredLlmResponse = await this.handleAfterModelCallback(
           invocationContext,
           llmResponse,
           modelResponseEvent
         );
+        if ((_h = invocationContext.abortSignal) == null ? void 0 : _h.aborted) {
+          return;
+        }
         yield alteredLlmResponse != null ? alteredLlmResponse : llmResponse;
       }
     }
   }
   async handleBeforeModelCallback(invocationContext, llmRequest, modelResponseEvent) {
+    var _a2, _b2;
     const callbackContext = new import_context.Context({
       invocationContext,
       eventActions: modelResponseEvent.actions
@@ -554,6 +597,9 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
       callbackContext,
       llmRequest
     });
+    if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return;
+    }
     if (beforeModelCallbackResponse) {
       return beforeModelCallbackResponse;
     }
@@ -562,6 +608,9 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         context: callbackContext,
         request: llmRequest
       });
+      if ((_b2 = invocationContext.abortSignal) == null ? void 0 : _b2.aborted) {
+        return;
+      }
       if (callbackResponse) {
         return callbackResponse;
       }
@@ -569,6 +618,7 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     return void 0;
   }
   async handleAfterModelCallback(invocationContext, llmResponse, modelResponseEvent) {
+    var _a2;
     const callbackContext = new import_context.Context({
       invocationContext,
       eventActions: modelResponseEvent.actions
@@ -585,6 +635,9 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
         context: callbackContext,
         response: llmResponse
       });
+      if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
       if (callbackResponse) {
         return callbackResponse;
       }
@@ -592,8 +645,12 @@ class LlmAgent extends (_b = import_base_agent.BaseAgent, _a = LLM_AGENT_SIGNATU
     return void 0;
   }
   async *runAndHandleError(responseGenerator, invocationContext, llmRequest, modelResponseEvent) {
+    var _a2;
     try {
       for await (const response of responseGenerator) {
+        if ((_a2 = invocationContext.abortSignal) == null ? void 0 : _a2.aborted) {
+          return;
+        }
         yield response;
       }
     } catch (modelError) {

package/dist/cjs/agents/loop_agent.js

@@ -50,11 +50,15 @@ class LoopAgent extends (_b = import_base_agent.BaseAgent, _a = LOOP_AGENT_SIGNA
     this.maxIterations = (_a2 = config.maxIterations) != null ? _a2 : Number.MAX_SAFE_INTEGER;
   }
   async *runAsyncImpl(context) {
+    var _a2;
     let iteration = 0;
     while (iteration < this.maxIterations) {
       for (const subAgent of this.subAgents) {
         let shouldExit = false;
         for await (const event of subAgent.runAsync(context)) {
+          if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+            return;
+          }
           yield event;
           if (event.actions.escalate) {
             shouldExit = true;

package/dist/cjs/agents/parallel_agent.js

@@ -49,10 +49,14 @@ class ParallelAgent extends (_b = import_base_agent.BaseAgent, _a = PARALLEL_AGE
     this[_a] = true;
   }
   async *runAsyncImpl(context) {
+    var _a2;
     const agentRuns = this.subAgents.map(
       (subAgent) => subAgent.runAsync(createBranchCtxForSubAgent(this, subAgent, context))
     );
     for await (const event of mergeAgentRuns(agentRuns)) {
+      if ((_a2 = context.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
       yield event;
     }
   }

package/dist/cjs/agents/processors/code_execution_request_processor.js

@@ -194,6 +194,7 @@ async function* runPreProcessor(invocationContext, llmRequest) {
       invocationContext,
       codeExecutionInput: {
         code: codeStr,
+        language: import_code_execution_utils.CodeExecutionLanguage.PYTHON,
         inputFiles: [file],
         executionId
       }
@@ -257,6 +258,7 @@ async function* runPostProcessor(invocationContext, llmResponse) {
     invocationContext,
     codeExecutionInput: {
       code: codeStr,
+      language: import_code_execution_utils.CodeExecutionLanguage.PYTHON,
       inputFiles: codeExecutorContext.getInputFiles(),
       executionId
     }

package/dist/cjs/agents/processors/context_compactor_request_processor.js

@@ -27,6 +27,7 @@ __export(context_compactor_request_processor_exports, {
   ContextCompactorRequestProcessor: () => ContextCompactorRequestProcessor
 });
 module.exports = __toCommonJS(context_compactor_request_processor_exports);
+var import_base_plugin = require("../../plugins/base_plugin.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -42,8 +43,16 @@ class ContextCompactorRequestProcessor {
         compactor.shouldCompact(invocationContext)
       );
       if (shouldCompact) {
+        await invocationContext.pluginManager.runBeforeContextCompaction({
+          invocationContext,
+          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+        });
         const oldEvents = new Set(invocationContext.session.events);
         await Promise.resolve(compactor.compact(invocationContext));
+        await invocationContext.pluginManager.runAfterContextCompaction({
+          invocationContext,
+          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+        });
         const newEvents = invocationContext.session.events.filter(
           (e) => !oldEvents.has(e)
         );

package/dist/cjs/agents/processors/tool_filter_request_processor.js

@@ -0,0 +1,73 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_filter_request_processor_exports = {};
+__export(tool_filter_request_processor_exports, {
+  TOOL_FILTER_REQUEST_PROCESSOR: () => TOOL_FILTER_REQUEST_PROCESSOR,
+  ToolFilterRequestProcessor: () => ToolFilterRequestProcessor
+});
+module.exports = __toCommonJS(tool_filter_request_processor_exports);
+var import_context = require("../context.js");
+var import_llm_agent = require("../llm_agent.js");
+var import_readonly_context = require("../readonly_context.js");
+var import_base_llm_processor = require("./base_llm_processor.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToolFilterRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /** Filters the set of tools on the request based on plugins. */
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const toolsList = await agent.canonicalTools(
+      new import_readonly_context.ReadonlyContext(invocationContext)
+    );
+    if (toolsList.length === 0) {
+      return;
+    }
+    const toolsDict = {};
+    for (const tool of toolsList) {
+      toolsDict[tool.name] = tool;
+    }
+    const callbackContext = new import_context.Context({ invocationContext });
+    const filteredTools = await invocationContext.pluginManager.runBeforeToolSelection({
+      callbackContext,
+      tools: toolsDict
+    });
+    if (filteredTools !== void 0) {
+      llmRequest.allowedTools = Object.keys(filteredTools);
+    }
+  }
+}
+const TOOL_FILTER_REQUEST_PROCESSOR = new ToolFilterRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TOOL_FILTER_REQUEST_PROCESSOR,
+  ToolFilterRequestProcessor
+});

package/dist/cjs/agents/routed_agent.js

@@ -0,0 +1,97 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var routed_agent_exports = {};
+__export(routed_agent_exports, {
+  RoutedAgent: () => RoutedAgent,
+  isRoutedAgent: () => isRoutedAgent
+});
+module.exports = __toCommonJS(routed_agent_exports);
+var import_base_agent = require("./base_agent.js");
+var import_experimental = require("../utils/experimental.js");
+var import_failover_utils = require("../utils/failover_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+const ROUTED_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.routedAgent");
+function isRoutedAgent(obj) {
+  return typeof obj === "object" && obj !== null && ROUTED_AGENT_SIGNATURE_SYMBOL in obj && obj[ROUTED_AGENT_SIGNATURE_SYMBOL] === true;
+}
+let RoutedAgent = class extends (_b = import_base_agent.BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    const agentsArray = Array.isArray(config.agents) ? config.agents : Object.values(config.agents);
+    super({
+      ...config,
+      subAgents: agentsArray
+    });
+    this[_a] = true;
+    if (Array.isArray(config.agents)) {
+      this.agents = Object.fromEntries(config.agents.map((a) => [a.name, a]));
+    } else {
+      this.agents = config.agents;
+    }
+    this.router = config.router;
+  }
+  /**
+   * Runs the selected agent via text-based conversation.
+   */
+  async *runAsyncImpl(context) {
+    yield* (0, import_failover_utils.runWithRouting)(
+      this.agents,
+      context,
+      this.router,
+      (agent) => agent.runAsync(context)
+    );
+  }
+  /**
+   * Runs the selected agent via video/audio-based conversation.
+   */
+  async *runLiveImpl(context) {
+    yield* (0, import_failover_utils.runWithRouting)(
+      this.agents,
+      context,
+      this.router,
+      (agent) => agent.runLive(context)
+    );
+  }
+};
+RoutedAgent = __decorateClass([
+  import_experimental.experimental
+], RoutedAgent);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RoutedAgent,
+  isRoutedAgent
+});

package/dist/cjs/auth/auth_handler.js

@@ -27,6 +27,8 @@ __export(auth_handler_exports, {
   AuthHandler: () => AuthHandler
 });
 module.exports = __toCommonJS(auth_handler_exports);
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_oauth2_credential_exchanger = require("./oauth2/oauth2_credential_exchanger.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -40,6 +42,22 @@ class AuthHandler {
     const credentialKey = "temp:" + this.authConfig.credentialKey;
     return state.get(credentialKey);
   }
+  async parseAndStoreAuthResponse(state) {
+    const credentialKey = "temp:" + this.authConfig.credentialKey;
+    const authSchemeType = this.authConfig.authScheme.type;
+    if (!["oauth2", "openIdConnect"].includes(authSchemeType)) {
+      state.set(credentialKey, this.authConfig.exchangedAuthCredential);
+      return;
+    }
+    if (this.authConfig.exchangedAuthCredential) {
+      const exchanger = new import_oauth2_credential_exchanger.OAuth2CredentialExchanger();
+      const exchangedCredential = await exchanger.exchange({
+        authCredential: this.authConfig.exchangedAuthCredential,
+        authScheme: this.authConfig.authScheme
+      });
+      state.set(credentialKey, exchangedCredential.credential);
+    }
+  }
   generateAuthRequest() {
     var _a, _b;
     const authSchemeType = this.authConfig.authScheme.type;
@@ -85,7 +103,54 @@ class AuthHandler {
    *     auth scheme.
    */
   generateAuthUri() {
-    return this.authConfig.rawAuthCredential;
+    const authScheme = this.authConfig.authScheme;
+    const authCredential = this.authConfig.rawAuthCredential;
+    if (!authCredential || !authCredential.oauth2) {
+      return authCredential;
+    }
+    let authorizationEndpoint = "";
+    let scopes = [];
+    if ("authorizationEndpoint" in authScheme) {
+      authorizationEndpoint = authScheme.authorizationEndpoint;
+      scopes = authScheme.scopes || [];
+    } else if (authScheme.type === "oauth2" && authScheme.flows) {
+      const flows = authScheme.flows;
+      const flow = flows.implicit || flows.authorizationCode || flows.clientCredentials || flows.password;
+      if (flow) {
+        if ("authorizationUrl" in flow && flow.authorizationUrl) {
+          authorizationEndpoint = flow.authorizationUrl;
+        } else if ("tokenUrl" in flow && flow.tokenUrl) {
+          authorizationEndpoint = flow.tokenUrl;
+        }
+        if (flow.scopes) {
+          scopes = Object.keys(flow.scopes);
+        }
+      }
+    }
+    if (!authorizationEndpoint) {
+      throw new Error("Authorization endpoint not configured in auth scheme.");
+    }
+    const state = (0, import_env_aware_utils.randomUUID)();
+    const url = new URL(authorizationEndpoint);
+    url.searchParams.set("client_id", authCredential.oauth2.clientId || "");
+    url.searchParams.set(
+      "redirect_uri",
+      authCredential.oauth2.redirectUri || ""
+    );
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("scope", scopes.join(" "));
+    url.searchParams.set("state", state);
+    url.searchParams.set("access_type", "offline");
+    url.searchParams.set("prompt", "consent");
+    const exchangedAuthCredential = {
+      ...authCredential,
+      oauth2: {
+        ...authCredential.oauth2,
+        authUri: url.toString(),
+        state
+      }
+    };
+    return exchangedAuthCredential;
   }
 }
 // Annotate the CommonJS export names for ESM import in node: