@google/adk 1.6.0 → 2.1.0

package/dist/web/tools/exit_loop_tool.js

@@ -1,43 +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
- */
-import { BaseTool } from "./base_tool.js";
-class ExitLoopTool extends BaseTool {
-  /** Creates an ExitLoopTool with its fixed name and description. */
-  constructor() {
-    super({
-      name: "exit_loop",
-      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
-    });
-  }
-  /** Returns the function declaration for this tool. */
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description
-    };
-  }
-  /**
-   * Sets `escalate` and `skipSummarization` on the event actions, signalling
-   * the {@link LoopAgent} to stop iterating.
-   *
-   * @param request The tool request containing the current tool context.
-   * @returns An empty string response.
-   */
-  async runAsync({
-    toolContext
-  }) {
-    toolContext.actions.escalate = true;
-    toolContext.actions.skipSummarization = true;
-    return "";
-  }
-}
-const EXIT_LOOP = new ExitLoopTool();
-export {
-  EXIT_LOOP,
-  ExitLoopTool
-};

package/dist/web/tools/forwarding_artifact_service.js

@@ -1,47 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-class ForwardingArtifactService {
-  constructor(toolContext) {
-    this.toolContext = toolContext;
-    this.invocationContext = toolContext.invocationContext;
-  }
-  async saveArtifact(request) {
-    return this.toolContext.saveArtifact(request.filename, request.artifact);
-  }
-  async loadArtifact(request) {
-    return this.toolContext.loadArtifact(request.filename, request.version);
-  }
-  async listArtifactKeys(_request) {
-    return this.toolContext.listArtifacts();
-  }
-  getArtifactService() {
-    const service = this.invocationContext.artifactService;
-    if (!service) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return service;
-  }
-  async deleteArtifact(request) {
-    return this.getArtifactService().deleteArtifact(request.filename);
-  }
-  async listVersions(request) {
-    return this.getArtifactService().listVersions(request.filename);
-  }
-  async listArtifactVersions(request) {
-    return this.getArtifactService().listArtifactVersions(request.filename);
-  }
-  async getArtifactVersion(request) {
-    return this.getArtifactService().getArtifactVersion({
-      filename: request.filename,
-      version: request.version
-    });
-  }
-}
-export {
-  ForwardingArtifactService
-};

package/dist/web/tools/function_tool.js

@@ -1,85 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a, _b;
-import { Type } from "@google/genai";
-import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
-import { BaseTool } from "./base_tool.js";
-function toSchema(parameters) {
-  if (parameters === void 0) {
-    return { type: Type.OBJECT, properties: {} };
-  }
-  if (isZodObject(parameters)) {
-    return zodObjectToSchema(parameters);
-  }
-  return parameters;
-}
-const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
-function isFunctionTool(obj) {
-  return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
-}
-class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
-  /**
-   * The constructor acts as the user-friendly factory.
-   * @param options The configuration for the tool.
-   */
-  constructor(options) {
-    var _a2;
-    const name = (_a2 = options.name) != null ? _a2 : options.execute.name;
-    if (!name) {
-      throw new Error(
-        "Tool name cannot be empty. Either name the `execute` function or provide a `name`."
-      );
-    }
-    super({
-      name,
-      description: options.description,
-      isLongRunning: options.isLongRunning
-    });
-    /** A unique symbol to identify ADK function tool class. */
-    this[_a] = true;
-    this.execute = options.execute;
-    this.parameters = options.parameters;
-  }
-  /**
-   * Returns the function declaration derived from the tool's name, description,
-   * and parameter schema.
-   */
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: toSchema(this.parameters)
-    };
-  }
-  /**
-   * Validates the model-provided arguments against the parameter schema and
-   * invokes the user-defined `execute` function.
-   *
-   * @param req The tool request containing arguments and tool context.
-   * @returns A promise resolving to the function's return value.
-   */
-  async runAsync(req) {
-    try {
-      let validatedArgs = req.args;
-      if (isZodObject(this.parameters)) {
-        validatedArgs = this.parameters.parse(req.args);
-      }
-      return await this.execute(
-        validatedArgs,
-        req.toolContext
-      );
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error("Error in tool '".concat(this.name, "': ").concat(errorMessage));
-    }
-  }
-}
-export {
-  FunctionTool,
-  isFunctionTool
-};

