@softactivate/adk 1.1.0

package/dist/cjs/agents/context.js

@@ -0,0 +1,180 @@
+/**
+  * @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 __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 context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_auth_handler = require("../auth/auth_handler.js");
+var import_event_actions = require("../events/event_actions.js");
+var import_state = require("../sessions/state.js");
+var import_tool_confirmation = require("../tools/tool_confirmation.js");
+var import_readonly_context = require("./readonly_context.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Context extends import_readonly_context.ReadonlyContext {
+  /**
+   * @param options The configuration options for the Context.
+   * @param options.invocationContext The invocation context.
+   * @param options.eventActions The event actions of the current call.
+   * @param options.functionCallId The function call id of the current tool call.
+   *     This id was returned in the function call event from LLM to identify a
+   *     function call. If LLM didn't return this id, ADK will assign one to it.
+   *     This id is used to map function call response to the original function
+   *     call.
+   * @param options.toolConfirmation The tool confirmation of the current tool
+   *     call.
+   */
+  constructor(options) {
+    super(options.invocationContext);
+    this.eventActions = options.eventActions || (0, import_event_actions.createEventActions)();
+    this._state = new import_state.State(
+      options.invocationContext.session.state,
+      this.eventActions.stateDelta
+    );
+    this.functionCallId = options.functionCallId;
+    this.toolConfirmation = options.toolConfirmation;
+    this.abortSignal = options.invocationContext.abortSignal;
+  }
+  /**
+   * The delta-aware state of the current session.
+   */
+  get state() {
+    return this._state;
+  }
+  get actions() {
+    return this.eventActions;
+  }
+  /**
+   * Loads an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param version The version of the artifact. If not provided, the latest
+   *     version will be used.
+   * @return A promise that resolves to the loaded artifact.
+   */
+  loadArtifact(filename, version) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.invocationContext.artifactService.loadArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      version
+    });
+  }
+  /**
+   * Saves an artifact attached to the current session.
+   *
+   * @param filename The filename of the artifact.
+   * @param artifact The artifact to save.
+   * @return A promise that resolves to the version of the saved artifact.
+   */
+  async saveArtifact(filename, artifact) {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    const version = await this.invocationContext.artifactService.saveArtifact({
+      appName: this.invocationContext.appName,
+      userId: this.invocationContext.userId,
+      sessionId: this.invocationContext.session.id,
+      filename,
+      artifact
+    });
+    this.eventActions.artifactDelta[filename] = version;
+    return version;
+  }
+  requestCredential(authConfig) {
+    if (!this.functionCallId) {
+      throw new Error("functionCallId is not set.");
+    }
+    const authHandler = new import_auth_handler.AuthHandler(authConfig);
+    this.eventActions.requestedAuthConfigs[this.functionCallId] = authHandler.generateAuthRequest();
+  }
+  /**
+   * Gets the auth credential for the given auth config.
+   *
+   * @param authConfig The auth config to get the auth credential for.
+   * @return The auth credential for the given auth config.
+   */
+  getAuthResponse(authConfig) {
+    const authHandler = new import_auth_handler.AuthHandler(authConfig);
+    return authHandler.getAuthResponse(this.state);
+  }
+  /**
+   * Lists the filenames of the artifacts attached to the current session.
+   *
+   * @return A promise that resolves to a list of artifact filenames.
+   */
+  listArtifacts() {
+    if (!this.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.invocationContext.artifactService.listArtifactKeys({
+      appName: this.invocationContext.session.appName,
+      userId: this.invocationContext.session.userId,
+      sessionId: this.invocationContext.session.id
+    });
+  }
+  /**
+   * Searches the memory of the current user.
+   *
+   * @param query The query to search memory for.
+   * @return A promise that resolves to SearchMemoryResponse containing the
+   *     matching memories.
+   */
+  searchMemory(query) {
+    if (!this.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    return this.invocationContext.memoryService.searchMemory({
+      appName: this.invocationContext.session.appName,
+      userId: this.invocationContext.session.userId,
+      query
+    });
+  }
+  /**
+   * Requests confirmation for the current tool call.
+   */
+  requestConfirmation({ hint, payload }) {
+    if (!this.functionCallId) {
+      throw new Error("functionCallId is not set.");
+    }
+    this.eventActions.requestedToolConfirmations[this.functionCallId] = new import_tool_confirmation.ToolConfirmation({
+      hint,
+      confirmed: false,
+      payload
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});

package/dist/cjs/agents/functions.js

@@ -0,0 +1,525 @@
+/**
+  * @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 __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 functions_exports = {};
+__export(functions_exports, {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME: () => REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
+  functionsExportedForTestingOnly: () => functionsExportedForTestingOnly,
+  generateAuthEvent: () => generateAuthEvent,
+  generateClientFunctionCallId: () => generateClientFunctionCallId,
+  generateRequestConfirmationEvent: () => generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
+  handleFunctionCallList: () => handleFunctionCallList,
+  handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  handleFunctionCallsStreamingAsync: () => handleFunctionCallsStreamingAsync,
+  mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
+  populateClientFunctionCallId: () => populateClientFunctionCallId,
+  removeClientFunctionCallId: () => removeClientFunctionCallId
+});
+module.exports = __toCommonJS(functions_exports);
+var import_genai = require("@google/genai");
+var import_lodash_es = require("lodash-es");
+var import_event = require("../events/event.js");
+var import_event_actions = require("../events/event_actions.js");
+var import_agent_tool = require("../tools/agent_tool.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_context = require("./context.js");
+var import_tracing = require("../telemetry/tracing.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AF_FUNCTION_CALL_ID_PREFIX = "adk-";
+const REQUEST_EUC_FUNCTION_CALL_NAME = "adk_request_credential";
+const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
+const functionsExportedForTestingOnly = {
+  handleFunctionCallList,
+  generateAuthEvent,
+  generateRequestConfirmationEvent
+};
+function generateClientFunctionCallId() {
+  return `${AF_FUNCTION_CALL_ID_PREFIX}${(0, import_env_aware_utils.randomUUID)()}`;
+}
+function populateClientFunctionCallId(modelResponseEvent) {
+  const functionCalls = (0, import_event.getFunctionCalls)(modelResponseEvent);
+  if (!functionCalls) {
+    return;
+  }
+  for (const functionCall of functionCalls) {
+    if (!functionCall.id) {
+      functionCall.id = generateClientFunctionCallId();
+    }
+  }
+}
+function removeClientFunctionCallId(content) {
+  if (content && content.parts) {
+    for (const part of content.parts) {
+      if (part.functionCall && part.functionCall.id && part.functionCall.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+        part.functionCall.id = void 0;
+      }
+      if (part.functionResponse && part.functionResponse.id && part.functionResponse.id.startsWith(AF_FUNCTION_CALL_ID_PREFIX)) {
+        part.functionResponse.id = void 0;
+      }
+    }
+  }
+}
+function getLongRunningFunctionCalls(functionCalls, toolsDict) {
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  for (const functionCall of functionCalls) {
+    if (functionCall.name && functionCall.name in toolsDict && toolsDict[functionCall.name].isLongRunning && functionCall.id) {
+      longRunningToolIds.add(functionCall.id);
+    }
+  }
+  return longRunningToolIds;
+}
+function generateAuthEvent(invocationContext, functionResponseEvent) {
+  var _a;
+  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedAuthConfigs) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedAuthConfigs)) {
+    return void 0;
+  }
+  const parts = [];
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  for (const [functionCallId, authConfig] of Object.entries(
+    functionResponseEvent.actions.requestedAuthConfigs
+  )) {
+    const requestEucFunctionCall = {
+      name: REQUEST_EUC_FUNCTION_CALL_NAME,
+      args: {
+        "function_call_id": functionCallId,
+        "auth_config": authConfig
+      },
+      id: generateClientFunctionCallId()
+    };
+    longRunningToolIds.add(requestEucFunctionCall.id);
+    parts.push({ functionCall: requestEucFunctionCall });
+  }
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: {
+      parts,
+      role: functionResponseEvent.content.role
+    },
+    longRunningToolIds: Array.from(longRunningToolIds)
+  });
+}
+function generateRequestConfirmationEvent({
+  invocationContext,
+  functionCallEvent,
+  functionResponseEvent
+}) {
+  var _a, _b;
+  if (!((_a = functionResponseEvent.actions) == null ? void 0 : _a.requestedToolConfirmations) || (0, import_lodash_es.isEmpty)(functionResponseEvent.actions.requestedToolConfirmations)) {
+    return;
+  }
+  const parts = [];
+  const longRunningToolIds = /* @__PURE__ */ new Set();
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  for (const [functionCallId, toolConfirmation] of Object.entries(
+    functionResponseEvent.actions.requestedToolConfirmations
+  )) {
+    const originalFunctionCall = (_b = functionCalls.find((call) => call.id === functionCallId)) != null ? _b : void 0;
+    if (!originalFunctionCall) {
+      continue;
+    }
+    const requestConfirmationFunctionCall = {
+      name: REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+      args: {
+        "originalFunctionCall": originalFunctionCall,
+        "toolConfirmation": toolConfirmation
+      },
+      id: generateClientFunctionCallId()
+    };
+    longRunningToolIds.add(requestConfirmationFunctionCall.id);
+    parts.push({ functionCall: requestConfirmationFunctionCall });
+  }
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    branch: invocationContext.branch,
+    content: {
+      parts,
+      role: functionResponseEvent.content.role
+    },
+    actions: functionResponseEvent.actions,
+    longRunningToolIds: Array.from(longRunningToolIds)
+  });
+}
+async function callToolAsync(tool, args, toolContext) {
+  return import_tracing.tracer.startActiveSpan(`execute_tool ${tool.name}`, async (span) => {
+    try {
+      import_logger.logger.debug(`callToolAsync ${tool.name}`);
+      const result = await tool.runAsync({ args, toolContext });
+      (0, import_tracing.traceToolCall)({
+        tool,
+        args,
+        functionResponseEvent: buildResponseEvent(
+          tool,
+          result,
+          toolContext,
+          toolContext.invocationContext
+        )
+      });
+      return result;
+    } finally {
+      span.end();
+    }
+  });
+}
+function buildResponseEvent(tool, functionResult, toolContext, invocationContext) {
+  let responseResult;
+  if (typeof functionResult !== "object" || functionResult == null) {
+    responseResult = { result: functionResult };
+  } else {
+    responseResult = functionResult;
+  }
+  const partFunctionResponse = {
+    functionResponse: {
+      name: tool.name,
+      response: responseResult,
+      id: toolContext.functionCallId
+    }
+  };
+  const content = {
+    role: "user",
+    parts: [partFunctionResponse]
+  };
+  return (0, import_event.createEvent)({
+    invocationId: invocationContext.invocationId,
+    author: invocationContext.agent.name,
+    content,
+    actions: toolContext.actions,
+    branch: invocationContext.branch
+  });
+}
+async function handleFunctionCallsAsync({
+  invocationContext,
+  functionCallEvent,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  return await handleFunctionCallList({
+    invocationContext,
+    functionCalls,
+    toolsDict,
+    beforeToolCallbacks,
+    afterToolCallbacks,
+    filters,
+    toolConfirmationDict
+  });
+}
+async function* handleFunctionCallsStreamingAsync({
+  invocationContext,
+  functionCallEvent,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  toolConfirmationDict
+}) {
+  var _a, _b;
+  const functionCalls = (0, import_event.getFunctionCalls)(functionCallEvent);
+  if (!functionCalls.length) {
+    return;
+  }
+  const agentToolCalls = [];
+  const regularCalls = [];
+  for (const functionCall of functionCalls) {
+    const tool = functionCall.name ? toolsDict[functionCall.name] : void 0;
+    if (tool && (0, import_agent_tool.isAgentTool)(tool)) {
+      agentToolCalls.push({ call: functionCall, tool });
+    } else {
+      regularCalls.push(functionCall);
+    }
+  }
+  const agentToolResponseEvents = [];
+  for (const { call, tool } of agentToolCalls) {
+    const toolContext = new import_context.Context({
+      invocationContext,
+      functionCallId: call.id || void 0,
+      toolConfirmation: toolConfirmationDict && call.id ? toolConfirmationDict[call.id] : void 0
+    });
+    let lastContent;
+    for await (const event of tool.runAsyncWithEvents({
+      args: (_a = call.args) != null ? _a : {},
+      toolContext
+    })) {
+      if ((_b = invocationContext.abortSignal) == null ? void 0 : _b.aborted) {
+        return;
+      }
+      if (event.content) {
+        lastContent = event.content;
+      }
+      yield event;
+    }
+    const toolResult = tool.buildToolResultFromContent(lastContent);
+    const responseValue = typeof toolResult !== "object" || toolResult == null ? { result: toolResult } : toolResult;
+    agentToolResponseEvents.push(
+      (0, import_event.createEvent)({
+        invocationId: invocationContext.invocationId,
+        author: invocationContext.agent.name,
+        content: (0, import_genai.createUserContent)({
+          functionResponse: {
+            id: call.id,
+            name: tool.name,
+            response: responseValue
+          }
+        }),
+        actions: toolContext.actions,
+        branch: invocationContext.branch
+      })
+    );
+  }
+  let regularResponseEvent = null;
+  if (regularCalls.length) {
+    regularResponseEvent = await handleFunctionCallList({
+      invocationContext,
+      functionCalls: regularCalls,
+      toolsDict,
+      beforeToolCallbacks,
+      afterToolCallbacks,
+      toolConfirmationDict
+    });
+  }
+  const allResponseEvents = [];
+  if (regularResponseEvent) {
+    allResponseEvents.push(regularResponseEvent);
+  }
+  allResponseEvents.push(...agentToolResponseEvents);
+  if (!allResponseEvents.length) {
+    return;
+  }
+  yield allResponseEvents.length === 1 ? allResponseEvents[0] : mergeParallelFunctionResponseEvents(allResponseEvents);
+}
+async function handleFunctionCallList({
+  invocationContext,
+  functionCalls,
+  toolsDict,
+  beforeToolCallbacks,
+  afterToolCallbacks,
+  filters,
+  toolConfirmationDict
+}) {
+  var _a;
+  const functionResponseEvents = [];
+  const filteredFunctionCalls = functionCalls.filter((functionCall) => {
+    return !filters || functionCall.id && filters.has(functionCall.id);
+  });
+  for (const functionCall of filteredFunctionCalls) {
+    let toolConfirmation = void 0;
+    if (toolConfirmationDict && functionCall.id) {
+      toolConfirmation = toolConfirmationDict[functionCall.id];
+    }
+    const { tool, toolContext } = getToolAndContext({
+      invocationContext,
+      functionCall,
+      toolsDict,
+      toolConfirmation
+    });
+    import_logger.logger.debug(`execute_tool ${tool.name}`);
+    const functionArgs = (_a = functionCall.args) != null ? _a : {};
+    let functionResponse = null;
+    let functionResponseError;
+    functionResponse = await invocationContext.pluginManager.runBeforeToolCallback({
+      tool,
+      toolArgs: functionArgs,
+      toolContext
+    });
+    if (functionResponse == null) {
+      for (const callback of beforeToolCallbacks) {
+        functionResponse = await callback({
+          tool,
+          args: functionArgs,
+          context: toolContext
+        });
+        if (functionResponse) {
+          break;
+        }
+      }
+    }
+    if (functionResponse == null) {
+      try {
+        functionResponse = await callToolAsync(tool, functionArgs, toolContext);
+      } catch (e) {
+        if (e instanceof Error) {
+          const onToolErrorResponse = await invocationContext.pluginManager.runOnToolErrorCallback({
+            tool,
+            toolArgs: functionArgs,
+            toolContext,
+            error: e
+          });
+          if (onToolErrorResponse) {
+            functionResponse = onToolErrorResponse;
+          } else {
+            functionResponseError = e.message;
+          }
+        } else {
+          functionResponseError = e;
+        }
+      }
+    }
+    let alteredFunctionResponse = await invocationContext.pluginManager.runAfterToolCallback({
+      tool,
+      toolArgs: functionArgs,
+      toolContext,
+      result: functionResponse
+    });
+    if (alteredFunctionResponse == null) {
+      for (const callback of afterToolCallbacks) {
+        alteredFunctionResponse = await callback({
+          tool,
+          args: functionArgs,
+          context: toolContext,
+          response: functionResponse
+        });
+        if (alteredFunctionResponse) {
+          break;
+        }
+      }
+    }
+    if (alteredFunctionResponse != null) {
+      functionResponse = alteredFunctionResponse;
+    }
+    if (tool.isLongRunning && !functionResponse) {
+      continue;
+    }
+    if (functionResponseError) {
+      functionResponse = { error: functionResponseError };
+    } else if (typeof functionResponse !== "object" || functionResponse == null) {
+      functionResponse = { result: functionResponse };
+    }
+    const functionResponseEvent = (0, import_event.createEvent)({
+      invocationId: invocationContext.invocationId,
+      author: invocationContext.agent.name,
+      content: (0, import_genai.createUserContent)({
+        functionResponse: {
+          id: toolContext.functionCallId,
+          name: tool.name,
+          response: functionResponse
+        }
+      }),
+      actions: toolContext.actions,
+      branch: invocationContext.branch
+    });
+    import_logger.logger.debug("traceToolCall", {
+      tool: tool.name,
+      args: functionArgs,
+      functionResponseEvent: functionResponseEvent.id
+    });
+    functionResponseEvents.push(functionResponseEvent);
+  }
+  if (!functionResponseEvents.length) {
+    return null;
+  }
+  const mergedEvent = mergeParallelFunctionResponseEvents(
+    functionResponseEvents
+  );
+  if (functionResponseEvents.length > 1) {
+    import_tracing.tracer.startActiveSpan("execute_tool (merged)", (span) => {
+      try {
+        import_logger.logger.debug("execute_tool (merged)");
+        import_logger.logger.debug("traceMergedToolCalls", {
+          responseEventId: mergedEvent.id,
+          functionResponseEvent: mergedEvent.id
+        });
+        (0, import_tracing.traceMergedToolCalls)({
+          responseEventId: mergedEvent.id,
+          functionResponseEvent: mergedEvent
+        });
+      } finally {
+        span.end();
+      }
+    });
+  }
+  return mergedEvent;
+}
+function getToolAndContext({
+  invocationContext,
+  functionCall,
+  toolsDict,
+  toolConfirmation
+}) {
+  if (!functionCall.name || !(functionCall.name in toolsDict)) {
+    throw new Error(
+      `Function ${functionCall.name} is not found in the toolsDict.`
+    );
+  }
+  const toolContext = new import_context.Context({
+    invocationContext,
+    functionCallId: functionCall.id || void 0,
+    toolConfirmation
+  });
+  const tool = toolsDict[functionCall.name];
+  return { tool, toolContext };
+}
+function mergeParallelFunctionResponseEvents(functionResponseEvents) {
+  if (!functionResponseEvents.length) {
+    throw new Error("No function response events provided.");
+  }
+  if (functionResponseEvents.length === 1) {
+    return functionResponseEvents[0];
+  }
+  const mergedParts = [];
+  for (const event of functionResponseEvents) {
+    if (event.content && event.content.parts) {
+      mergedParts.push(...event.content.parts);
+    }
+  }
+  const baseEvent = functionResponseEvents[0];
+  const actionsList = functionResponseEvents.map(
+    (event) => event.actions || {}
+  );
+  const mergedActions = (0, import_event_actions.mergeEventActions)(actionsList);
+  return (0, import_event.createEvent)({
+    invocationId: baseEvent.invocationId,
+    author: baseEvent.author,
+    branch: baseEvent.branch,
+    content: { role: "user", parts: mergedParts },
+    actions: mergedActions,
+    timestamp: baseEvent.timestamp
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REQUEST_CONFIRMATION_FUNCTION_CALL_NAME,
+  REQUEST_EUC_FUNCTION_CALL_NAME,
+  functionsExportedForTestingOnly,
+  generateAuthEvent,
+  generateClientFunctionCallId,
+  generateRequestConfirmationEvent,
+  getLongRunningFunctionCalls,
+  handleFunctionCallList,
+  handleFunctionCallsAsync,
+  handleFunctionCallsStreamingAsync,
+  mergeParallelFunctionResponseEvents,
+  populateClientFunctionCallId,
+  removeClientFunctionCallId
+});