@softactivate/adk 1.1.0

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

@@ -0,0 +1,79 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isCompactedEvent } from "../../events/compacted_event.js";
+import { isLlmAgent } from "../llm_agent.js";
+import {
+  getContents,
+  getCurrentTurnContents
+} from "./content_processor_utils.js";
+class ContentRequestProcessor {
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      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];
+      }
+      if (agent.includeContents === "default") {
+        llmRequest.contents = getContents(
+          events,
+          agent.name,
+          invocationContext.branch
+        );
+      } else {
+        llmRequest.contents = getCurrentTurnContents(
+          events,
+          agent.name,
+          invocationContext.branch
+        );
+      }
+      return;
+    });
+  }
+}
+const CONTENT_REQUEST_PROCESSOR = new ContentRequestProcessor();
+export {
+  CONTENT_REQUEST_PROCESSOR,
+  ContentRequestProcessor
+};

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

@@ -0,0 +1,60 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ContextCompactionTrigger } from "../../plugins/base_plugin.js";
+class ContextCompactorRequestProcessor {
+  constructor(compactors) {
+    this.compactors = compactors;
+  }
+  runAsync(invocationContext, _llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      for (const compactor of this.compactors) {
+        const shouldCompact = yield new __await(Promise.resolve(
+          compactor.shouldCompact(invocationContext)
+        ));
+        if (shouldCompact) {
+          yield new __await(invocationContext.pluginManager.runBeforeContextCompaction({
+            invocationContext,
+            trigger: ContextCompactionTrigger.Auto
+          }));
+          const oldEvents = new Set(invocationContext.session.events);
+          yield new __await(Promise.resolve(compactor.compact(invocationContext)));
+          yield new __await(invocationContext.pluginManager.runAfterContextCompaction({
+            invocationContext,
+            trigger: ContextCompactionTrigger.Auto
+          }));
+          const newEvents = invocationContext.session.events.filter(
+            (e) => !oldEvents.has(e)
+          );
+          for (const e of newEvents) {
+            yield e;
+          }
+          return;
+        }
+      }
+    });
+  }
+}
+export {
+  ContextCompactorRequestProcessor
+};

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

@@ -0,0 +1,43 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../../models/llm_request.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class IdentityLlmRequestProcessor extends BaseLlmRequestProcessor {
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      const si = ['You are an agent. Your internal name is "'.concat(agent.name, '".')];
+      if (agent.description) {
+        si.push('The description about you is "'.concat(agent.description, '"'));
+      }
+      appendInstructions(llmRequest, si);
+    });
+  }
+}
+const IDENTITY_LLM_REQUEST_PROCESSOR = new IdentityLlmRequestProcessor();
+export {
+  IDENTITY_LLM_REQUEST_PROCESSOR,
+  IdentityLlmRequestProcessor
+};

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

@@ -0,0 +1,74 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { appendInstructions } from "../../models/llm_request.js";
+import { injectSessionState } from "../instructions.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class InstructionsLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /**
+   * Handles instructions and global instructions for LLM flow.
+   */
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent)) {
+        return;
+      }
+      const rootAgent = agent.rootAgent;
+      if (isLlmAgent(rootAgent) && rootAgent.globalInstruction) {
+        const { instruction, requireStateInjection } = yield new __await(rootAgent.canonicalGlobalInstruction(
+          new ReadonlyContext(invocationContext)
+        ));
+        let instructionWithState = instruction;
+        if (requireStateInjection) {
+          instructionWithState = yield new __await(injectSessionState(
+            instruction,
+            new ReadonlyContext(invocationContext)
+          ));
+        }
+        appendInstructions(llmRequest, [instructionWithState]);
+      }
+      if (agent.instruction) {
+        const { instruction, requireStateInjection } = yield new __await(agent.canonicalInstruction(
+          new ReadonlyContext(invocationContext)
+        ));
+        let instructionWithState = instruction;
+        if (requireStateInjection) {
+          instructionWithState = yield new __await(injectSessionState(
+            instruction,
+            new ReadonlyContext(invocationContext)
+          ));
+        }
+        appendInstructions(llmRequest, [instructionWithState]);
+      }
+    });
+  }
+}
+const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();
+export {
+  INSTRUCTIONS_LLM_REQUEST_PROCESSOR,
+  InstructionsLlmRequestProcessor
+};

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

