@google/adk 1.5.0 → 2.0.0

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

@@ -0,0 +1,228 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  getFunctionCalls,
+  getFunctionResponses
+} from "../../events/event.js";
+import { ToolConfirmation } from "../../tools/tool_confirmation.js";
+import { AsyncQueue } from "../../utils/async_queue.js";
+import { isNodeTool } from "../../workflow/nodes/node_tool.js";
+import {
+  interruptResponseMismatch,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  responseSchemasByInterruptId
+} from "../../workflow/utils/hitl_utils.js";
+import { unwrapResponse } from "../../workflow/utils/rehydration_utils.js";
+import { handleFunctionCallList } from "../functions.js";
+import { isLlmAgent } from "../llm_agent.js";
+import { ReadonlyContext } from "../readonly_context.js";
+import { BaseLlmRequestProcessor } from "./base_llm_processor.js";
+const _RequestInputLlmRequestProcessor = class _RequestInputLlmRequestProcessor extends BaseLlmRequestProcessor {
+  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 resumeInputs = collectResumeInputs(events);
+      if (Object.keys(resumeInputs).length === 0) {
+        return;
+      }
+      const toolsList = yield new __await(agent.canonicalTools(
+        new ReadonlyContext(invocationContext)
+      ));
+      const toolsDict = Object.fromEntries(toolsList.map((t) => [t.name, t]));
+      const nodeToolNames = new Set(
+        toolsList.filter((t) => isNodeTool(t)).map((t) => t.name)
+      );
+      if (nodeToolNames.size === 0) {
+        return;
+      }
+      const answeredIds = /* @__PURE__ */ new Set();
+      for (const event of events) {
+        for (const fr of getFunctionResponses(event)) {
+          if (fr.id) {
+            answeredIds.add(fr.id);
+          }
+        }
+      }
+      const pending = {};
+      for (const event of events) {
+        if (event.author !== agent.name) {
+          continue;
+        }
+        for (const fc of getFunctionCalls(event)) {
+          if (fc.id && fc.name && nodeToolNames.has(fc.name) && !answeredIds.has(fc.id)) {
+            pending[fc.id] = fc;
+          }
+        }
+      }
+      if (Object.keys(pending).length === 0) {
+        return;
+      }
+      const toolConfirmationDict = {};
+      for (const id of Object.keys(pending)) {
+        toolConfirmationDict[id] = new ToolConfirmation({
+          confirmed: true,
+          payload: resumeInputs
+        });
+      }
+      const eventQueue = new AsyncQueue();
+      invocationContext.eventQueue = eventQueue;
+      const task = (async () => {
+        try {
+          return await handleFunctionCallList({
+            invocationContext,
+            functionCalls: Object.values(pending),
+            toolsDict,
+            beforeToolCallbacks: agent.canonicalBeforeToolCallbacks,
+            afterToolCallbacks: agent.canonicalAfterToolCallbacks,
+            filters: new Set(Object.keys(pending)),
+            toolConfirmationDict
+          });
+        } finally {
+          eventQueue.close();
+        }
+      })();
+      try {
+        for (var iter = __forAwait(eventQueue), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const queuedEvent = temp.value;
+          yield queuedEvent;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      const functionResponseEvent = yield new __await(task);
+      invocationContext.eventQueue = void 0;
+      if (functionResponseEvent) {
+        yield functionResponseEvent;
+      }
+    });
+  }
+};
+__name(_RequestInputLlmRequestProcessor, "RequestInputLlmRequestProcessor");
+let RequestInputLlmRequestProcessor = _RequestInputLlmRequestProcessor;
+function collectResumeInputs(events) {
+  var _a, _b;
+  const responseSchemas = responseSchemasByInterruptId(events);
+  let isCurrentTurn = true;
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.author !== "user") {
+      continue;
+    }
+    const structured = {};
+    let found = false;
+    for (const fr of getFunctionResponses(event)) {
+      if (fr.name === REQUEST_INPUT_FUNCTION_CALL_NAME && fr.id) {
+        const schema = responseSchemas.get(fr.id);
+        const response = unwrapResponse(fr.response, schema);
+        const mismatch = interruptResponseMismatch(fr.id, response, schema);
+        if (mismatch) {
+          if (isCurrentTurn) {
+            throw new Error(mismatch);
+          }
+          continue;
+        }
+        structured[fr.id] = response;
+        found = true;
+      }
+    }
+    if (found) {
+      return structured;
+    }
+    isCurrentTurn = false;
+  }
+  const pending = pendingInterruptIds(events, responseSchemas);
+  if (pending.size === 0) {
+    return {};
+  }
+  const lastUser = [...events].reverse().find((e) => e.author === "user");
+  const parts = (_b = (_a = lastUser == null ? void 0 : lastUser.content) == null ? void 0 : _a.parts) != null ? _b : [];
+  const isPlainText = parts.length > 0 && parts.every((p) => typeof p.text === "string");
+  if (!isPlainText) {
+    return {};
+  }
+  const text = parts.map((p) => p.text).join("");
+  const inputs = {};
+  for (const id of pending) {
+    inputs[id] = text;
+  }
+  return inputs;
+}
+__name(collectResumeInputs, "collectResumeInputs");
+function pendingInterruptIds(events, responseSchemas) {
+  const answered = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.author !== "user") {
+      continue;
+    }
+    for (const fr of getFunctionResponses(event)) {
+      if (!fr.id) {
+        continue;
+      }
+      const schema = responseSchemas.get(fr.id);
+      const mismatch = interruptResponseMismatch(
+        fr.id,
+        unwrapResponse(fr.response, schema),
+        schema
+      );
+      if (!mismatch) {
+        answered.add(fr.id);
+      }
+    }
+  }
+  const pending = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.author === "user") {
+      continue;
+    }
+    for (const fc of getFunctionCalls(event)) {
+      if (fc.name === REQUEST_INPUT_FUNCTION_CALL_NAME && fc.id && !answered.has(fc.id)) {
+        pending.add(fc.id);
+      }
+    }
+  }
+  return pending;
+}
+__name(pendingInterruptIds, "pendingInterruptIds");
+const REQUEST_INPUT_LLM_REQUEST_PROCESSOR = new RequestInputLlmRequestProcessor();
+export {
+  REQUEST_INPUT_LLM_REQUEST_PROCESSOR,
+  RequestInputLlmRequestProcessor
+};

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

