@google/adk 1.6.0 → 2.1.0

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

@@ -1,97 +0,0 @@
-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 = "".concat(this.prefix, "_").concat(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/web/tools/openapi_tool/rest_api_tool.js

@@ -1,229 +0,0 @@
-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: ".concat(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 = "".concat(endpoint.baseUrl).concat(endpoint.path);
-  for (const [key, value] of Object.entries(pathParams)) {
-    url = url.replace("{".concat(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 += "?".concat(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/web/tools/preload_memory_tool.js

@@ -1,77 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { appendInstructions } from "../models/llm_request.js";
-import { logger } from "../utils/logger.js";
-import {
-  BaseTool
-} from "./base_tool.js";
-class PreloadMemoryTool extends 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 (_) {
-      logger.warn("Failed to preload memory for query: ".concat(userQuery));
-      return;
-    }
-    if (!response.memories || response.memories.length === 0) {
-      return;
-    }
-    const memoryTextLines = [];
-    for (const memory of response.memories) {
-      const timeStr = memory.timestamp ? "Time: ".concat(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 ? "".concat(memory.author, ": ").concat(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.\nThey may be useful for answering the user's current query.\n<PAST_CONVERSATIONS>\n".concat(fullMemoryText, "\n</PAST_CONVERSATIONS>\n");
-    appendInstructions(request.llmRequest, [si]);
-  }
-}
-const PRELOAD_MEMORY = new PreloadMemoryTool();
-export {
-  PRELOAD_MEMORY,
-  PreloadMemoryTool
-};

package/dist/web/tools/request_input_tool.js

@@ -1,26 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { z } from "zod";
-import { LongRunningFunctionTool } from "./long_running_tool.js";
-const requestInputTool = new LongRunningFunctionTool({
-  name: "adk_request_input",
-  description: "Presents a custom message to the user and awaits unstructured or structured input.",
-  parameters: z.object({
-    message: z.string().describe("The prompt for the user."),
-    responseSchema: z.record(z.string(), z.unknown()).optional().describe("Expected schema of the response.")
-  }),
-  execute: async (input, context) => {
-    if (context) {
-      context.actions.skipSummarization = true;
-    }
-    return null;
-  }
-});
-export {
-  requestInputTool
-};

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

@@ -1,50 +0,0 @@
-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 { formatSkillsAsXml } from "../../skills/prompt.js";
-import { experimental } from "../../utils/experimental.js";
-import { BaseTool } from "../base_tool.js";
-let ListSkillsTool = class extends 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: Type.OBJECT,
-        properties: {}
-      }
-    };
-  }
-  async runAsync(_request) {
-    const skills = Object.values(this.toolset.skills);
-    return formatSkillsAsXml(skills);
-  }
-};
-ListSkillsTool = __decorateClass([
-  experimental
-], ListSkillsTool);
-export {
-  ListSkillsTool
-};

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

@@ -1,190 +0,0 @@
-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 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.";
-let LoadSkillResourceTool = class extends 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: Type.OBJECT,
-        properties: {
-          skill_name: {
-            type: Type.STRING,
-            description: "The name of the skill."
-          },
-          path: {
-            type: 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,
-    toolContext
-  }) {
-    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 = path.posix.normalize(resourcePath);
-    let skill;
-    try {
-      skill = await this.toolset.getOrFetchSkill(
-        skillName,
-        toolContext.invocationId
-      );
-    } catch (e) {
-      return {
-        error: "Failed to fetch skill '".concat(skillName, "' from registry: ").concat(e.message || e),
-        error_code: "REGISTRY_ERROR"
-      };
-    }
-    if (!skill) {
-      return {
-        error: "Skill '".concat(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 '".concat(resourcePath, "' not found in skill '").concat(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"];
-          let skill;
-          try {
-            skill = await this.toolset.getOrFetchSkill(
-              skillName,
-              request.toolContext.invocationId
-            );
-          } catch (_e) {
-            continue;
-          }
-          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 '".concat(resourcePath, "' is:") },
-                {
-                  inlineData: {
-                    data: content.toString("base64"),
-                    mimeType
-                  }
-                }
-              ]
-            });
-          }
-        }
-      }
-    }
-  }
-};
-LoadSkillResourceTool = __decorateClass([
-  experimental
-], LoadSkillResourceTool);
-export {
-  LoadSkillResourceTool
-};