@google/adk 0.6.1 → 1.1.0

package/dist/cjs/skills/loader.js

@@ -0,0 +1,283 @@
+/**
+  * @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 loader_exports = {};
+__export(loader_exports, {
+  loadAllSkillsInDir: () => loadAllSkillsInDir,
+  loadSkillFromDir: () => loadSkillFromDir,
+  parseSkillMdContent: () => parseSkillMdContent,
+  validateSkillDir: () => validateSkillDir
+});
+module.exports = __toCommonJS(loader_exports);
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_logger = require("../utils/logger.js");
+var import_skill = require("./skill.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ALLOWED_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "license",
+  "allowed-tools",
+  "metadata",
+  "compatibility"
+]);
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "node_modules",
+  "coverage",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  ".git",
+  ".vscode",
+  ".idea"
+]);
+const IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".pyd",
+  ".tsbuildinfo",
+  ".DS_Store"
+]);
+async function loadDir(directoryPath) {
+  const files = {};
+  async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const relativePath = path.relative(directoryPath, fullPath);
+        if (IGNORED_EXTENSIONS.has(path.extname(entry.name))) {
+          continue;
+        }
+        const fileData = await fs.readFile(fullPath);
+        try {
+          files[relativePath] = fileData.toString("utf-8");
+        } catch (_e) {
+          files[relativePath] = fileData;
+        }
+      }
+    }
+  }
+  try {
+    const stats = await fs.stat(directoryPath);
+    if (stats.isDirectory()) {
+      await walk(directoryPath);
+    }
+  } catch (e) {
+    import_logger.logger.warn(
+      `Failed to load directory '${directoryPath}': ${e.message}`
+    );
+  }
+  return files;
+}
+function parseSkillMdContent(content) {
+  if (!content.startsWith("---")) {
+    throw new Error("SKILL.md must start with YAML frontmatter (---)");
+  }
+  const parts = content.split("---", 3);
+  if (parts.length < 3) {
+    throw new Error("SKILL.md frontmatter not properly closed with ---");
+  }
+  const frontmatterStr = parts[1];
+  const body = parts[2].trim();
+  try {
+    const parsed = import_js_yaml.default.load(frontmatterStr);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("SKILL.md frontmatter must be a YAML mapping");
+    }
+    const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+    return { frontmatter, body };
+  } catch (e) {
+    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+  }
+}
+async function loadSkillFromDir(skillDir) {
+  const resolvedDir = path.resolve(skillDir);
+  const skill = await loadSkillFile(skillDir);
+  const referencesDir = path.join(resolvedDir, "references");
+  const assetsDir = path.join(resolvedDir, "assets");
+  const scriptsDir = path.join(resolvedDir, "scripts");
+  const [references, assets, rawScripts] = await Promise.all([
+    loadDir(referencesDir),
+    loadDir(assetsDir),
+    loadDir(scriptsDir)
+  ]);
+  const scripts = {};
+  for (const [name, src] of Object.entries(rawScripts)) {
+    if (typeof src === "string") {
+      scripts[name] = { src };
+    }
+  }
+  const resources = { references, assets, scripts };
+  return {
+    ...skill,
+    resources
+  };
+}
+async function validateSkillDir(skillDir) {
+  const problems = [];
+  const resolvedDir = path.resolve(skillDir);
+  let skill;
+  try {
+    skill = await loadSkillFile(resolvedDir);
+  } catch (e) {
+    return [e.message];
+  }
+  try {
+    const keys = Object.keys(skill.frontmatter);
+    const unknown = keys.filter((k) => !ALLOWED_FRONTMATTER_KEYS.has(k));
+    if (unknown.length > 0) {
+      problems.push(
+        `Unknown frontmatter fields: [${unknown.sort().join(", ")}]`
+      );
+    }
+    const dirName = path.basename(resolvedDir);
+    if (dirName !== skill.frontmatter.name) {
+      problems.push(
+        `Skill name '${skill.frontmatter.name}' does not match directory name '${dirName}'.`
+      );
+    }
+  } catch (e) {
+    problems.push(e.message);
+  }
+  return problems;
+}
+async function loadSkillFile(skillDir) {
+  const resolvedDir = path.resolve(skillDir);
+  let skillMdPath = "";
+  let content = "";
+  try {
+    const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+        const p = path.join(resolvedDir, entry.name);
+        try {
+          content = await fs.readFile(p, "utf-8");
+          skillMdPath = p;
+          break;
+        } catch (_e) {
+        }
+      }
+    }
+  } catch (e) {
+    import_logger.logger.warn(
+      `Failed to load directory '${skillDir}': ${e.message}`
+    );
+  }
+  if (!skillMdPath) {
+    throw new Error(
+      `SKILL.md (or any case variation like skill.md) not found in '${skillDir}'.`
+    );
+  }
+  const { frontmatter: parsed, body } = parseSkillMdContent(content);
+  const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+  const dirName = path.basename(resolvedDir);
+  if (dirName !== frontmatter.name) {
+    throw new Error(
+      `Skill name '${frontmatter.name}' does not match directory name '${dirName}'.`
+    );
+  }
+  return {
+    frontmatter,
+    instructions: body
+  };
+}
+async function loadAllSkillsInDir(skillsBasePath) {
+  const resolvedPath = path.resolve(skillsBasePath);
+  const skills = {};
+  async function scanDir(currentDir) {
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch (_e) {
+      return;
+    }
+    let isSkillDir = false;
+    if (currentDir !== resolvedPath) {
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
+          isSkillDir = true;
+          break;
+        }
+      }
+    }
+    if (isSkillDir) {
+      try {
+        const skill = await loadSkillFromDir(currentDir);
+        skills[skill.frontmatter.name] = skill;
+      } catch (e) {
+        import_logger.logger.warn(`Skipping invalid skill in '${currentDir}':`, e);
+      }
+    } else {
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (IGNORED_DIRECTORIES.has(entry.name)) {
+            continue;
+          }
+          await scanDir(path.join(currentDir, entry.name));
+        }
+      }
+    }
+  }
+  try {
+    await fs.readdir(resolvedPath);
+    await scanDir(resolvedPath);
+  } catch (e) {
+    import_logger.logger.warn(`Skills base path '${skillsBasePath}' is not a directory.`, e);
+  }
+  return skills;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadAllSkillsInDir,
+  loadSkillFromDir,
+  parseSkillMdContent,
+  validateSkillDir
+});

package/dist/cjs/skills/prompt.js

@@ -0,0 +1,58 @@
+/**
+  * @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 prompt_exports = {};
+__export(prompt_exports, {
+  formatSkillsAsXml: () => formatSkillsAsXml
+});
+module.exports = __toCommonJS(prompt_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function escapeHtml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function formatSkillsAsXml(skills) {
+  if (!skills || skills.length === 0) {
+    return "<available_skills>\n</available_skills>";
+  }
+  const lines = ["<available_skills>"];
+  for (const item of skills) {
+    const frontmatter = "frontmatter" in item ? item.frontmatter : item;
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeHtml(frontmatter.name)}</name>`);
+    lines.push(
+      `    <description>${escapeHtml(frontmatter.description)}</description>`
+    );
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatSkillsAsXml
+});

package/dist/cjs/skills/skill.js

@@ -0,0 +1,78 @@
+/**
+  * @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 skill_exports = {};
+__export(skill_exports, {
+  FrontmatterSchema: () => FrontmatterSchema,
+  SNAKE_OR_KEBAB_NAME_PATTERN: () => SNAKE_OR_KEBAB_NAME_PATTERN
+});
+module.exports = __toCommonJS(skill_exports);
+var import_zod = require("zod");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const SNAKE_OR_KEBAB_NAME_PATTERN = /^([a-z0-9]+(-[a-z0-9]+)*|[a-z0-9]+(_[a-z0-9]+)*)$/;
+const FrontmatterSchema = import_zod.z.preprocess(
+  (data) => {
+    if (typeof data === "object" && data !== null) {
+      const obj = data;
+      if ("allowed-tools" in obj && !("allowedTools" in obj)) {
+        return {
+          ...obj,
+          allowedTools: obj["allowed-tools"]
+        };
+      }
+    }
+    return data;
+  },
+  import_zod.z.object({
+    name: import_zod.z.string().regex(SNAKE_OR_KEBAB_NAME_PATTERN, {
+      message: "name must be lowercase kebab-case (a-z, 0-9, hyphens) or snake_case (a-z, 0-9, underscores), with no leading, trailing, or consecutive delimiters. Mixing hyphens and underscores is not allowed."
+    }).max(64),
+    description: import_zod.z.string().min(1).max(1024),
+    license: import_zod.z.string().optional(),
+    compatibility: import_zod.z.string().max(500).optional(),
+    "allowed-tools": import_zod.z.string().optional(),
+    metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).default({}).refine(
+      (data) => {
+        if ("adk_additional_tools" in data) {
+          return Array.isArray(data.adk_additional_tools) && data.adk_additional_tools.every(
+            (item) => typeof item === "string"
+          );
+        }
+        return true;
+      },
+      {
+        message: "adk_additional_tools must be a list of strings"
+      }
+    )
+  }).loose()
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FrontmatterSchema,
+  SNAKE_OR_KEBAB_NAME_PATTERN
+});

package/dist/cjs/tools/agent_tool.js

@@ -93,7 +93,7 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
     args,
     toolContext
   }) {
-    var _a2, _b2, _c, _d;
+    var _a2, _b2, _c, _d, _e, _f;
     if (this.skipSummarization) {
       toolContext.actions.skipSummarization = true;
     }
@@ -116,24 +116,31 @@ class AgentTool extends (_b = import_base_tool.BaseTool, _a = AGENT_TOOL_SIGNATU
       memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new import_in_memory_memory_service.InMemoryMemoryService(),
       credentialService: toolContext.invocationContext.credentialService
     });
-    const session = await runner.sessionService.createSession({
+    const session = await runner.sessionService.getOrCreateSession({
       appName: this.agent.name,
       userId: toolContext.invocationContext.userId,
       sessionId: toolContext.invocationContext.session.id,
       state: toolContext.state.toRecord()
     });
+    if ((_c = toolContext.abortSignal) == null ? void 0 : _c.aborted) {
+      return "";
+    }
     let lastEvent;
     for await (const event of runner.runAsync({
       userId: session.userId,
       sessionId: session.id,
-      newMessage: content
+      newMessage: content,
+      abortSignal: toolContext.abortSignal
     })) {
+      if ((_d = toolContext.abortSignal) == null ? void 0 : _d.aborted) {
+        return;
+      }
       if (event.actions.stateDelta) {
         toolContext.state.update(event.actions.stateDelta);
       }
       lastEvent = event;
     }
-    if (!((_d = (_c = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _c.parts) == null ? void 0 : _d.length)) {
+    if (!((_f = (_e = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _e.parts) == null ? void 0 : _f.length)) {
       return "";
     }
     const hasOutputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;

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

@@ -35,10 +35,11 @@ var import_base_tool = require("../base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class MCPTool extends import_base_tool.BaseTool {
-  constructor(mcpTool, mcpSessionManager) {
+  constructor(mcpTool, mcpSessionManager, originalName) {
     super({ name: mcpTool.name, description: mcpTool.description || "" });
     this.mcpTool = mcpTool;
     this.mcpSessionManager = mcpSessionManager;
+    this.originalName = originalName || mcpTool.name;
   }
   _getDeclaration() {
     return {
@@ -53,8 +54,11 @@ class MCPTool extends import_base_tool.BaseTool {
   async runAsync(request) {
     const session = await this.mcpSessionManager.createSession();
     const callRequest = {};
-    callRequest.params = { name: this.mcpTool.name, arguments: request.args };
-    return await session.callTool(callRequest.params);
+    callRequest.params = { name: this.originalName, arguments: request.args };
+    const result = await session.callTool(callRequest.params, void 0, {
+      signal: request.toolContext.abortSignal
+    });
+    return result;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -53,7 +53,7 @@ class MCPToolset extends import_base_toolset.BaseToolset {
         ...tool,
         name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
       };
-      return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager);
+      return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
   }
   async close() {

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