package/dist/web/tools/get_user_choice_tool.js

@@ -1,25 +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
- */
-import { z } from "zod";
-import { LongRunningFunctionTool } from "./long_running_tool.js";
-const getUserChoiceTool = new LongRunningFunctionTool({
-  name: "get_user_choice",
-  description: "Presents a list of options to the user and awaits their selection.",
-  parameters: z.object({
-    options: z.array(z.string()).describe("List of options to present to the user.")
-  }),
-  execute: async (input, context) => {
-    if (context) {
-      context.actions.skipSummarization = true;
-    }
-    return null;
-  }
-});
-export {
-  getUserChoiceTool
-};

package/dist/web/tools/google_maps_grounding_tool.js

@@ -1,54 +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
- */
-import {
-  isGemini1Model,
-  isGeminiModel,
-  isGeminiModelIdCheckDisabled
-} from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-function applyGoogleMapsGrounding(llmRequest) {
-  if (!llmRequest.model) {
-    return;
-  }
-  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
-  llmRequest.config = llmRequest.config || {};
-  llmRequest.config.tools = llmRequest.config.tools || [];
-  if (isGemini1Model(llmRequest.model)) {
-    throw new Error(
-      "Google Maps grounding tool cannot be used with Gemini 1.x models."
-    );
-  }
-  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
-    llmRequest.config.tools.push({
-      googleMaps: {}
-    });
-    return;
-  }
-  throw new Error(
-    "Google maps tool is not supported for model ".concat(llmRequest.model)
-  );
-}
-class GoogleMapsGroundingTool extends BaseTool {
-  constructor() {
-    super({ name: "google_maps", description: "Google Maps Grounding Tool" });
-  }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
-    llmRequest
-  }) {
-    applyGoogleMapsGrounding(llmRequest);
-  }
-}
-const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
-export {
-  GOOGLE_MAPS_GROUNDING,
-  GoogleMapsGroundingTool,
-  applyGoogleMapsGrounding
-};

package/dist/web/tools/google_search_tool.js

@@ -1,51 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { isGemini1Model, isGeminiModel } from "../utils/model_name.js";
-import { BaseTool } from "./base_tool.js";
-class GoogleSearchTool extends BaseTool {
-  constructor() {
-    super({ name: "google_search", description: "Google Search Tool" });
-  }
-  runAsync() {
-    return Promise.resolve();
-  }
-  async processLlmRequest({
-    llmRequest
-  }) {
-    if (!llmRequest.model) {
-      return;
-    }
-    llmRequest.config = llmRequest.config || {};
-    llmRequest.config.tools = llmRequest.config.tools || [];
-    if (isGemini1Model(llmRequest.model)) {
-      if (llmRequest.config.tools.length > 0) {
-        throw new Error(
-          "Google search tool can not be used with other tools in Gemini 1.x."
-        );
-      }
-      llmRequest.config.tools.push({
-        googleSearchRetrieval: {}
-      });
-      return;
-    }
-    if (isGeminiModel(llmRequest.model)) {
-      llmRequest.config.tools.push({
-        googleSearch: {}
-      });
-      return;
-    }
-    throw new Error(
-      "Google search tool is not supported for model ".concat(llmRequest.model)
-    );
-  }
-}
-const GOOGLE_SEARCH = new GoogleSearchTool();
-export {
-  GOOGLE_SEARCH,
-  GoogleSearchTool
-};

package/dist/web/tools/load_artifacts_tool.js

@@ -1,152 +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
- */
-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();
-}
-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: ".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.]")
-  };
-}
-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]
-            });
-          }
-        }
-      }
-    }
-  }
-}
-const LOAD_ARTIFACTS = new LoadArtifactsTool();
-export {
-  LOAD_ARTIFACTS,
-  LoadArtifactsTool
-};

package/dist/web/tools/load_memory_tool.js

@@ -1,79 +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
- */
-import { Type } from "@google/genai";
-import { appendInstructions } from "../models/llm_request.js";
-import {
-  BaseTool
-} from "./base_tool.js";
-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."
-    ]);
-  }
-}
-const LOAD_MEMORY = new LoadMemoryTool();
-export {
-  LOAD_MEMORY,
-  LoadMemoryTool
-};