@google/adk 1.5.0 → 2.0.0

package/dist/cjs/workflow/utils/graph_parser.js

@@ -0,0 +1,212 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 graph_parser_exports = {};
+__export(graph_parser_exports, {
+  parseEdgeItems: () => parseEdgeItems
+});
+module.exports = __toCommonJS(graph_parser_exports);
+var import_graph = require("../graph.js");
+var import_workflow_graph_utils = require("./workflow_graph_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function normalizeRouteKey(routeKey) {
+  if (/^-?\d+$/.test(routeKey)) {
+    return Number(routeKey);
+  }
+  if (routeKey === "true" || routeKey === "false") {
+    return routeKey === "true";
+  }
+  return routeKey;
+}
+__name(normalizeRouteKey, "normalizeRouteKey");
+function expandRoutingMap(fromElement, routingMap) {
+  const keys = Object.keys(routingMap);
+  if (keys.length === 0) {
+    throw new Error(
+      "Routing map must not be empty. Provide at least one route -> node mapping."
+    );
+  }
+  const expanded = [];
+  for (const routeKey of keys) {
+    const normalizedKey = normalizeRouteKey(routeKey);
+    const target = routingMap[routeKey];
+    if (Array.isArray(target)) {
+      for (const node of target) {
+        if (!(0, import_workflow_graph_utils.isNodeLike)(node)) {
+          throw new Error(
+            `Invalid node in fan-out tuple for route ${String(routeKey)}.`
+          );
+        }
+      }
+    } else if (!(0, import_workflow_graph_utils.isNodeLike)(target)) {
+      throw new Error(
+        `Invalid routing map value for route ${String(routeKey)}.`
+      );
+    }
+    expanded.push([
+      fromElement,
+      target,
+      normalizedKey
+    ]);
+  }
+  return expanded;
+}
+__name(expandRoutingMap, "expandRoutingMap");
+function nodesFromRoutingMap(routingMap) {
+  const nodes = [];
+  for (const target of Object.values(routingMap)) {
+    if (Array.isArray(target)) {
+      nodes.push(...target);
+    } else {
+      nodes.push(target);
+    }
+  }
+  return nodes;
+}
+__name(nodesFromRoutingMap, "nodesFromRoutingMap");
+function flattenElement(element) {
+  if ((0, import_workflow_graph_utils.isPlainObject)(element)) {
+    return nodesFromRoutingMap(element);
+  }
+  if (Array.isArray(element)) {
+    return [...element];
+  }
+  return [element];
+}
+__name(flattenElement, "flattenElement");
+function getOrBuildNode(nodeLike, nodeMap) {
+  if (nodeLike === "START") {
+    return (0, import_workflow_graph_utils.buildNode)("START");
+  }
+  if (typeof nodeLike === "object" || typeof nodeLike === "function") {
+    const cached = nodeMap.get(nodeLike);
+    if (cached) {
+      return cached;
+    }
+    const built = (0, import_workflow_graph_utils.buildNode)(nodeLike);
+    nodeMap.set(nodeLike, built);
+    return built;
+  }
+  return (0, import_workflow_graph_utils.buildNode)(nodeLike);
+}
+__name(getOrBuildNode, "getOrBuildNode");
+function processExplicitEdge({
+  edge,
+  nodeMap,
+  out
+}) {
+  out.push(
+    new import_graph.Edge(
+      getOrBuildNode(edge.fromNode, nodeMap),
+      getOrBuildNode(edge.toNode, nodeMap),
+      edge.route
+    )
+  );
+}
+__name(processExplicitEdge, "processExplicitEdge");
+function processRoutingMapEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  if ((0, import_workflow_graph_utils.isPlainObject)(fromEl)) {
+    throw new Error(
+      "Consecutive routing maps are not allowed in a chain. Split them into separate edge items."
+    );
+  }
+  for (const [expFrom, expTo, route] of expandRoutingMap(fromEl, toEl)) {
+    for (const fromNode of flattenElement(expFrom)) {
+      for (const toNode of flattenElement(expTo)) {
+        out.push(
+          new import_graph.Edge(
+            getOrBuildNode(fromNode, nodeMap),
+            getOrBuildNode(toNode, nodeMap),
+            route
+          )
+        );
+      }
+    }
+  }
+}
+__name(processRoutingMapEdge, "processRoutingMapEdge");
+function processUnconditionalEdge({
+  fromEl,
+  toEl,
+  nodeMap,
+  out
+}) {
+  for (const fromNode of flattenElement(fromEl)) {
+    for (const toNode of flattenElement(toEl)) {
+      out.push(
+        new import_graph.Edge(
+          getOrBuildNode(fromNode, nodeMap),
+          getOrBuildNode(toNode, nodeMap),
+          null
+        )
+      );
+    }
+  }
+}
+__name(processUnconditionalEdge, "processUnconditionalEdge");
+function processChain({
+  chain,
+  nodeMap,
+  out
+}) {
+  for (let i = 0; i < chain.length - 1; i++) {
+    const fromEl = chain[i];
+    const toEl = chain[i + 1];
+    if ((0, import_workflow_graph_utils.isPlainObject)(toEl)) {
+      processRoutingMapEdge({ fromEl, toEl, nodeMap, out });
+    } else {
+      processUnconditionalEdge({ fromEl, toEl, nodeMap, out });
+    }
+  }
+}
+__name(processChain, "processChain");
+function parseEdgeItems(edgeItems) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const item of edgeItems) {
+    if ((0, import_graph.isEdge)(item)) {
+      processExplicitEdge({ edge: item, nodeMap, out });
+    } else if (Array.isArray(item)) {
+      processChain({ chain: item, nodeMap, out });
+    } else {
+      throw new Error(`Invalid edge item type: ${typeof item}`);
+    }
+  }
+  return out;
+}
+__name(parseEdgeItems, "parseEdgeItems");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseEdgeItems
+});