@@ -1,6 +1,8 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -25,7 +27,7 @@ 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 {
+const _ToolFilterRequestProcessor = class _ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
   /**
    * Invokes plugin-based tool filtering and updates {@link LlmRequest.allowedTools}
    * with the reduced tool set if any plugin returns a filtered result.
@@ -60,7 +62,9 @@ class ToolFilterRequestProcessor extends BaseLlmRequestProcessor {
       }
     });
   }
-}
+};
+__name(_ToolFilterRequestProcessor, "ToolFilterRequestProcessor");
+let ToolFilterRequestProcessor = _ToolFilterRequestProcessor;
 const TOOL_FILTER_REQUEST_PROCESSOR = new ToolFilterRequestProcessor();
 export {
   TOOL_FILTER_REQUEST_PROCESSOR,

package/dist/web/agents/readonly_context.js

@@ -1,12 +1,15 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { State } from "../sessions/state.js";
-class ReadonlyContext {
+import { requireAgent } from "./invocation_context.js";
+const _ReadonlyContext = class _ReadonlyContext {
   constructor(invocationContext) {
     this.invocationContext = invocationContext;
   }
@@ -38,7 +41,7 @@ class ReadonlyContext {
    * The current agent name.
    */
   get agentName() {
-    return this.invocationContext.agent.name;
+    return requireAgent(this.invocationContext).name;
   }
   /**
    * The state of the current session.
@@ -49,7 +52,9 @@ class ReadonlyContext {
       {}
     );
   }
-}
+};
+__name(_ReadonlyContext, "ReadonlyContext");
+let ReadonlyContext = _ReadonlyContext;
 export {
   ReadonlyContext
 };

package/dist/web/agents/routed_agent.js

@@ -2,7 +2,6 @@ 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;
@@ -24,14 +23,7 @@ var __spreadValues = (a, b) => {
   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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __await = function(promise, isYieldStar) {
   this[0] = promise;
   this[1] = isYieldStar;
@@ -82,13 +74,13 @@ var __yieldStar = (value) => {
  */
 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) {
+__name(isRoutedAgent, "isRoutedAgent");
+const _RoutedAgent = class _RoutedAgent 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), {
@@ -152,9 +144,8 @@ let RoutedAgent = class extends (_b = BaseAgent, _a = ROUTED_AGENT_SIGNATURE_SYM
     });
   }
 };
