@google/adk 0.6.1 → 1.0.0

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

@@ -0,0 +1,191 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 {
+  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.";
+const EXTENSION_TO_MIME_TYPE = {
+  "pdf": "application/pdf",
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "png": "image/png",
+  "gif": "image/gif",
+  "csv": "text/csv",
+  "json": "application/json",
+  "xml": "application/xml",
+  "sh": "text/x-shellscript",
+  "bash": "text/x-shellscript",
+  "py": "text/x-python",
+  "js": "text/javascript",
+  "cjs": "text/javascript",
+  "mjs": "text/javascript",
+  "ts": "text/javascript",
+  "cts": "text/javascript",
+  "mts": "text/javascript"
+};
+function guessMimeType(filePath) {
+  var _a;
+  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+}
+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 }) {
+    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);
+    const skill = this.toolset.getSkill(skillName);
+    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"];
+          const skill = this.toolset.getSkill(skillName);
+          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
+                  }
+                }
+              ]
+            });
+          }
+        }
+      }
+    }
+  }
+};
+LoadSkillResourceTool = __decorateClass([
+  experimental
+], LoadSkillResourceTool);
+export {
+  LoadSkillResourceTool
+};

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

@@ -0,0 +1,82 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 { 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"
+      };
+    }
+    const skill = this.toolset.getSkill(skillName);
+    if (!skill) {
+      return {
+        error: "Skill '".concat(skillName, "' not found."),
+        error_code: "SKILL_NOT_FOUND"
+      };
+    }
+    const agentName = toolContext.invocationContext.agent.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
+    };
+  }
+};
+LoadSkillTool = __decorateClass([
+  experimental
+], LoadSkillTool);
+export {
+  LoadSkillTool
+};

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

@@ -0,0 +1,120 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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";
+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"
+      };
+    }
+    if (!language) {
+      return {
+        error: "Language is required.",
+        errorCode: "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"
+      };
+    }
+    try {
+      const result = await codeExecutor.executeCode({
+        invocationContext: toolContext.invocationContext,
+        codeExecutionInput: {
+          code: inlineScriptContent,
+          inputFiles: [],
+          language,
+          args: scriptArgs
+        }
+      });
+      result.outputFiles = await materializeFiles(result.outputFiles);
+      return result;
+    } catch (e) {
+      return {
+        error: "Failed to execute inline script: ".concat(e.message),
+        errorCode: "EXECUTION_ERROR"
+      };
+    }
+  }
+};
+RunSkillInlineScriptTool = __decorateClass([
+  experimental
+], RunSkillInlineScriptTool);
+export {
+  RunSkillInlineScriptTool
+};

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