package/dist/cjs/workflow/utils/graph_validation.js

@@ -0,0 +1,216 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 graph_validation_exports = {};
+__export(graph_validation_exports, {
+  validateGraph: () => validateGraph
+});
+module.exports = __toCommonJS(graph_validation_exports);
+var import_base_node = require("../base_node.js");
+var import_graph = require("../graph.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function validateDuplicateNodeNames(nodes) {
+  var _a;
+  const counts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    counts.set(node.name, ((_a = counts.get(node.name)) != null ? _a : 0) + 1);
+  }
+  const duplicates = [...counts.entries()].filter(([, c]) => c > 1).map(([name]) => name).sort();
+  if (duplicates.length > 0) {
+    throw new Error(
+      `Graph validation failed. Duplicate node names found: ${JSON.stringify(
+        duplicates
+      )}. Pass the exact same object instance to reuse a node, or give distinct nodes unique names.`
+    );
+  }
+  return new Set(counts.keys());
+}
+__name(validateDuplicateNodeNames, "validateDuplicateNodeNames");
+function validateStartNode(nodeNames) {
+  if (!nodeNames.has(import_base_node.START.name)) {
+    throw new Error(
+      `Graph validation failed. START node (name: '${import_base_node.START.name}') not found in graph nodes.`
+    );
+  }
+}
+__name(validateStartNode, "validateStartNode");
+function validateStartEdges(edges) {
+  for (const edge of edges) {
+    if (edge.fromNode.name === import_base_node.START.name && edge.route !== null) {
+      throw new Error(
+        `Graph validation failed. Edges from START must not have routes (edge to ${edge.toNode.name} has route ${String(
+          edge.route
+        )}).`
+      );
+    }
+  }
+}
+__name(validateStartEdges, "validateStartEdges");
+function validateConnectivity(edges, nodeNames) {
+  var _a;
+  const adj = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    adj.set(name, /* @__PURE__ */ new Set());
+  }
+  const toNodes = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    adj.get(edge.fromNode.name).add(edge.toNode.name);
+    toNodes.add(edge.toNode.name);
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [import_base_node.START.name];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (reachable.has(node)) {
+      continue;
+    }
+    reachable.add(node);
+    for (const next of (_a = adj.get(node)) != null ? _a : []) {
+      if (!reachable.has(next)) {
+        stack.push(next);
+      }
+    }
+  }
+  const unreachable = [...nodeNames].filter((n) => !reachable.has(n)).sort();
+  if (unreachable.length > 0) {
+    throw new Error(
+      `Graph validation failed. The following nodes are unreachable from START: ${JSON.stringify(
+        unreachable
+      )}`
+    );
+  }
+  if (toNodes.has(import_base_node.START.name)) {
+    throw new Error(
+      "Graph validation failed. START node must not have incoming edges."
+    );
+  }
+}
+__name(validateConnectivity, "validateConnectivity");
+function validateDuplicateEdges(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const unconditional = edge.route === null || edge.route === void 0;
+    const routes = unconditional ? [null] : (Array.isArray(edge.route) ? edge.route : [edge.route]).map(String);
+    for (const route of routes) {
+      const key = JSON.stringify([edge.fromNode.name, edge.toNode.name, route]);
+      if (seen.has(key)) {
+        throw new Error(
+          `Graph validation failed. Duplicate edge found: from=${edge.fromNode.name}, to=${edge.toNode.name}${unconditional ? "" : `, route=${JSON.stringify(route)}`}. ${unconditional ? "The same pair is already connected unconditionally" : "That route already points at this node"}, so the target would be triggered twice.`
+        );
+      }
+      seen.add(key);
+    }
+  }
+}
+__name(validateDuplicateEdges, "validateDuplicateEdges");
+function validateDefaultRoutes(edges) {
+  const defaultRouteEdges = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (Array.isArray(edge.route) && edge.route.includes(import_graph.DEFAULT_ROUTE)) {
+      throw new Error(
+        `Graph validation failed. DEFAULT_ROUTE cannot be combined with other routes in a list (edge from=${edge.fromNode.name}, to=${edge.toNode.name}). Use a separate edge for DEFAULT_ROUTE.`
+      );
+    }
+    if (edge.route === import_graph.DEFAULT_ROUTE) {
+      const from = edge.fromNode.name;
+      if (defaultRouteEdges.has(from)) {
+        throw new Error(
+          `Graph validation failed. Multiple DEFAULT_ROUTE edges found from node ${from} to ${defaultRouteEdges.get(
+            from
+          )} and ${edge.toNode.name}`
+        );
+      }
+      defaultRouteEdges.set(from, edge.toNode.name);
+    }
+  }
+}
+__name(validateDefaultRoutes, "validateDefaultRoutes");
+function detectUnconditionalCycles(edges, nodeNames) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const name of nodeNames) {
+    adj.set(name, []);
+  }
+  for (const edge of edges) {
+    if (edge.route === null) {
+      adj.get(edge.fromNode.name).push(edge.toNode.name);
+    }
+  }
+  const inStack = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const dfs = /* @__PURE__ */ __name((node, path) => {
+    var _a;
+    inStack.add(node);
+    path.push(node);
+    for (const neighbor of (_a = adj.get(node)) != null ? _a : []) {
+      if (inStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        const cycle = [...path.slice(cycleStart), neighbor];
+        throw new Error(
+          `Graph validation failed. Unconditional cycle detected: ${cycle.join(
+            " -> "
+          )}. An unconditional cycle has no exit and would loop forever; break it with at least one conditional (routed) edge so a node can leave the cycle by not emitting that route. (A routed cycle can still loop if a node keeps emitting the route \u2014 bounding that is the node's responsibility, not this validator's.)`
+        );
+      }
+      if (!done.has(neighbor)) {
+        dfs(neighbor, path);
+      }
+    }
+    path.pop();
+    inStack.delete(node);
+    done.add(node);
+  }, "dfs");
+  for (const name of nodeNames) {
+    if (!done.has(name)) {
+      dfs(name, []);
+    }
+  }
+}
+__name(detectUnconditionalCycles, "detectUnconditionalCycles");
+function computeTerminalNodes(nodes, edges) {
+  const fromNames = new Set(edges.map((e) => e.fromNode.name));
+  return new Set(
+    nodes.filter((n) => n.name !== import_base_node.START.name && !fromNames.has(n.name)).map((n) => n.name)
+  );
+}
+__name(computeTerminalNodes, "computeTerminalNodes");
+function validateGraph(nodes, edges) {
+  const nodeNames = validateDuplicateNodeNames(nodes);
+  validateStartNode(nodeNames);
+  validateStartEdges(edges);
+  validateConnectivity(edges, nodeNames);
+  validateDuplicateEdges(edges);
+  validateDefaultRoutes(edges);
+  detectUnconditionalCycles(edges, nodeNames);
+  return computeTerminalNodes(nodes, edges);
+}
+__name(validateGraph, "validateGraph");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateGraph
+});

