@google/adk 1.6.0 → 2.0.0

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

@@ -0,0 +1,222 @@
+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 {
+  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 '${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) === 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 = {
+      ...authConfig,
+      exchangedAuthCredential: buildCredentialFromValue(
+        authConfig,
+        responseData
+      )
+    };
+  }
+  if (!responseConfig) {
+    logger.warn(
+      `Ignoring auth resume response for '${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
+};

package/dist/esm/workflow/utils/rehydration_utils.js

@@ -0,0 +1,342 @@
+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 { requiresUserInput } from "../../agents/user_input_request.js";
+import {
+  interruptResponseMismatch,
+  REQUEST_INPUT_FUNCTION_CALL_NAME,
+  responseSchemasByInterruptId
+} from "./hitl_utils.js";
+const RESULT_KEY = "result";
+function eventsForCurrentRun(events, currentInvocationId) {
+  var _a;
+  const priorRuns = [];
+  let currentStart = events.length;
+  let lastInvocationId;
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const invocationId = event.invocationId || lastInvocationId;
+    if (event.invocationId) {
+      lastInvocationId = event.invocationId;
+    }
+    if (invocationId === currentInvocationId) {
+      if (currentStart === events.length) {
+        currentStart = i;
+      }
+      continue;
+    }
+    if (!((_a = event.nodeInfo) == null ? void 0 : _a.path)) {
+      continue;
+    }
+    let entry = priorRuns[priorRuns.length - 1];
+    if (!entry || entry.invocationId !== invocationId) {
+      entry = { start: i, invocationId, paused: false };
+      priorRuns.push(entry);
+    }
+    if (raisedInterrupt(event)) {
+      entry.paused = true;
+    }
+  }
+  let boundary = currentStart;
+  for (let i = priorRuns.length - 1; i >= 0 && priorRuns[i].paused; i--) {
+    boundary = priorRuns[i].start;
+  }
+  return events.slice(boundary);
+}
+__name(eventsForCurrentRun, "eventsForCurrentRun");
+function raisedInterrupt(event) {
+  return requiresUserInput(event);
+}
+__name(raisedInterrupt, "raisedInterrupt");
+function reconstructNodeStates(events, parentPath) {
+  if (parentPath) {
+    return reconstruct(
+      events,
+      (event) => {
+        var _a;
+        return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? directChildName(event.nodeInfo.path, parentPath) : void 0;
+      }
+    );
+  }
+  return reconstruct(
+    events,
+    (event) => {
+      var _a;
+      return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? nodeNameFromPath(event.nodeInfo.path) : event.author;
+    }
+  );
+}
+__name(reconstructNodeStates, "reconstructNodeStates");
+function reconstructNodeStatesByPath(events) {
+  return reconstruct(events, (event) => {
+    var _a, _b;
+    return (_b = (_a = event.nodeInfo) == null ? void 0 : _a.path) != null ? _b : event.author;
+  });
+}
+__name(reconstructNodeStatesByPath, "reconstructNodeStatesByPath");
+function resolvedInterruptResponses(events) {
+  var _a, _b;
+  const responseSchemas = responseSchemasByInterruptId(events);
+  const newestUserTurn = lastUserEvent(events);
+  const raised = /* @__PURE__ */ new Set();
+  const open = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.author === "user" && ((_a = event.content) == null ? void 0 : _a.parts)) {
+      for (const part of event.content.parts) {
+        const fr = part.functionResponse;
+        if (!(fr == null ? void 0 : fr.id)) {
+          continue;
+        }
+        if (!open.has(fr.id)) {
+          if (fr.name === REQUEST_INPUT_FUNCTION_CALL_NAME && event === newestUserTurn) {
+            throw new Error(
+              raised.has(fr.id) ? alreadyAnsweredMessage(fr.id, open) : unroutableReplyMessage(fr.id, open)
+            );
+          }
+          continue;
+        }
+        const schema = responseSchemas.get(fr.id);
+        const response = unwrapResponse(fr.response, schema);
+        const mismatch = interruptResponseMismatch(fr.id, response, schema);
+        if (mismatch) {
+          if (event === newestUserTurn) {
+            throw new Error(mismatch);
+          }
+          continue;
+        }
+        open.delete(fr.id);
+        resolved.set(fr.id, response);
+      }
+      continue;
+    }
+    for (const id of (_b = event.longRunningToolIds) != null ? _b : []) {
+      raised.add(id);
+      open.add(id);
+    }
+  }
+  return resolved;
+}
+__name(resolvedInterruptResponses, "resolvedInterruptResponses");
+function waitingList(open) {
+  return open.size ? `Still waiting: ${[...open].map((id) => `'${id}'`).join(", ")}.` : "This run has no interrupt waiting for an answer.";
+}
+__name(waitingList, "waitingList");
+function unroutableReplyMessage(interruptId, open) {
+  return `The reply carries interrupt id '${interruptId}', which does not match any interrupt this run raised. ${waitingList(open)} A reply must use the id from the 'adk_request_input' function call it answers. Nothing was resolved, so any waiting interrupt can still be answered.`;
+}
+__name(unroutableReplyMessage, "unroutableReplyMessage");
+function alreadyAnsweredMessage(interruptId, open) {
+  return `Interrupt '${interruptId}' has already been answered, so this reply resolves nothing. Sending it again does not change the earlier answer, and it would otherwise be served as a new message, restarting the node that asked. ${waitingList(open)}`;
+}
+__name(alreadyAnsweredMessage, "alreadyAnsweredMessage");
+function reconstructNodeRuns(events, parentPath) {
+  return reconstructRuns(events, keyFn(parentPath));
+}
+__name(reconstructNodeRuns, "reconstructNodeRuns");
+function keyFn(parentPath) {
+  if (parentPath) {
+    return (event) => {
+      var _a;
+      return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? directChildName(event.nodeInfo.path, parentPath) : void 0;
+    };
+  }
+  return (event) => {
+    var _a;
+    return ((_a = event.nodeInfo) == null ? void 0 : _a.path) ? nodeNameFromPath(event.nodeInfo.path) : event.author;
+  };
+}
+__name(keyFn, "keyFn");
+function isRunClosed(node) {
+  return node.output !== void 0 || node.route !== void 0 || node.interruptIds.size > 0;
+}
+__name(isRunClosed, "isRunClosed");
+function reconstruct(events, keyFor) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const [key, runs] of reconstructRuns(events, keyFor)) {
+    const node = {
+      interruptIds: /* @__PURE__ */ new Set(),
+      resolvedResponses: /* @__PURE__ */ new Map()
+    };
+    for (const run of runs) {
+      if (run.output !== void 0) {
+        node.output = run.output;
+        node.branch = run.branch;
+      }
+      if (run.route !== void 0) node.route = run.route;
+      if (run.input !== void 0) node.input = run.input;
+      for (const id of run.interruptIds) node.interruptIds.add(id);
+      for (const [id, value] of run.resolvedResponses) {
+        node.resolvedResponses.set(id, value);
+      }
+    }
+    merged.set(key, node);
+  }
+  return merged;
+}
+__name(reconstruct, "reconstruct");
+function reconstructRuns(events, keyFor) {
+  var _a, _b, _c;
+  const nodes = /* @__PURE__ */ new Map();
+  const interruptOwner = /* @__PURE__ */ new Map();
+  const resolved = resolvedInterruptResponses(events);
+  const currentRun = /* @__PURE__ */ __name((name) => {
+    let runs = nodes.get(name);
+    if (!runs) {
+      runs = [];
+      nodes.set(name, runs);
+    }
+    const open = runs[runs.length - 1];
+    if (open && !isRunClosed(open)) {
+      return open;
+    }
+    const run = {
+      interruptIds: /* @__PURE__ */ new Set(),
+      resolvedResponses: /* @__PURE__ */ new Map()
+    };
+    runs.push(run);
+    return run;
+  }, "currentRun");
+  for (const event of events) {
+    if (event.author === "user" && ((_a = event.content) == null ? void 0 : _a.parts)) {
+      for (const part of event.content.parts) {
+        const fr = part.functionResponse;
+        if ((fr == null ? void 0 : fr.id) && interruptOwner.has(fr.id) && resolved.has(fr.id)) {
+          interruptOwner.get(fr.id).resolvedResponses.set(fr.id, resolved.get(fr.id));
+        }
+      }
+      continue;
+    }
+    const key = keyFor(event);
+    if (!key) {
+      continue;
+    }
+    const node = currentRun(key);
+    if (event.output !== void 0) {
+      node.output = event.output;
+      node.branch = event.branch;
+    }
+    if (event.route !== void 0) {
+      node.route = event.route;
+    }
+    for (const id of (_b = event.longRunningToolIds) != null ? _b : []) {
+      node.interruptIds.add(id);
+      interruptOwner.set(id, node);
+    }
+    const agentState = (_c = event.actions) == null ? void 0 : _c.agentState;
+    if (isRecord(agentState) && "input" in agentState) {
+      node.input = agentState.input;
+    }
+  }
+  return nodes;
+}
+__name(reconstructRuns, "reconstructRuns");
+function lastUserEvent(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].author === "user") {
+      return events[i];
+    }
+  }
+  return void 0;
+}
+__name(lastUserEvent, "lastUserEvent");
+function isFastForwardable(node) {
+  if (node.output === void 0 && node.route === void 0) {
+    return false;
+  }
+  for (const id of node.interruptIds) {
+    if (!node.resolvedResponses.has(id)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isFastForwardable, "isFastForwardable");
+function makeFastForwardResult(parent, prior) {
+  var _a;
+  return {
+    output: prior.output,
+    route: prior.route,
+    branch: (_a = prior.branch) != null ? _a : parent.branch,
+    interruptIds: []
+  };
+}
+__name(makeFastForwardResult, "makeFastForwardResult");
+function nodeNameFromPath(path) {
+  var _a;
+  const leaf = (_a = path.split(/[./]/).pop()) != null ? _a : path;
+  return leaf.split("@")[0];
+}
+__name(nodeNameFromPath, "nodeNameFromPath");
+function directChildName(path, parentPath) {
+  const prefix = `${parentPath}.`;
+  if (!path.startsWith(prefix)) {
+    return void 0;
+  }
+  const rest = path.slice(prefix.length);
+  if (rest.includes(".")) {
+    return void 0;
+  }
+  return rest.split("@")[0];
+}
+__name(directChildName, "directChildName");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function unwrapResponse(response, responseSchema) {
+  if (response && typeof response === "object" && !Array.isArray(response) && Object.keys(response).length === 1 && RESULT_KEY in response) {
+    const value = response[RESULT_KEY];
+    if (typeof value !== "string" || acceptsString(responseSchema)) {
+      return value;
+    }
+    return parseJsonIfPossible(value);
+  }
+  return response;
+}
+__name(unwrapResponse, "unwrapResponse");
+function acceptsString(jsonSchema) {
+  if (!isRecord(jsonSchema)) {
+    return false;
+  }
+  const type = jsonSchema["type"];
+  if (type === "string") {
+    return true;
+  }
+  if (Array.isArray(type) && type.includes("string")) {
+    return true;
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    const branches = jsonSchema[key];
+    if (Array.isArray(branches) && branches.some(acceptsString)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(acceptsString, "acceptsString");
+function parseJsonIfPossible(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+__name(parseJsonIfPossible, "parseJsonIfPossible");
+export {
+  eventsForCurrentRun,
+  isFastForwardable,
+  makeFastForwardResult,
+  nodeNameFromPath,
+  reconstructNodeRuns,
+  reconstructNodeStates,
+  reconstructNodeStatesByPath,
+  resolvedInterruptResponses,
+  unwrapResponse
+};

package/dist/esm/workflow/utils/retry_utils.js

@@ -0,0 +1,82 @@
+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
+ */
+const DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_INITIAL_DELAY_SECONDS = 1;
+const DEFAULT_MAX_DELAY_SECONDS = 60;
+const DEFAULT_BACKOFF_FACTOR = 2;
+const DEFAULT_JITTER = 1;
+function errorNames(error) {
+  var _a;
+  if (error instanceof Error) {
+    const names = [(_a = error.constructor) == null ? void 0 : _a.name, error.name].filter(
+      (name) => !!name
+    );
+    return [...new Set(names)];
+  }
+  if (typeof error === "object" && error !== null) {
+    return [error.constructor.name];
+  }
+  return [typeof error];
+}
+__name(errorNames, "errorNames");
+function errorName(error) {
+  const [className, assigned] = errorNames(error);
+  if (className === "Error" && assigned) {
+    return assigned;
+  }
+  return className;
+}
+__name(errorName, "errorName");
+function shouldRetryNode({
+  error,
+  retryConfig,
+  nodeState
+}) {
+  var _a;
+  const attemptCount = nodeState.attemptCount;
+  const maxAttempts = (_a = retryConfig.maxAttempts) != null ? _a : DEFAULT_MAX_ATTEMPTS;
+  if (attemptCount >= maxAttempts) {
+    return false;
+  }
+  const exceptions = retryConfig.exceptions;
+  if (exceptions !== void 0 && !errorNames(error).some((name) => exceptions.includes(name))) {
+    return false;
+  }
+  return true;
+}
+__name(shouldRetryNode, "shouldRetryNode");
+function getRetryDelaySeconds({
+  retryConfig,
+  nodeState,
+  randomFn = Math.random
+}) {
+  var _a, _b, _c, _d;
+  const initialDelay = (_a = retryConfig.initialDelay) != null ? _a : DEFAULT_INITIAL_DELAY_SECONDS;
+  const maxDelay = (_b = retryConfig.maxDelay) != null ? _b : DEFAULT_MAX_DELAY_SECONDS;
+  const backoffFactor = (_c = retryConfig.backoffFactor) != null ? _c : DEFAULT_BACKOFF_FACTOR;
+  const jitter = (_d = retryConfig.jitter) != null ? _d : DEFAULT_JITTER;
+  const attemptCount = nodeState.attemptCount || 1;
+  const attemptForCalc = Math.max(0, attemptCount - 1);
+  let delay = initialDelay * Math.pow(backoffFactor, attemptForCalc);
+  if (jitter > 0) {
+    delay = Math.min(delay, maxDelay / (1 + jitter));
+    const span = jitter * delay;
+    const randomOffset = -span + randomFn() * (2 * span);
+    delay = Math.max(0, delay + randomOffset);
+  }
+  return Math.min(delay, maxDelay);
+}
+__name(getRetryDelaySeconds, "getRetryDelaySeconds");
+export {
+  errorName,
+  errorNames,
+  getRetryDelaySeconds,
+  shouldRetryNode
+};