@@ -0,0 +1,160 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  getFunctionCalls,
+  getFunctionResponses
+} from "../../events/event.js";
+import { ToolConfirmation } from "../../tools/tool_confirmation.js";
+import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  handleFunctionCallList
+} from "../functions.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class RequestConfirmationLlmRequestProcessor extends BaseLlmRequestProcessor {
+  /** Handles tool confirmation information to build the LLM request. */
+  runAsync(invocationContext) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent)) {
+        return;
+      }
+      const events = invocationContext.session.events;
+      if (!events || events.length === 0) {
+        return;
+      }
+      const requestConfirmationFunctionResponses = {};
+      let confirmationEventIndex = -1;
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.author !== "user") {
+          continue;
+        }
+        const responses = getFunctionResponses(event);
+        if (!responses) {
+          continue;
+        }
+        let foundConfirmation = false;
+        for (const functionResponse of responses) {
+          if (functionResponse.name !== REQUEST_CONFIRMATION_FUNCTION_CALL_NAME) {
+            continue;
+          }
+          foundConfirmation = true;
+          let toolConfirmation = null;
+          if (functionResponse.response && Object.keys(functionResponse.response).length === 1 && "response" in functionResponse.response) {
+            toolConfirmation = JSON.parse(
+              functionResponse.response["response"]
+            );
+          } else if (functionResponse.response) {
+            toolConfirmation = new ToolConfirmation({
+              hint: functionResponse.response["hint"],
+              payload: functionResponse.response["payload"],
+              confirmed: functionResponse.response["confirmed"]
+            });
+          }
+          if (functionResponse.id && toolConfirmation) {
+            requestConfirmationFunctionResponses[functionResponse.id] = toolConfirmation;
+          }
+        }
+        if (foundConfirmation) {
+          confirmationEventIndex = i;
+          break;
+        }
+      }
+      if (Object.keys(requestConfirmationFunctionResponses).length === 0) {
+        return;
+      }
+      for (let i = confirmationEventIndex - 1; i >= 0; i--) {
+        const event = events[i];
+        const functionCalls = getFunctionCalls(event);
+        if (!functionCalls) {
+          continue;
+        }
+        const toolsToResumeWithConfirmation = {};
+        const toolsToResumeWithArgs = {};
+        for (const functionCall of functionCalls) {
+          if (!functionCall.id || !(functionCall.id in requestConfirmationFunctionResponses)) {
+            continue;
+          }
+          const args = functionCall.args;
+          if (!args || !("originalFunctionCall" in args)) {
+            continue;
+          }
+          const originalFunctionCall = args["originalFunctionCall"];
+          if (originalFunctionCall.id) {
+            toolsToResumeWithConfirmation[originalFunctionCall.id] = requestConfirmationFunctionResponses[functionCall.id];
+            toolsToResumeWithArgs[originalFunctionCall.id] = originalFunctionCall;
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          continue;
+        }
+        for (let j = events.length - 1; j > confirmationEventIndex; j--) {
+          const eventToCheck = events[j];
+          const functionResponses = getFunctionResponses(eventToCheck);
+          if (!functionResponses) {
+            continue;
+          }
+          for (const fr of functionResponses) {
+            if (fr.id && fr.id in toolsToResumeWithConfirmation) {
+              delete toolsToResumeWithConfirmation[fr.id];
+              delete toolsToResumeWithArgs[fr.id];
+            }
+          }
+          if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+            break;
+          }
+        }
+        if (Object.keys(toolsToResumeWithConfirmation).length === 0) {
+          continue;
+        }
+        const toolsList = yield new __await(agent.canonicalTools(
+          new ReadonlyContext(invocationContext)
+        ));
+        const toolsDict = Object.fromEntries(
+          toolsList.map((tool) => [tool.name, tool])
+        );
+        const functionResponseEvent = yield new __await(handleFunctionCallList({
+          invocationContext,
+          functionCalls: Object.values(toolsToResumeWithArgs),
+          toolsDict,
+          beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+          afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+          filters: new Set(Object.keys(toolsToResumeWithConfirmation)),
+          toolConfirmationDict: toolsToResumeWithConfirmation
+        }));
+        if (functionResponseEvent) {
+          yield functionResponseEvent;
+        }
+        return;
+      }
+    });
+  }
+}
+const REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR = new RequestConfirmationLlmRequestProcessor();
+export {
+  REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
+  RequestConfirmationLlmRequestProcessor
+};

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