package/dist/cjs/workflow/utils/hitl_utils.js

@@ -0,0 +1,252 @@
+/**
+  * @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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 hitl_utils_exports = {};
+__export(hitl_utils_exports, {
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME: () => import_functions2.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME: () => import_functions2.REQUEST_INPUT_FUNCTION_CALL_NAME,
+  createAuthRequestEvent: () => createAuthRequestEvent,
+  createRequestInputEvent: () => createRequestInputEvent,
+  createRequestInputResponse: () => createRequestInputResponse,
+  getRequestInputInterruptIds: () => getRequestInputInterruptIds,
+  hasAuthCredential: () => hasAuthCredential,
+  hasAuthRequestFunctionCall: () => hasAuthRequestFunctionCall,
+  hasRequestInputFunctionCall: () => hasRequestInputFunctionCall,
+  interruptResponseMismatch: () => interruptResponseMismatch,
+  processAuthResume: () => processAuthResume,
+  responseSchemasByInterruptId: () => responseSchemasByInterruptId
+});
+module.exports = __toCommonJS(hitl_utils_exports);
+var import_functions = require("../../agents/functions.js");
+var import_auth_credential = require("../../auth/auth_credential.js");
+var import_auth_handler = require("../../auth/auth_handler.js");
+var import_credential_response_binding = require("../../auth/credential_response_binding.js");
+var import_event = require("../../events/event.js");
+var import_logger = require("../../utils/logger.js");
+var import_schema = require("../../utils/schema.js");
+var import_functions2 = require("../../agents/functions.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const RESPONSE_SCHEMA_ARG = "response_schema";
+function createRequestInputEvent(requestInput) {
+  var _a, _b;
+  const args = {
+    interruptId: requestInput.interruptId,
+    payload: (_a = requestInput.payload) != null ? _a : null,
+    message: (_b = requestInput.message) != null ? _b : null,
+    [RESPONSE_SCHEMA_ARG]: requestInput.responseSchema ? (0, import_schema.toJsonSchema)(requestInput.responseSchema) : null
+  };
+  return (0, import_event.createEvent)({
+    content: {
+      role: "model",
+      parts: [
+        {
+          functionCall: {
+            name: import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME,
+            args,
+            id: requestInput.interruptId
+          }
+        }
+      ]
+    },
+    longRunningToolIds: [requestInput.interruptId]
+  });
+}
+__name(createRequestInputEvent, "createRequestInputEvent");
+function responseSchemasByInterruptId(events) {
+  var _a, _b, _c;
+  const schemas = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+      const fc = part.functionCall;
+      if ((fc == null ? void 0 : fc.name) !== import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME || !fc.id) {
+        continue;
+      }
+      const schema = (_c = fc.args) == null ? void 0 : _c[RESPONSE_SCHEMA_ARG];
+      if (schema) {
+        schemas.set(fc.id, schema);
+      }
+    }
+  }
+  return schemas;
+}
+__name(responseSchemasByInterruptId, "responseSchemasByInterruptId");
+function interruptResponseMismatch(interruptId, value, jsonSchema) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const validator = (0, import_schema.compileJsonSchema)(jsonSchema);
+  if (!validator) {
+    return void 0;
+  }
+  const result = validator.safeParse(value);
+  if (result.success) {
+    return void 0;
+  }
+  const issues = result.error.issues.map((issue) => {
+    const at = issue.path.length ? ` at '${issue.path.join(".")}'` : "";
+    return `${issue.message}${at}`;
+  }).join("; ");
+  return `The reply to interrupt '${interruptId}' does not match the responseSchema it declared: ${issues}. A structured reply must either match that schema, or wrap a bare value as {result: <value>}; a plain-text reply is accepted as-is and is not checked. The interrupt is still waiting, so you can answer it again.`;
+}
+__name(interruptResponseMismatch, "interruptResponseMismatch");
+function hasRequestInputFunctionCall(event) {
+  var _a, _b;
+  return ((_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []).some(
+    (p) => {
+      var _a2;
+      return ((_a2 = p.functionCall) == null ? void 0 : _a2.name) === import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME;
+    }
+  );
+}
+__name(hasRequestInputFunctionCall, "hasRequestInputFunctionCall");
+function hasAuthRequestFunctionCall(event) {
+  var _a, _b;
+  return ((_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []).some(
+    (p) => {
+      var _a2;
+      return ((_a2 = p.functionCall) == null ? void 0 : _a2.name) === import_functions.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME;
+    }
+  );
+}
+__name(hasAuthRequestFunctionCall, "hasAuthRequestFunctionCall");
+function getRequestInputInterruptIds(event) {
+  var _a, _b;
+  const ids = [];
+  for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+    const fc = part.functionCall;
+    if (fc && fc.name === import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME && fc.id) {
+      ids.push(fc.id);
+    }
+  }
+  return ids;
+}
+__name(getRequestInputInterruptIds, "getRequestInputInterruptIds");
+function createRequestInputResponse(interruptId, response) {
+  return {
+    functionResponse: {
+      id: interruptId,
+      name: import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME,
+      response
+    }
+  };
+}
+__name(createRequestInputResponse, "createRequestInputResponse");
+function hasAuthCredential(authConfig, state) {
+  return new import_auth_handler.AuthHandler(authConfig).getAuthResponse(state) !== void 0;
+}
+__name(hasAuthCredential, "hasAuthCredential");
+function createAuthRequestEvent(authConfig, interruptId) {
+  const authRequest = new import_auth_handler.AuthHandler(authConfig).generateAuthRequest();
+  const args = {
+    functionCallId: interruptId,
+    authConfig: authRequest,
+    message: buildAuthMessage(authConfig)
+  };
+  return (0, import_event.createEvent)({
+    content: {
+      role: "model",
+      parts: [
+        {
+          functionCall: {
+            name: import_functions.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+            id: interruptId,
+            args
+          }
+        }
+      ]
+    },
+    longRunningToolIds: [interruptId]
+  });
+}
+__name(createAuthRequestEvent, "createAuthRequestEvent");
+async function processAuthResume({
+  responseData,
+  authConfig,
+  state
+}) {
+  let responseConfig;
+  if (isAuthConfigLike(responseData)) {
+    responseConfig = (0, import_credential_response_binding.bindCredentialResponse)(authConfig, responseData);
+  } else {
+    responseConfig = {
+      ...authConfig,
+      exchangedAuthCredential: buildCredentialFromValue(
+        authConfig,
+        responseData
+      )
+    };
+  }
+  if (!responseConfig) {
+    import_logger.logger.warn(
+      `Ignoring auth resume response for '${authConfig.credentialKey}': it carries no credential for the request that was raised.`
+    );
+    return;
+  }
+  await new import_auth_handler.AuthHandler(responseConfig).parseAndStoreAuthResponse(state);
+}
+__name(processAuthResume, "processAuthResume");
+function isAuthConfigLike(value) {
+  return typeof value === "object" && value !== null && "authScheme" in value && "credentialKey" in value;
+}
+__name(isAuthConfigLike, "isAuthConfigLike");
+function buildCredentialFromValue(authConfig, value) {
+  var _a;
+  if (((_a = authConfig.rawAuthCredential) == null ? void 0 : _a.authType) === import_auth_credential.AuthCredentialTypes.API_KEY) {
+    return { authType: import_auth_credential.AuthCredentialTypes.API_KEY, apiKey: String(value) };
+  }
+  return value;
+}
+__name(buildCredentialFromValue, "buildCredentialFromValue");
+function buildAuthMessage(authConfig) {
+  var _a;
+  const authType = (_a = authConfig.rawAuthCredential) == null ? void 0 : _a.authType;
+  if (authType === import_auth_credential.AuthCredentialTypes.API_KEY) {
+    return "Please provide your API key.";
+  }
+  if (authType === import_auth_credential.AuthCredentialTypes.OAUTH2 || authType === import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT) {
+    return "Please complete the authentication flow.";
+  }
+  return "Please provide your authentication credentials.";
+}
+__name(buildAuthMessage, "buildAuthMessage");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  createAuthRequestEvent,
+  createRequestInputEvent,
+  createRequestInputResponse,
+  getRequestInputInterruptIds,
+  hasAuthCredential,
+  hasAuthRequestFunctionCall,
+  hasRequestInputFunctionCall,
+  interruptResponseMismatch,
+  processAuthResume,
+  responseSchemasByInterruptId
+});