@google/adk 1.1.0 → 1.3.0

package/dist/esm/tools/openapi_tool/openapi_spec_parser/operation_parser.js

@@ -0,0 +1,198 @@
+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";
+let OperationParser = class {
+  constructor(operation, options = {}) {
+    this.operation = operation;
+    this.params = [];
+    var _a;
+    this.preservePropertyNames = (_a = options.preservePropertyNames) != null ? _a : false;
+    this.processOperationParameters();
+    this.processRequestBody();
+    this.processReturnValue();
+    this.dedupeParamNames();
+  }
+  getParamName(originalName) {
+    if (this.preservePropertyNames) {
+      return originalName;
+    }
+    return originalName.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()).replace(/^_/, "");
+  }
+  processOperationParameters() {
+    const parameters = this.operation.parameters || [];
+    for (const param of parameters) {
+      if ("name" in param) {
+        const originalName = param.name;
+        const description = param.description || "";
+        const location = param.in || "";
+        const schema = param.schema || {};
+        this.params.push({
+          originalName,
+          paramLocation: location,
+          paramSchema: schema,
+          description,
+          required: param.required || false,
+          name: this.getParamName(originalName)
+        });
+      }
+    }
+  }
+  processRequestBody() {
+    const requestBody = this.operation.requestBody;
+    if (!requestBody || "$ref" in requestBody) {
+      return;
+    }
+    const content = requestBody.content || {};
+    const firstMimeType = Object.keys(content)[0];
+    if (!firstMimeType) {
+      return;
+    }
+    const mediaTypeObject = content[firstMimeType];
+    const schema = mediaTypeObject.schema;
+    const description = requestBody.description || "";
+    if (schema && !("$ref" in schema)) {
+      if (schema.type === "object") {
+        const properties = schema.properties || {};
+        if (Object.keys(properties).length > 0) {
+          for (const [propName, propDetails] of Object.entries(properties)) {
+            if (!("$ref" in propDetails)) {
+              this.params.push({
+                originalName: propName,
+                paramLocation: "body",
+                paramSchema: propDetails,
+                description: propDetails.description,
+                required: (schema.required || []).includes(propName),
+                name: this.getParamName(propName)
+              });
+            }
+          }
+        } else {
+          this.params.push({
+            originalName: "",
+            paramLocation: "body",
+            paramSchema: schema,
+            description,
+            required: true,
+            name: "body"
+          });
+        }
+      } else if (schema.type === "array") {
+        this.params.push({
+          originalName: "array",
+          paramLocation: "body",
+          paramSchema: schema,
+          description,
+          required: true,
+          name: "body"
+        });
+      } else {
+        this.params.push({
+          originalName: "body",
+          paramLocation: "body",
+          paramSchema: schema,
+          description,
+          required: true,
+          name: "body"
+        });
+      }
+    }
+  }
+  processReturnValue() {
+    const responses = this.operation.responses || {};
+    const validCodes = Object.keys(responses).filter((k) => k.startsWith("2"));
+    const min20x = validCodes.sort()[0];
+    let returnSchema = {};
+    if (min20x) {
+      const response = responses[min20x];
+      if (!("$ref" in response) && response.content) {
+        const firstMimeType = Object.keys(response.content)[0];
+        if (firstMimeType) {
+          const schema = response.content[firstMimeType].schema;
+          if (schema && !("$ref" in schema)) {
+            returnSchema = schema;
+          }
+        }
+      }
+    }
+    this.returnValue = {
+      originalName: "",
+      paramLocation: "",
+      paramSchema: returnSchema,
+      required: true,
+      name: "return"
+    };
+  }
+  dedupeParamNames() {
+    const nameCounts = /* @__PURE__ */ new Map();
+    for (const param of this.params) {
+      const name = param.name;
+      const count = nameCounts.get(name) || 0;
+      if (count > 0) {
+        param.name = `${name}_${count}`;
+      }
+      nameCounts.set(name, count + 1);
+    }
+  }
+  getParameters() {
+    return this.params;
+  }
+  getJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const param of this.params) {
+      properties[param.name] = param.paramSchema;
+      if (param.required) {
+        required.push(param.name);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0,
+      title: `${this.operation.operationId || "unnamed"}_Arguments`
+    };
+  }
+  getFunctionName() {
+    const operationId = this.operation.operationId;
+    if (!operationId) {
+      throw new Error("Operation ID is missing");
+    }
+    return this.getParamName(operationId).substring(0, 60);
+  }
+  getDescription() {
+    return this.operation.description || this.operation.summary || "";
+  }
+};
+__decorateClass([
+  experimental
+], OperationParser.prototype, "getParameters", 1);
+__decorateClass([
+  experimental
+], OperationParser.prototype, "getJsonSchema", 1);
+__decorateClass([
+  experimental
+], OperationParser.prototype, "getFunctionName", 1);
+__decorateClass([
+  experimental
+], OperationParser.prototype, "getDescription", 1);
+OperationParser = __decorateClass([
+  experimental
+], OperationParser);
+export {
+  OperationParser
+};

package/dist/esm/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.js

