@google/adk 1.2.0 → 1.3.0

package/dist/esm/tools/openapi_tool/rest_api_tool.js

@@ -0,0 +1,229 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { experimental } from "../../utils/experimental.js";
+import { BaseTool } from "../base_tool.js";
+import { applyCredential } from "./auth/auth_helpers.js";
+import {
+  OperationParser
+} from "./openapi_spec_parser/operation_parser.js";
+import { ToolAuthHandler } from "./openapi_spec_parser/tool_auth_handler.js";
+let RestApiTool = class extends BaseTool {
+  constructor(name, description, endpoint, operation, authScheme, authCredential, options = {}) {
+    super({ name, description });
+    this.endpoint = endpoint;
+    this.operation = operation;
+    this.authScheme = authScheme;
+    this.authCredential = authCredential;
+    this.authScheme = authScheme;
+    this.authCredential = authCredential;
+    this.headerProvider = options.headerProvider;
+    this.credentialKey = options.credentialKey;
+    this.operationParser = new OperationParser(operation, options);
+  }
+  configureAuthScheme(authScheme) {
+    this.authScheme = authScheme;
+  }
+  configureAuthCredential(authCredential) {
+    this.authCredential = authCredential;
+  }
+  configureCredentialKey(credentialKey) {
+    this.credentialKey = credentialKey;
+  }
+  _getDeclaration() {
+    const schema = this.operationParser.getJsonSchema();
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: schema
+    };
+  }
+  async runAsync(request) {
+    const context = request.toolContext;
+    const args = request.args;
+    const authHandler = ToolAuthHandler.fromToolContext(
+      context,
+      this.authScheme,
+      this.authCredential,
+      { credentialKey: this.credentialKey }
+    );
+    const authResult = await authHandler.prepareAuthCredentials();
+    if (authResult.state === "pending") {
+      return {
+        pending: true,
+        message: "Needs your authorization to access your data."
+      };
+    }
+    const credential = authResult.authCredential;
+    const method = this.endpoint.method.toUpperCase();
+    const {
+      url: initialUrl,
+      headers,
+      body: parsedBody,
+      bodyData
+    } = prepareRequestParams(
+      this.endpoint,
+      this.operationParser.getParameters(),
+      args
+    );
+    const body = prepareRequestBody(
+      this.operation.requestBody,
+      parsedBody,
+      bodyData,
+      headers
+    );
+    const url = applyCredential(
+      initialUrl,
+      headers,
+      credential,
+      this.authScheme
+    );
+    if (this.headerProvider) {
+      const providerHeaders = this.headerProvider(context);
+      Object.assign(headers, providerHeaders);
+    }
+    try {
+      const response = await globalThis.fetch(url, {
+        method,
+        headers,
+        // eslint-disable-next-line no-undef
+        body
+      });
+      const contentType = response.headers.get("content-type");
+      if (contentType && contentType.includes("application/json")) {
+        return await response.json();
+      } else {
+        return await response.text();
+      }
+    } catch (error) {
+      return {
+        error: `Failed to execute API call: ${error.message}`
+      };
+    }
+  }
+};
+__decorateClass([
+  experimental
+], RestApiTool.prototype, "configureAuthScheme", 1);
+__decorateClass([
+  experimental
+], RestApiTool.prototype, "configureAuthCredential", 1);
+__decorateClass([
+  experimental
+], RestApiTool.prototype, "configureCredentialKey", 1);
+__decorateClass([
+  experimental
+], RestApiTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  experimental
+], RestApiTool.prototype, "runAsync", 1);
+RestApiTool = __decorateClass([
+  experimental
+], RestApiTool);
+function prepareRequestParams(endpoint, parameters, args) {
+  const headers = {};
+  const queryParams = new URLSearchParams();
+  let body = void 0;
+  const paramsMap = new Map(parameters.map((p) => [p.name, p]));
+  const pathParams = {};
+  const bodyData = {};
+  for (const [argName, argValue] of Object.entries(args)) {
+    const param = paramsMap.get(argName);
+    if (!param) continue;
+    const originalName = param.originalName;
+    const location = param.paramLocation;
+    if (location === "path") {
+      pathParams[originalName] = String(argValue);
+    } else if (location === "query") {
+      queryParams.append(originalName, String(argValue));
+    } else if (location === "header") {
+      headers[originalName] = String(argValue);
+    } else if (location === "body") {
+      if (originalName === "body" || originalName === "array" || originalName === "") {
+        body = argValue;
+      } else {
+        bodyData[originalName] = argValue;
+      }
+    }
+  }
+  let url = `${endpoint.baseUrl}${endpoint.path}`;
+  for (const [key, value] of Object.entries(pathParams)) {
+    url = url.replace(`{${key}}`, value);
+  }
+  const urlParts = url.split("?");
+  if (urlParts.length > 1) {
+    const pathQueryParams = new URLSearchParams(urlParts[1]);
+    for (const [key, value] of pathQueryParams.entries()) {
+      queryParams.append(key, value);
+    }
+    url = urlParts[0];
+  }
+  const queryString = queryParams.toString();
+  if (queryString) {
+    url += `?${queryString}`;
+  }
+  return { url, headers, body, bodyData };
+}
+function prepareRequestBody(requestBody, body, bodyData, headers) {
+  const finalData = body !== void 0 ? body : Object.keys(bodyData).length > 0 ? bodyData : void 0;
+  if (requestBody && "content" in requestBody) {
+    const content = requestBody.content;
+    for (const [mimeType, _mediaTypeObject] of Object.entries(content)) {
+      if (finalData !== void 0) {
+        if (mimeType === "application/json" || mimeType.endsWith("+json")) {
+          headers["Content-Type"] = mimeType;
+          return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
+        } else if (mimeType === "application/x-www-form-urlencoded") {
+          return new URLSearchParams(finalData);
+        } else if (mimeType === "multipart/form-data") {
+          const formData = new FormData();
+          if (typeof finalData === "object" && finalData !== null) {
+            for (const [key, value] of Object.entries(finalData)) {
+              formData.append(key, String(value));
+            }
+          }
+          return formData;
+        } else if (mimeType === "text/plain") {
+          headers["Content-Type"] = mimeType;
+          return String(finalData);
+        }
+      }
+      break;
+    }
+  } else if (finalData !== void 0) {
+    headers["Content-Type"] = "application/json";
+    return typeof finalData === "string" ? finalData : JSON.stringify(finalData);
+  }
+  return void 0;
+}
+function createRestApiTool(parsed, options = {}) {
+  return new RestApiTool(
+    parsed.name,
+    parsed.description,
+    parsed.endpoint,
+    parsed.operation,
+    parsed.authScheme,
+    void 0,
+    options
+  );
+}
+export {
+  RestApiTool,
+  createRestApiTool,
+  prepareRequestBody,
+  prepareRequestParams
+};

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

