@google/adk 2.0.0 → 2.2.0

package/dist/web/tools/load_artifacts_tool.js

@@ -1,159 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { appendInstructions } from "../models/llm_request.js";
-import { getLogger } from "../utils/logger.js";
-import {
-  BaseTool
-} from "./base_tool.js";
-const 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();
-}
-__name(normalizeMimeType, "normalizeMimeType");
-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);
-}
-__name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
-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: ".concat(artifactName, ", type: ").concat(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 (e) {
-    }
-  }
-  const sizeKb = decodedBuffer.length / 1024;
-  return {
-    text: "[Binary artifact: ".concat(artifactName, ", type: ").concat(mimeType, ", size: ").concat(sizeKb.toFixed(1), " KB. Content cannot be displayed inline.]")
-  };
-}
-__name(asSafePartForLlm, "asSafePartForLlm");
-const _LoadArtifactsTool = class _LoadArtifactsTool extends BaseTool {
-  constructor() {
-    super({
-      name: "load_artifacts",
-      description: "Loads artifacts into the session for this request.\n\nNOTE: 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: Type.OBJECT,
-        properties: {
-          artifact_names: {
-            type: Type.ARRAY,
-            items: {
-              type: 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;
-    }
-    appendInstructions(llmRequest, [
-      "You have a list of artifacts:\n  ".concat(JSON.stringify(
-        artifactNames
-      ), "\n\n  When the user asks questions about any of the artifacts, you should call the\n  `load_artifacts` function to load the artifact. Always call load_artifacts\n  before answering questions related to the artifacts, regardless of whether the\n  artifacts have been loaded before. Do not depend on prior answers about the\n  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:".concat(artifactName);
-              artifact = await toolContext.loadArtifact(prefixedName);
-            }
-            if (!artifact) {
-              logger.warn('Artifact "'.concat(artifactName, '" not found, skipping'));
-              continue;
-            }
-            const artifactPart = asSafePartForLlm(artifact, artifactName);
-            llmRequest.contents.push({
-              role: "user",
-              parts: [{ text: "Artifact ".concat(artifactName, " is:") }, artifactPart]
-            });
-          }
-        }
-      }
-    }
-  }
-};
-__name(_LoadArtifactsTool, "LoadArtifactsTool");
-let LoadArtifactsTool = _LoadArtifactsTool;
-const LOAD_ARTIFACTS = new LoadArtifactsTool();
-export {
-  LOAD_ARTIFACTS,
-  LoadArtifactsTool
-};

package/dist/web/tools/load_memory_tool.js

@@ -1,83 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { appendInstructions } from "../models/llm_request.js";
-import {
-  BaseTool
-} from "./base_tool.js";
-const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
-  constructor() {
-    super({
-      name: "load_memory",
-      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
-    });
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          query: {
-            type: Type.STRING,
-            description: "The query to load the memory for."
-          }
-        },
-        required: ["query"]
-      }
-    };
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    try {
-      const query = args["query"];
-      if (!toolContext.invocationContext.memoryService) {
-        throw new Error("Memory service is not initialized.");
-      }
-      const searchMemoryResponse = await toolContext.searchMemory(query);
-      return {
-        memories: searchMemoryResponse.memories.map((m) => {
-          var _a, _b;
-          return {
-            // Join all text parts by a space, or empty string if no text parts
-            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
-              var _a2;
-              return (_a2 = p.text) != null ? _a2 : "";
-            }).join(" ")) != null ? _b : "",
-            author: m.author,
-            timestamp: m.timestamp
-          };
-        })
-      };
-    } catch (e) {
-      console.error("ERROR in LoadMemoryTool runAsync:", e);
-      throw e;
-    }
-  }
-  async processLlmRequest(request) {
-    await super.processLlmRequest(request);
-    if (!request.toolContext.invocationContext.memoryService) {
-      return;
-    }
-    appendInstructions(request.llmRequest, [
-      "You have memory. You can use it to answer questions. If any questions need\nyou to look up the memory, you should call load_memory function with a query."
-    ]);
-  }
-};
-__name(_LoadMemoryTool, "LoadMemoryTool");
-let LoadMemoryTool = _LoadMemoryTool;
-const LOAD_MEMORY = new LoadMemoryTool();
-export {
-  LOAD_MEMORY,
-  LoadMemoryTool
-};

package/dist/web/tools/long_running_tool.js

