@google/adk 2.3.0 → 2.4.0

package/dist/esm/tools/application_integration_tool/clients/integration_client.js

@@ -50,7 +50,7 @@ let IntegrationClient = class {
     this.project = options.project;
     this.location = options.location;
     this.integration = options.integration;
-    this.trigger = options.trigger;
+    this.triggers = options.triggers;
     this.connection = options.connection;
     this.entityOperations = (_a = options.entityOperations) != null ? _a : {};
     this.actions = (_b = options.actions) != null ? _b : [];
@@ -65,7 +65,10 @@ let IntegrationClient = class {
    *   that carries no parseable spec.
    */
   async getOpenApiSpecForIntegration() {
+    var _a;
     const url = `https://${this.location}-integrations.googleapis.com/v1/projects/${this.project}/locations/${this.location}:generateOpenApiSpec`;
+    const triggerId = (_a = this.triggers) != null ? _a : null;
+    const invalidRequestMessage = `Invalid request. Please check the provided values of project(${this.project}), location(${this.location}), integration(${this.integration}).`;
     const body = await sendCloudRequest({
       url,
       method: "POST",
@@ -73,13 +76,13 @@ let IntegrationClient = class {
         apiTriggerResources: [
           {
             integrationResource: this.integration,
-            triggerId: [this.trigger]
+            triggerId
           }
         ],
         fileFormat: "JSON"
       },
       tokenSource: this.tokenSource,
-      invalidRequestMessage: `Invalid request. Please check the provided values of project(${this.project}), location(${this.location}), integration(${this.integration}) and trigger(${this.trigger}).`
+      invalidRequestMessage
     });
     try {
       const spec = isJsonObject(body) ? body["openApiSpec"] : void 0;
@@ -185,20 +188,21 @@ let IntegrationClient = class {
     }
     for (const action of this.actions) {
       const { inputSchema, outputSchema, displayName } = await connectionsClient.getActionSchema(action);
+      const actionDisplayName = displayName.replace(/ /g, "");
       let operation = "EXECUTE_ACTION";
       if (action === EXECUTE_CUSTOM_QUERY_ACTION) {
-        schemas[`${action}_Request`] = executeCustomQueryRequest();
+        schemas[`${actionDisplayName}_Request`] = executeCustomQueryRequest();
         operation = "EXECUTE_QUERY";
       } else {
-        schemas[`${displayName}_Request`] = actionRequest(displayName);
-        schemas[`connectorInputPayload_${displayName}`] = connectorPayload(inputSchema);
+        schemas[`${actionDisplayName}_Request`] = actionRequest(actionDisplayName);
+        schemas[`connectorInputPayload_${actionDisplayName}`] = connectorPayload(inputSchema);
       }
-      schemas[`connectorOutputPayload_${displayName}`] = connectorPayload(outputSchema);
-      schemas[`${displayName}_Response`] = actionResponse(displayName);
+      schemas[`connectorOutputPayload_${actionDisplayName}`] = connectorPayload(outputSchema);
+      schemas[`${actionDisplayName}_Response`] = actionResponse(actionDisplayName);
       connectorSpec.paths[`${pathPrefix}#${action}`] = getActionOperation({
         action,
         operation,
-        actionDisplayName: displayName,
+        actionDisplayName,
         toolName,
         toolInstructions
       });

package/dist/esm/tools/application_integration_tool/integration_connector_tool.js

@@ -0,0 +1,158 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 { logger } from "../../utils/logger.js";
+import { BaseTool } from "../base_tool.js";
+import { ToolAuthHandler } from "../openapi_tool/openapi_spec_parser/tool_auth_handler.js";
+const DYNAMIC_AUTH_EXCLUDE_FIELDS = Object.freeze([
+  "dynamic_auth_config",
+  "dynamicAuthConfig"
+]);
+let IntegrationConnectorTool = class extends BaseTool {
+  constructor(options) {
+    var _a, _b, _c;
+    super(options);
+    this.connectionName = options.connectionName;
+    this.connectionHost = options.connectionHost;
+    this.connectionServiceName = options.connectionServiceName;
+    this.entity = (_a = options.entity) != null ? _a : "";
+    this.operation = (_b = options.operation) != null ? _b : "";
+    this.action = (_c = options.action) != null ? _c : "";
+    this.restApiTool = options.restApiTool;
+    this.authScheme = options.authScheme;
+    this.authCredential = options.authCredential;
+  }
+  _getDeclaration() {
+    const declaration = this.restApiTool._getDeclaration();
+    const rawParameters = declaration == null ? void 0 : declaration.parameters;
+    let parameters;
+    if (rawParameters) {
+      parameters = { ...rawParameters };
+      if (rawParameters.properties) {
+        const properties = { ...rawParameters.properties };
+        for (const field of [
+          ...IntegrationConnectorTool.EXCLUDE_FIELDS,
+          ...DYNAMIC_AUTH_EXCLUDE_FIELDS
+        ]) {
+          delete properties[field];
+        }
+        parameters.properties = properties;
+      }
+      if (rawParameters.required) {
+        parameters.required = rawParameters.required.filter(
+          (field) => !IntegrationConnectorTool.EXCLUDE_FIELDS.includes(field) && !DYNAMIC_AUTH_EXCLUDE_FIELDS.includes(field) && !IntegrationConnectorTool.OPTIONAL_FIELDS.includes(field)
+        );
+      }
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      parameters
+    };
+  }
+  async runAsync(request) {
+    const toolAuthHandler = ToolAuthHandler.fromToolContext(
+      request.toolContext,
+      this.authScheme,
+      this.authCredential
+    );
+    const authResult = await toolAuthHandler.prepareAuthCredentials();
+    if (authResult.state === "pending") {
+      return {
+        pending: true,
+        message: "Needs your authorization to access your data."
+      };
+    }
+    const updatedArgs = {
+      ...request.args,
+      connection_name: this.connectionName,
+      connectionName: this.connectionName,
+      service_name: this.connectionServiceName,
+      serviceName: this.connectionServiceName,
+      host: this.connectionHost
+    };
+    if (this.entity) {
+      updatedArgs["entity"] = this.entity;
+    }
+    if (this.operation) {
+      updatedArgs["operation"] = this.operation;
+    }
+    if (this.action) {
+      updatedArgs["action"] = this.action;
+    }
+    if (authResult.authCredential) {
+      const token = prepareDynamicEuc(authResult.authCredential);
+      const dynamicAuthPayload = {
+        "oauth2_auth_code_flow.access_token": token != null ? token : {}
+      };
+      updatedArgs["dynamic_auth_config"] = dynamicAuthPayload;
+      updatedArgs["dynamicAuthConfig"] = dynamicAuthPayload;
+    }
+    logger.debug(`Running tool: ${this.name}`);
+    return this.restApiTool.runAsync({
+      args: updatedArgs,
+      toolContext: request.toolContext
+    });
+  }
+};
+__name(IntegrationConnectorTool, "IntegrationConnectorTool");
+/**
+ * Request fields that {@link IntegrationConnectorTool} injects at runtime and
+ * excludes from the function declaration shown to the model.
+ */
+IntegrationConnectorTool.EXCLUDE_FIELDS = Object.freeze([
+  "connection_name",
+  "connectionName",
+  "service_name",
+  "serviceName",
+  "host",
+  "entity",
+  "operation",
+  "action"
+]);
+/**
+ * Request fields that {@link IntegrationConnectorTool} removes from the
+ * `required` list in the function declaration shown to the model.
+ */
+IntegrationConnectorTool.OPTIONAL_FIELDS = Object.freeze([
+  "page_size",
+  "pageSize",
+  "page_token",
+  "pageToken",
+  "filter",
+  "filter_clause",
+  "filterClause"
+]);
+__decorateClass([
+  experimental
+], IntegrationConnectorTool.prototype, "_getDeclaration", 1);
+__decorateClass([
+  experimental
+], IntegrationConnectorTool.prototype, "runAsync", 1);
+IntegrationConnectorTool = __decorateClass([
+  experimental
+], IntegrationConnectorTool);
+function prepareDynamicEuc(authCredential) {
+  var _a, _b;
+  return ((_b = (_a = authCredential.http) == null ? void 0 : _a.credentials) == null ? void 0 : _b.token) || void 0;
+}
+__name(prepareDynamicEuc, "prepareDynamicEuc");
+export {
+  IntegrationConnectorTool
+};

package/dist/esm/tools/google_api_tool/google_api_tool.js

@@ -26,7 +26,7 @@ function isGoogleApiTool(obj) {
 }
 __name(isGoogleApiTool, "isGoogleApiTool");
 let GoogleApiTool = class extends (_b = BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE_SYMBOL, _b) {
-  constructor(restApiTool) {
+  constructor(restApiTool, options = {}) {
     super({
       name: restApiTool.name,
       description: restApiTool.description,
@@ -34,6 +34,9 @@ let GoogleApiTool = class extends (_b = BaseTool, _a = GOOGLE_API_TOOL_SIGNATURE
     });
     this[_a] = true;
     this.restApiTool = restApiTool;
+    if (options.clientId !== void 0 || options.clientSecret !== void 0) {
+      this.configureAuth(options.clientId, options.clientSecret);
+    }
   }
   _getDeclaration() {
     return this.restApiTool._getDeclaration();

package/dist/esm/tools/google_api_tool/google_api_toolset.js

@@ -0,0 +1,146 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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
+ */
+var _a, _b;
+import { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { GoogleApiTool } from "./google_api_tool.js";
+import { GoogleApiToOpenApiConverter } from "./googleapi_to_openapi_converter.js";
+const GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "google.adk.googleApiToolset"
+);
+const GOOGLE_OIDC_AUTH_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_OIDC_TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+const GOOGLE_OIDC_USERINFO_ENDPOINT = "https://openidconnect.googleapis.com/v1/userinfo";
+const GOOGLE_OIDC_REVOCATION_ENDPOINT = "https://oauth2.googleapis.com/revoke";
+function isGoogleApiToolset(obj) {
+  return typeof obj === "object" && obj !== null && GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL in obj && obj[GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+__name(isGoogleApiToolset, "isGoogleApiToolset");
+let GoogleApiToolset = class extends (_b = BaseToolset, _a = GOOGLE_API_TOOLSET_SIGNATURE_SYMBOL, _b) {
+  constructor(options = {}) {
+    var _a2;
+    const toolFilter = (_a2 = options.toolFilter) != null ? _a2 : [];
+    super(toolFilter);
+    this[_a] = true;
+    this.tools = [];
+    this.toolFilter = toolFilter;
+    this.apiName = options.apiName;
+    this.apiVersion = options.apiVersion;
+    this.clientId = options.clientId;
+    this.clientSecret = options.clientSecret;
+  }
+  async loadToolsetWithOidcAuth() {
+    var _a2, _b2, _c, _d, _e;
+    if (!this.apiName || !this.apiVersion) {
+      throw new Error(
+        "Both apiName and apiVersion are required to load a GoogleApiToolset."
+      );
+    }
+    const specDict = await new GoogleApiToOpenApiConverter(
+      this.apiName,
+      this.apiVersion
+    ).convert();
+    const oauth2Scheme = (_b2 = (_a2 = specDict.components) == null ? void 0 : _a2.securitySchemes) == null ? void 0 : _b2["oauth2"];
+    const scopesMap = (_e = (_d = (_c = oauth2Scheme == null ? void 0 : oauth2Scheme.flows) == null ? void 0 : _c.authorizationCode) == null ? void 0 : _d.scopes) != null ? _e : {};
+    const firstScope = Object.keys(scopesMap)[0];
+    const scopes = firstScope ? [firstScope] : void 0;
+    const authScheme = {
+      type: "openIdConnect",
+      openIdConnectUrl: "",
+      authorizationEndpoint: GOOGLE_OIDC_AUTH_ENDPOINT,
+      tokenEndpoint: GOOGLE_OIDC_TOKEN_ENDPOINT,
+      userinfoEndpoint: GOOGLE_OIDC_USERINFO_ENDPOINT,
+      revocationEndpoint: GOOGLE_OIDC_REVOCATION_ENDPOINT,
+      tokenEndpointAuthMethodsSupported: [
+        "client_secret_post",
+        "client_secret_basic"
+      ],
+      grantTypesSupported: ["authorization_code"],
+      scopes
+    };
+    return new OpenAPIToolset({
+      specDict,
+      specType: "yaml",
+      authScheme
+    });
+  }
+  async ensureToolsLoaded() {
+    var _a2;
+    if (this.openapiToolset || !this.apiName || !this.apiVersion) {
+      return;
+    }
+    (_a2 = this.loadingPromise) != null ? _a2 : this.loadingPromise = (async () => {
+      try {
+        const openapiToolset = await this.loadToolsetWithOidcAuth();
+        const restTools = await openapiToolset.getTools();
+        this.tools = restTools.map(
+          (tool) => new GoogleApiTool(tool, {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret
+          })
+        );
+        this.openapiToolset = openapiToolset;
+      } catch (error) {
+        this.loadingPromise = void 0;
+        throw error;
+      }
+    })();
+    await this.loadingPromise;
+  }
+  async getTools(context) {
+    await this.ensureToolsLoaded();
+    return this.tools.filter((tool) => this.isToolSelected(tool, context));
+  }
+  setToolFilter(toolFilter) {
+    this.toolFilter = toolFilter;
+  }
+  configureAuth(clientId, clientSecret) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    for (const tool of this.tools) {
+      tool.configureAuth(clientId, clientSecret);
+    }
+  }
+  async close() {
+    if (this.openapiToolset) {
+      await this.openapiToolset.close();
+    }
+  }
+};
+__name(GoogleApiToolset, "GoogleApiToolset");
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "getTools", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "setToolFilter", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "configureAuth", 1);
+__decorateClass([
+  experimental
+], GoogleApiToolset.prototype, "close", 1);
+GoogleApiToolset = __decorateClass([
+  experimental
+], GoogleApiToolset);
+export {
+  GoogleApiToolset,
+  isGoogleApiToolset
+};

package/dist/esm/tools/google_api_tool/google_api_toolsets.js

@@ -0,0 +1,94 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 {
+  GoogleApiToolset
+} from "./google_api_toolset.js";
+let BigQueryToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "bigquery", apiVersion: "v2" });
+  }
+};
+__name(BigQueryToolset, "BigQueryToolset");
+BigQueryToolset = __decorateClass([
+  experimental
+], BigQueryToolset);
+let CalendarToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "calendar", apiVersion: "v3" });
+  }
+};
+__name(CalendarToolset, "CalendarToolset");
+CalendarToolset = __decorateClass([
+  experimental
+], CalendarToolset);
+let GmailToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "gmail", apiVersion: "v1" });
+  }
+};
+__name(GmailToolset, "GmailToolset");
+GmailToolset = __decorateClass([
+  experimental
+], GmailToolset);
+let YoutubeToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "youtube", apiVersion: "v3" });
+  }
+};
+__name(YoutubeToolset, "YoutubeToolset");
+YoutubeToolset = __decorateClass([
+  experimental
+], YoutubeToolset);
+let SlidesToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "slides", apiVersion: "v1" });
+  }
+};
+__name(SlidesToolset, "SlidesToolset");
+SlidesToolset = __decorateClass([
+  experimental
+], SlidesToolset);
+let SheetsToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "sheets", apiVersion: "v4" });
+  }
+};
+__name(SheetsToolset, "SheetsToolset");
+SheetsToolset = __decorateClass([
+  experimental
+], SheetsToolset);
+let DocsToolset = class extends GoogleApiToolset {
+  constructor(options = {}) {
+    super({ ...options, apiName: "docs", apiVersion: "v1" });
+  }
+};
+__name(DocsToolset, "DocsToolset");
+DocsToolset = __decorateClass([
+  experimental
+], DocsToolset);
+export {
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+};

