@paean-ai/adk 0.2.19 → 0.2.21

package/dist/cjs/tools/base_toolset.js

@@ -0,0 +1,76 @@
+/**
+  * @license
+  * Copyright 2025 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 base_toolset_exports = {};
+__export(base_toolset_exports, {
+  BaseToolset: () => BaseToolset
+});
+module.exports = __toCommonJS(base_toolset_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseToolset {
+  constructor(toolFilter) {
+    this.toolFilter = toolFilter;
+  }
+  /**
+   * Returns whether the tool should be exposed to LLM.
+   *
+   * @param tool The tool to check.
+   * @param context Context used to filter tools available to the agent.
+   * @return Whether the tool should be exposed to LLM.
+   */
+  isToolSelected(tool, context) {
+    if (!this.toolFilter) {
+      return true;
+    }
+    if (typeof this.toolFilter === "function") {
+      return this.toolFilter(tool, context);
+    }
+    if (Array.isArray(this.toolFilter)) {
+      return this.toolFilter.includes(tool.name);
+    }
+    return false;
+  }
+  /**
+   * Processes the outgoing LLM request for this toolset. This method will be
+   * called before each tool processes the llm request.
+   *
+   * Use cases:
+   * - Instead of let each tool process the llm request, we can let the toolset
+   *   process the llm request. e.g. ComputerUseToolset can add computer use
+   *   tool to the llm request.
+   *
+   * @param toolContext The context of the tool.
+   * @param llmRequest The outgoing LLM request, mutable this method.
+   */
+  async processLlmRequest(toolContext, llmRequest) {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseToolset
+});

package/dist/cjs/tools/forwarding_artifact_service.js

@@ -0,0 +1,71 @@
+/**
+  * @license
+  * Copyright 2025 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 forwarding_artifact_service_exports = {};
+__export(forwarding_artifact_service_exports, {
+  ForwardingArtifactService: () => ForwardingArtifactService
+});
+module.exports = __toCommonJS(forwarding_artifact_service_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ForwardingArtifactService {
+  constructor(toolContext) {
+    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(request) {
+    return this.toolContext.listArtifacts();
+  }
+  async deleteArtifact(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.deleteArtifact(
+      request
+    );
+  }
+  async listVersions(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.listVersions(
+      request
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ForwardingArtifactService
+});

package/dist/cjs/tools/function_tool.js

@@ -0,0 +1,101 @@
+/**
+  * @license
+  * Copyright 2025 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 function_tool_exports = {};
+__export(function_tool_exports, {
+  FunctionTool: () => FunctionTool
+});
+module.exports = __toCommonJS(function_tool_exports);
+var import_genai = require("@google/genai");
+var import_zod = require("zod");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function toSchema(parameters) {
+  if (parameters === void 0) {
+    return { type: import_genai.Type.OBJECT, properties: {} };
+  }
+  if ((0, import_simple_zod_to_json.isZodObject)(parameters)) {
+    return (0, import_simple_zod_to_json.zodObjectToSchema)(parameters);
+  }
+  return parameters;
+}
+class FunctionTool extends import_base_tool.BaseTool {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    var _a;
+    const name = (_a = options.name) != null ? _a : options.execute.name;
+    if (!name) {
+      throw new Error(
+        "Tool name cannot be empty. Either name the `execute` function or provide a `name`."
+      );
+    }
+    super({
+      name,
+      description: options.description,
+      isLongRunning: options.isLongRunning
+    });
+    this.execute = options.execute;
+    this.parameters = options.parameters;
+  }
+  /**
+   * Provide a schema for the function.
+   */
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: toSchema(this.parameters)
+    };
+  }
+  /**
+   * Logic for running the tool.
+   */
+  async runAsync(req) {
+    try {
+      let validatedArgs = req.args;
+      if (this.parameters instanceof import_zod.ZodObject) {
+        validatedArgs = this.parameters.parse(req.args);
+      }
+      return await this.execute(
+        validatedArgs,
+        req.toolContext
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Error in tool '${this.name}': ${errorMessage}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FunctionTool
+});

package/dist/cjs/tools/google_search_tool.js

@@ -0,0 +1,77 @@
+/**
+  * @license
+  * Copyright 2025 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 google_search_tool_exports = {};
+__export(google_search_tool_exports, {
+  GOOGLE_SEARCH: () => GOOGLE_SEARCH
+});
+module.exports = __toCommonJS(google_search_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class GoogleSearchTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "google_search", description: "Google Search Tool" });
+  }
+  runAsync(request) {
+    return Promise.resolve();
+  }
+  async processLlmRequest({ toolContext, llmRequest }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    llmRequest.toolsDict[this.name] = this;
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    if ((0, import_model_name.isGemini1Model)(llmRequest.model)) {
+      if (llmRequest.config.tools.length > 0) {
+        throw new Error(
+          "Google search tool can not be used with other tools in Gemini 1.x."
+        );
+      }
+      llmRequest.config.tools.push({
+        googleSearchRetrieval: {}
+      });
+      return;
+    }
+    if ((0, import_model_name.isGeminiModel)(llmRequest.model)) {
+      llmRequest.config.tools.push({
+        googleSearch: {}
+      });
+      return;
+    }
+    throw new Error(
+      `Google search tool is not supported for model ${llmRequest.model}`
+    );
+  }
+}
+const GOOGLE_SEARCH = new GoogleSearchTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GOOGLE_SEARCH
+});

package/dist/cjs/tools/long_running_tool.js

@@ -0,0 +1,63 @@
+/**
+  * @license
+  * Copyright 2025 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 long_running_tool_exports = {};
+__export(long_running_tool_exports, {
+  LongRunningFunctionTool: () => LongRunningFunctionTool
+});
+module.exports = __toCommonJS(long_running_tool_exports);
+var import_function_tool = require("./function_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const LONG_RUNNING_INSTRUCTION = `
+
+NOTE: This is a long-running operation. Do not call this tool again if it has already returned some intermediate or pending status.`;
+class LongRunningFunctionTool extends import_function_tool.FunctionTool {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    super({ ...options, isLongRunning: true });
+  }
+  /**
+   * Provide a schema for the function.
+   */
+  _getDeclaration() {
+    const declaration = super._getDeclaration();
+    if (declaration.description) {
+      declaration.description += LONG_RUNNING_INSTRUCTION;
+    } else {
+      declaration.description = LONG_RUNNING_INSTRUCTION.trimStart();
+    }
+    return declaration;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LongRunningFunctionTool
+});

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