@@ -0,0 +1,101 @@
+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 { AutoAuthCredentialExchanger } from "../auth/credential_exchangers/auto_auth_credential_exchanger.js";
+class ToolContextCredentialStore {
+  constructor(context) {
+    this.context = context;
+  }
+  getCredentialKey(authScheme) {
+    const schemeName = (authScheme == null ? void 0 : authScheme.type) || "default";
+    return `${schemeName}_existing_exchanged_credential`;
+  }
+  getCredential(authScheme) {
+    const key = this.getCredentialKey(authScheme);
+    const state = this.context.state;
+    if (state) {
+      const serialized = state[key];
+      if (serialized) {
+        return serialized;
+      }
+    }
+    return void 0;
+  }
+  storeCredential(key, credential) {
+    const state = this.context.state;
+    if (state) {
+      state[key] = credential;
+    }
+  }
+}
+let ToolAuthHandler = class {
+  constructor(context, authScheme, authCredential, credentialKey) {
+    this.context = context;
+    this.authScheme = authScheme;
+    this.authCredential = authCredential;
+    this.credentialKey = credentialKey;
+  }
+  static fromToolContext(context, authScheme, authCredential, options = {}) {
+    return new ToolAuthHandler(
+      context,
+      authScheme,
+      authCredential,
+      options.credentialKey
+    );
+  }
+  async prepareAuthCredentials() {
+    if (!this.authScheme) {
+      return { state: "done" };
+    }
+    const store = new ToolContextCredentialStore(this.context);
+    const existingCredential = store.getCredential(this.authScheme);
+    if (existingCredential) {
+      return { state: "done", authCredential: existingCredential };
+    }
+    const authConfig = {
+      authScheme: this.authScheme,
+      rawAuthCredential: this.authCredential,
+      credentialKey: this.credentialKey || "default_openapi_key"
+    };
+    const credential = this.context.getAuthResponse(authConfig);
+    if (credential) {
+      const exchanger = new AutoAuthCredentialExchanger();
+      const result = await exchanger.exchange({
+        authScheme: this.authScheme,
+        authCredential: credential
+      });
+      const key = store.getCredentialKey(this.authScheme);
+      store.storeCredential(key, result.credential);
+      return { state: "done", authCredential: result.credential };
+    }
+    this.context.requestCredential(authConfig);
+    return { state: "pending" };
+  }
+};
+__decorateClass([
+  experimental
+], ToolAuthHandler.prototype, "prepareAuthCredentials", 1);
+__decorateClass([
+  experimental
+], ToolAuthHandler, "fromToolContext", 1);
+ToolAuthHandler = __decorateClass([
+  experimental
+], ToolAuthHandler);
+export {
+  ToolAuthHandler
+};

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

@@ -0,0 +1,97 @@
+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 yaml from "js-yaml";
+import { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenApiSpecParser } from "./openapi_spec_parser/openapi_spec_parser.js";
+import { createRestApiTool } from "./rest_api_tool.js";
+let OpenAPIToolset = class extends BaseToolset {
+  constructor(options = {}) {
+    super(options.toolFilter || [], options.prefix);
+    this.tools = [];
+    let spec = options.specDict;
+    if (!spec && options.specStr) {
+      if (options.specType === "yaml" || !options.specType && options.specStr.trim().startsWith("---")) {
+        spec = yaml.load(options.specStr);
+      } else {
+        spec = JSON.parse(options.specStr);
+      }
+    }
+    if (!spec) {
+      throw new Error("Either specDict or specStr must be provided.");
+    }
+    const parser = new OpenApiSpecParser({
+      preservePropertyNames: options.preservePropertyNames
+    });
+    const parsedOperations = parser.parse(spec);
+    for (const op of parsedOperations) {
+      let toolName = op.name;
+      if (this.prefix) {
+        toolName = `${this.prefix}_${toolName}`;
+      }
+      const tool = createRestApiTool(
+        {
+          name: toolName,
+          description: op.description,
+          endpoint: op.endpoint,
+          operation: op.operation,
+          authScheme: op.authScheme
+        },
+        {
+          preservePropertyNames: options.preservePropertyNames,
+          headerProvider: options.headerProvider,
+          credentialKey: options.credentialKey
+        }
+      );
+      this.tools.push(tool);
+    }
+    if (options.authScheme || options.authCredential) {
+      for (const tool of this.tools) {
+        if (options.authScheme) tool.configureAuthScheme(options.authScheme);
+        if (options.authCredential)
+          tool.configureAuthCredential(options.authCredential);
+      }
+    }
+  }
+  async getTools(context) {
+    return this.tools.filter((tool) => {
+      if (Array.isArray(this.toolFilter) && this.toolFilter.length > 0) {
+        return this.toolFilter.includes(tool.name);
+      }
+      if (context) {
+        return this.isToolSelected(tool, context);
+      }
+      return true;
+    });
+  }
+  async close() {
+    return Promise.resolve();
+  }
+};
+__decorateClass([
+  experimental
+], OpenAPIToolset.prototype, "getTools", 1);
+__decorateClass([
+  experimental
+], OpenAPIToolset.prototype, "close", 1);
+OpenAPIToolset = __decorateClass([
+  experimental
+], OpenAPIToolset);
+export {
+  OpenAPIToolset
+};

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

@@ -18,34 +18,11 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { Type } from "@google/genai";
 import path from "node:path";
 import { experimental } from "../../utils/experimental.js";
+import { guessMimeType } from "../../utils/file_utils.js";
 import {
   BaseTool
 } from "../base_tool.js";
 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 BaseTool {
   constructor(toolset) {
     super({
@@ -74,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"];
@@ -91,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.`,
@@ -154,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;