@google/adk 2.0.0 → 2.2.0

package/dist/web/tools/preload_memory_tool.js

@@ -1,81 +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 { appendInstructions } from "../models/llm_request.js";
-import { logger } from "../utils/logger.js";
-import {
-  BaseTool
-} from "./base_tool.js";
-const _PreloadMemoryTool = class _PreloadMemoryTool extends BaseTool {
-  constructor() {
-    super({
-      // Name and description are not used because this tool only
-      // changes llm_request.
-      name: "preload_memory",
-      description: "preload_memory"
-    });
-  }
-  async runAsync({
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    args,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    toolContext
-  }) {
-    throw new Error("PreloadMemoryTool should not be called by model");
-  }
-  async processLlmRequest(request) {
-    var _a, _b, _c;
-    await super.processLlmRequest(request);
-    const userContent = request.toolContext.userContent;
-    if (!userContent || !userContent.parts || !((_a = userContent.parts[0]) == null ? void 0 : _a.text)) {
-      return;
-    }
-    const userQuery = userContent.parts[0].text;
-    let response;
-    try {
-      if (!request.toolContext.invocationContext.memoryService) {
-        return;
-      }
-      response = await request.toolContext.searchMemory(userQuery);
-    } catch (_) {
-      logger.warn("Failed to preload memory for query: ".concat(userQuery));
-      return;
-    }
-    if (!response.memories || response.memories.length === 0) {
-      return;
-    }
-    const memoryTextLines = [];
-    for (const memory of response.memories) {
-      const timeStr = memory.timestamp ? "Time: ".concat(memory.timestamp) : "";
-      if (timeStr) memoryTextLines.push(timeStr);
-      const memoryText = (_c = (_b = memory.content.parts) == null ? void 0 : _b.map((p) => {
-        var _a2;
-        return (_a2 = p.text) != null ? _a2 : "";
-      }).join(" ")) != null ? _c : "";
-      if (memoryText) {
-        memoryTextLines.push(
-          memory.author ? "".concat(memory.author, ": ").concat(memoryText) : memoryText
-        );
-      }
-    }
-    if (memoryTextLines.length === 0) {
-      return;
-    }
-    const fullMemoryText = memoryTextLines.join("\n");
-    const si = "The following content is from your previous conversations with the user.\nThey may be useful for answering the user's current query.\n<PAST_CONVERSATIONS>\n".concat(fullMemoryText, "\n</PAST_CONVERSATIONS>\n");
-    appendInstructions(request.llmRequest, [si]);
-  }
-};
-__name(_PreloadMemoryTool, "PreloadMemoryTool");
-let PreloadMemoryTool = _PreloadMemoryTool;
-const PRELOAD_MEMORY = new PreloadMemoryTool();
-export {
-  PRELOAD_MEMORY,
-  PreloadMemoryTool
-};

package/dist/web/tools/request_input_tool.js

@@ -1,29 +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 { z } from "zod";
-import { REQUEST_INPUT_FUNCTION_CALL_NAME } from "../agents/functions.js";
-import { LongRunningFunctionTool } from "./long_running_tool.js";
-const requestInputTool = new LongRunningFunctionTool({
-  name: REQUEST_INPUT_FUNCTION_CALL_NAME,
-  description: "Presents a custom message to the user and awaits unstructured or structured input.",
-  parameters: z.object({
-    message: z.string().describe("The prompt for the user."),
-    response_schema: z.record(z.string(), z.unknown()).optional().describe("Expected schema of the response.")
-  }),
-  execute: /* @__PURE__ */ __name(async (input, context) => {
-    if (context) {
-      context.actions.skipSummarization = true;
-    }
-    return null;
-  }, "execute")
-});
-export {
-  requestInputTool
-};

package/dist/web/tools/skill/list_skills_tool.js

@@ -1,52 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { formatSkillsAsXml } from "../../skills/prompt.js";
-import { experimental } from "../../utils/experimental.js";
-import { BaseTool } from "../base_tool.js";
-let ListSkillsTool = class extends BaseTool {
-  constructor(toolset) {
-    super({
-      name: "list_skills",
-      description: "Lists all available skills with their names and descriptions."
-    });
-    this.toolset = toolset;
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {}
-      }
-    };
-  }
-  async runAsync(_request) {
-    const skills = Object.values(this.toolset.skills);
-    return formatSkillsAsXml(skills);
-  }
-};
-__name(ListSkillsTool, "ListSkillsTool");
-ListSkillsTool = __decorateClass([
-  experimental
-], ListSkillsTool);
-export {
-  ListSkillsTool
-};