@@ -0,0 +1,190 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 * as path from "node:path";
+import { isLlmAgent } from "../../agents/llm_agent.js";
+import {
+  CodeExecutionLanguage
+} from "../../code_executors/code_execution_utils.js";
+import { experimental } from "../../utils/experimental.js";
+import {
+  getMimeTypeAndEncoding,
+  getScriptLanguageByExtension
+} from "../../utils/file_extension_utils.js";
+import { materializeFiles } from "../../utils/file_utils.js";
+import { BaseTool } from "../base_tool.js";
+let RunSkillScriptTool = class extends BaseTool {
+  constructor(toolset) {
+    super({
+      name: "run_skill_script",
+      description: "Executes a script from a skill's scripts/ directory."
+    });
+    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."
+          },
+          script_path: {
+            type: Type.STRING,
+            description: "The relative path to the script (e.g., 'scripts/setup.js')."
+          },
+          args: {
+            type: Type.OBJECT,
+            description: "Optional arguments to pass to the script as key-value pairs."
+          }
+        },
+        required: ["skill_name", "script_path"]
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    var _a, _b, _c, _d;
+    const skillName = args["skill_name"];
+    const scriptPath = args["script_path"];
+    const scriptArgs = args["args"] || {};
+    if (!skillName) {
+      return {
+        error: "Skill name is required.",
+        errorCode: "MISSING_SKILL_NAME"
+      };
+    }
+    if (!scriptPath) {
+      return {
+        error: "Script path is required.",
+        errorCode: "MISSING_SCRIPT_PATH"
+      };
+    }
+    const skill = this.toolset.getSkill(skillName);
+    if (!skill) {
+      return {
+        error: "Skill '".concat(skillName, "' not found."),
+        errorCode: "SKILL_NOT_FOUND"
+      };
+    }
+    const relScriptPath = scriptPath.startsWith("scripts/") ? scriptPath.substring("scripts/".length) : scriptPath;
+    let script = (_b = (_a = skill.resources) == null ? void 0 : _a.scripts) == null ? void 0 : _b[relScriptPath];
+    if (!script) {
+      script = (_d = (_c = skill.resources) == null ? void 0 : _c.scripts) == null ? void 0 : _d[scriptPath];
+    }
+    if (!script) {
+      return {
+        error: "Script '".concat(scriptPath, "' not found in skill '").concat(skillName, "'."),
+        errorCode: "SCRIPT_NOT_FOUND"
+      };
+    }
+    let codeExecutor = this.toolset.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"
+      };
+    }
+    try {
+      const language = getScriptLanguageByExtension(path.extname(scriptPath));
+      const result = await codeExecutor.executeCode({
+        invocationContext: toolContext.invocationContext,
+        codeExecutionInput: {
+          code: buildWrapperCode(scriptPath, language),
+          inputFiles: getSkillResourceFiles(skill),
+          language,
+          args: scriptArgs
+        }
+      });
+      result.outputFiles = await materializeFiles(result.outputFiles);
+      return result;
+    } catch (e) {
+      return {
+        error: "Failed to execute script '".concat(scriptPath, "': ").concat(e.message),
+        errorCode: "EXECUTION_ERROR"
+      };
+    }
+  }
+};
+RunSkillScriptTool = __decorateClass([
+  experimental
+], RunSkillScriptTool);
+function buildWrapperCode(scriptPath, language) {
+  switch (language) {
+    case CodeExecutionLanguage.JAVASCRIPT:
+      return "require('./".concat(scriptPath, "');");
+    case CodeExecutionLanguage.TYPESCRIPT:
+      return "require('ts-node/register');\nrequire('./".concat(scriptPath, "');");
+    case CodeExecutionLanguage.PYTHON:
+      return "import runpy\nrunpy.run_path('./".concat(scriptPath, "', run_name='__main__')");
+    case CodeExecutionLanguage.SHELL:
+      return "source ./".concat(scriptPath, ' "$@"');
+    case CodeExecutionLanguage.POWERSHELL:
+      return "& .\\".concat(scriptPath.replace(/\//g, "\\\\"), " $args");
+    case CodeExecutionLanguage.WINDOWS_CMD:
+      return "call .\\".concat(scriptPath.replace(/\//g, "\\\\"), " %*");
+    default:
+      throw new Error("Unsupported wrapper language: ".concat(language));
+  }
+}
+function getSkillResourceFiles(skill) {
+  var _a, _b, _c;
+  const files = [];
+  for (const resourceType of ["references", "assets", "scripts"]) {
+    const resources = (_b = (_a = skill.resources) == null ? void 0 : _a[resourceType]) != null ? _b : {};
+    for (const resourceName of Object.keys(resources)) {
+      const content = (_c = resources[resourceName]) != null ? _c : void 0;
+      if (content === void 0) {
+        continue;
+      }
+      let fileContent = void 0;
+      if (typeof content === "string" || Buffer.isBuffer(content)) {
+        fileContent = content;
+      } else if (typeof content === "object" && content !== null && "src" in content && typeof content.src === "string") {
+        fileContent = content.src;
+      }
+      if (fileContent === void 0) {
+        continue;
+      }
+      const ext = path.extname(resourceName).toLowerCase();
+      const { encoding, mimeType } = getMimeTypeAndEncoding(ext);
+      files.push({
+        name: "".concat(resourceType, "/").concat(resourceName),
+        content: Buffer.from(fileContent).toString(encoding),
+        contentEncoding: encoding,
+        mimeType
+      });
+    }
+  }
+  return files;
+}
+export {
+  RunSkillScriptTool,
+  getSkillResourceFiles
+};