@@ -1,58 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import {
-  FunctionTool
-} from "./function_tool.js";
-const LONG_RUNNING_INSTRUCTION = "\n\nNOTE: This is a long-running operation. Do not call this tool again if it has already returned some intermediate or pending status.";
-const _LongRunningFunctionTool = class _LongRunningFunctionTool extends FunctionTool {
-  /**
-   * The constructor acts as the user-friendly factory.
-   * @param options The configuration for the tool.
-   */
-  constructor(options) {
-    super(__spreadProps(__spreadValues({}, options), { isLongRunning: true }));
-  }
-  /**
-   * Returns the function declaration with an appended instruction warning the
-   * model not to re-invoke the tool while it is still running.
-   */
-  _getDeclaration() {
-    const declaration = super._getDeclaration();
-    if (declaration.description) {
-      declaration.description += LONG_RUNNING_INSTRUCTION;
-    } else {
-      declaration.description = LONG_RUNNING_INSTRUCTION.trimStart();
-    }
-    return declaration;
-  }
-};
-__name(_LongRunningFunctionTool, "LongRunningFunctionTool");
-let LongRunningFunctionTool = _LongRunningFunctionTool;
-export {
-  LongRunningFunctionTool
-};

package/dist/web/tools/mcp/index.js

@@ -1,11 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export * from "./load_mcp_resource_tool.js";
-export * from "./mcp_session_manager.js";
-export * from "./mcp_tool.js";
-export * from "./mcp_toolset.js";

package/dist/web/tools/mcp/load_mcp_resource_tool.js

@@ -1,111 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { appendInstructions } from "../../models/llm_request.js";
-import { logger } from "../../utils/logger.js";
-import {
-  BaseTool
-} from "../base_tool.js";
-const _LoadMcpResourceTool = class _LoadMcpResourceTool extends BaseTool {
-  constructor(mcpToolset) {
-    super({
-      name: "load_mcp_resource",
-      description: "Loads resources from the MCP server.\n\nNOTE: Call when you need access to resources."
-    });
-    this.mcpToolset = mcpToolset;
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          resource_names: {
-            type: Type.ARRAY,
-            items: {
-              type: Type.STRING
-            },
-            description: "The names of the MCP resources to load."
-          }
-        }
-      }
-    };
-  }
-  async runAsync({ args }) {
-    const resourceNames = args["resource_names"] || [];
-    return {
-      resource_names: resourceNames,
-      status: "resource contents temporarily inserted and removed. to access these resources, call load_mcp_resource tool again."
-    };
-  }
-  async processLlmRequest(request) {
-    await super.processLlmRequest(request);
-    await this.appendResourcesToLlmRequest(request.llmRequest);
-  }
-  async appendResourcesToLlmRequest(llmRequest) {
-    var _a, _b;
-    try {
-      const availableResourceNames = await this.mcpToolset.listResources();
-      if (availableResourceNames.length > 0) {
-        appendInstructions(llmRequest, [
-          "You have a list of MCP resources:\n".concat(JSON.stringify(
-            availableResourceNames
-          ), "\n\nWhen the user asks questions about any of the resources, you should call the\n`load_mcp_resource` function to load the resource. Always call load_mcp_resource\nbefore answering questions related to the resources.")
-        ]);
-      }
-    } catch (e) {
-      logger.warn("Failed to list MCP resources: ".concat(e));
-    }
-    const lastContent = llmRequest.contents.at(-1);
-    const functionResponse = (_b = (_a = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a[0]) == null ? void 0 : _b.functionResponse;
-    if (!functionResponse || functionResponse.name !== this.name) {
-      return;
-    }
-    const response = functionResponse.response || {};
-    const requestedResourceNames = response["resource_names"] || [];
-    for (const resourceName of requestedResourceNames) {
-      try {
-        const resourceContents = await this.mcpToolset.readResource(resourceName);
-        for (const content of resourceContents) {
-          llmRequest.contents.push({
-            role: "user",
-            parts: [
-              { text: "Resource ".concat(resourceName, " is:") },
-              this.mcpContentToPart(content, resourceName)
-            ]
-          });
-        }
-      } catch (e) {
-        logger.warn("Failed to read MCP resource '".concat(resourceName, "': ").concat(e));
-      }
-    }
-  }
-  mcpContentToPart(content, resourceName) {
-    var _a;
-    if ("text" in content) {
-      return { text: content.text };
-    }
-    if ("blob" in content) {
-      return {
-        inlineData: {
-          data: content.blob,
-          mimeType: (_a = content.mimeType) != null ? _a : "application/octet-stream"
-        }
-      };
-    }
-    return { text: "[Unknown content type for ".concat(resourceName, "]") };
-  }
-};
-__name(_LoadMcpResourceTool, "LoadMcpResourceTool");
-let LoadMcpResourceTool = _LoadMcpResourceTool;
-export {
-  LoadMcpResourceTool
-};