package/dist/web/tools/skill/load_skill_resource_tool.js

@@ -1,192 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import path from "node:path";
-import { experimental } from "../../utils/experimental.js";
-import { guessMimeType } from "../../utils/file_utils.js";
-import {
-  BaseTool
-} from "../base_tool.js";
-const BINARY_FILE_DETECTED_MSG = "Binary file detected. The content has been injected into the conversation history for you to analyze.";
-let LoadSkillResourceTool = class extends BaseTool {
-  constructor(toolset) {
-    super({
-      name: "load_skill_resource",
-      description: "Loads a resource file (from references/, assets/, or scripts/) from within a skill."
-    });
-    this.toolset = toolset;
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          skill_name: {
-            type: Type.STRING,
-            description: "The name of the skill."
-          },
-          path: {
-            type: Type.STRING,
-            description: "The relative path to the resource (e.g., 'references/my_doc.md', 'assets/template.txt', or 'scripts/setup.sh')."
-          }
-        },
-        required: ["skill_name", "path"]
-      }
-    };
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    var _a, _b, _c;
-    const skillName = args["skill_name"];
-    let resourcePath = args["path"];
-    if (!skillName) {
-      return {
-        error: "Skill name is required.",
-        error_code: "MISSING_SKILL_NAME"
-      };
-    }
-    if (!resourcePath) {
-      return {
-        error: "Resource path is required.",
-        error_code: "MISSING_RESOURCE_PATH"
-      };
-    }
-    resourcePath = path.posix.normalize(resourcePath);
-    let skill;
-    try {
-      skill = await this.toolset.getOrFetchSkill(
-        skillName,
-        toolContext.invocationId
-      );
-    } catch (e) {
-      return {
-        error: "Failed to fetch skill '".concat(skillName, "' from registry: ").concat(e.message || e),
-        error_code: "REGISTRY_ERROR"
-      };
-    }
-    if (!skill) {
-      return {
-        error: "Skill '".concat(skillName, "' not found."),
-        error_code: "SKILL_NOT_FOUND"
-      };
-    }
-    let content;
-    const skillResources = skill.resources || {};
-    if (resourcePath.startsWith("references/")) {
-      const refName = resourcePath.substring("references/".length);
-      content = (_a = skillResources.references) == null ? void 0 : _a[refName];
-    } else if (resourcePath.startsWith("assets/")) {
-      const assetName = resourcePath.substring("assets/".length);
-      content = (_b = skillResources.assets) == null ? void 0 : _b[assetName];
-    } else if (resourcePath.startsWith("scripts/")) {
-      const scriptName = resourcePath.substring("scripts/".length);
-      const script = (_c = skillResources.scripts) == null ? void 0 : _c[scriptName];
-      if (script) {
-        content = script.src;
-      }
-    } else {
-      return {
-        error: "Path must start with 'references/', 'assets/', or 'scripts/'.",
-        error_code: "INVALID_RESOURCE_PATH"
-      };
-    }
-    if (content === void 0) {
-      return {
-        error: "Resource '".concat(resourcePath, "' not found in skill '").concat(skillName, "'."),
-        error_code: "RESOURCE_NOT_FOUND"
-      };
-    }
-    if (Buffer.isBuffer(content)) {
-      return {
-        skill_name: skillName,
-        path: resourcePath,
-        status: BINARY_FILE_DETECTED_MSG
-      };
-    }
-    return {
-      skill_name: skillName,
-      path: resourcePath,
-      content
-    };
-  }
-  async processLlmRequest(request) {
-    var _a, _b;
-    await super.processLlmRequest(request);
-    const llmRequest = request.llmRequest;
-    if (!llmRequest.contents || llmRequest.contents.length === 0) {
-      return;
-    }
-    const lastContent = llmRequest.contents[llmRequest.contents.length - 1];
-    if (lastContent.role !== "user" || !lastContent.parts) {
-      return;
-    }
-    for (const part of lastContent.parts) {
-      if (part.functionResponse && part.functionResponse.name === this.name) {
-        const response = part.functionResponse.response || {};
-        if (response["status"] === BINARY_FILE_DETECTED_MSG) {
-          const skillName = response["skill_name"];
-          const resourcePath = response["path"];
-          let skill;
-          try {
-            skill = await this.toolset.getOrFetchSkill(
-              skillName,
-              request.toolContext.invocationId
-            );
-          } catch (_e) {
-            continue;
-          }
-          if (!skill) continue;
-          const skillResources = skill.resources || {};
-          let content;
-          if (resourcePath.startsWith("references/")) {
-            content = (_a = skillResources.references) == null ? void 0 : _a[resourcePath.substring("references/".length)];
-          } else if (resourcePath.startsWith("assets/")) {
-            content = (_b = skillResources.assets) == null ? void 0 : _b[resourcePath.substring("assets/".length)];
-          }
-          if (Buffer.isBuffer(content)) {
-            const mimeType = guessMimeType(resourcePath);
-            llmRequest.contents.push({
-              role: "user",
-              parts: [
-                { text: "The content of binary file '".concat(resourcePath, "' is:") },
-                {
-                  inlineData: {
-                    data: content.toString("base64"),
-                    mimeType
-                  }
-                }
-              ]
-            });
-          }
-        }
-      }
-    }
-  }
-};
-__name(LoadSkillResourceTool, "LoadSkillResourceTool");
-LoadSkillResourceTool = __decorateClass([
-  experimental
-], LoadSkillResourceTool);
-export {
-  LoadSkillResourceTool
-};