@@ -0,0 +1,62 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from "../context.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+class ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
+  /** Filters the set of tools on the request based on plugins. */
+  // eslint-disable-next-line require-yield
+  runAsync(invocationContext, llmRequest) {
+    return __asyncGenerator(this, null, function* () {
+      const agent = invocationContext.agent;
+      if (!isLlmAgent(agent)) {
+        return;
+      }
+      const toolsList = yield new __await(agent.canonicalTools(
+        new ReadonlyContext(invocationContext)
+      ));
+      if (toolsList.length === 0) {
+        return;
+      }
+      const toolsDict = {};
+      for (const tool of toolsList) {
+        toolsDict[tool.name] = tool;
+      }
+      const callbackContext = new Context({ invocationContext });
+      const filteredTools = yield new __await(invocationContext.pluginManager.runBeforeToolSelection({
+        callbackContext,
+        tools: toolsDict
+      }));
+      if (filteredTools !== void 0) {
+        llmRequest.allowedTools = Object.keys(filteredTools);
+      }
+    });
+  }
+}
+const TOOL_FILTER_REQUEST_PROCESSOR = new ToolFilterRequestProcessor();
+export {
+  TOOL_FILTER_REQUEST_PROCESSOR,
+  ToolFilterRequestProcessor
+};

package/dist/web/agents/readonly_context.js

@@ -0,0 +1,55 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { State } from "../sessions/state.js";
+class ReadonlyContext {
+  constructor(invocationContext) {
+    this.invocationContext = invocationContext;
+  }
+  /**
+   * The user content that started this invocation.
+   */
+  get userContent() {
+    return this.invocationContext.userContent;
+  }
+  /**
+   * The current invocation id.
+   */
+  get invocationId() {
+    return this.invocationContext.invocationId;
+  }
+  /**
+   * The user ID of the current session.
+   */
+  get userId() {
+    return this.invocationContext.userId;
+  }
+  /**
+   * The ID of the current session.
+   */
+  get sessionId() {
+    return this.invocationContext.session.id;
+  }
+  /**
+   * The current agent name.
+   */
+  get agentName() {
+    return this.invocationContext.agent.name;
+  }
+  /**
+   * The state of the current session.
+   */
+  get state() {
+    return new State(
+      this.invocationContext.session.state,
+      {}
+    );
+  }
+}
+export {
+  ReadonlyContext
+};

package/dist/web/agents/routed_agent.js

@@ -0,0 +1,138 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { BaseAgent } from "./base_agent.js";
+import { experimental } from "../utils/experimental.js";
+import { runWithRouting } from "../utils/failover_utils.js";
+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 = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYMBOL, _b) {
+  constructor(config) {
+    const agentsArray = Array.isArray(config.agents) ? config.agents : Object.values(config.agents);
+    super(__spreadProps(__spreadValues({}, 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.
+   */
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      yield* __yieldStar(runWithRouting(
+        this.agents,
+        context,
+        this.router,
+        (agent) => agent.runAsync(context)
+      ));
+    });
+  }
+  /**
+   * Runs the selected agent via video/audio-based conversation.
+   */
+  runLiveImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      yield* __yieldStar(runWithRouting(
+        this.agents,
+        context,
+        this.router,
+        (agent) => agent.runLive(context)
+      ));
+    });
+  }
+};
+RoutedAgent = __decorateClass([
+  experimental
+], RoutedAgent);
+export {
+  RoutedAgent,
+  isRoutedAgent
+};