@google/adk 0.6.0 → 1.0.0

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

@@ -0,0 +1,225 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"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)
+    __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 __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 __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;
+};
+var load_skill_resource_tool_exports = {};
+__export(load_skill_resource_tool_exports, {
+  LoadSkillResourceTool: () => LoadSkillResourceTool
+});
+module.exports = __toCommonJS(load_skill_resource_tool_exports);
+var import_genai = require("@google/genai");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_experimental = require("../../utils/experimental.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {
+          skill_name: {
+            type: import_genai.Type.STRING,
+            description: "The name of the skill."
+          },
+          path: {
+            type: import_genai.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 = import_node_path.default.posix.normalize(resourcePath);
+    const skill = this.toolset.getSkill(skillName);
+    if (!skill) {
+      return {
+        error: `Skill '${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 '${resourcePath}' not found in skill '${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 '${resourcePath}' is:` },
+                {
+                  inlineData: {
+                    data: content.toString("base64"),
+                    mimeType
+                  }
+                }
+              ]
+            });
+          }
+        }
+      }
+    }
+  }
+};
+LoadSkillResourceTool = __decorateClass([
+  import_experimental.experimental
+], LoadSkillResourceTool);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadSkillResourceTool
+});

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

@@ -0,0 +1,108 @@
+/**
+  * @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 __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;
+};
+var load_skill_tool_exports = {};
+__export(load_skill_tool_exports, {
+  LoadSkillTool: () => LoadSkillTool
+});
+module.exports = __toCommonJS(load_skill_tool_exports);
+var import_genai = require("@google/genai");
+var import_experimental = require("../../utils/experimental.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let LoadSkillTool = class extends import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {
+          name: {
+            type: import_genai.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 '${skillName}' not found.`,
+        error_code: "SKILL_NOT_FOUND"
+      };
+    }
+    const agentName = toolContext.invocationContext.agent.name;
+    const stateKey = `_adk_activated_skill_${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([
+  import_experimental.experimental
+], LoadSkillTool);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoadSkillTool
+});

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

@@ -0,0 +1,146 @@
+/**
+  * @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 __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;
+};
+var run_skill_inline_script_tool_exports = {};
+__export(run_skill_inline_script_tool_exports, {
+  RunSkillInlineScriptTool: () => RunSkillInlineScriptTool
+});
+module.exports = __toCommonJS(run_skill_inline_script_tool_exports);
+var import_genai = require("@google/genai");
+var import_llm_agent = require("../../agents/llm_agent.js");
+var import_code_execution_utils = require("../../code_executors/code_execution_utils.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_file_utils = require("../../utils/file_utils.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let RunSkillInlineScriptTool = class extends import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {
+          script_content: {
+            type: import_genai.Type.STRING,
+            description: "The content of the script to execute."
+          },
+          language: {
+            type: import_genai.Type.STRING,
+            description: "The language/type of the script.",
+            enum: Object.values(import_code_execution_utils.CodeExecutionLanguage).filter(
+              (l) => l !== import_code_execution_utils.CodeExecutionLanguage.UNSPECIFIED
+            )
+          },
+          args: {
+            anyOf: [
+              { type: import_genai.Type.OBJECT },
+              { type: import_genai.Type.ARRAY, items: { type: import_genai.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 ((0, import_llm_agent.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 (0, import_file_utils.materializeFiles)(result.outputFiles);
+      return result;
+    } catch (e) {
+      return {
+        error: `Failed to execute inline script: ${e.message}`,
+        errorCode: "EXECUTION_ERROR"
+      };
+    }
+  }
+};
+RunSkillInlineScriptTool = __decorateClass([
+  import_experimental.experimental
+], RunSkillInlineScriptTool);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RunSkillInlineScriptTool
+});

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

@@ -0,0 +1,224 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"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)
+    __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 __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 __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;
+};
+var run_skill_script_tool_exports = {};
+__export(run_skill_script_tool_exports, {
+  RunSkillScriptTool: () => RunSkillScriptTool,
+  getSkillResourceFiles: () => getSkillResourceFiles
+});
+module.exports = __toCommonJS(run_skill_script_tool_exports);
+var import_genai = require("@google/genai");
+var path = __toESM(require("node:path"), 1);
+var import_llm_agent = require("../../agents/llm_agent.js");
+var import_code_execution_utils = require("../../code_executors/code_execution_utils.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_file_extension_utils = require("../../utils/file_extension_utils.js");
+var import_file_utils = require("../../utils/file_utils.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let RunSkillScriptTool = class extends import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {
+          skill_name: {
+            type: import_genai.Type.STRING,
+            description: "The name of the skill."
+          },
+          script_path: {
+            type: import_genai.Type.STRING,
+            description: "The relative path to the script (e.g., 'scripts/setup.js')."
+          },
+          args: {
+            type: import_genai.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 '${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 '${scriptPath}' not found in skill '${skillName}'.`,
+        errorCode: "SCRIPT_NOT_FOUND"
+      };
+    }
+    let codeExecutor = this.toolset.codeExecutor;
+    if (!codeExecutor) {
+      const agent = toolContext.invocationContext.agent;
+      if ((0, import_llm_agent.isLlmAgent)(agent)) {
+        codeExecutor = agent.codeExecutor;
+      }
+    }
+    if (!codeExecutor) {
+      return {
+        error: "No code executor configured.",
+        errorCode: "NO_CODE_EXECUTOR"
+      };
+    }
+    try {
+      const language = (0, import_file_extension_utils.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 (0, import_file_utils.materializeFiles)(result.outputFiles);
+      return result;
+    } catch (e) {
+      return {
+        error: `Failed to execute script '${scriptPath}': ${e.message}`,
+        errorCode: "EXECUTION_ERROR"
+      };
+    }
+  }
+};
+RunSkillScriptTool = __decorateClass([
+  import_experimental.experimental
+], RunSkillScriptTool);
+function buildWrapperCode(scriptPath, language) {
+  switch (language) {
+    case import_code_execution_utils.CodeExecutionLanguage.JAVASCRIPT:
+      return `require('./${scriptPath}');`;
+    case import_code_execution_utils.CodeExecutionLanguage.TYPESCRIPT:
+      return `require('ts-node/register');
+require('./${scriptPath}');`;
+    case import_code_execution_utils.CodeExecutionLanguage.PYTHON:
+      return `import runpy
+runpy.run_path('./${scriptPath}', run_name='__main__')`;
+    case import_code_execution_utils.CodeExecutionLanguage.SHELL:
+      return `source ./${scriptPath} "$@"`;
+    case import_code_execution_utils.CodeExecutionLanguage.POWERSHELL:
+      return `& .\\${scriptPath.replace(/\//g, "\\\\")} $args`;
+    case import_code_execution_utils.CodeExecutionLanguage.WINDOWS_CMD:
+      return `call .\\${scriptPath.replace(/\//g, "\\\\")} %*`;
+    default:
+      throw new Error(`Unsupported wrapper language: ${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 } = (0, import_file_extension_utils.getMimeTypeAndEncoding)(ext);
+      files.push({
+        name: `${resourceType}/${resourceName}`,
+        content: Buffer.from(fileContent).toString(encoding),
+        contentEncoding: encoding,
+        mimeType
+      });
+    }
+  }
+  return files;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RunSkillScriptTool,
+  getSkillResourceFiles
+});