@@ -0,0 +1,65 @@
+/**
+  * @license
+  * Copyright 2025 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 mcp_session_manager_exports = {};
+__export(mcp_session_manager_exports, {
+  MCPSessionManager: () => MCPSessionManager
+});
+module.exports = __toCommonJS(mcp_session_manager_exports);
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPSessionManager {
+  constructor(connectionParams) {
+    this.connectionParams = connectionParams;
+  }
+  async createSession() {
+    const client = new import_client.Client({ name: "MCPClient", version: "1.0.0" });
+    switch (this.connectionParams.type) {
+      case "StdioConnectionParams":
+        await client.connect(
+          new import_stdio.StdioClientTransport(this.connectionParams.serverParams)
+        );
+        break;
+      case "StreamableHTTPConnectionParams":
+        await client.connect(new import_streamableHttp.StreamableHTTPClientTransport(
+          new URL(this.connectionParams.url)
+        ));
+        break;
+      default:
+        const _exhaustiveCheck = this.connectionParams;
+        break;
+    }
+    return client;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPSessionManager
+});

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

@@ -0,0 +1,65 @@
+/**
+  * @license
+  * Copyright 2025 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 mcp_tool_exports = {};
+__export(mcp_tool_exports, {
+  MCPTool: () => MCPTool
+});
+module.exports = __toCommonJS(mcp_tool_exports);
+var import_gemini_schema_util = require("../../utils/gemini_schema_util.js");
+var import_base_tool = require("../base_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPTool extends import_base_tool.BaseTool {
+  constructor(mcpTool, mcpSessionManager) {
+    super({ name: mcpTool.name, description: mcpTool.description || "" });
+    this.mcpTool = mcpTool;
+    this.mcpSessionManager = mcpSessionManager;
+  }
+  _getDeclaration() {
+    let declaration;
+    declaration = {
+      name: this.mcpTool.name,
+      description: this.mcpTool.description,
+      parameters: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.inputSchema),
+      // TODO: need revisit, refer to this
+      // https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-result
+      response: (0, import_gemini_schema_util.toGeminiSchema)(this.mcpTool.outputSchema)
+    };
+    return declaration;
+  }
+  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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPTool
+});

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

@@ -0,0 +1,61 @@
+/**
+  * @license
+  * Copyright 2025 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 mcp_toolset_exports = {};
+__export(mcp_toolset_exports, {
+  MCPToolset: () => MCPToolset
+});
+module.exports = __toCommonJS(mcp_toolset_exports);
+var import_logger = require("../../utils/logger.js");
+var import_base_toolset = require("../base_toolset.js");
+var import_mcp_session_manager = require("./mcp_session_manager.js");
+var import_mcp_tool = require("./mcp_tool.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class MCPToolset extends import_base_toolset.BaseToolset {
+  constructor(connectionParams, toolFilter = []) {
+    super(toolFilter);
+    this.mcpSessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParams);
+  }
+  async getTools(context) {
+    const session = await this.mcpSessionManager.createSession();
+    const listResult = await session.listTools();
+    import_logger.logger.debug(`number of tools: ${listResult.tools.length}`);
+    for (const tool of listResult.tools) {
+      import_logger.logger.debug(`tool: ${tool.name}`);
+    }
+    return listResult.tools.map(
+      (tool) => new import_mcp_tool.MCPTool(tool, this.mcpSessionManager)
+    );
+  }
+  async close() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPToolset
+});

package/dist/cjs/tools/tool_confirmation.js

@@ -0,0 +1,49 @@
+/**
+  * @license
+  * Copyright 2025 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 tool_confirmation_exports = {};
+__export(tool_confirmation_exports, {
+  ToolConfirmation: () => ToolConfirmation
+});
+module.exports = __toCommonJS(tool_confirmation_exports);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ToolConfirmation {
+  constructor({
+    hint,
+    confirmed,
+    payload
+  }) {
+    this.hint = hint != null ? hint : "";
+    this.confirmed = confirmed;
+    this.payload = payload;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolConfirmation
+});