@softactivate/adk 1.1.0

package/dist/cjs/tools/mcp/mcp_toolset.js

@@ -0,0 +1,80 @@
+/**
+  * @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 mcp_toolset_exports = {};
+__export(mcp_toolset_exports, {
+  MCPToolset: () => MCPToolset
+});
+module.exports = __toCommonJS(mcp_toolset_exports);
+var import_logger = require("../../utils/logger.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_mcp_session_manager = require("./mcp_session_manager.js");
+var import_mcp_tool = require("./mcp_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPToolset extends import_base_toolset.BaseToolset {
+  constructor(connectionParams, toolFilter = [], prefix) {
+    super(toolFilter, prefix);
+    this.mcpSessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParams);
+  }
+  async getTools(context) {
+    const session = await this.mcpSessionManager.createSession();
+    const listResult = await session.listTools();
+    await session.close();
+    import_logger.logger.debug(`number of tools: ${listResult.tools.length}`);
+    for (const tool of listResult.tools) {
+      import_logger.logger.debug(`tool: ${tool.name}`);
+    }
+    const tools = listResult.tools.map((tool) => {
+      const toolWithPrefix = {
+        ...tool,
+        name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
+      };
+      return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
+    });
+    const filter = this.toolFilter;
+    if (!filter || Array.isArray(filter) && filter.length === 0) {
+      return tools;
+    }
+    if (Array.isArray(filter)) {
+      return tools.filter((tool) => filter.includes(tool.name));
+    }
+    if (context) {
+      return tools.filter((tool) => filter(tool, context));
+    }
+    import_logger.logger.warn(
+      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
+    );
+    return tools;
+  }
+  async close() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPToolset
+});

package/dist/cjs/tools/preload_memory_tool.js

@@ -0,0 +1,109 @@
+/**
+  * @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 preload_memory_tool_exports = {};
+__export(preload_memory_tool_exports, {
+  PRELOAD_MEMORY: () => PRELOAD_MEMORY,
+  PreloadMemoryTool: () => PreloadMemoryTool
+});
+module.exports = __toCommonJS(preload_memory_tool_exports);
+var import_llm_request = require("../models/llm_request.js");
+var import_logger = require("../utils/logger.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class PreloadMemoryTool extends import_base_tool.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 (_) {
+      import_logger.logger.warn(`Failed to preload memory for query: ${userQuery}`);
+      return;
+    }
+    if (!response.memories || response.memories.length === 0) {
+      return;
+    }
+    const memoryTextLines = [];
+    for (const memory of response.memories) {
+      const timeStr = memory.timestamp ? `Time: ${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 ? `${memory.author}: ${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.
+They may be useful for answering the user's current query.
+<PAST_CONVERSATIONS>
+${fullMemoryText}
+</PAST_CONVERSATIONS>
+`;
+    (0, import_llm_request.appendInstructions)(request.llmRequest, [si]);
+  }
+}
+const PRELOAD_MEMORY = new PreloadMemoryTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRELOAD_MEMORY,
+  PreloadMemoryTool
+});

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

@@ -0,0 +1,76 @@
+/**
+  * @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 list_skills_tool_exports = {};
+__export(list_skills_tool_exports, {
+  ListSkillsTool: () => ListSkillsTool
+});
+module.exports = __toCommonJS(list_skills_tool_exports);
+var import_genai = require("@google/genai");
+var import_prompt = require("../../skills/prompt.js");
+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 ListSkillsTool = class extends import_base_tool.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: import_genai.Type.OBJECT,
+        properties: {}
+      }
+    };
+  }
+  async runAsync(_request) {
+    const skills = Object.values(this.toolset.skills);
+    return (0, import_prompt.formatSkillsAsXml)(skills);
+  }
+};
+ListSkillsTool = __decorateClass([
+  import_experimental.experimental
+], ListSkillsTool);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ListSkillsTool
+});

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