@google/adk 2.0.0 → 2.2.0

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

@@ -1,189 +0,0 @@
-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
- */
-import { START } from "../base_node.js";
-import { DEFAULT_ROUTE } from "../graph.js";
-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: ".concat(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(START.name)) {
-    throw new Error(
-      "Graph validation failed. START node (name: '".concat(START.name, "') not found in graph nodes.")
-    );
-  }
-}
-__name(validateStartNode, "validateStartNode");
-function validateStartEdges(edges) {
-  for (const edge of edges) {
-    if (edge.fromNode.name === START.name && edge.route !== null) {
-      throw new Error(
-        "Graph validation failed. Edges from START must not have routes (edge to ".concat(edge.toNode.name, " has route ").concat(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 = [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: ".concat(JSON.stringify(
-        unreachable
-      ))
-    );
-  }
-  if (toNodes.has(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=".concat(edge.fromNode.name, ", to=").concat(edge.toNode.name).concat(unconditional ? "" : ", route=".concat(JSON.stringify(route)), ". ").concat(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(DEFAULT_ROUTE)) {
-      throw new Error(
-        "Graph validation failed. DEFAULT_ROUTE cannot be combined with other routes in a list (edge from=".concat(edge.fromNode.name, ", to=").concat(edge.toNode.name, "). Use a separate edge for DEFAULT_ROUTE.")
-      );
-    }
-    if (edge.route === DEFAULT_ROUTE) {
-      const from = edge.fromNode.name;
-      if (defaultRouteEdges.has(from)) {
-        throw new Error(
-          "Graph validation failed. Multiple DEFAULT_ROUTE edges found from node ".concat(from, " to ").concat(defaultRouteEdges.get(
-            from
-          ), " and ").concat(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: ".concat(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 !== 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");
-export {
-  validateGraph
-};

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

@@ -1,239 +0,0 @@
-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 {
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
-  REQUEST_INPUT_FUNCTION_CALL_NAME
-} from "../../agents/functions.js";
-import {
-  AuthCredentialTypes
-} from "../../auth/auth_credential.js";
-import { AuthHandler } from "../../auth/auth_handler.js";
-import { bindCredentialResponse } from "../../auth/credential_response_binding.js";
-import { createEvent } from "../../events/event.js";
-import { logger } from "../../utils/logger.js";
-import { compileJsonSchema, toJsonSchema } from "../../utils/schema.js";
-import {
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2,
-  REQUEST_INPUT_FUNCTION_CALL_NAME as REQUEST_INPUT_FUNCTION_CALL_NAME2
-} from "../../agents/functions.js";
-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 ? toJsonSchema(requestInput.responseSchema) : null
-  };
-  return createEvent({
-    content: {
-      role: "model",
-      parts: [
-        {
-          functionCall: {
-            name: 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) !== 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 = 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 '".concat(issue.path.join("."), "'") : "";
-    return "".concat(issue.message).concat(at);
-  }).join("; ");
-  return "The reply to interrupt '".concat(interruptId, "' does not match the ") + "responseSchema it declared: ".concat(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) === 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) === 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 === 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: REQUEST_INPUT_FUNCTION_CALL_NAME,
-      response
-    }
-  };
-}
-__name(createRequestInputResponse, "createRequestInputResponse");
-function hasAuthCredential(authConfig, state) {
-  return new AuthHandler(authConfig).getAuthResponse(state) !== void 0;
-}
-__name(hasAuthCredential, "hasAuthCredential");
-function createAuthRequestEvent(authConfig, interruptId) {
-  const authRequest = new AuthHandler(authConfig).generateAuthRequest();
-  const args = {
-    functionCallId: interruptId,
-    authConfig: authRequest,
-    message: buildAuthMessage(authConfig)
-  };
-  return createEvent({
-    content: {
-      role: "model",
-      parts: [
-        {
-          functionCall: {
-            name: 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 = bindCredentialResponse(authConfig, responseData);
-  } else {
-    responseConfig = __spreadProps(__spreadValues({}, authConfig), {
-      exchangedAuthCredential: buildCredentialFromValue(
-        authConfig,
-        responseData
-      )
-    });
-  }
-  if (!responseConfig) {
-    logger.warn(
-      "Ignoring auth resume response for '".concat(authConfig.credentialKey, "': it carries no credential for the request that was raised.")
-    );
-    return;
-  }
-  await new 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) === AuthCredentialTypes.API_KEY) {
-    return { authType: 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 === AuthCredentialTypes.API_KEY) {
-    return "Please provide your API key.";
-  }
-  if (authType === AuthCredentialTypes.OAUTH2 || authType === AuthCredentialTypes.OPEN_ID_CONNECT) {
-    return "Please complete the authentication flow.";
-  }
-  return "Please provide your authentication credentials.";
-}
-__name(buildAuthMessage, "buildAuthMessage");
-export {
-  REQUEST_CREDENTIAL_FUNCTION_CALL_NAME2 as REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
-  REQUEST_INPUT_FUNCTION_CALL_NAME2 as REQUEST_INPUT_FUNCTION_CALL_NAME,
-  createAuthRequestEvent,
-  createRequestInputEvent,
-  createRequestInputResponse,
-  getRequestInputInterruptIds,
-  hasAuthCredential,
-  hasAuthRequestFunctionCall,
-  hasRequestInputFunctionCall,
-  interruptResponseMismatch,
-  processAuthResume,
-  responseSchemasByInterruptId
-};