@google/adk 0.3.0 → 0.5.0

package/dist/esm/a2a/event_converter_utils.js

@@ -0,0 +1,187 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createModelContent,
+  createUserContent
+} from "@google/genai";
+import { createEvent } from "../events/event.js";
+import { createEventActions } from "../events/event_actions.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import {
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent,
+  MessageRole
+} from "./a2a_event.js";
+import {
+  A2AMetadataKeys,
+  getA2AEventMetadata
+} from "./metadata_converter_utils.js";
+import { toA2AParts, toGenAIPart, toGenAIParts } from "./part_converter_utils.js";
+function toA2AMessage(event, {
+  appName,
+  userId,
+  sessionId
+}) {
+  var _a;
+  return {
+    kind: "message",
+    messageId: randomUUID(),
+    role: event.author === MessageRole.USER ? MessageRole.USER : MessageRole.AGENT,
+    parts: toA2AParts(((_a = event.content) == null ? void 0 : _a.parts) || [], event.longRunningToolIds),
+    metadata: getA2AEventMetadata(event, { appName, userId, sessionId })
+  };
+}
+function toAdkEvent(event, invocationId, agentName) {
+  if (isMessage(event)) {
+    return messageToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTask(event)) {
+    return taskToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTaskArtifactUpdateEvent(event)) {
+    return artifactUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTaskStatusUpdateEvent(event)) {
+    return event.final ? finalTaskStatusUpdateToAdkEvent(event, invocationId, agentName) : taskStatusUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  return void 0;
+}
+function messageToAdkEvent(msg, invocationId, agentName, parentEvent) {
+  const parts = toGenAIParts(msg.parts);
+  return {
+    ...createAdkEventFromMetadata(parentEvent || msg),
+    invocationId,
+    author: msg.role === MessageRole.USER ? MessageRole.USER : agentName,
+    content: msg.role === MessageRole.USER ? createUserContent(parts) : createModelContent(parts),
+    turnComplete: true,
+    partial: false
+  };
+}
+function artifactUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  var _a;
+  const partsToConvert = ((_a = a2aEvent.artifact) == null ? void 0 : _a.parts) || [];
+  if (partsToConvert.length === 0) {
+    return void 0;
+  }
+  const partial = !!getEventMetadata(a2aEvent)[A2AMetadataKeys.PARTIAL] || a2aEvent.append || !a2aEvent.lastChunk;
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    content: createModelContent(toGenAIParts(partsToConvert)),
+    longRunningToolIds: getLongRunningToolIDs(partsToConvert),
+    partial
+  };
+}
+function finalTaskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  var _a;
+  const partsToConvert = ((_a = a2aEvent.status.message) == null ? void 0 : _a.parts) || [];
+  if (partsToConvert.length === 0) {
+    return void 0;
+  }
+  const parts = toGenAIParts(partsToConvert);
+  const isFailedTask = isFailedTaskStatusUpdateEvent(a2aEvent);
+  const hasContent = !isFailedTask && parts.length > 0;
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    errorMessage: isFailedTask ? getFailedTaskStatusUpdateEventError(a2aEvent) : void 0,
+    content: hasContent ? createModelContent(parts) : void 0,
+    longRunningToolIds: getLongRunningToolIDs(partsToConvert),
+    turnComplete: true
+  };
+}
+function taskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  const msg = a2aEvent.status.message;
+  if (!msg) {
+    return void 0;
+  }
+  const parts = toGenAIParts(msg.parts);
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    content: createModelContent(parts),
+    turnComplete: false,
+    partial: true
+  };
+}
+function taskToAdkEvent(a2aTask, invocationId, agentName) {
+  var _a, _b;
+  const parts = [];
+  const longRunningToolIds = [];
+  if (a2aTask.artifacts) {
+    for (const artifact of a2aTask.artifacts) {
+      if (((_a = artifact.parts) == null ? void 0 : _a.length) > 0) {
+        const artifactParts = toGenAIParts(artifact.parts);
+        parts.push(...artifactParts);
+        longRunningToolIds.push(...getLongRunningToolIDs(artifact.parts));
+      }
+    }
+  }
+  if ((_b = a2aTask.status) == null ? void 0 : _b.message) {
+    const a2aParts = a2aTask.status.message.parts;
+    const genAIParts = toGenAIParts(a2aParts);
+    parts.push(...genAIParts);
+    longRunningToolIds.push(...getLongRunningToolIDs(a2aParts));
+  }
+  const isTerminal = isTerminalTaskStatusUpdateEvent(a2aTask) || isInputRequiredTaskStatusUpdateEvent(a2aTask);
+  const isFailed = isFailedTaskStatusUpdateEvent(a2aTask);
+  if (parts.length === 0 && !isTerminal) {
+    return void 0;
+  }
+  return {
+    ...createAdkEventFromMetadata(a2aTask),
+    invocationId,
+    author: agentName,
+    content: isFailed ? void 0 : createModelContent(parts),
+    errorMessage: isFailed ? getFailedTaskStatusUpdateEventError(a2aTask) : void 0,
+    longRunningToolIds,
+    turnComplete: isTerminal
+  };
+}
+function createAdkEventFromMetadata(a2aEvent) {
+  const metadata = a2aEvent.metadata || {};
+  return createEvent({
+    branch: metadata[A2AMetadataKeys.BRANCH],
+    author: metadata[A2AMetadataKeys.AUTHOR],
+    partial: metadata[A2AMetadataKeys.PARTIAL],
+    errorCode: metadata[A2AMetadataKeys.ERROR_CODE],
+    errorMessage: metadata[A2AMetadataKeys.ERROR_MESSAGE],
+    citationMetadata: metadata[A2AMetadataKeys.CITATION_METADATA],
+    groundingMetadata: metadata[A2AMetadataKeys.GROUNDING_METADATA],
+    usageMetadata: metadata[A2AMetadataKeys.USAGE_METADATA],
+    customMetadata: metadata[A2AMetadataKeys.CUSTOM_METADATA],
+    actions: createEventActions({
+      escalate: !!metadata[A2AMetadataKeys.ESCALATE],
+      transferToAgent: metadata[A2AMetadataKeys.TRANSFER_TO_AGENT]
+    })
+  });
+}
+function getLongRunningToolIDs(parts) {
+  const ids = [];
+  for (const a2aPart of parts) {
+    if (a2aPart.metadata && a2aPart.metadata[A2AMetadataKeys.IS_LONG_RUNNING]) {
+      const genAIPart = toGenAIPart(a2aPart);
+      if (genAIPart.functionCall && genAIPart.functionCall.id) {
+        ids.push(genAIPart.functionCall.id);
+      }
+    }
+  }
+  return ids;
+}
+export {
+  toA2AMessage,
+  toAdkEvent
+};