@@ -51,7 +51,10 @@ let LoadSkillResourceTool = class extends BaseTool {
       }
     };
   }
-  async runAsync({ args }) {
+  async runAsync({
+    args,
+    toolContext
+  }) {
     var _a, _b, _c;
     const skillName = args["skill_name"];
     let resourcePath = args["path"];
@@ -68,7 +71,18 @@ let LoadSkillResourceTool = class extends BaseTool {
       };
     }
     resourcePath = path.posix.normalize(resourcePath);
-    const skill = this.toolset.getSkill(skillName);
+    let skill;
+    try {
+      skill = await this.toolset.getOrFetchSkill(
+        skillName,
+        toolContext.invocationId
+      );
+    } catch (e) {
+      return {
+        error: `Failed to fetch skill '${skillName}' from registry: ${e.message || e}`,
+        error_code: "REGISTRY_ERROR"
+      };
+    }
     if (!skill) {
       return {
         error: `Skill '${skillName}' not found.`,
@@ -131,7 +145,15 @@ let LoadSkillResourceTool = class extends BaseTool {
         if (response["status"] === BINARY_FILE_DETECTED_MSG) {
           const skillName = response["skill_name"];
           const resourcePath = response["path"];
-          const skill = this.toolset.getSkill(skillName);
+          let skill;
+          try {
+            skill = await this.toolset.getOrFetchSkill(
+              skillName,
+              request.toolContext.invocationId
+            );
+          } catch (_e) {
+            continue;
+          }
           if (!skill) continue;
           const skillResources = skill.resources || {};
           let content;

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

@@ -53,7 +53,18 @@ let LoadSkillTool = class extends BaseTool {
         error_code: "MISSING_SKILL_NAME"
       };
     }
-    const skill = this.toolset.getSkill(skillName);
+    let skill;
+    try {
+      skill = await this.toolset.getOrFetchSkill(
+        skillName,
+        toolContext.invocationId
+      );
+    } catch (e) {
+      return {
+        error: `Failed to fetch skill '${skillName}' from registry: ${e.message || e}`,
+        error_code: "REGISTRY_ERROR"
+      };
+    }
     if (!skill) {
       return {
         error: `Skill '${skillName}' not found.`,

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

@@ -80,7 +80,18 @@ let RunSkillScriptTool = class extends BaseTool {
         errorCode: "MISSING_SCRIPT_PATH"
       };
     }
-    const skill = this.toolset.getSkill(skillName);
+    let skill;
+    try {
+      skill = await this.toolset.getOrFetchSkill(
+        skillName,
+        toolContext.invocationId
+      );
+    } catch (e) {
+      return {
+        error: `Failed to fetch skill '${skillName}' from registry: ${e.message || e}`,
+        errorCode: "REGISTRY_ERROR"
+      };
+    }
     if (!skill) {
       return {
         error: `Skill '${skillName}' not found.`,

package/dist/esm/tools/skill/search_skills_tool.js

@@ -0,0 +1,82 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+let SearchSkillsTool = class extends BaseTool {
+  constructor(toolset) {
+    var _a, _b;
+    if (!toolset.registry) {
+      throw new Error("SearchSkillsTool requires a configured skill registry.");
+    }
+    super({
+      name: "search_skills",
+      description: ((_b = (_a = toolset.registry).searchToolDescription) == null ? void 0 : _b.call(_a)) || "Searches for relevant skills in the registry based on a semantic or keyword query."
+    });
+    this.toolset = toolset;
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "Semantic or keyword search query."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const query = args["query"];
+    if (!query) {
+      return {
+        error: "Argument 'query' is required.",
+        error_code: "INVALID_ARGUMENTS"
+      };
+    }
+    try {
+      const results = await this.toolset.registry.searchSkills(query);
+      return results.filter((r) => {
+        if (this.toolset.skills[r.name]) {
+          logger.warn(
+            `Skill naming conflict: skill '${r.name}' already exists locally. Registry skill is filtered.`
+          );
+          return false;
+        }
+        return true;
+      });
+    } catch (e) {
+      return {
+        error: `Failed to search skills from registry: ${e.message || e}`,
+        error_code: "REGISTRY_ERROR"
+      };
+    }
+  }
+};
+SearchSkillsTool = __decorateClass([
+  experimental
+], SearchSkillsTool);
+export {
+  SearchSkillsTool
+};

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

@@ -18,6 +18,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { appendInstructions } from "../../models/llm_request.js";
 import { formatSkillsAsXml } from "../../skills/prompt.js";
 import { experimental } from "../../utils/experimental.js";
+import { logger } from "../../utils/logger.js";
 import { BaseTool } from "../base_tool.js";
 import { BaseToolset } from "../base_toolset.js";
 import { ListSkillsTool } from "./list_skills_tool.js";
@@ -25,6 +26,7 @@ import { LoadSkillResourceTool } from "./load_skill_resource_tool.js";
 import { LoadSkillTool } from "./load_skill_tool.js";
 import { RunSkillInlineScriptTool } from "./run_skill_inline_script_tool.js";
 import { RunSkillScriptTool } from "./run_skill_script_tool.js";
+import { SearchSkillsTool } from "./search_skills_tool.js";
 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:
@@ -44,9 +46,11 @@ let SkillToolset = class extends BaseToolset {
   constructor(skills, options = {}) {
     super([], "adk_skill_toolset");
     this.toolCache = /* @__PURE__ */ new Map();
+    this.fetchedSkillCache = /* @__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.registry = options.registry;
     this.tools = [
       new ListSkillsTool(this),
       new LoadSkillTool(this),
@@ -54,24 +58,55 @@ let SkillToolset = class extends BaseToolset {
       new RunSkillScriptTool(this),
       new RunSkillInlineScriptTool(this)
     ];
+    if (this.registry) {
+      this.tools.push(new SearchSkillsTool(this));
+    }
   }
   async getTools(context) {
     const dynamicTools = await this.resolveAdditionalTools(context);
     return [...this.tools, ...dynamicTools];
   }
   async close() {
+    this.fetchedSkillCache.clear();
   }
   getSkill(name) {
     return this.skills[name];
   }
+  async getOrFetchSkill(name, invocationId) {
+    if (this.skills[name]) {
+      return this.skills[name];
+    }
+    if (!this.registry) {
+      return void 0;
+    }
+    const contextKey = invocationId || "default";
+    if (!this.fetchedSkillCache.has(contextKey)) {
+      this.fetchedSkillCache.set(contextKey, /* @__PURE__ */ new Map());
+    }
+    const cache = this.fetchedSkillCache.get(contextKey);
+    if (cache.has(name)) {
+      return cache.get(name);
+    }
+    try {
+      const skill = await this.registry.getSkill(name);
+      cache.set(name, skill);
+      return skill;
+    } catch (e) {
+      logger.warn(`Failed to fetch skill '${name}' from registry: ${e}`);
+      throw e;
+    }
+  }
   async processLlmRequest(toolContext, llmRequest) {
     await super.processLlmRequest(toolContext, llmRequest);
     const skills = Object.values(this.skills);
     const skillsXml = formatSkillsAsXml(skills);
-    appendInstructions(llmRequest, [
-      DEFAULT_SKILL_SYSTEM_INSTRUCTION,
-      skillsXml
-    ]);
+    const instructions = [DEFAULT_SKILL_SYSTEM_INSTRUCTION, skillsXml];
+    if (this.registry) {
+      instructions.push(
+        "\nIf the locally available skills are not sufficient to complete your task, you can use the `search_skills` tool to discover additional skills from the registry."
+      );
+    }
+    appendInstructions(llmRequest, instructions);
   }
   async resolveAdditionalTools(context) {
     if (!context) return [];
@@ -85,7 +120,7 @@ let SkillToolset = class extends BaseToolset {
     }
     const additionalToolNames = /* @__PURE__ */ new Set();
     for (const skillName of activatedSkills) {
-      const skill = this.skills[skillName];
+      const skill = await this.getOrFetchSkill(skillName, context.invocationId);
       if (skill && skill.frontmatter.metadata) {
         const tools = skill.frontmatter.metadata["adk_additional_tools"];
         if (tools) {

package/dist/esm/utils/async_queue.js

@@ -0,0 +1,60 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AsyncQueue {
+  constructor() {
+    this.queue = [];
+    this.resolvers = [];
+    this.closed = false;
+  }
+  push(value) {
+    if (this.closed) return;
+    if (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value, done: false });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  error(err) {
+    this.errorVal = err;
+    while (this.resolvers.length > 0) {
+      const { reject } = this.resolvers.shift();
+      reject(err);
+    }
+  }
+  close() {
+    this.closed = true;
+    while (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.errorVal) {
+          const err = this.errorVal;
+          this.errorVal = void 0;
+          return Promise.reject(err);
+        }
+        if (this.queue.length > 0) {
+          return Promise.resolve({ value: this.queue.shift(), done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          this.resolvers.push({ resolve, reject });
+        });
+      }
+    };
+  }
+}
+export {
+  AsyncQueue
+};

package/dist/esm/utils/case_utils.js

@@ -0,0 +1,25 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function camelCaseKeys(val) {
+  if (Array.isArray(val)) {
+    return val.map(camelCaseKeys);
+  }
+  if (val !== null && typeof val === "object" && val.constructor === Object) {
+    const obj = val;
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+      const camelKey = key.replace(/_([a-z])/g, (_, g) => g.toUpperCase());
+      newObj[camelKey] = camelCaseKeys(obj[key]);
+    }
+    return newObj;
+  }
+  return val;
+}
+export {
+  camelCaseKeys
+};

package/dist/esm/utils/env_aware_utils.js

@@ -10,6 +10,10 @@ function isBrowser() {
 }
 const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
 function randomUUID() {
+  var _a;
+  if ((_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
   let uuid = "";
   for (let i = 0; i < UUID_MASK.length; i++) {
     const randomValue = Math.random() * 16 | 0;