@google/adk 1.2.0 → 1.4.0

package/dist/cjs/skills/gcp_skill_registry.js

@@ -0,0 +1,104 @@
+/**
+  * @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 gcp_skill_registry_exports = {};
+__export(gcp_skill_registry_exports, {
+  GCPSkillRegistry: () => GCPSkillRegistry
+});
+module.exports = __toCommonJS(gcp_skill_registry_exports);
+var import_vertexai = require("@google-cloud/vertexai");
+var import_experimental = require("../utils/experimental.js");
+var import_loader = require("./loader.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let GCPSkillRegistry = class {
+  constructor(options = {}) {
+    this.projectId = options.projectId || process.env.GOOGLE_CLOUD_PROJECT;
+    this.location = options.location || process.env.GOOGLE_CLOUD_LOCATION;
+    this.client = options.client || new import_vertexai.Client({
+      project: this.projectId,
+      location: this.location
+    });
+  }
+  async getSkill(name) {
+    const apiClient = this.client.apiClient;
+    const httpResponse = await apiClient.request({
+      path: `skills/${name}`,
+      httpMethod: "GET",
+      httpOptions: { apiVersion: "v1beta1" }
+    });
+    const response = await httpResponse.json();
+    const zippedFilesystem = response.zippedFilesystem || response.zipped_filesystem;
+    if (!zippedFilesystem) {
+      throw new Error(`Skill '${name}' does not contain zipped filesystem.`);
+    }
+    const zipBuffer = Buffer.from(zippedFilesystem, "base64");
+    return (0, import_loader.loadSkillFromZipBuffer)(zipBuffer);
+  }
+  async searchSkills(query) {
+    const apiClient = this.client.apiClient;
+    const trimmedQuery = query.trim();
+    const isSearch = trimmedQuery.length > 0;
+    const path = isSearch ? `skills:retrieve?query=${encodeURIComponent(trimmedQuery)}` : "skills";
+    const httpResponse = await apiClient.request({
+      path,
+      httpMethod: "GET",
+      httpOptions: { apiVersion: "v1beta1" }
+    });
+    const response = await httpResponse.json();
+    const skillsList = isSearch ? response.retrievedSkills || response.retrieved_skills : response.skills;
+    const results = [];
+    if (skillsList && Array.isArray(skillsList)) {
+      for (const s of skillsList) {
+        const skillNameStr = s.skillName || s.skill_name || s.name || "";
+        const descriptionStr = s.description || "";
+        const parts = skillNameStr.split("/");
+        const name = skillNameStr ? parts[parts.length - 1] : "";
+        results.push({
+          name,
+          description: descriptionStr
+        });
+      }
+    }
+    return results;
+  }
+};
+GCPSkillRegistry = __decorateClass([
+  import_experimental.experimental
+], GCPSkillRegistry);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GCPSkillRegistry
+});

package/dist/cjs/skills/loader.js

@@ -36,10 +36,12 @@ var loader_exports = {};
 __export(loader_exports, {
   loadAllSkillsInDir: () => loadAllSkillsInDir,
   loadSkillFromDir: () => loadSkillFromDir,
+  loadSkillFromZipBuffer: () => loadSkillFromZipBuffer,
   parseSkillMdContent: () => parseSkillMdContent,
   validateSkillDir: () => validateSkillDir
 });
 module.exports = __toCommonJS(loader_exports);
+var import_adm_zip = __toESM(require("adm-zip"), 1);
 var import_js_yaml = __toESM(require("js-yaml"), 1);
 var fs = __toESM(require("node:fs/promises"), 1);
 var path = __toESM(require("node:path"), 1);
@@ -121,12 +123,12 @@ function parseSkillMdContent(content) {
   if (!content.startsWith("---")) {
     throw new Error("SKILL.md must start with YAML frontmatter (---)");
   }
-  const parts = content.split("---", 3);
+  const parts = content.split("---");
   if (parts.length < 3) {
     throw new Error("SKILL.md frontmatter not properly closed with ---");
   }
   const frontmatterStr = parts[1];
-  const body = parts[2].trim();
+  const body = parts.filter((_, i) => i >= 2).join("---").trim();
   try {
     const parsed = import_js_yaml.default.load(frontmatterStr);
     if (typeof parsed !== "object" || parsed === null) {
@@ -274,10 +276,73 @@ async function loadAllSkillsInDir(skillsBasePath) {
   }
   return skills;
 }
+function loadSkillFromZipBuffer(zipBuffer) {
+  const zip = new import_adm_zip.default(zipBuffer);
+  const entries = zip.getEntries();
+  let skillMdContent = "";
+  for (const entry of entries) {
+    if (entry.isDirectory) continue;
+    if (entry.entryName.toLowerCase() === "skill.md") {
+      skillMdContent = entry.getData().toString("utf-8");
+      break;
+    }
+  }
+  if (!skillMdContent) {
+    throw new Error("SKILL.md not found in zipped filesystem.");
+  }
+  const { frontmatter: parsed, body } = parseSkillMdContent(skillMdContent);
+  const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
+  const references = {};
+  const assets = {};
+  const scripts = {};
+  function loadZipDir(prefix) {
+    const res = {};
+    const normPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+    for (const entry of entries) {
+      if (entry.isDirectory) continue;
+      if (entry.entryName.startsWith(normPrefix)) {
+        if (entry.entryName.includes("__pycache__")) continue;
+        const relativePath = entry.entryName.substring(normPrefix.length);
+        if (!relativePath) continue;
+        const data = entry.getData();
+        try {
+          res[relativePath] = data.toString("utf-8");
+        } catch (_e) {
+          res[relativePath] = data;
+        }
+      }
+    }
+    return res;
+  }
+  const refFiles = loadZipDir("references");
+  for (const [key, val] of Object.entries(refFiles)) {
+    references[key] = val;
+  }
+  const assetFiles = loadZipDir("assets");
+  for (const [key, val] of Object.entries(assetFiles)) {
+    assets[key] = val;
+  }
+  const rawScripts = loadZipDir("scripts");
+  for (const [key, val] of Object.entries(rawScripts)) {
+    if (typeof val === "string") {
+      scripts[key] = { src: val };
+    }
+  }
+  return {
+    frontmatter,
+    instructions: body,
+    resources: {
+      references,
+      assets,
+      scripts
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   loadAllSkillsInDir,
   loadSkillFromDir,
+  loadSkillFromZipBuffer,
   parseSkillMdContent,
   validateSkillDir
 });

package/dist/cjs/skills/skill_registry.js

@@ -0,0 +1,27 @@
+/**
+  * @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 __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_registry_exports = {};
+module.exports = __toCommonJS(skill_registry_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/cjs/tools/base_toolset.js

@@ -53,7 +53,7 @@ class BaseToolset {
    * @return Whether the tool should be exposed to LLM.
    */
   isToolSelected(tool, context) {
-    if (!this.toolFilter) {
+    if (!this.toolFilter || Array.isArray(this.toolFilter) && this.toolFilter.length === 0) {
       return true;
     }
     if (typeof this.toolFilter === "function") {

package/dist/cjs/tools/consolidate_context_tool.js

@@ -0,0 +1,79 @@
+/**
+  * @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 consolidate_context_tool_exports = {};
+__export(consolidate_context_tool_exports, {
+  ConsolidateContextTool: () => ConsolidateContextTool
+});
+module.exports = __toCommonJS(consolidate_context_tool_exports);
+var import_genai = require("@google/genai");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ConsolidateContextTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({
+      name: "consolidate_context",
+      description: "Requests context consolidation (compaction) to manage history size. Use this when a subtask is complete and you want to summarize progress and clear detailed history."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: import_genai.Type.OBJECT,
+        properties: {
+          detail: {
+            type: import_genai.Type.STRING,
+            description: "Optional description of what has been accomplished so far. This detail will be used to guide the summarization of the history."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    toolContext.state.set("temp:consolidate_context", true);
+    if (args["detail"] !== void 0) {
+      toolContext.state.set(
+        "temp:consolidate_context_detail",
+        args["detail"]
+      );
+    }
+    return {
+      status: "success",
+      message: "Context consolidation requested."
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsolidateContextTool
+});

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -37,48 +37,36 @@ class ForwardingArtifactService {
     this.toolContext = toolContext;
     this.invocationContext = toolContext.invocationContext;
   }
-  // TODO - b/425992518: Remove unnecessary parameters. We should rethink the
-  // abstraction layer to make it more clear.
   async saveArtifact(request) {
     return this.toolContext.saveArtifact(request.filename, request.artifact);
   }
   async loadArtifact(request) {
     return this.toolContext.loadArtifact(request.filename, request.version);
   }
-  async listArtifactKeys() {
+  async listArtifactKeys(_request) {
     return this.toolContext.listArtifacts();
   }
-  async deleteArtifact(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
+  getArtifactService() {
+    const service = this.invocationContext.artifactService;
+    if (!service) {
       throw new Error("Artifact service is not initialized.");
     }
-    return this.toolContext.invocationContext.artifactService.deleteArtifact(
-      request
-    );
+    return service;
+  }
+  async deleteArtifact(request) {
+    return this.getArtifactService().deleteArtifact(request.filename);
   }
   async listVersions(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.listVersions(
-      request
-    );
+    return this.getArtifactService().listVersions(request.filename);
   }
-  listArtifactVersions(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.listArtifactVersions(
-      request
-    );
+  async listArtifactVersions(request) {
+    return this.getArtifactService().listArtifactVersions(request.filename);
   }
-  getArtifactVersion(request) {
-    if (!this.toolContext.invocationContext.artifactService) {
-      throw new Error("Artifact service is not initialized.");
-    }
-    return this.toolContext.invocationContext.artifactService.getArtifactVersion(
-      request
-    );
+  async getArtifactVersion(request) {
+    return this.getArtifactService().getArtifactVersion({
+      filename: request.filename,
+      version: request.version
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.js

@@ -0,0 +1,232 @@
+/**
+  * @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 openapi_spec_parser_exports = {};
+__export(openapi_spec_parser_exports, {
+  OpenApiSpecParser: () => OpenApiSpecParser
+});
+module.exports = __toCommonJS(openapi_spec_parser_exports);
+var import_experimental = require("../../../utils/experimental.js");
+var import_operation_parser = require("./operation_parser.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const VALID_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string"
+]);
+let OpenApiSpecParser = class {
+  constructor(options = {}) {
+    var _a;
+    this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  }
+  parse(openapiSpec) {
+    const resolvedSpec = resolveReferences(openapiSpec);
+    const sanitizedSpec = sanitizeSchemaTypes(resolvedSpec);
+    return collectOperations(sanitizedSpec, {
+      preservePropertyNames: this.preservePropertyNames
+    });
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], OpenApiSpecParser.prototype, "parse", 1);
+OpenApiSpecParser = __decorateClass([
+  import_experimental.experimental
+], OpenApiSpecParser);
+function resolveReferences(spec) {
+  const resolvedCache = /* @__PURE__ */ new Map();
+  const specCopy = JSON.parse(JSON.stringify(spec));
+  const recursiveResolve = (obj, currentDoc, seenRefs = /* @__PURE__ */ new Set()) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => recursiveResolve(item, currentDoc, seenRefs));
+    }
+    const objRecord = obj;
+    if ("$ref" in objRecord && typeof objRecord["$ref"] === "string") {
+      const refString = objRecord["$ref"];
+      if (seenRefs.has(refString) && !resolvedCache.has(refString)) {
+        const copy = { ...objRecord };
+        delete copy["$ref"];
+        return copy;
+      }
+      seenRefs.add(refString);
+      if (resolvedCache.has(refString)) {
+        return resolvedCache.get(refString);
+      }
+      let resolvedValue = resolveRef(refString, currentDoc);
+      if (resolvedValue !== void 0) {
+        resolvedValue = recursiveResolve(resolvedValue, currentDoc, seenRefs);
+        resolvedCache.set(refString, resolvedValue);
+        return resolvedValue;
+      } else {
+        return obj;
+      }
+    }
+    const newDict = {};
+    for (const [key, value] of Object.entries(objRecord)) {
+      newDict[key] = recursiveResolve(value, currentDoc, seenRefs);
+    }
+    return newDict;
+  };
+  return recursiveResolve(specCopy, specCopy);
+}
+function resolveRef(refString, currentDoc) {
+  const parts = refString.split("/");
+  if (parts[0] !== "#") {
+    throw new Error(`External references not supported: ${refString}`);
+  }
+  let current = currentDoc;
+  for (const part of parts.slice(1)) {
+    if (typeof current === "object" && current !== null && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function sanitizeSchemaTypes(openapiSpec) {
+  const specCopy = JSON.parse(JSON.stringify(openapiSpec));
+  const sanitizeTypeField = (schemaDict) => {
+    if (!("type" in schemaDict)) return;
+    const typeValue = schemaDict["type"];
+    if (typeof typeValue === "string") {
+      const normalizedType = typeValue.toLowerCase();
+      if (VALID_SCHEMA_TYPES.has(normalizedType)) {
+        schemaDict["type"] = normalizedType;
+      } else {
+        delete schemaDict["type"];
+      }
+      return;
+    }
+    if (Array.isArray(typeValue)) {
+      const validTypes = [];
+      for (const entry of typeValue) {
+        if (typeof entry !== "string") continue;
+        const normalizedEntry = entry.toLowerCase();
+        if (VALID_SCHEMA_TYPES.has(normalizedEntry) && !validTypes.includes(normalizedEntry)) {
+          validTypes.push(normalizedEntry);
+        }
+      }
+      if (validTypes.length > 0) {
+        schemaDict["type"] = validTypes;
+      } else {
+        delete schemaDict["type"];
+      }
+    }
+  };
+  const sanitizeRecursive = (obj, inSchema) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => sanitizeRecursive(item, inSchema));
+    }
+    const objRecord = obj;
+    if (inSchema) {
+      sanitizeTypeField(objRecord);
+    }
+    for (const [key, value] of Object.entries(objRecord)) {
+      const isSchemaContainer = key === "schema" || key === "schemas";
+      objRecord[key] = sanitizeRecursive(value, inSchema || isSchemaContainer);
+    }
+    return objRecord;
+  };
+  return sanitizeRecursive(specCopy, false);
+}
+function collectOperations(spec, options = {}) {
+  var _a, _b, _c, _d;
+  const preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+  const operations = [];
+  const baseUrl = ((_c = (_b = spec.servers) == null ? void 0 : _b[0]) == null ? void 0 : _c.url) || "";
+  const globalSecurity = spec.security || [];
+  let globalSchemeName;
+  if (globalSecurity.length > 0) {
+    globalSchemeName = Object.keys(globalSecurity[0])[0];
+  }
+  const authSchemes = ((_d = spec.components) == null ? void 0 : _d.securitySchemes) || {};
+  for (const [path, pathItem] of Object.entries(spec.paths || {})) {
+    if (!pathItem) continue;
+    const methods = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "head",
+      "options",
+      "trace"
+    ];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const pathParams = pathItem.parameters || [];
+      const opParams = operation.parameters || [];
+      operation.parameters = [...opParams, ...pathParams];
+      if (!operation.operationId) {
+        operation.operationId = `${method}_${path.replace(/[^a-zA-Z0-9]/g, "_")}`;
+      }
+      const parser = new import_operation_parser.OperationParser(operation, {
+        preservePropertyNames
+      });
+      let authSchemeName;
+      if (operation.security && operation.security.length > 0) {
+        authSchemeName = Object.keys(operation.security[0])[0];
+      }
+      authSchemeName = authSchemeName || globalSchemeName;
+      const authScheme = authSchemeName ? authSchemes[authSchemeName] : void 0;
+      operations.push({
+        name: parser.getFunctionName(),
+        description: parser.getDescription(),
+        endpoint: { baseUrl, path, method },
+        operation,
+        parameters: parser.getParameters(),
+        authScheme
+      });
+    }
+  }
+  return operations;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenApiSpecParser
+});