-RoutedAgent = __decorateClass([
-  experimental
-], RoutedAgent);
+__name(_RoutedAgent, "RoutedAgent");
+let RoutedAgent = _RoutedAgent;
 function cloneRoutingTargets(agents) {
   if (Array.isArray(agents)) {
     return agents.map((agent) => agent.clone());
@@ -163,6 +154,7 @@ function cloneRoutingTargets(agents) {
     Object.entries(agents).map(([key, agent]) => [key, agent.clone()])
   );
 }
+__name(cloneRoutingTargets, "cloneRoutingTargets");
 export {
   RoutedAgent,
   isRoutedAgent

package/dist/web/agents/run_config.js

@@ -19,6 +19,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -33,6 +34,7 @@ var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
 })(StreamingMode || {});
 function createRunConfig(params = {}) {
   var _a;
+  validateStreamingMode(params.streamingMode);
   return __spreadProps(__spreadValues({
     saveInputBlobsAsArtifacts: false,
     supportCfc: false,
@@ -43,6 +45,15 @@ function createRunConfig(params = {}) {
     maxLlmCalls: validateMaxLlmCalls((_a = params.maxLlmCalls) != null ? _a : 500)
   });
 }
+__name(createRunConfig, "createRunConfig");
+function validateStreamingMode(streamingMode) {
+  if (streamingMode === "bidi" /* BIDI */) {
+    throw new Error(
+      "StreamingMode.BIDI is not supported; use StreamingMode.SSE."
+    );
+  }
+}
+__name(validateStreamingMode, "validateStreamingMode");
 function validateMaxLlmCalls(value) {
   if (value > Number.MAX_SAFE_INTEGER) {
     throw new Error(
@@ -56,6 +67,7 @@ function validateMaxLlmCalls(value) {
   }
   return value;
 }
+__name(validateMaxLlmCalls, "validateMaxLlmCalls");
 export {
   StreamingMode,
   createRunConfig

package/dist/web/agents/sequential_agent.js

@@ -1,6 +1,17 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
@@ -24,6 +35,7 @@ var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")])
  */
 var _a, _b;
 import { FunctionTool } from "../tools/function_tool.js";
+import { deprecated } from "../utils/deprecated.js";
 import { BaseAgent } from "./base_agent.js";
 import { isLlmAgent } from "./llm_agent.js";
 import { ReadonlyContext } from "./readonly_context.js";
@@ -34,7 +46,8 @@ const SEQUENTIAL_AGENT_SIGNATURE_SYMBOL = Symbol.for(
 function isSequentialAgent(obj) {
   return typeof obj === "object" && obj !== null && SEQUENTIAL_AGENT_SIGNATURE_SYMBOL in obj && obj[SEQUENTIAL_AGENT_SIGNATURE_SYMBOL] === true;
 }
-class SequentialAgent extends (_b = BaseAgent, _a = SEQUENTIAL_AGENT_SIGNATURE_SYMBOL, _b) {
+__name(isSequentialAgent, "isSequentialAgent");
+let SequentialAgent = class extends (_b = BaseAgent, _a = SEQUENTIAL_AGENT_SIGNATURE_SYMBOL, _b) {
   constructor() {
     super(...arguments);
     /**
@@ -89,7 +102,7 @@ class SequentialAgent extends (_b = BaseAgent, _a = SEQUENTIAL_AGENT_SIGNATURE_S
               new FunctionTool({
                 name: TASK_COMPLETED_TOOL_NAME,
                 description: "Signals that the model has successfully completed the user's question or task.",
-                execute: () => "Task completion signaled."
+                execute: /* @__PURE__ */ __name(() => "Task completion signaled.", "execute")
               })
             );
             subAgent.instruction += "If you finished the user's request according to its description, call the ".concat(TASK_COMPLETED_TOOL_NAME, " function to exit so the next agents can take over. When calling this function, do not generate any text other than the function call.");
@@ -115,7 +128,13 @@ class SequentialAgent extends (_b = BaseAgent, _a = SEQUENTIAL_AGENT_SIGNATURE_S
       }
     });
   }
-}
+};
+__name(SequentialAgent, "SequentialAgent");
+SequentialAgent = __decorateClass([
+  deprecated(
+    "SequentialAgent is deprecated in favor of Workflow and will be removed in a future version. Workflow cannot yet be used as an LlmAgent sub-agent."
+  )
+], SequentialAgent);
 export {
   SequentialAgent,
   isSequentialAgent

package/dist/web/agents/user_input_request.js

@@ -0,0 +1,135 @@
+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;
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { camelCaseKeys } from "../utils/case_utils.js";
+import {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME
+} from "./functions.js";
+function getUserInputRequests(event) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const requests = [];
+  for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+    const functionCall = part.functionCall;
+    if (!(functionCall == null ? void 0 : functionCall.name)) {
+      continue;
+    }
+    const args = normalizeArgs(functionCall.name, functionCall.args);
+    const interruptId = (_d = (_c = functionCall.id) != null ? _c : asString(args["interruptId"])) != null ? _d : asString(args["functionCallId"]);
+    if (!interruptId) {
+      continue;
+    }
+    const base = {
+      interruptId,
+      functionCallName: functionCall.name,
+      author: event.author
+    };
+    switch (functionCall.name) {
+      case REQUEST_INPUT_FUNCTION_CALL_NAME:
+        requests.push(__spreadProps(__spreadValues({}, base), {
+          kind: "input",
+          message: asString(args["message"]),
+          payload: (_e = args["payload"]) != null ? _e : void 0,
+          responseSchema: (_f = args["response_schema"]) != null ? _f : void 0
+        }));
+        break;
+      case REQUEST_CREDENTIAL_FUNCTION_CALL_NAME:
+        requests.push(__spreadProps(__spreadValues({}, base), {
+          kind: "credential",
+          message: asString(args["message"]),
+          authConfig: (_g = args["authConfig"]) != null ? _g : void 0
+        }));
+        break;
+      case REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: {
+        const confirmation = args["toolConfirmation"];
+        const originalCall = args["originalFunctionCall"];
+        requests.push(__spreadProps(__spreadValues({}, base), {
+          kind: "confirmation",
+          // Surfaced as `message` so callers can render any kind uniformly.
+          message: asNonEmptyString(confirmation == null ? void 0 : confirmation.hint),
+          payload: (_h = confirmation == null ? void 0 : confirmation.payload) != null ? _h : void 0,
+          toolName: asString(originalCall == null ? void 0 : originalCall.name)
+        }));
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return requests;
+}
+__name(getUserInputRequests, "getUserInputRequests");
+function requiresUserInput(event) {
+  return getUserInputRequests(event).length > 0;
+}
+__name(requiresUserInput, "requiresUserInput");
+function getPendingUserInputRequests(events) {
+  var _a, _b, _c;
+  const answeredIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+      const id = (_c = part.functionResponse) == null ? void 0 : _c.id;
+      if (id) {
+        answeredIds.add(id);
+      }
+    }
+  }
+  const pending = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    for (const request of getUserInputRequests(event)) {
+      if (answeredIds.has(request.interruptId) || seenIds.has(request.interruptId)) {
+        continue;
+      }
+      seenIds.add(request.interruptId);
+      pending.push(request);
+    }
+  }
+  return pending;
+}
+__name(getPendingUserInputRequests, "getPendingUserInputRequests");
+function normalizeArgs(functionCallName, args) {
+  if (!args) {
+    return {};
+  }
+  return functionCallName === REQUEST_CREDENTIAL_FUNCTION_CALL_NAME ? camelCaseKeys(args) : args;
+}
+__name(normalizeArgs, "normalizeArgs");
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+__name(asString, "asString");
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+__name(asNonEmptyString, "asNonEmptyString");
+export {
+  getPendingUserInputRequests,
+  getUserInputRequests,
+  requiresUserInput
+};