package/dist/esm/a2a/executor_context.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createExecutorContext({
+  session,
+  userContent,
+  requestContext
+}) {
+  return {
+    userId: session.userId,
+    sessionId: session.id,
+    agentName: session.appName,
+    readonlyState: session.state,
+    events: session.events,
+    userContent,
+    requestContext
+  };
+}
+export {
+  createExecutorContext
+};

package/dist/esm/a2a/metadata_converter_utils.js

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isTask } from "./a2a_event.js";
+const ADK_METADATA_KEY_PREFIX = "adk_";
+const A2A_METADATA_KEY_PREFIX = "a2a:";
+var A2AMetadataKeys = ((A2AMetadataKeys2) => {
+  A2AMetadataKeys2["APP_NAME"] = `${ADK_METADATA_KEY_PREFIX}app_name`;
+  A2AMetadataKeys2["USER_ID"] = `${ADK_METADATA_KEY_PREFIX}user_id`;
+  A2AMetadataKeys2["SESSION_ID"] = `${ADK_METADATA_KEY_PREFIX}session_id`;
+  A2AMetadataKeys2["INVOCATION_ID"] = `${ADK_METADATA_KEY_PREFIX}invocation_id`;
+  A2AMetadataKeys2["AUTHOR"] = `${ADK_METADATA_KEY_PREFIX}author`;
+  A2AMetadataKeys2["BRANCH"] = `${ADK_METADATA_KEY_PREFIX}branch`;
+  A2AMetadataKeys2["DATA_PART_TYPE"] = `${ADK_METADATA_KEY_PREFIX}type`;
+  A2AMetadataKeys2["PARTIAL"] = `${ADK_METADATA_KEY_PREFIX}partial`;
+  A2AMetadataKeys2["ESCALATE"] = `${ADK_METADATA_KEY_PREFIX}escalate`;
+  A2AMetadataKeys2["TRANSFER_TO_AGENT"] = `${ADK_METADATA_KEY_PREFIX}transfer_to_agent`;
+  A2AMetadataKeys2["IS_LONG_RUNNING"] = `${ADK_METADATA_KEY_PREFIX}is_long_running`;
+  A2AMetadataKeys2["THOUGHT"] = `${ADK_METADATA_KEY_PREFIX}thought`;
+  A2AMetadataKeys2["ERROR_CODE"] = `${ADK_METADATA_KEY_PREFIX}error_code`;
+  A2AMetadataKeys2["ERROR_MESSAGE"] = `${ADK_METADATA_KEY_PREFIX}error_message`;
+  A2AMetadataKeys2["CITATION_METADATA"] = `${ADK_METADATA_KEY_PREFIX}citation_metadata`;
+  A2AMetadataKeys2["GROUNDING_METADATA"] = `${ADK_METADATA_KEY_PREFIX}grounding_metadata`;
+  A2AMetadataKeys2["USAGE_METADATA"] = `${ADK_METADATA_KEY_PREFIX}usage_metadata`;
+  A2AMetadataKeys2["CUSTOM_METADATA"] = `${ADK_METADATA_KEY_PREFIX}custom_metadata`;
+  return A2AMetadataKeys2;
+})(A2AMetadataKeys || {});
+var AdkMetadataKeys = ((AdkMetadataKeys2) => {
+  AdkMetadataKeys2["TASK_ID"] = `${A2A_METADATA_KEY_PREFIX}task_id`;
+  AdkMetadataKeys2["CONTEXT_ID"] = `${A2A_METADATA_KEY_PREFIX}context_id`;
+  return AdkMetadataKeys2;
+})(AdkMetadataKeys || {});
+function getAdkEventMetadata(a2aEvent) {
+  return {
+    [AdkMetadataKeys.TASK_ID]: isTask(a2aEvent) ? a2aEvent.id : a2aEvent.taskId,
+    [AdkMetadataKeys.CONTEXT_ID]: a2aEvent.contextId
+  };
+}
+function getA2AEventMetadata(adkEvent, {
+  appName,
+  userId,
+  sessionId
+}) {
+  return {
+    ...getA2AEventMetadataFromActions(adkEvent.actions),
+    ...getA2ASessionMetadata({
+      appName,
+      userId,
+      sessionId
+    }),
+    [A2AMetadataKeys.INVOCATION_ID]: adkEvent.invocationId,
+    [A2AMetadataKeys.AUTHOR]: adkEvent.author,
+    [A2AMetadataKeys.BRANCH]: adkEvent.branch,
+    [A2AMetadataKeys.ERROR_CODE]: adkEvent.errorMessage,
+    [A2AMetadataKeys.ERROR_MESSAGE]: adkEvent.errorMessage,
+    [A2AMetadataKeys.CITATION_METADATA]: adkEvent.citationMetadata,
+    [A2AMetadataKeys.GROUNDING_METADATA]: adkEvent.groundingMetadata,
+    [A2AMetadataKeys.USAGE_METADATA]: adkEvent.usageMetadata,
+    [A2AMetadataKeys.CUSTOM_METADATA]: adkEvent.customMetadata,
+    [A2AMetadataKeys.PARTIAL]: adkEvent.partial,
+    [A2AMetadataKeys.IS_LONG_RUNNING]: (adkEvent.longRunningToolIds || []).length > 0
+  };
+}
+function getA2ASessionMetadata({
+  appName,
+  userId,
+  sessionId
+}) {
+  return {
+    [A2AMetadataKeys.APP_NAME]: appName,
+    [A2AMetadataKeys.USER_ID]: userId,
+    [A2AMetadataKeys.SESSION_ID]: sessionId
+  };
+}
+function getA2AEventMetadataFromActions(actions) {
+  return {
+    [A2AMetadataKeys.ESCALATE]: actions.escalate,
+    [A2AMetadataKeys.TRANSFER_TO_AGENT]: actions.transferToAgent
+  };
+}
+export {
+  A2AMetadataKeys,
+  AdkMetadataKeys,
+  getA2AEventMetadata,
+  getA2AEventMetadataFromActions,
+  getA2ASessionMetadata,
+  getAdkEventMetadata
+};