package/dist/web/tools/skill/load_skill_tool.js

@@ -1,96 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { requireAgent } from "../../agents/invocation_context.js";
-import { experimental } from "../../utils/experimental.js";
-import { BaseTool } from "../base_tool.js";
-let LoadSkillTool = class extends BaseTool {
-  constructor(toolset) {
-    super({
-      name: "load_skill",
-      description: "Loads the SKILL.md instructions for a given skill."
-    });
-    this.toolset = toolset;
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          name: {
-            type: Type.STRING,
-            description: "The name of the skill to load."
-          }
-        },
-        required: ["name"]
-      }
-    };
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    const skillName = args["name"];
-    if (!skillName) {
-      return {
-        error: "Skill name is required.",
-        error_code: "MISSING_SKILL_NAME"
-      };
-    }
-    let skill;
-    try {
-      skill = await this.toolset.getOrFetchSkill(
-        skillName,
-        toolContext.invocationId
-      );
-    } catch (e) {
-      return {
-        error: "Failed to fetch skill '".concat(skillName, "' from registry: ").concat(e.message || e),
-        error_code: "REGISTRY_ERROR"
-      };
-    }
-    if (!skill) {
-      return {
-        error: "Skill '".concat(skillName, "' not found."),
-        error_code: "SKILL_NOT_FOUND"
-      };
-    }
-    const agentName = requireAgent(toolContext.invocationContext).name;
-    const stateKey = "_adk_activated_skill_".concat(agentName);
-    const currentActivated = toolContext.state.get(stateKey) || [];
-    if (!currentActivated.includes(skillName)) {
-      toolContext.state.set(stateKey, [...currentActivated, skillName]);
-    }
-    return {
-      skill_name: skillName,
-      instructions: skill.instructions,
-      frontmatter: skill.frontmatter,
-      resources: skill.resources
-    };
-  }
-};
-__name(LoadSkillTool, "LoadSkillTool");
-LoadSkillTool = __decorateClass([
-  experimental
-], LoadSkillTool);
-export {
-  LoadSkillTool
-};

package/dist/web/tools/skill/run_skill_inline_script_tool.js