package/dist/esm/tools/google_api_tool/googleapi_to_openapi_converter.js

@@ -273,10 +273,10 @@ function convertOperation(methodData, pathParams) {
 }
 __name(convertOperation, "convertOperation");
 function convertMethods(methods, _resourcePath, openapiSpec) {
-  var _a, _b;
+  var _a, _b, _c;
   for (const methodData of Object.values(methods)) {
     const httpMethod = ((_a = methodData.httpMethod) != null ? _a : "GET").toLowerCase();
-    let restPath = ((_b = methodData.path) != null ? _b : "/").replace(
+    let restPath = ((_c = (_b = methodData.flatPath) != null ? _b : methodData.path) != null ? _c : "/").replace(
       /\{\+([^{}]+)\}/g,
       (_match, paramName) => `{${paramName}}`
     );

package/dist/esm/tools/google_api_tool/index.js

@@ -6,28 +6,26 @@ const require = topLevelCreateRequire(import.meta.url);
  * SPDX-License-Identifier: Apache-2.0
  */
 import { GoogleApiTool, isGoogleApiTool } from "./google_api_tool.js";
-import { GoogleApiToolSet, isGoogleApiToolSet } from "./google_api_tool_set.js";
+import { GoogleApiToolset, isGoogleApiToolset } from "./google_api_toolset.js";
 import {
-  bigqueryToolSet,
-  calendarToolSet,
-  docsToolSet,
-  gmailToolSet,
-  sheetsToolSet,
-  slidesToolSet,
-  youtubeToolSet
-} from "./google_api_tool_sets.js";
-import { GoogleApiToOpenApiConverter } from "./googleapi_to_openapi_converter.js";
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset
+} from "./google_api_toolsets.js";
 export {
-  GoogleApiToOpenApiConverter,
+  BigQueryToolset,
+  CalendarToolset,
+  DocsToolset,
+  GmailToolset,
   GoogleApiTool,
-  GoogleApiToolSet,
-  bigqueryToolSet,
-  calendarToolSet,
-  docsToolSet,
-  gmailToolSet,
+  GoogleApiToolset,
+  SheetsToolset,
+  SlidesToolset,
+  YoutubeToolset,
   isGoogleApiTool,
-  isGoogleApiToolSet,
-  sheetsToolSet,
-  slidesToolSet,
-  youtubeToolSet
+  isGoogleApiToolset
 };

package/dist/esm/tools/load_artifacts_tool.js

@@ -9,6 +9,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  */
 import { Type } from "@google/genai";
 import { appendInstructions } from "../models/llm_request.js";
+import { base64Decode } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
 import {
   BaseTool
@@ -37,6 +38,11 @@ function isInlineMimeTypeSupported(mimeType) {
   ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
 }
 __name(isInlineMimeTypeSupported, "isInlineMimeTypeSupported");
+function base64ByteLength(data) {
+  const digits = data.replace(/[=\s]/g, "").length;
+  return Math.floor(digits * 3 / 4);
+}
+__name(base64ByteLength, "base64ByteLength");
 function asSafePartForLlm(artifact, artifactName) {
   const inlineData = artifact.inlineData;
   if (!inlineData) {
@@ -53,15 +59,13 @@ function asSafePartForLlm(artifact, artifactName) {
     };
   }
   const isTextLike = mimeType.startsWith("text/") || TEXT_LIKE_MIME_TYPES.has(mimeType);
-  const decodedBuffer = Buffer.from(data, "base64");
   if (isTextLike) {
     try {
-      const decoded = decodedBuffer.toString("utf8");
-      return { text: decoded };
+      return { text: base64Decode(data.replace(/-/g, "+").replace(/_/g, "/")) };
     } catch {
     }
   }
-  const sizeKb = decodedBuffer.length / 1024;
+  const sizeKb = base64ByteLength(data) / 1024;
   return {
     text: `[Binary artifact: ${artifactName}, type: ${mimeType}, size: ${sizeKb.toFixed(1)} KB. Content cannot be displayed inline.]`
   };
@@ -188,5 +192,6 @@ let LoadArtifactsTool = _LoadArtifactsTool;
 const LOAD_ARTIFACTS = new LoadArtifactsTool();
 export {
   LOAD_ARTIFACTS,
-  LoadArtifactsTool
+  LoadArtifactsTool,
+  asSafePartForLlm
 };

package/dist/esm/tools/load_memory_tool.js

@@ -13,11 +13,13 @@ import {
   BaseTool
 } from "./base_tool.js";
 const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
-  constructor() {
+  constructor(options = {}) {
+    var _a;
     super({
       name: "load_memory",
       description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
     });
+    this.textOnlyContent = (_a = options.textOnlyContent) != null ? _a : false;
   }
   _getDeclaration() {
     return {
@@ -39,12 +41,12 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
     args,
     toolContext
   }) {
-    try {
-      const query = args["query"];
-      if (!toolContext.invocationContext.memoryService) {
-        throw new Error("Memory service is not initialized.");
-      }
-      const searchMemoryResponse = await toolContext.searchMemory(query);
+    const query = args["query"];
+    if (!toolContext.invocationContext.memoryService) {
+      throw new Error("Memory service is not initialized.");
+    }
+    const searchMemoryResponse = await toolContext.searchMemory(query);
+    if (this.textOnlyContent) {
       return {
         memories: searchMemoryResponse.memories.map((m) => {
           var _a, _b;
@@ -59,10 +61,10 @@ const _LoadMemoryTool = class _LoadMemoryTool extends BaseTool {
           };
         })
       };
-    } catch (e) {
-      console.error("ERROR in LoadMemoryTool runAsync:", e);
-      throw e;
     }
+    return {
+      memories: searchMemoryResponse.memories
+    };
   }
   async processLlmRequest(request) {
     await super.processLlmRequest(request);

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

@@ -35,20 +35,7 @@ const _MCPToolset = class _MCPToolset extends BaseToolset {
       };
       return new MCPTool(toolWithPrefix, this.mcpSessionManager, tool.name);
     });
-    const filter = this.toolFilter;
-    if (!filter || Array.isArray(filter) && filter.length === 0) {
-      return tools;
-    }
-    if (Array.isArray(filter)) {
-      return tools.filter((tool) => filter.includes(tool.name));
-    }
-    if (context) {
-      return tools.filter((tool) => filter(tool, context));
-    }
-    logger.warn(
-      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
-    );
-    return tools;
+    return tools.filter((tool) => this.isToolSelected(tool, context));
   }
   /**
    * Lists the names of the resources advertised by the MCP server.

package/dist/esm/tools/openapi_tool/auth/credential_exchangers/oauth2_exchanger.js

@@ -55,12 +55,12 @@ function generateAuthToken(authCredential) {
 }
 __name(generateAuthToken, "generateAuthToken");
 function exchangeCredential(authScheme, authCredential) {
-  var _a, _b;
+  var _a;
   checkSchemeCredentialType(authScheme, authCredential);
   if (authCredential.http) {
     return authCredential;
   }
-  if (((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) || ((_b = authCredential.oauth2) == null ? void 0 : _b.refreshToken)) {
+  if ((_a = authCredential.oauth2) == null ? void 0 : _a.accessToken) {
     return generateAuthToken(authCredential);
   }
   return null;