package/dist/web/apps/app.js

@@ -1,12 +1,16 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a;
-import { isBaseAgent } from "../agents/base_agent.js";
+import {
+  asRunnableRoot
+} from "../workflow/run_node_as_invocation.js";
 const VALID_APP_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
 function validateAppName(name) {
   if (!VALID_APP_NAME_RE.test(name)) {
@@ -18,30 +22,29 @@ function validateAppName(name) {
     throw new Error("App name cannot be 'user'; reserved for end-user input.");
   }
 }
+__name(validateAppName, "validateAppName");
 const APP_SIGNATURE_SYMBOL = Symbol.for("google.adk.app");
 function isApp(obj) {
   return typeof obj === "object" && obj !== null && APP_SIGNATURE_SYMBOL in obj && obj[APP_SIGNATURE_SYMBOL] === true;
 }
+__name(isApp, "isApp");
 _a = APP_SIGNATURE_SYMBOL;
-class App {
+const _App = class _App {
   constructor(options) {
     this[_a] = true;
-    var _a2, _b, _c, _d;
+    var _a2;
     validateAppName(options.name);
     if (options.rootAgent === void 0 || options.rootAgent === null) {
       throw new Error("rootAgent must be provided.");
     }
-    if (!isBaseAgent(options.rootAgent)) {
-      throw new TypeError(
-        "rootAgent must be a BaseAgent instance, got ".concat((_c = (_b = (_a2 = options.rootAgent) == null ? void 0 : _a2.constructor) == null ? void 0 : _b.name) != null ? _c : typeof options.rootAgent)
-      );
-    }
     this.name = options.name;
-    this.rootAgent = options.rootAgent;
-    this.plugins = (_d = options.plugins) != null ? _d : [];
+    this.rootAgent = asRunnableRoot(options.rootAgent);
+    this.plugins = (_a2 = options.plugins) != null ? _a2 : [];
     this.resumabilityConfig = options.resumabilityConfig;
   }
-}
+};
+__name(_App, "App");
+let App = _App;
 export {
   App,
   isApp,

package/dist/web/apps/resumability_config.js

@@ -16,6 +16,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -26,6 +27,7 @@ function createResumabilityConfig(params = {}) {
     isResumable: false
   }, params);
 }
+__name(createResumabilityConfig, "createResumabilityConfig");
 export {
   createResumabilityConfig
 };