package/dist/web/tools/mcp/mcp_session_manager.js

@@ -1,114 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-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 __name = (target, value) => __defProp(target, "name", { value, configurable: 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 __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
-));
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { formatError } from "../../utils/error_utils.js";
-import { logger } from "../../utils/logger.js";
-import { loadOptionalPeer } from "../../utils/optional_peer.js";
-const MCP_SDK = {
-  packageName: "@modelcontextprotocol/sdk",
-  feature: "MCPSessionManager (and the MCP tools built on it)"
-};
-function logTransportError(err) {
-  logger.error("MCP transport error: " + formatError(err));
-}
-__name(logTransportError, "logTransportError");
-const _MCPSessionManager = class _MCPSessionManager {
-  constructor(connectionParams) {
-    this.activeSessions = /* @__PURE__ */ new Set();
-    this.connectionParams = connectionParams;
-  }
-  async createSession() {
-    var _a;
-    const { Client } = await loadOptionalPeer(
-      MCP_SDK,
-      () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/index.js"), 1))
-    );
-    const client = new Client({ name: "MCPClient", version: "1.0.0" });
-    try {
-      switch (this.connectionParams.type) {
-        case "StdioConnectionParams": {
-          const { StdioClientTransport } = await loadOptionalPeer(
-            MCP_SDK,
-            () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/stdio.js"), 1))
-          );
-          const transport = new StdioClientTransport(
-            this.connectionParams.serverParams
-          );
-          transport.onerror = logTransportError;
-          await client.connect(transport);
-          break;
-        }
-        case "StreamableHTTPConnectionParams": {
-          const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
-          if (!options.requestInit && this.connectionParams.header !== void 0) {
-            options.requestInit = {
-              headers: this.connectionParams.header
-            };
-          }
-          const { StreamableHTTPClientTransport } = await loadOptionalPeer(
-            MCP_SDK,
-            () => Promise.resolve().then(() => __toESM(require("@modelcontextprotocol/sdk/client/streamableHttp.js"), 1))
-          );
-          const transport = new StreamableHTTPClientTransport(
-            new URL(this.connectionParams.url),
-            options
-          );
-          transport.onerror = logTransportError;
-          await client.connect(transport);
-          break;
-        }
-        default: {
-          const _exhaustiveCheck = this.connectionParams;
-          break;
-        }
-      }
-    } catch (err) {
-      throw new Error("Failed to create MCP session: " + formatError(err), {
-        cause: err
-      });
-    }
-    this.activeSessions.add(client);
-    return client;
-  }
-  async closeSession(client) {
-    if (this.activeSessions.has(client)) {
-      this.activeSessions.delete(client);
-      await client.close();
-    }
-  }
-  getActiveSessions() {
-    return Array.from(this.activeSessions);
-  }
-};
-__name(_MCPSessionManager, "MCPSessionManager");
-let MCPSessionManager = _MCPSessionManager;
-export {
-  MCPSessionManager
-};

package/dist/web/tools/mcp/mcp_tool.js

@@ -1,47 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { toGeminiSchema } from "../../utils/gemini_schema_util.js";
-import { BaseTool } from "../base_tool.js";
-const _MCPTool = class _MCPTool extends BaseTool {
-  constructor(mcpTool, mcpSessionManager, originalName) {
-    super({ name: mcpTool.name, description: mcpTool.description || "" });
-    this.mcpTool = mcpTool;
-    this.mcpSessionManager = mcpSessionManager;
-    this.originalName = originalName || mcpTool.name;
-  }
-  _getDeclaration() {
-    return {
-      name: this.mcpTool.name,
-      description: this.mcpTool.description,
-      parameters: toGeminiSchema(this.mcpTool.inputSchema),
-      // TODO: need revisit, refer to this
-      // https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-result
-      response: toGeminiSchema(this.mcpTool.outputSchema)
-    };
-  }
-  async runAsync(request) {
-    const session = await this.mcpSessionManager.createSession();
-    try {
-      const callRequest = {};
-      callRequest.params = { name: this.originalName, arguments: request.args };
-      const result = await session.callTool(callRequest.params, void 0, {
-        signal: request.toolContext.abortSignal
-      });
-      return result;
-    } finally {
-      await this.mcpSessionManager.closeSession(session);
-    }
-  }
-};
-__name(_MCPTool, "MCPTool");
-let MCPTool = _MCPTool;
-export {
-  MCPTool
-};