@softactivate/adk 1.1.0

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
+});

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

@@ -0,0 +1,163 @@
+/**
+  * @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 skill_toolset_exports = {};
+__export(skill_toolset_exports, {
+  SkillToolset: () => SkillToolset
+});
+module.exports = __toCommonJS(skill_toolset_exports);
+var import_llm_request = require("../../models/llm_request.js");
+var import_prompt = require("../../skills/prompt.js");
+var import_experimental = require("../../utils/experimental.js");
+var import_base_tool = require("../base_tool.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_list_skills_tool = require("./list_skills_tool.js");
+var import_load_skill_resource_tool = require("./load_skill_resource_tool.js");
+var import_load_skill_tool = require("./load_skill_tool.js");
+var import_run_skill_inline_script_tool = require("./run_skill_inline_script_tool.js");
+var import_run_skill_script_tool = require("./run_skill_script_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_SKILL_SYSTEM_INSTRUCTION = `You can use specialized 'skills' to help you with complex tasks. You MUST use the skill tools to interact with these skills.
+
+Skills are folders of instructions and resources that extend your capabilities for specialized tasks. Each skill folder contains:
+- **SKILL.md** (required): The main instruction file with skill metadata and detailed markdown instructions.
+- **references/** (Optional): Additional documentation or examples for skill usage.
+- **assets/** (Optional): Templates, scripts or other resources used by the skill.
+- **scripts/** (Optional): Executable scripts that can be run via bash.
+
+This is very important:
+
+1. If a skill seems relevant to the current user query, you MUST use the \`load_skill\` tool with \`name="<SKILL_NAME>"\` to read its full instructions before proceeding.
+2. Once you have read the instructions, follow them exactly as documented before replying to the user. For example, If the instruction lists multiple steps, please make sure you complete all of them in order.
+3. The \`load_skill_resource\` tool is for viewing files within a skill's directory (e.g., \`references/*\`, \`assets/*\`, \`scripts/*\`). Do NOT use other tools to access these files.
+4. Use \`run_skill_script\` to run scripts from a skill's \`scripts/\` directory. Use \`load_skill_resource\` to view script content first if needed.
+`;
+let SkillToolset = class extends import_base_toolset.BaseToolset {
+  constructor(skills, options = {}) {
+    super([], "adk_skill_toolset");
+    this.toolCache = /* @__PURE__ */ new Map();
+    this.skills = Array.isArray(skills) ? Object.fromEntries(skills.map((s) => [s.frontmatter.name, s])) : skills;
+    this.codeExecutor = options.codeExecutor;
+    this.additionalTools = options.additionalTools || [];
+    this.tools = [
+      new import_list_skills_tool.ListSkillsTool(this),
+      new import_load_skill_tool.LoadSkillTool(this),
+      new import_load_skill_resource_tool.LoadSkillResourceTool(this),
+      new import_run_skill_script_tool.RunSkillScriptTool(this),
+      new import_run_skill_inline_script_tool.RunSkillInlineScriptTool(this)
+    ];
+  }
+  async getTools(context) {
+    const dynamicTools = await this.resolveAdditionalTools(context);
+    return [...this.tools, ...dynamicTools];
+  }
+  async close() {
+  }
+  getSkill(name) {
+    return this.skills[name];
+  }
+  async processLlmRequest(toolContext, llmRequest) {
+    await super.processLlmRequest(toolContext, llmRequest);
+    const skills = Object.values(this.skills);
+    const skillsXml = (0, import_prompt.formatSkillsAsXml)(skills);
+    (0, import_llm_request.appendInstructions)(llmRequest, [
+      DEFAULT_SKILL_SYSTEM_INSTRUCTION,
+      skillsXml
+    ]);
+  }
+  async resolveAdditionalTools(context) {
+    if (!context) return [];
+    const agentName = context.agentName;
+    const stateKey = `_adk_activated_skill_${agentName}`;
+    const activatedSkills = context.state.get(stateKey) || [];
+    if (activatedSkills.length === 0) return [];
+    const cacheKey = `${agentName}:${activatedSkills.join(",")}`;
+    if (this.toolCache.has(cacheKey)) {
+      return this.toolCache.get(cacheKey);
+    }
+    const additionalToolNames = /* @__PURE__ */ new Set();
+    for (const skillName of activatedSkills) {
+      const skill = this.skills[skillName];
+      if (skill && skill.frontmatter.metadata) {
+        const tools = skill.frontmatter.metadata["adk_additional_tools"];
+        if (tools) {
+          tools.forEach((t) => additionalToolNames.add(t));
+        }
+      }
+    }
+    if (additionalToolNames.size === 0) {
+      this.toolCache.set(cacheKey, []);
+      return [];
+    }
+    const candidateTools = {};
+    for (const toolUnion of this.additionalTools) {
+      if (toolUnion instanceof import_base_tool.BaseTool) {
+        if (candidateTools[toolUnion.name]) {
+          throw new Error(`Duplicate tool name: ${toolUnion.name}`);
+        }
+        candidateTools[toolUnion.name] = toolUnion;
+      } else if (toolUnion instanceof import_base_toolset.BaseToolset) {
+        const tsTools = await toolUnion.getTools(context);
+        for (const t of tsTools) {
+          if (candidateTools[t.name]) {
+            throw new Error(`Duplicate tool name: ${t.name}`);
+          }
+          candidateTools[t.name] = t;
+        }
+      }
+    }
+    const resolvedTools = [];
+    const existingNames = new Set(this.tools.map((t) => t.name));
+    for (const name of additionalToolNames) {
+      if (candidateTools[name]) {
+        const tool = candidateTools[name];
+        if (!existingNames.has(tool.name)) {
+          resolvedTools.push(tool);
+          existingNames.add(tool.name);
+        }
+      }
+    }
+    this.toolCache.set(cacheKey, resolvedTools);
+    return resolvedTools;
+  }
+};
+SkillToolset = __decorateClass([
+  import_experimental.experimental
+], SkillToolset);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SkillToolset
+});

package/dist/cjs/tools/tool_confirmation.js

@@ -0,0 +1,49 @@
+/**
+  * @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 tool_confirmation_exports = {};
+__export(tool_confirmation_exports, {
+  ToolConfirmation: () => ToolConfirmation
+});
+module.exports = __toCommonJS(tool_confirmation_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToolConfirmation {
+  constructor({
+    hint,
+    confirmed,
+    payload
+  }) {
+    this.hint = hint != null ? hint : "";
+    this.confirmed = confirmed;
+    this.payload = payload;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolConfirmation
+});

package/dist/cjs/tools/url_context_tool.js

@@ -0,0 +1,73 @@
+/**
+  * @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 url_context_tool_exports = {};
+__export(url_context_tool_exports, {
+  URL_CONTEXT: () => URL_CONTEXT,
+  UrlContextTool: () => UrlContextTool
+});
+module.exports = __toCommonJS(url_context_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class UrlContextTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "url_context", description: "URL Context Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    if (!(0, import_model_name.isGeminiModel)(llmRequest.model)) {
+      throw new Error(
+        `URL context tool is not supported for model ${llmRequest.model}`
+      );
+    }
+    if (!(0, import_model_name.isGemini2OrAbove)(llmRequest.model)) {
+      throw new Error(
+        `URL context tool requires Gemini 2 or above, but got ${llmRequest.model}`
+      );
+    }
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      urlContext: {}
+    });
+  }
+}
+const URL_CONTEXT = new UrlContextTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  URL_CONTEXT,
+  UrlContextTool
+});