package/dist/esm/a2a/part_converter_utils.js

@@ -0,0 +1,175 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createModelContent,
+  createUserContent
+} from "@google/genai";
+import { A2AMetadataKeys } from "./metadata_converter_utils.js";
+var DataPartType = /* @__PURE__ */ ((DataPartType2) => {
+  DataPartType2["FUNCTION_CALL"] = "function_call";
+  DataPartType2["FUNCTION_RESPONSE"] = "function_response";
+  DataPartType2["CODE_EXEC_RESULT"] = "code_execution_result";
+  DataPartType2["CODE_EXECUTABLE_CODE"] = "executable_code";
+  return DataPartType2;
+})(DataPartType || {});
+function toA2AParts(parts = [], longRunningToolIDs = []) {
+  return parts.map((part) => toA2APart(part, longRunningToolIDs));
+}
+function toA2APart(part, longRunningToolIDs) {
+  if (part.text !== void 0 && part.text !== null) {
+    return toA2ATextPart(part);
+  }
+  if (part.inlineData || part.fileData) {
+    return toA2AFilePart(part);
+  }
+  return toA2ADataPart(part, longRunningToolIDs);
+}
+function toA2ATextPart(part) {
+  const a2aPart = { kind: "text", text: part.text || "" };
+  if (part.thought) {
+    a2aPart.metadata = {
+      [A2AMetadataKeys.THOUGHT]: true
+    };
+  }
+  return a2aPart;
+}
+function toA2AFilePart(part) {
+  if (part.fileData) {
+    return {
+      kind: "file",
+      file: {
+        uri: part.fileData.fileUri || "",
+        mimeType: part.fileData.mimeType
+      },
+      metadata: {}
+    };
+  }
+  if (part.inlineData) {
+    return {
+      kind: "file",
+      file: {
+        bytes: part.inlineData.data || "",
+        mimeType: part.inlineData.mimeType
+      },
+      metadata: {}
+    };
+  }
+  throw new Error(`Not a file part: ${JSON.stringify(part)}`);
+}
+function toA2ADataPart(part, longRunningToolIDs = []) {
+  let dataPartType;
+  let data;
+  if (part.functionCall) {
+    dataPartType = "function_call" /* FUNCTION_CALL */;
+    data = part.functionCall;
+  } else if (part.functionResponse) {
+    dataPartType = "function_response" /* FUNCTION_RESPONSE */;
+    data = part.functionResponse;
+  } else if (part.executableCode) {
+    dataPartType = "executable_code" /* CODE_EXECUTABLE_CODE */;
+    data = part.executableCode;
+  } else if (part.codeExecutionResult) {
+    dataPartType = "code_execution_result" /* CODE_EXEC_RESULT */;
+    data = part.codeExecutionResult;
+  } else {
+    throw new Error(`Unknown part type: ${JSON.stringify(part)}`);
+  }
+  const metadata = {
+    [A2AMetadataKeys.DATA_PART_TYPE]: dataPartType
+  };
+  if (part.functionCall && part.functionCall.id && longRunningToolIDs.includes(part.functionCall.id)) {
+    metadata[A2AMetadataKeys.IS_LONG_RUNNING] = true;
+  }
+  if (part.functionResponse && part.functionResponse.id && longRunningToolIDs.includes(part.functionResponse.id)) {
+    metadata[A2AMetadataKeys.IS_LONG_RUNNING] = true;
+  }
+  return {
+    kind: "data",
+    data,
+    metadata
+  };
+}
+function toGenAIContent(a2aMessage) {
+  const parts = toGenAIParts(a2aMessage.parts);
+  return a2aMessage.role === "user" ? createUserContent(parts) : createModelContent(parts);
+}
+function toGenAIParts(a2aParts) {
+  return a2aParts.map((a2aPart) => toGenAIPart(a2aPart));
+}
+function toGenAIPart(a2aPart) {
+  if (a2aPart.kind === "text") {
+    return toGenAIPartText(a2aPart);
+  }
+  if (a2aPart.kind === "file") {
+    return toGenAIPartFile(a2aPart);
+  }
+  if (a2aPart.kind === "data") {
+    return toGenAIPartData(a2aPart);
+  }
+  throw new Error(`Unknown part kind: ${JSON.stringify(a2aPart)}`);
+}
+function toGenAIPartText(a2aPart) {
+  var _a;
+  return {
+    text: a2aPart.text,
+    thought: !!((_a = a2aPart.metadata) == null ? void 0 : _a[A2AMetadataKeys.THOUGHT])
+  };
+}
+function toGenAIPartFile(a2aPart) {
+  if ("bytes" in a2aPart.file) {
+    return {
+      inlineData: {
+        data: a2aPart.file.bytes,
+        mimeType: a2aPart.file.mimeType || ""
+      }
+    };
+  }
+  if ("uri" in a2aPart.file) {
+    return {
+      fileData: {
+        fileUri: a2aPart.file.uri,
+        mimeType: a2aPart.file.mimeType || ""
+      }
+    };
+  }
+  throw new Error(`Not a file part: ${JSON.stringify(a2aPart)}`);
+}
+function toGenAIPartData(a2aPart) {
+  var _a;
+  if (!a2aPart.data) {
+    throw new Error(`No data in part: ${JSON.stringify(a2aPart)}`);
+  }
+  const data = a2aPart.data;
+  const type = (_a = a2aPart.metadata) == null ? void 0 : _a[A2AMetadataKeys.DATA_PART_TYPE];
+  if (type === "function_call" /* FUNCTION_CALL */) {
+    return { functionCall: data };
+  }
+  if (type === "function_response" /* FUNCTION_RESPONSE */) {
+    return { functionResponse: data };
+  }
+  if (type === "executable_code" /* CODE_EXECUTABLE_CODE */) {
+    return { executableCode: data };
+  }
+  if (type === "code_execution_result" /* CODE_EXEC_RESULT */) {
+    return { codeExecutionResult: data };
+  }
+  return {
+    text: JSON.stringify(a2aPart.data)
+  };
+}
+export {
+  toA2ADataPart,
+  toA2AFilePart,
+  toA2APart,
+  toA2AParts,
+  toA2ATextPart,
+  toGenAIContent,
+  toGenAIPart,
+  toGenAIPartData,
+  toGenAIPartFile,
+  toGenAIPartText,
+  toGenAIParts
+};

