@google/adk 1.0.0 → 1.2.0

package/dist/cjs/tools/google_maps_grounding_tool.js

@@ -0,0 +1,80 @@
+/**
+  * @license
+  * Copyright 2026 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_maps_grounding_tool_exports = {};
+__export(google_maps_grounding_tool_exports, {
+  GOOGLE_MAPS_GROUNDING: () => GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool: () => GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding: () => applyGoogleMapsGrounding
+});
+module.exports = __toCommonJS(google_maps_grounding_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = (0, import_model_name.isGeminiModelIdCheckDisabled)();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if ((0, import_model_name.isGemini1Model)(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if ((0, import_model_name.isGeminiModel)(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    `Google maps tool is not supported for model ${llmRequest.model}`
+  );
+}
+class GoogleMapsGroundingTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "google_maps", description: "Google Maps Grounding Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    applyGoogleMapsGrounding(llmRequest);
+  }
+}
+const GOOGLE_MAPS_GROUNDING = new GoogleMapsGroundingTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+});

package/dist/cjs/tools/long_running_tool.js

@@ -45,7 +45,8 @@ class LongRunningFunctionTool extends import_function_tool.FunctionTool {
     super({ ...options, isLongRunning: true });
   }
   /**
-   * Provide a schema for the function.
+   * Returns the function declaration with an appended instruction warning the
+   * model not to re-invoke the tool while it is still running.
    */
   _getDeclaration() {
     const declaration = super._getDeclaration();

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

@@ -37,6 +37,7 @@ var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamable
  */
 class MCPSessionManager {
   constructor(connectionParams) {
+    this.activeSessions = /* @__PURE__ */ new Set();
     this.connectionParams = connectionParams;
   }
   async createSession() {
@@ -68,8 +69,18 @@ class MCPSessionManager {
         break;
       }
     }
+    this.activeSessions.add(client);
     return client;
   }
+  async closeSession(client) {
+    if (this.activeSessions.has(client)) {
+      this.activeSessions.delete(client);
+      await client.close();
+    }
+  }
+  getActiveSessions() {
+    return Array.from(this.activeSessions);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -35,10 +35,11 @@ var import_base_tool = require("../base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 class MCPTool extends import_base_tool.BaseTool {
-  constructor(mcpTool, mcpSessionManager) {
+  constructor(mcpTool, mcpSessionManager, originalName) {
     super({ name: mcpTool.name, description: mcpTool.description || "" });
     this.mcpTool = mcpTool;
     this.mcpSessionManager = mcpSessionManager;
+    this.originalName = originalName || mcpTool.name;
   }
   _getDeclaration() {
     return {
@@ -52,12 +53,16 @@ class MCPTool extends import_base_tool.BaseTool {
   }
   async runAsync(request) {
     const session = await this.mcpSessionManager.createSession();
-    const callRequest = {};
-    callRequest.params = { name: this.mcpTool.name, arguments: request.args };
-    const result = await session.callTool(callRequest.params, void 0, {
-      signal: request.toolContext.abortSignal
-    });
-    return result;
+    try {
+      const callRequest = {};
+      callRequest.params = { name: this.originalName, arguments: request.args };
+      const result = await session.callTool(callRequest.params, void 0, {
+        signal: request.toolContext.abortSignal
+      });
+      return result;
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -41,22 +41,45 @@ class MCPToolset extends import_base_toolset.BaseToolset {
     super(toolFilter, prefix);
     this.mcpSessionManager = new import_mcp_session_manager.MCPSessionManager(connectionParams);
   }
-  async getTools() {
+  async getTools(context) {
     const session = await this.mcpSessionManager.createSession();
-    const listResult = await session.listTools();
+    let listResult;
+    try {
+      listResult = await session.listTools();
+    } finally {
+      await this.mcpSessionManager.closeSession(session);
+    }
     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) => {
+    const tools = listResult.tools.map((tool) => {
       const toolWithPrefix = {
         ...tool,
         name: this.prefix ? `${this.prefix}_${tool.name}` : tool.name
       };
-      return new import_mcp_tool.MCPTool(toolWithPrefix, this.mcpSessionManager);
+      return new import_mcp_tool.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));
+    }
+    import_logger.logger.warn(
+      "MCPToolset: a ToolPredicate toolFilter was provided but getTools() was called without a ReadonlyContext. The filter will not be applied."
+    );
+    return tools;
   }
   async close() {
+    const sessions = this.mcpSessionManager.getActiveSessions();
+    await Promise.allSettled(
+      sessions.map((session) => this.mcpSessionManager.closeSession(session))
+    );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/tools/openapi_tool/auth/auth_helpers.js

@@ -0,0 +1,78 @@
+/**
+  * @license
+  * Copyright 2026 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 auth_helpers_exports = {};
+__export(auth_helpers_exports, {
+  applyCredential: () => applyCredential,
+  createApiKeyScheme: () => createApiKeyScheme,
+  createBearerScheme: () => createBearerScheme
+});
+module.exports = __toCommonJS(auth_helpers_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function applyCredential(url, headers, credential, authScheme) {
+  if (!credential) return url;
+  if (credential.apiKey) {
+    let inLocation;
+    let name = "key";
+    if (authScheme && authScheme.type === "apiKey") {
+      const apiKeyScheme = authScheme;
+      inLocation = apiKeyScheme.in;
+      name = apiKeyScheme.name;
+    }
+    if (inLocation === "header") {
+      headers[name] = credential.apiKey;
+    } else if (inLocation === "query") {
+      const separator = url.includes("?") ? "&" : "?";
+      url += `${separator}${name}=${encodeURIComponent(credential.apiKey)}`;
+    } else {
+      headers["Authorization"] = credential.apiKey;
+    }
+  } else if (credential.http && credential.http.credentials && credential.http.credentials.token) {
+    headers["Authorization"] = `Bearer ${credential.http.credentials.token}`;
+  }
+  return url;
+}
+function createApiKeyScheme(name, inLocation) {
+  return {
+    type: "apiKey",
+    name,
+    in: inLocation
+  };
+}
+function createBearerScheme() {
+  return {
+    type: "http",
+    scheme: "bearer"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyCredential,
+  createApiKeyScheme,
+  createBearerScheme
+});

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.js

@@ -0,0 +1,84 @@
+/**
+  * @license
+  * Copyright 2026 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 __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;
+};
+var auto_auth_credential_exchanger_exports = {};
+__export(auto_auth_credential_exchanger_exports, {
+  AutoAuthCredentialExchanger: () => AutoAuthCredentialExchanger
+});
+module.exports = __toCommonJS(auto_auth_credential_exchanger_exports);
+var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_oauth2_credential_exchanger = require("../../../../auth/oauth2/oauth2_credential_exchanger.js");
+var import_experimental = require("../../../../utils/experimental.js");
+var import_service_account_exchanger = require("./service_account_exchanger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let AutoAuthCredentialExchanger = class {
+  constructor() {
+    this.exchangers = /* @__PURE__ */ new Map();
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.OAUTH2,
+      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.OPEN_ID_CONNECT,
+      new import_oauth2_credential_exchanger.OAuth2CredentialExchanger()
+    );
+    this.exchangers.set(
+      import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT,
+      new import_service_account_exchanger.ServiceAccountCredentialExchanger()
+    );
+  }
+  async exchange(params) {
+    const { authCredential, authScheme } = params;
+    const exchanger = this.exchangers.get(authCredential.authType);
+    if (!exchanger) {
+      return {
+        credential: authCredential,
+        wasExchanged: false
+      };
+    }
+    return exchanger.exchange({ authScheme, authCredential });
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], AutoAuthCredentialExchanger.prototype, "exchange", 1);
+AutoAuthCredentialExchanger = __decorateClass([
+  import_experimental.experimental
+], AutoAuthCredentialExchanger);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoAuthCredentialExchanger
+});

package/dist/cjs/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.js

@@ -0,0 +1,133 @@
+/**
+  * @license
+  * Copyright 2026 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 __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;
+};
+var service_account_exchanger_exports = {};
+__export(service_account_exchanger_exports, {
+  ServiceAccountCredentialExchanger: () => ServiceAccountCredentialExchanger
+});
+module.exports = __toCommonJS(service_account_exchanger_exports);
+var import_google_auth_library = require("google-auth-library");
+var import_auth_credential = require("../../../../auth/auth_credential.js");
+var import_base_credential_exchanger = require("../../../../auth/exchanger/base_credential_exchanger.js");
+var import_experimental = require("../../../../utils/experimental.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_SCOPES = ["https://www.googleapis.com/auth/cloud-platform"];
+let ServiceAccountCredentialExchanger = class {
+  async exchange(params) {
+    const { authCredential } = params;
+    if (authCredential.authType !== import_auth_credential.AuthCredentialTypes.SERVICE_ACCOUNT || !authCredential.serviceAccount) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        "Invalid credential type for ServiceAccountCredentialExchanger"
+      );
+    }
+    const saConfig = authCredential.serviceAccount;
+    if (saConfig.useDefaultCredential) {
+      return this.exchangeForDefaultCredential(saConfig);
+    }
+    return this.exchangeForExplicitCredential(saConfig);
+  }
+  async exchangeForDefaultCredential(saConfig) {
+    try {
+      const auth = new import_google_auth_library.GoogleAuth({
+        scopes: saConfig.scopes || DEFAULT_SCOPES
+      });
+      const client = await auth.getClient();
+      const tokenResponse = await client.getAccessToken();
+      const token = tokenResponse.token;
+      if (!token) {
+        throw new Error("Failed to get access token from default credentials");
+      }
+      return {
+        credential: {
+          authType: import_auth_credential.AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        `Failed to exchange default service account token: ${error.message}`
+      );
+    }
+  }
+  async exchangeForExplicitCredential(saConfig) {
+    const creds = saConfig.serviceAccountCredential;
+    if (!creds) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        "Service account credentials are missing."
+      );
+    }
+    try {
+      const client = new import_google_auth_library.JWT({
+        email: creds.clientEmail,
+        key: creds.privateKey,
+        scopes: saConfig.scopes
+      });
+      const tokens = await client.authorize();
+      const token = tokens.access_token;
+      if (!token) {
+        throw new Error("Failed to get access token from explicit credentials");
+      }
+      return {
+        credential: {
+          authType: import_auth_credential.AuthCredentialTypes.HTTP,
+          http: {
+            scheme: "bearer",
+            credentials: { token }
+          }
+        },
+        wasExchanged: true
+      };
+    } catch (error) {
+      throw new import_base_credential_exchanger.CredentialExchangeError(
+        `Failed to exchange explicit service account token: ${error.message}`
+      );
+    }
+  }
+};
+__decorateClass([
+  import_experimental.experimental
+], ServiceAccountCredentialExchanger.prototype, "exchange", 1);
+ServiceAccountCredentialExchanger = __decorateClass([
+  import_experimental.experimental
+], ServiceAccountCredentialExchanger);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServiceAccountCredentialExchanger
+});

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

@@ -48,6 +48,7 @@ module.exports = __toCommonJS(load_skill_resource_tool_exports);
 var import_genai = require("@google/genai");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_experimental = require("../../utils/experimental.js");
+var import_file_utils = require("../../utils/file_utils.js");
 var import_base_tool = require("../base_tool.js");
 /**
  * @license
@@ -55,30 +56,6 @@ var import_base_tool = require("../base_tool.js");
  * SPDX-License-Identifier: Apache-2.0
  */
 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 import_base_tool.BaseTool {
   constructor(toolset) {
     super({
@@ -197,7 +174,7 @@ let LoadSkillResourceTool = class extends import_base_tool.BaseTool {
             content = (_b = skillResources.assets) == null ? void 0 : _b[resourcePath.substring("assets/".length)];
           }
           if (Buffer.isBuffer(content)) {
-            const mimeType = guessMimeType(resourcePath);
+            const mimeType = (0, import_file_utils.guessMimeType)(resourcePath);
             llmRequest.contents.push({
               role: "user",
               parts: [

package/dist/cjs/tools/url_context_tool.js

@@ -0,0 +1,73 @@
+/**
+  * @license
+  * Copyright 2026 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 url_context_tool_exports = {};
+__export(url_context_tool_exports, {
+  URL_CONTEXT: () => URL_CONTEXT,
+  UrlContextTool: () => UrlContextTool
+});
+module.exports = __toCommonJS(url_context_tool_exports);
+var import_model_name = require("../utils/model_name.js");
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class UrlContextTool extends import_base_tool.BaseTool {
+  constructor() {
+    super({ name: "url_context", description: "URL Context Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    if (!(0, import_model_name.isGeminiModel)(llmRequest.model)) {
+      throw new Error(
+        `URL context tool is not supported for model ${llmRequest.model}`
+      );
+    }
+    if (!(0, import_model_name.isGemini2OrAbove)(llmRequest.model)) {
+      throw new Error(
+        `URL context tool requires Gemini 2 or above, but got ${llmRequest.model}`
+      );
+    }
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      urlContext: {}
+    });
+  }
+}
+const URL_CONTEXT = new UrlContextTool();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  URL_CONTEXT,
+  UrlContextTool
+});