@@ -1,191 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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 });
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { isLlmAgent } from "../../agents/llm_agent.js";
-import { CodeExecutionLanguage } from "../../code_executors/code_execution_utils.js";
-import { experimental } from "../../utils/experimental.js";
-import { materializeFiles } from "../../utils/file_utils.js";
-import { BaseTool } from "../base_tool.js";
-var RunSkillInlineScriptErrorCode = /* @__PURE__ */ ((RunSkillInlineScriptErrorCode2) => {
-  RunSkillInlineScriptErrorCode2["MISSING_SCRIPT_CONTENT"] = "MISSING_SCRIPT_CONTENT";
-  RunSkillInlineScriptErrorCode2["MISSING_LANGUAGE"] = "MISSING_LANGUAGE";
-  RunSkillInlineScriptErrorCode2["NO_CODE_EXECUTOR"] = "NO_CODE_EXECUTOR";
-  RunSkillInlineScriptErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
-  RunSkillInlineScriptErrorCode2["CONFIRMATION_REJECTED"] = "CONFIRMATION_REJECTED";
-  return RunSkillInlineScriptErrorCode2;
-})(RunSkillInlineScriptErrorCode || {});
-const REQUIRE_CONFIRMATION_MESSAGE = "This tool call needs external confirmation before completion.";
-let RunSkillInlineScriptTool = class extends BaseTool {
-  constructor(toolset) {
-    super({
-      name: "run_skill_inline_script",
-      description: "Executes an inline script provided directly in the request."
-    });
-    this.toolset = toolset;
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          script_content: {
-            type: Type.STRING,
-            description: "The content of the script to execute."
-          },
-          language: {
-            type: Type.STRING,
-            description: "The language/type of the script.",
-            enum: Object.values(CodeExecutionLanguage).filter(
-              (l) => l !== CodeExecutionLanguage.UNSPECIFIED
-            )
-          },
-          args: {
-            anyOf: [
-              { type: Type.OBJECT },
-              { type: Type.ARRAY, items: { type: Type.STRING } }
-            ],
-            description: "Optional arguments to pass to the script as key-value pairs or an array of strings."
-          }
-        },
-        required: ["script_content", "language"]
-      }
-    };
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    var _a;
-    const inlineScriptContent = args["script_content"];
-    const language = args["language"];
-    const scriptArgs = args["args"];
-    if (!inlineScriptContent) {
-      return {
-        error: "Script content is required.",
-        errorCode: "MISSING_SCRIPT_CONTENT" /* MISSING_SCRIPT_CONTENT */
-      };
-    }
-    if (!language) {
-      return {
-        error: "Language is required.",
-        errorCode: "MISSING_LANGUAGE" /* MISSING_LANGUAGE */
-      };
-    }
-    let codeExecutor = (_a = this.toolset) == null ? void 0 : _a.codeExecutor;
-    if (!codeExecutor) {
-      const agent = toolContext.invocationContext.agent;
-      if (isLlmAgent(agent)) {
-        codeExecutor = agent.codeExecutor;
-      }
-    }
-    if (!codeExecutor) {
-      return {
-        error: "No code executor configured.",
-        errorCode: "NO_CODE_EXECUTOR" /* NO_CODE_EXECUTOR */
-      };
-    }
-    const confirmationResult = this.enforceConfirmation(
-      toolContext,
-      inlineScriptContent,
-      language
-    );
-    if (confirmationResult) {
-      return confirmationResult;
-    }
-    try {
-      const result = await codeExecutor.executeCode({
-        invocationContext: toolContext.invocationContext,
-        codeExecutionInput: {
-          code: inlineScriptContent,
-          inputFiles: [],
-          language,
-          args: scriptArgs
-        }
-      });
-      const outputDir = await this.toolset.getScriptOutputDir();
-      result.outputFiles = await materializeFiles(
-        result.outputFiles,
-        outputDir
-      );
-      return __spreadProps(__spreadValues({}, result), { outputDirectory: outputDir });
-    } catch (e) {
-      return {
-        error: "Failed to execute inline script: ".concat(e.message),
-        errorCode: "EXECUTION_ERROR" /* EXECUTION_ERROR */
-      };
-    }
-  }
-  /**
-   * Enforces a human-in-the-loop confirmation gate before executing an inline
-   * script, using the repo's standard tool-confirmation mechanism.
-   *
-   * - When no confirmation has been provided yet, a confirmation is requested
-   *   (surfacing the language and script that would run) and an intermediate
-   *   result is returned so the tool call pauses until the client responds.
-   * - When a confirmation exists but was not confirmed, a rejection error is
-   *   returned and execution is refused.
-   * - When the confirmation is confirmed, `undefined` is returned to allow the
-   *   caller to proceed with execution.
-   */
-  enforceConfirmation(toolContext, scriptContent, language) {
-    const confirmation = toolContext.toolConfirmation;
-    if (!confirmation) {
-      toolContext.requestConfirmation({
-        hint: "Confirmation is required before executing an inline skill script. " + "The agent requested to run the following ".concat(language, " script in the ") + "code executor. Only approve if you trust its contents:\n\n" + scriptContent,
-        payload: { language, scriptContent }
-      });
-      return { partial: REQUIRE_CONFIRMATION_MESSAGE };
-    }
-    if (!confirmation.confirmed) {
-      return {
-        error: "Inline script execution was not confirmed and was rejected.",
-        errorCode: "CONFIRMATION_REJECTED" /* CONFIRMATION_REJECTED */
-      };
-    }
-    return void 0;
-  }
-};
-__name(RunSkillInlineScriptTool, "RunSkillInlineScriptTool");
-RunSkillInlineScriptTool = __decorateClass([
-  experimental
-], RunSkillInlineScriptTool);
-export {
-  RunSkillInlineScriptErrorCode,
-  RunSkillInlineScriptTool
-};