@google/adk 0.4.0 → 0.6.0

package/dist/cjs/memory/in_memory_memory_service.js

@@ -87,7 +87,7 @@ function getUserKey(appName, userId) {
 }
 function extractWordsLower(text) {
   return new Set(
-    [...text.matchAll(/[A-Za-z]+/)].map((match) => match[0].toLowerCase())
+    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
   );
 }
 function formatTimestamp(timestamp) {

package/dist/cjs/models/llm_response.js

@@ -41,6 +41,7 @@ function createLlmResponse(response) {
       return {
         content: candidate.content,
         groundingMetadata: candidate.groundingMetadata,
+        citationMetadata: candidate.citationMetadata,
         usageMetadata,
         finishReason: candidate.finishReason
       };
@@ -49,6 +50,7 @@ function createLlmResponse(response) {
       errorCode: candidate.finishReason,
       errorMessage: candidate.finishMessage,
       usageMetadata,
+      citationMetadata: candidate.citationMetadata,
       finishReason: candidate.finishReason
     };
   }

package/dist/cjs/plugins/base_plugin.js

@@ -227,7 +227,7 @@ class BasePlugin {
      * Callback executed when a tool call encounters an error.
       tool: BaseTool;
       toolArgs: Record<string, unknown>;
-      toolContext: ToolContext;
+      toolContext: Context;
       result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined> {
       return;

package/dist/cjs/runner/runner.js

@@ -24,7 +24,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runner_exports = {};
 __export(runner_exports, {
-  Runner: () => Runner
+  Runner: () => Runner,
+  isRunner: () => isRunner
 });
 module.exports = __toCommonJS(runner_exports);
 var import_genai = require("@google/genai");
@@ -44,12 +45,19 @@ var import_model_name = require("../utils/model_name.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const RUNNER_SIGNATURE_SYMBOL = Symbol.for("google.adk.runner");
+function isRunner(obj) {
+  return typeof obj === "object" && obj !== null && RUNNER_SIGNATURE_SYMBOL in obj && obj[RUNNER_SIGNATURE_SYMBOL] === true;
+}
+_a = RUNNER_SIGNATURE_SYMBOL;
 class Runner {
   constructor(input) {
-    var _a;
+    this[_a] = true;
+    var _a2;
     this.appName = input.appName;
     this.agent = input.agent;
-    this.pluginManager = new import_plugin_manager.PluginManager((_a = input.plugins) != null ? _a : []);
+    this.pluginManager = new import_plugin_manager.PluginManager((_a2 = input.plugins) != null ? _a2 : []);
     this.artifactService = input.artifactService;
     this.sessionService = input.sessionService;
     this.memoryService = input.memoryService;
@@ -109,7 +117,7 @@ class Runner {
         ctx,
         this,
         async function* () {
-          var _a;
+          var _a2;
           const session = await this.sessionService.getSession({
             appName: this.appName,
             userId,
@@ -154,7 +162,7 @@ class Runner {
             newMessage = pluginUserMessage;
           }
           if (newMessage) {
-            if (!((_a = newMessage.parts) == null ? void 0 : _a.length)) {
+            if (!((_a2 = newMessage.parts) == null ? void 0 : _a2.length)) {
               throw new Error("No parts in the newMessage.");
             }
             if (runConfig.saveInputBlobsAsArtifacts) {
@@ -230,8 +238,8 @@ class Runner {
    * @param message The message containing parts to process.
    */
   async saveArtifacts(invocationId, userId, sessionId, message) {
-    var _a;
-    if (!this.artifactService || !((_a = message.parts) == null ? void 0 : _a.length)) {
+    var _a2;
+    if (!this.artifactService || !((_a2 = message.parts) == null ? void 0 : _a2.length)) {
       return;
     }
     for (let i = 0; i < message.parts.length; i++) {
@@ -264,7 +272,7 @@ class Runner {
       return rootAgent.findAgent(event.author) || rootAgent;
     }
     for (let i = session.events.length - 1; i >= 0; i--) {
-      import_logger.logger.info("event: ", JSON.stringify(session.events[i]));
+      import_logger.logger.info("event:", JSON.stringify(session.events[i]));
       const event2 = session.events[i];
       if (event2.author === "user" || !event2.author) {
         continue;
@@ -312,12 +320,12 @@ class Runner {
   // TODO - b/425992518: Implement runLive and related methods.
 }
 function findEventByLastFunctionResponseId(events) {
-  var _a, _b, _c, _d;
+  var _a2, _b, _c, _d;
   if (!events.length) {
     return null;
   }
   const lastEvent = events[events.length - 1];
-  const functionCallId = (_d = (_c = (_b = (_a = lastEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.find(
+  const functionCallId = (_d = (_c = (_b = (_a2 = lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b.find(
     (part) => part.functionResponse
   )) == null ? void 0 : _c.functionResponse) == null ? void 0 : _d.id;
   if (!functionCallId) {
@@ -339,5 +347,6 @@ function findEventByLastFunctionResponseId(events) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Runner
+  Runner,
+  isRunner
 });

package/dist/cjs/sessions/database_session_service.js

@@ -51,7 +51,7 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     super();
     this.initialized = false;
     if (typeof connectionStringOrOptions === "string") {
-      this.options = (0, import_operations.getConnectionOptionsFromUri)(connectionStringOrOptions);
+      this.connectionString = connectionStringOrOptions;
     } else {
       if (!connectionStringOrOptions.driver) {
         throw new Error("Driver is required when passing options object.");
@@ -66,6 +66,9 @@ class DatabaseSessionService extends import_base_session_service.BaseSessionServ
     if (this.initialized) {
       return;
     }
+    if (this.connectionString && (!this.options || !this.options.driver)) {
+      this.options = await (0, import_operations.getConnectionOptionsFromUri)(this.connectionString);
+    }
     this.orm = await import_core.MikroORM.init(this.options);
     await (0, import_operations.ensureDatabaseCreated)(this.orm);
     await (0, import_operations.validateDatabaseSchemaVersion)(this.orm);

package/dist/cjs/sessions/db/operations.js

@@ -5,9 +5,11 @@
   */
 
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -21,6 +23,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var operations_exports = {};
 __export(operations_exports, {
@@ -29,30 +39,29 @@ __export(operations_exports, {
   validateDatabaseSchemaVersion: () => validateDatabaseSchemaVersion
 });
 module.exports = __toCommonJS(operations_exports);
-var import_core = require("@mikro-orm/core");
-var import_mariadb = require("@mikro-orm/mariadb");
-var import_mssql = require("@mikro-orm/mssql");
-var import_mysql = require("@mikro-orm/mysql");
-var import_postgresql = require("@mikro-orm/postgresql");
-var import_sqlite = require("@mikro-orm/sqlite");
 var import_schema = require("./schema.js");
 /**
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-function getConnectionOptionsFromUri(uri) {
+async function getConnectionOptionsFromUri(uri) {
   let driver;
   if (uri.startsWith("postgres://") || uri.startsWith("postgresql://")) {
-    driver = import_postgresql.PostgreSqlDriver;
+    const { PostgreSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/postgresql"), 1));
+    driver = PostgreSqlDriver;
   } else if (uri.startsWith("mysql://")) {
-    driver = import_mysql.MySqlDriver;
+    const { MySqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mysql"), 1));
+    driver = MySqlDriver;
   } else if (uri.startsWith("mariadb://")) {
-    driver = import_mariadb.MariaDbDriver;
+    const { MariaDbDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mariadb"), 1));
+    driver = MariaDbDriver;
   } else if (uri.startsWith("sqlite://")) {
-    driver = import_sqlite.SqliteDriver;
+    const { SqliteDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/sqlite"), 1));
+    driver = SqliteDriver;
   } else if (uri.startsWith("mssql://")) {
-    driver = import_mssql.MsSqlDriver;
+    const { MsSqlDriver } = await Promise.resolve().then(() => __toESM(require("@mikro-orm/mssql"), 1));
+    driver = MsSqlDriver;
   } else {
     throw new Error(`Unsupported database URI: ${uri}`);
   }
@@ -65,9 +74,10 @@ function getConnectionOptionsFromUri(uri) {
   }
   const { host, port, username, password, pathname } = new URL(uri);
   const hostName = host.split(":")[0];
+  const dbName = uri.startsWith("sqlite://") ? uri.substring("sqlite://".length) : pathname.slice(1);
   return {
     entities: import_schema.ENTITIES,
-    dbName: pathname.slice(1),
+    dbName,
     host: hostName,
     port: port ? parseInt(port) : void 0,
     user: username,
@@ -75,17 +85,9 @@ function getConnectionOptionsFromUri(uri) {
     driver
   };
 }
-async function ensureDatabaseCreated(ormOrUrlOrOptions) {
-  let orm;
-  if (ormOrUrlOrOptions instanceof import_core.MikroORM) {
-    orm = ormOrUrlOrOptions;
-  } else if (typeof ormOrUrlOrOptions === "string") {
-    orm = await import_core.MikroORM.init(getConnectionOptionsFromUri(ormOrUrlOrOptions));
-  } else {
-    orm = await import_core.MikroORM.init(ormOrUrlOrOptions);
-  }
+async function ensureDatabaseCreated(orm) {
   await orm.schema.ensureDatabase();
-  await orm.schema.updateSchema();
+  await orm.schema.updateSchema({ safe: true });
 }
 async function validateDatabaseSchemaVersion(orm) {
   const em = orm.em.fork();

package/dist/cjs/sessions/state.js

@@ -82,8 +82,8 @@ class State {
    * @param delta The delta to update the state with.
    */
   update(delta) {
-    this.delta = { ...this.delta, ...delta };
-    this.value = { ...this.value, ...delta };
+    Object.assign(this.delta, delta);
+    Object.assign(this.value, delta);
   }
   /**
    * Returns the state as a plain JSON object.

package/dist/cjs/tools/agent_tool.js

@@ -93,7 +93,7 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
     args,
     toolContext
   }) {
-    var _a2, _b2;
+    var _a2, _b2, _c, _d;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -112,13 +112,14 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
       appName: this.agent.name,
       agent: this.agent,
       artifactService: new import_forwarding_artifact_service.ForwardingArtifactService(toolContext),
-      sessionService: new import_in_memory_session_service.InMemorySessionService(),
-      memoryService: new import_in_memory_memory_service.InMemoryMemoryService(),
+      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new import_in_memory_memory_service.InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
     const session = await runner.sessionService.createSession({
       appName: this.agent.name,
-      userId: "tmp_user",
+      userId: toolContext.invocationContext.userId,
+      sessionId: toolContext.invocationContext.session.id,
       state: toolContext.state.toRecord()
     });
     let lastEvent;
@@ -132,7 +133,7 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
       }
       lastEvent = event;
     }
-    if (!((_b2 = (_a2 = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _a2.parts) == null ? void 0 : _b2.length)) {
+    if (!((_d = (_c = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.length)) {
       return "";
     }
     const hasOutputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;

package/dist/cjs/tools/base_tool.js

@@ -84,6 +84,9 @@ class BaseTool {
     if (!functionDeclaration) {
       return;
     }
+    if (this.name in llmRequest.toolsDict) {
+      throw new Error(`Duplicate tool name: ${this.name}`);
+    }
     llmRequest.toolsDict[this.name] = this;
     const tool = findToolWithFunctionDeclarations(llmRequest);
     if (tool) {

package/dist/cjs/tools/base_toolset.js

@@ -24,7 +24,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var base_toolset_exports = {};
 __export(base_toolset_exports, {
-  BaseToolset: () => BaseToolset
+  BaseToolset: () => BaseToolset,
+  isBaseToolset: () => isBaseToolset
 });
 module.exports = __toCommonJS(base_toolset_exports);
 /**
@@ -32,9 +33,17 @@ module.exports = __toCommonJS(base_toolset_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var _a;
+const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+function isBaseToolset(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
 class BaseToolset {
-  constructor(toolFilter) {
+  constructor(toolFilter, prefix) {
     this.toolFilter = toolFilter;
+    this.prefix = prefix;
+    this[_a] = true;
   }
   /**
    * Returns whether the tool should be exposed to LLM.
@@ -72,5 +81,6 @@ class BaseToolset {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseToolset
+  BaseToolset,
+  isBaseToolset
 });

package/dist/cjs/tools/exit_loop_tool.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 exit_loop_tool_exports = {};
+__export(exit_loop_tool_exports, {
+  EXIT_LOOP: () => EXIT_LOOP,
+  ExitLoopTool: () => ExitLoopTool
+});
+module.exports = __toCommonJS(exit_loop_tool_exports);
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ExitLoopTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description
+    };
+  }
+  async runAsync({
+    toolContext
+  }) {
+    toolContext.actions.escalate = true;
+    toolContext.actions.skipSummarization = true;
+    return "";
+  }
+}
+const EXIT_LOOP = new ExitLoopTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXIT_LOOP,
+  ExitLoopTool
+});

package/dist/cjs/tools/load_artifacts_tool.js

@@ -0,0 +1,188 @@
+/**
+  * @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 load_artifacts_tool_exports = {};
+__export(load_artifacts_tool_exports, {
+  LOAD_ARTIFACTS: () => LOAD_ARTIFACTS,
+  LoadArtifactsTool: () => LoadArtifactsTool
+});
+module.exports = __toCommonJS(load_artifacts_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_request = require("../models/llm_request.js");
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = (0, import_logger.getLogger)();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: `[Artifact: ${artifactName}, type: ${mimeType}. No inline data was provided.]`
+    };
+  }
+  const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
+  const decodedBuffer = Buffer.from(data, "base64");
+  if (isTextLike) {
+    try {
+      const decoded = decodedBuffer.toString("utf8");
+      return { text: decoded };
+    } catch {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
+  };
+}
+class LoadArtifactsTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: `Loads artifacts into the session for this request.
+
+NOTE: Call when you need access to artifacts (for example, uploads saved by the web UI).`
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: import_genai.Type.ARRAY,
+            items: {
+              type: import_genai.Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      `You have a list of artifacts:
+  ${JSON.stringify(
+        artifactNames
+      )}
+
+  When the user asks questions about any of the artifacts, you should call the
+  \`load_artifacts\` function to load the artifact. Always call load_artifacts
+  before answering questions related to the artifacts, regardless of whether the
+  artifacts have been loaded before. Do not depend on prior answers about the
+  artifacts.`
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = `user:${artifactName}`;
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn(`Artifact "${artifactName}" not found, skipping`);
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: `Artifact ${artifactName} is:` }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+});