@google/adk 1.2.0 → 1.4.0

package/dist/cjs/agents/processors/content_processor_utils.js

@@ -25,7 +25,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var content_processor_utils_exports = {};
 __export(content_processor_utils_exports, {
   getContents: () => getContents,
-  getCurrentTurnContents: () => getCurrentTurnContents
+  getCurrentTurnContents: () => getCurrentTurnContents,
+  mergeFunctionResponseEvents: () => mergeFunctionResponseEvents,
+  removeClientFunctionCallId: () => removeClientFunctionCallId
 });
 module.exports = __toCommonJS(content_processor_utils_exports);
 var import_genai = require("@google/genai");
@@ -38,6 +40,17 @@ var import_functions = require("../functions.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+function removeClientFunctionCallId(content) {
+  var _a, _b, _c, _d, _e;
+  for (const part of (_a = content == null ? void 0 : content.parts) != null ? _a : []) {
+    if ((_c = (_b = part.functionCall) == null ? void 0 : _b.id) == null ? void 0 : _c.startsWith(import_functions.AF_FUNCTION_CALL_ID_PREFIX)) {
+      part.functionCall.id = void 0;
+    }
+    if ((_e = (_d = part.functionResponse) == null ? void 0 : _d.id) == null ? void 0 : _e.startsWith(import_functions.AF_FUNCTION_CALL_ID_PREFIX)) {
+      part.functionResponse.id = void 0;
+    }
+  }
+}
 function getContents(events, agentName, currentBranch) {
   var _a, _b, _c;
   const filteredEvents = [];
@@ -67,7 +80,7 @@ function getContents(events, agentName, currentBranch) {
   const contents = [];
   for (const event of resultEvents) {
     const content = (0, import_lodash_es.cloneDeep)(event.content);
-    (0, import_functions.removeClientFunctionCallId)(content);
+    removeClientFunctionCallId(content);
     contents.push(content);
   }
   return contents;
@@ -127,17 +140,19 @@ function convertForeignEvent(event) {
         text: `[${event.author}] said: ${part.text}`
       });
     } else if (part.functionCall) {
-      const argsText = safeStringify(part.functionCall.args);
       (_d = content.parts) == null ? void 0 : _d.push({
-        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${argsText}`
+        text: `[${event.author}] called tool \`${part.functionCall.name}\` with parameters: ${safeStringify(
+          part.functionCall.args
+        )}`
       });
     } else if (part.functionResponse) {
-      const responseText = safeStringify(part.functionResponse.response);
       (_e = content.parts) == null ? void 0 : _e.push({
-        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${responseText}`
+        text: `[${event.author}] tool \`${part.functionResponse.name}\` returned result: ${safeStringify(
+          part.functionResponse.response
+        )}`
       });
     } else {
-      (_f = content.parts) == null ? void 0 : _f.push(part);
+      (_f = content.parts) == null ? void 0 : _f.push((0, import_lodash_es.cloneDeep)(part));
     }
   }
   return (0, import_event.createEvent)({
@@ -153,9 +168,12 @@ function mergeFunctionResponseEvents(events) {
   if (events.length === 0) {
     throw new Error("Cannot merge an empty list of events.");
   }
-  const mergedEvent = (0, import_event.createEvent)(events[0]);
-  const partsInMergedEvent = ((_a = mergedEvent.content) == null ? void 0 : _a.parts) || [];
-  if (partsInMergedEvent.length === 0) {
+  const mergedEvent = (0, import_event.createEvent)({
+    ...events[0],
+    content: events[0].content ? (0, import_lodash_es.cloneDeep)(events[0].content) : void 0
+  });
+  const partsInMergedEvent = (_a = mergedEvent.content) == null ? void 0 : _a.parts;
+  if (!partsInMergedEvent || partsInMergedEvent.length === 0) {
     throw new Error("There should be at least one function_response part.");
   }
   const partIndicesInMergedEvent = {};
@@ -170,16 +188,17 @@ function mergeFunctionResponseEvents(events) {
       throw new Error("There should be at least one function_response part.");
     }
     for (const part of event.content.parts) {
-      if (part.functionResponse && part.functionResponse.id) {
-        const functionCallId = part.functionResponse.id;
+      const clonedPart = (0, import_lodash_es.cloneDeep)(part);
+      if (clonedPart.functionResponse && clonedPart.functionResponse.id) {
+        const functionCallId = clonedPart.functionResponse.id;
         if (functionCallId in partIndicesInMergedEvent) {
-          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = part;
+          partsInMergedEvent[partIndicesInMergedEvent[functionCallId]] = clonedPart;
         } else {
-          partsInMergedEvent.push(part);
+          partsInMergedEvent.push(clonedPart);
           partIndicesInMergedEvent[functionCallId] = partsInMergedEvent.length - 1;
         }
       } else {
-        partsInMergedEvent.push(part);
+        partsInMergedEvent.push(clonedPart);
       }
     }
   }
@@ -194,7 +213,7 @@ function rearrangeEventsForLatestFunctionResponse(events) {
   if (!(functionResponses == null ? void 0 : functionResponses.length)) {
     return events;
   }
-  let functionResponsesIds = new Set(
+  const functionResponsesIds = new Set(
     functionResponses.filter((response) => !!response.id).map((response) => response.id)
   );
   const secondLatestEvent = events.at(-2);
@@ -208,16 +227,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
       }
     }
   }
-  let functionCallEventIdx = -1;
+  let match;
   for (let idx = events.length - 2; idx >= 0; idx--) {
     const event = events[idx];
     const functionCalls = (0, import_event.getFunctionCalls)(event);
     if (!(functionCalls == null ? void 0 : functionCalls.length)) {
       continue;
     }
+    let matchedInEvent = false;
     for (const functionCall of functionCalls) {
       if (functionCall.id && functionResponsesIds.has(functionCall.id)) {
-        functionCallEventIdx = idx;
         const functionCallIds = new Set(
           functionCalls.map((fc) => fc.id).filter((id) => !!id)
         );
@@ -231,12 +250,16 @@ function rearrangeEventsForLatestFunctionResponse(events) {
             )}, function response ids provided: ${Array.from(functionResponsesIds).join(", ")}`
           );
         }
-        functionResponsesIds = functionCallIds;
+        match = { eventIdx: idx, responseIds: functionCallIds };
+        matchedInEvent = true;
         break;
       }
     }
+    if (matchedInEvent) {
+      break;
+    }
   }
-  if (functionCallEventIdx === -1) {
+  if (!match) {
     throw new Error(
       `No function call event found for function responses ids: ${Array.from(
         functionResponsesIds
@@ -244,17 +267,18 @@ function rearrangeEventsForLatestFunctionResponse(events) {
     );
   }
   const functionResponseEvents = [];
-  for (let idx = functionCallEventIdx + 1; idx < events.length - 1; idx++) {
+  const activeResponses = match.responseIds;
+  for (let idx = match.eventIdx + 1; idx < events.length - 1; idx++) {
     const event = events[idx];
     const responses = (0, import_event.getFunctionResponses)(event);
     if (responses && responses.some(
-      (response) => response.id && functionResponsesIds.has(response.id)
+      (response) => response.id && activeResponses.has(response.id)
     )) {
       functionResponseEvents.push(event);
     }
   }
   functionResponseEvents.push(events[events.length - 1]);
-  const resultEvents = events.slice(0, functionCallEventIdx + 1);
+  const resultEvents = events.slice(0, match.eventIdx + 1);
   resultEvents.push(mergeFunctionResponseEvents(functionResponseEvents));
   return resultEvents;
 }
@@ -293,7 +317,7 @@ function rearrangeEventsForAsyncFunctionResponsesInHistory(events) {
         continue;
       }
       if (functionResponseEventsIndices.size === 1) {
-        const [responseIndex] = [...functionResponseEventsIndices];
+        const [responseIndex] = Array.from(functionResponseEventsIndices);
         resultEvents.push(events[responseIndex]);
       } else {
         const indicesArray = Array.from(functionResponseEventsIndices).sort(
@@ -334,5 +358,7 @@ ${event.compactedContent}`
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getContents,
-  getCurrentTurnContents
+  getCurrentTurnContents,
+  mergeFunctionResponseEvents,
+  removeClientFunctionCallId
 });

package/dist/cjs/agents/processors/content_request_processor.js

@@ -37,6 +37,13 @@ var import_content_processor_utils = require("./content_processor_utils.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ContentRequestProcessor {
+  /**
+   * Fills {@link LlmRequest.contents} based on the session event history and
+   * agent configuration.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose contents field will be populated.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;

package/dist/cjs/agents/processors/context_compactor_request_processor.js

@@ -34,24 +34,38 @@ var import_base_plugin = require("../../plugins/base_plugin.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ContextCompactorRequestProcessor {
+  /**
+   * @param compactors - Ordered list of compactors to evaluate; the first one
+   *   that reports it should compact will perform the compaction.
+   */
   constructor(compactors) {
     this.compactors = compactors;
   }
+  /**
+   * Evaluates compactors in priority order. The first compactor that indicates
+   * it should compact will compact the session history, fire plugin hooks, and
+   * yield any newly generated events. Iteration stops after one compaction.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param _llmRequest - Unused; present to satisfy the {@link BaseLlmRequestProcessor} interface.
+   */
   async *runAsync(invocationContext, _llmRequest) {
+    var _a;
     for (const compactor of this.compactors) {
       const shouldCompact = await Promise.resolve(
         compactor.shouldCompact(invocationContext)
       );
       if (shouldCompact) {
+        const trigger = (_a = compactor.trigger) != null ? _a : import_base_plugin.ContextCompactionTrigger.Auto;
         await invocationContext.pluginManager.runBeforeContextCompaction({
           invocationContext,
-          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+          trigger
         });
         const oldEvents = new Set(invocationContext.session.events);
         await Promise.resolve(compactor.compact(invocationContext));
         await invocationContext.pluginManager.runAfterContextCompaction({
           invocationContext,
-          trigger: import_base_plugin.ContextCompactionTrigger.Auto
+          trigger
         });
         const newEvents = invocationContext.session.events.filter(
           (e) => !oldEvents.has(e)

package/dist/cjs/agents/processors/identity_llm_request_processor.js

@@ -36,6 +36,13 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class IdentityLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
+  /**
+   * Appends agent name and description as identity instructions to the system
+   * prompt of the request.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request object to append instructions to.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;

package/dist/cjs/agents/processors/instructions_llm_request_processor.js

@@ -75,6 +75,11 @@ class InstructionsLlmRequestProcessor extends import_base_llm_processor.BaseLlmR
       }
       (0, import_llm_request.appendInstructions)(llmRequest, [instructionWithState]);
     }
+    if (agent.outputSchema && agent.tools && agent.tools.length > 0) {
+      (0, import_llm_request.appendInstructions)(llmRequest, [
+        'To output the final result, you must call the "set_model_response" function with the appropriate values. Do not output anything else.'
+      ]);
+    }
   }
 }
 const INSTRUCTIONS_LLM_REQUEST_PROCESSOR = new InstructionsLlmRequestProcessor();

package/dist/cjs/agents/processors/interactions_request_processor.js

@@ -0,0 +1,63 @@
+/**
+  * @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 interactions_request_processor_exports = {};
+__export(interactions_request_processor_exports, {
+  INTERACTIONS_REQUEST_PROCESSOR: () => INTERACTIONS_REQUEST_PROCESSOR,
+  InteractionsRequestProcessor: () => InteractionsRequestProcessor
+});
+module.exports = __toCommonJS(interactions_request_processor_exports);
+var import_google_llm = require("../../models/google_llm.js");
+var import_llm_agent = require("../llm_agent.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InteractionsRequestProcessor {
+  // eslint-disable-next-line require-yield
+  async *runAsync(invocationContext, llmRequest) {
+    const agent = invocationContext.agent;
+    if (!agent || !(0, import_llm_agent.isLlmAgent)(agent)) {
+      return;
+    }
+    const model = agent.canonicalModel;
+    if ((0, import_google_llm.isGemini)(model) && model.useInteractionsApi) {
+      const events = invocationContext.session.events;
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.branch === invocationContext.branch && event.author === agent.name && event.interactionId) {
+          llmRequest.previousInteractionId = event.interactionId;
+          break;
+        }
+      }
+    }
+  }
+}
+const INTERACTIONS_REQUEST_PROCESSOR = new InteractionsRequestProcessor();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERACTIONS_REQUEST_PROCESSOR,
+  InteractionsRequestProcessor
+});

package/dist/cjs/agents/processors/request_confirmation_llm_request_processor.js

@@ -40,7 +40,15 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class RequestConfirmationLlmRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  /** Handles tool confirmation information to build the LLM request. */
+  /**
+   * Resumes tool calls that were paused for user confirmation, re-invoking
+   * them with the confirmed or denied decision before the next LLM turn.
+   *
+   * @param invocationContext - The current invocation context, including the
+   *   session event history used to locate pending confirmation responses.
+   * @yields Function response events for tools that have been confirmed and
+   *   are ready to resume.
+   */
   async *runAsync(invocationContext) {
     const agent = invocationContext.agent;
     if (!(0, import_llm_agent.isLlmAgent)(agent)) {

package/dist/cjs/agents/processors/tool_filter_request_processor.js

@@ -38,7 +38,13 @@ var import_base_llm_processor = require("./base_llm_processor.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class ToolFilterRequestProcessor extends import_base_llm_processor.BaseLlmRequestProcessor {
-  /** Filters the set of tools on the request based on plugins. */
+  /**
+   * Invokes plugin-based tool filtering and updates {@link LlmRequest.allowedTools}
+   * with the reduced tool set if any plugin returns a filtered result.
+   *
+   * @param invocationContext - The current invocation context.
+   * @param llmRequest - The request whose allowed tools may be restricted.
+   */
   // eslint-disable-next-line require-yield
   async *runAsync(invocationContext, llmRequest) {
     const agent = invocationContext.agent;

package/dist/cjs/apps/app.js

@@ -0,0 +1,79 @@
+/**
+  * @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 app_exports = {};
+__export(app_exports, {
+  App: () => App,
+  isApp: () => isApp,
+  validateAppName: () => validateAppName
+});
+module.exports = __toCommonJS(app_exports);
+var import_base_agent = require("../agents/base_agent.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const VALID_APP_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function validateAppName(name) {
+  if (!VALID_APP_NAME_RE.test(name)) {
+    throw new Error(
+      `Invalid app name '${name}': must start with a letter and can only consist of letters, digits, underscores, and hyphens.`
+    );
+  }
+  if (name === "user") {
+    throw new Error("App name cannot be 'user'; reserved for end-user input.");
+  }
+}
+const APP_SIGNATURE_SYMBOL = Symbol.for("google.adk.app");
+function isApp(obj) {
+  return typeof obj === "object" && obj !== null && APP_SIGNATURE_SYMBOL in obj && obj[APP_SIGNATURE_SYMBOL] === true;
+}
+_a = APP_SIGNATURE_SYMBOL;
+class App {
+  constructor(options) {
+    this[_a] = true;
+    var _a2, _b, _c, _d;
+    validateAppName(options.name);
+    if (options.rootAgent === void 0 || options.rootAgent === null) {
+      throw new Error("rootAgent must be provided.");
+    }
+    if (!(0, import_base_agent.isBaseAgent)(options.rootAgent)) {
+      throw new TypeError(
+        `rootAgent must be a BaseAgent instance, got ${(_c = (_b = (_a2 = options.rootAgent) == null ? void 0 : _a2.constructor) == null ? void 0 : _b.name) != null ? _c : typeof options.rootAgent}`
+      );
+    }
+    this.name = options.name;
+    this.rootAgent = options.rootAgent;
+    this.plugins = (_d = options.plugins) != null ? _d : [];
+    this.resumabilityConfig = options.resumabilityConfig;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  App,
+  isApp,
+  validateAppName
+});

package/dist/cjs/apps/resumability_config.js

@@ -0,0 +1,44 @@
+/**
+  * @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 resumability_config_exports = {};
+__export(resumability_config_exports, {
+  createResumabilityConfig: () => createResumabilityConfig
+});
+module.exports = __toCommonJS(resumability_config_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createResumabilityConfig(params = {}) {
+  return {
+    isResumable: false,
+    ...params
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResumabilityConfig
+});

package/dist/cjs/artifacts/file_artifact_service.js

@@ -67,7 +67,7 @@ class FileArtifactService {
     artifact,
     customMetadata
   }) {
-    if (!artifact.inlineData && !artifact.text) {
+    if (!artifact.inlineData && !artifact.text && !artifact.fileData) {
       throw new Error("Artifact must have either inlineData or text content.");
     }
     const artifactDir = getArtifactDir(
@@ -85,12 +85,19 @@ class FileArtifactService {
     const storedFilename = path.basename(artifactDir);
     const contentPath = path.join(versionDir, storedFilename);
     let mimeType;
+    let fileUri;
     if (artifact.inlineData) {
       const data = artifact.inlineData.data || "";
       await fs.writeFile(contentPath, Buffer.from(data, "base64"));
       mimeType = artifact.inlineData.mimeType || "application/octet-stream";
     } else if (artifact.text !== void 0) {
       await fs.writeFile(contentPath, artifact.text, "utf-8");
+    } else {
+      fileUri = artifact.fileData.fileUri;
+      if (!fileUri) {
+        throw new Error("Artifact fileData must have a fileUri.");
+      }
+      mimeType = artifact.fileData.mimeType;
     }
     const canonicalUri = await getCanonicalUri(
       this.rootDir,
@@ -102,6 +109,7 @@ class FileArtifactService {
     const metadata = {
       fileName: filename,
       mimeType,
+      fileUri,
       version: nextVersion,
       canonicalUri,
       customMetadata
@@ -153,6 +161,11 @@ class FileArtifactService {
       );
       const metadataPath = path.join(versionDir, "metadata.json");
       const metadata = await readMetadata(metadataPath);
+      if (metadata.fileUri) {
+        return {
+          fileData: { fileUri: metadata.fileUri, mimeType: metadata.mimeType }
+        };
+      }
       const storedFilename = path.basename(artifactDir);
       let contentPath = path.join(versionDir, storedFilename);
       if (metadata.canonicalUri) {

package/dist/cjs/artifacts/gcs_artifact_service.js

@@ -35,12 +35,16 @@ var import_logger = require("../utils/logger.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+const GCS_FILE_URI_METADATA_KEY = "adkFileUri";
+const GCS_FILE_MIME_TYPE_METADATA_KEY = "adkFileMimeType";
+const GCS_DISPLAY_NAME_METADATA_KEY = "adkDisplayName";
+const GCS_IS_TEXT_METADATA_KEY = "adkIsText";
 class GcsArtifactService {
-  constructor(bucket) {
-    this.bucket = new import_storage.Storage().bucket(bucket);
+  constructor(bucket, options) {
+    this.bucket = new import_storage.Storage(options).bucket(bucket);
   }
   async saveArtifact(request) {
-    if (!request.artifact.inlineData && !request.artifact.text) {
+    if (!request.artifact.inlineData && !request.artifact.text && !request.artifact.fileData) {
       throw new Error("Artifact must have either inlineData or text content.");
     }
     const versions = await this.listVersions(request);
@@ -51,24 +55,48 @@ class GcsArtifactService {
         version
       })
     );
-    const metadata = request.customMetadata || {};
+    const customMetadata = {
+      ...request.customMetadata
+    };
     if (request.artifact.inlineData) {
+      if (request.artifact.inlineData.displayName) {
+        customMetadata[GCS_DISPLAY_NAME_METADATA_KEY] = request.artifact.inlineData.displayName;
+      }
       await file.save(
         Buffer.from(request.artifact.inlineData.data || "", "base64"),
         {
           contentType: request.artifact.inlineData.mimeType,
-          metadata
+          metadata: { metadata: customMetadata }
         }
       );
       return version;
+    } else if (request.artifact.text !== void 0) {
+      await file.save(request.artifact.text, {
+        contentType: "text/plain",
+        metadata: {
+          metadata: { ...customMetadata, [GCS_IS_TEXT_METADATA_KEY]: "true" }
+        }
+      });
+      return version;
+    } else {
+      const fileData = request.artifact.fileData;
+      const fileUri = fileData == null ? void 0 : fileData.fileUri;
+      if (!fileUri) {
+        throw new Error("Artifact fileData must have a fileUri.");
+      }
+      customMetadata[GCS_FILE_URI_METADATA_KEY] = fileUri;
+      if (fileData.mimeType) {
+        customMetadata[GCS_FILE_MIME_TYPE_METADATA_KEY] = fileData.mimeType;
+      }
+      await file.save("", {
+        contentType: fileData.mimeType || void 0,
+        metadata: { metadata: customMetadata }
+      });
+      return version;
     }
-    await file.save(request.artifact.text, {
-      contentType: "text/plain",
-      metadata
-    });
-    return version;
   }
   async loadArtifact(request) {
+    var _a, _b, _c;
     try {
       let version = request.version;
       if (version === void 0) {
@@ -84,11 +112,25 @@ class GcsArtifactService {
           version
         })
       );
-      const [[metadata], [rawDataBuffer]] = await Promise.all([
-        file.getMetadata(),
-        file.download()
-      ]);
-      if (metadata.contentType === "text/plain") {
+      const [metadata] = await file.getMetadata();
+      const customMeta = (_a = metadata.metadata) != null ? _a : {};
+      const fileUri = customMeta[GCS_FILE_URI_METADATA_KEY];
+      if (fileUri) {
+        const mimeType = (_c = (_b = customMeta[GCS_FILE_MIME_TYPE_METADATA_KEY]) != null ? _b : metadata.contentType) != null ? _c : void 0;
+        return { fileData: { fileUri, mimeType } };
+      }
+      const [rawDataBuffer] = await file.download();
+      const displayName = customMeta[GCS_DISPLAY_NAME_METADATA_KEY];
+      if (displayName) {
+        return {
+          inlineData: {
+            data: rawDataBuffer.toString("base64"),
+            mimeType: metadata.contentType,
+            displayName
+          }
+        };
+      }
+      if (customMeta[GCS_IS_TEXT_METADATA_KEY] === "true" || metadata.contentType === "text/plain") {
         return (0, import_genai.createPartFromText)(rawDataBuffer.toString("utf-8"));
       }
       return (0, import_genai.createPartFromBase64)(

package/dist/cjs/artifacts/in_memory_artifact_service.js

@@ -48,7 +48,7 @@ class InMemoryArtifactService {
     artifact,
     customMetadata
   }) {
-    if (!artifact.inlineData && !artifact.text) {
+    if (!artifact.inlineData && !artifact.text && !artifact.fileData) {
       return Promise.reject(
         new Error("Artifact must have either inlineData or text content.")
       );
@@ -62,6 +62,10 @@ class InMemoryArtifactService {
       version,
       customMetadata
     };
+    if (!artifact.inlineData && artifact.text === void 0) {
+      const fileData = artifact.fileData;
+      metadata.mimeType = fileData.mimeType;
+    }
     this.artifacts[path].push({ part: artifact, metadata });
     return Promise.resolve(version);
   }