package/dist/esm/agents/base_agent.js

@@ -11,7 +11,7 @@ import {
   traceAgentInvocation,
   tracer
 } from "../telemetry/tracing.js";
-import { CallbackContext } from "./callback_context.js";
+import { Context } from "./context.js";
 import { InvocationContext } from "./invocation_context.js";
 const BASE_AGENT_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseAgent");
 function isBaseAgent(obj) {
@@ -153,7 +153,7 @@ class BaseAgent {
     if (this.beforeAgentCallback.length === 0) {
       return void 0;
     }
-    const callbackContext = new CallbackContext({ invocationContext });
+    const callbackContext = new Context({ invocationContext });
     for (const callback of this.beforeAgentCallback) {
       const content = await callback(callbackContext);
       if (content) {
@@ -188,7 +188,7 @@ class BaseAgent {
     if (this.afterAgentCallback.length === 0) {
       return void 0;
     }
-    const callbackContext = new CallbackContext({ invocationContext });
+    const callbackContext = new Context({ invocationContext });
     for (const callback of this.afterAgentCallback) {
       const content = await callback(callbackContext);
       if (content) {
@@ -225,7 +225,7 @@ class BaseAgent {
 function validateAgentName(name) {
   if (!isIdentifier(name)) {
     throw new Error(
-      `Found invalid agent name: "${name}". Agent name must be a valid identifier. It should start with a letter (a-z, A-Z) or an underscore (_), and can only contain letters, digits (0-9), and underscores.`
+      `Found invalid agent name: "${name}". Agent name must be a valid identifier. It should start with a letter (a-z, A-Z) or an underscore (_), and can only contain letters, digits (0-9), underscores, and hyphens.`
     );
   }
   if (name === "user") {
@@ -236,7 +236,7 @@ function validateAgentName(name) {
   return name;
 }
 function isIdentifier(str) {
-  return /^[\p{ID_Start}$_][\p{ID_Continue}$_]*$/u.test(str);
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$_-]*$/u.test(str);
 }
 function getRootAgent(rootAgent) {
   while (rootAgent.parentAgent) {

package/dist/esm/{tools/tool_context.js → agents/context.js}

@@ -3,29 +3,84 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { CallbackContext } from "../agents/callback_context.js";
 import { AuthHandler } from "../auth/auth_handler.js";
+import { createEventActions } from "../events/event_actions.js";
+import { State } from "../sessions/state.js";
 import { ToolConfirmation } from "../tools/tool_confirmation.js";
-class ToolContext extends CallbackContext {
+import { ReadonlyContext } from "./readonly_context.js";
+class Context extends ReadonlyContext {
   /**
-   * @param params.invocationContext The invocation context of the tool.
-   * @param params.eventActions The event actions of the current tool call.
-   * @param params.functionCallId The function call id of the current tool call.
+   * @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 params.toolConfirmation The tool confirmation of the current tool
+   * @param options.toolConfirmation The tool confirmation of the current tool
    *     call.
    */
-  constructor(params) {
-    super(params);
-    this.functionCallId = params.functionCallId;
-    this.toolConfirmation = params.toolConfirmation;
+  constructor(options) {
+    super(options.invocationContext);
+    this.eventActions = options.eventActions || createEventActions();
+    this._state = new State(
+      options.invocationContext.session.state,
+      this.eventActions.stateDelta
+    );
+    this.functionCallId = options.functionCallId;
+    this.toolConfirmation = options.toolConfirmation;
+  }
+  /**
+   * 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.");
@@ -90,5 +145,5 @@ class ToolContext extends CallbackContext {
   }
 }
 export {
-  ToolContext
+  Context
 };

package/dist/esm/agents/functions.js

@@ -7,9 +7,9 @@ import { createUserContent } from "@google/genai";
 import { isEmpty } from "lodash-es";
 import { createEvent, getFunctionCalls } from "../events/event.js";
 import { mergeEventActions } from "../events/event_actions.js";
-import { ToolContext } from "../tools/tool_context.js";
 import { randomUUID } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
+import { Context } from "./context.js";
 import {
   traceMergedToolCalls,
   tracer,
@@ -128,6 +128,7 @@ function generateRequestConfirmationEvent({
       parts,
       role: functionResponseEvent.content.role
     },
+    actions: functionResponseEvent.actions,
     longRunningToolIds: Array.from(longRunningToolIds)
   });
 }
@@ -351,7 +352,7 @@ function getToolAndContext({
       `Function ${functionCall.name} is not found in the toolsDict.`
     );
   }
-  const toolContext = new ToolContext({
+  const toolContext = new Context({
     invocationContext,
     functionCallId: functionCall.id || void 0,
     toolConfirmation