@softactivate/adk 1.1.0

package/dist/web/tools/base_toolset.js

@@ -0,0 +1,57 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+const BASE_TOOLSET_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseToolset");
+function isBaseToolset(obj) {
+  return typeof obj === "object" && obj !== null && BASE_TOOLSET_SIGNATURE_SYMBOL in obj && obj[BASE_TOOLSET_SIGNATURE_SYMBOL] === true;
+}
+_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
+class BaseToolset {
+  constructor(toolFilter, prefix) {
+    this.toolFilter = toolFilter;
+    this.prefix = prefix;
+    this[_a] = true;
+  }
+  /**
+   * 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) {
+  }
+}
+export {
+  BaseToolset,
+  isBaseToolset
+};

package/dist/web/tools/exit_loop_tool.js

@@ -0,0 +1,34 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool } from "./base_tool.js";
+class ExitLoopTool extends BaseTool {
+  constructor() {
+    super({
+      name: "exit_loop",
+      description: "Exits the loop.\n\nCall this function only when you are instructed to do so."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description
+    };
+  }
+  async runAsync({
+    toolContext
+  }) {
+    toolContext.actions.escalate = true;
+    toolContext.actions.skipSummarization = true;
+    return "";
+  }
+}
+const EXIT_LOOP = new ExitLoopTool();
+export {
+  EXIT_LOOP,
+  ExitLoopTool
+};

package/dist/web/tools/forwarding_artifact_service.js

@@ -0,0 +1,59 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @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() {
+    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
+    );
+  }
+  listArtifactVersions(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.listArtifactVersions(
+      request
+    );
+  }
+  getArtifactVersion(request) {
+    if (!this.toolContext.invocationContext.artifactService) {
+      throw new Error("Artifact service is not initialized.");
+    }
+    return this.toolContext.invocationContext.artifactService.getArtifactVersion(
+      request
+    );
+  }
+}
+export {
+  ForwardingArtifactService
+};

package/dist/web/tools/function_tool.js

@@ -0,0 +1,80 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a, _b;
+import { Type } from "@google/genai";
+import { isZodObject, zodObjectToSchema } from "../utils/simple_zod_to_json.js";
+import { BaseTool } from "./base_tool.js";
+function toSchema(parameters) {
+  if (parameters === void 0) {
+    return { type: Type.OBJECT, properties: {} };
+  }
+  if (isZodObject(parameters)) {
+    return zodObjectToSchema(parameters);
+  }
+  return parameters;
+}
+const FUNCTION_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.functionTool");
+function isFunctionTool(obj) {
+  return typeof obj === "object" && obj !== null && FUNCTION_TOOL_SIGNATURE_SYMBOL in obj && obj[FUNCTION_TOOL_SIGNATURE_SYMBOL] === true;
+}
+class FunctionTool extends (_b = BaseTool, _a = FUNCTION_TOOL_SIGNATURE_SYMBOL, _b) {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    var _a2;
+    const name = (_a2 = options.name) != null ? _a2 : 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
+    });
+    /** A unique symbol to identify ADK function tool class. */
+    this[_a] = true;
+    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 (isZodObject(this.parameters)) {
+        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 '".concat(this.name, "': ").concat(errorMessage));
+    }
+  }
+}
+export {
+  FunctionTool,
+  isFunctionTool
+};

package/dist/web/tools/google_maps_grounding_tool.js

@@ -0,0 +1,54 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  isGemini1Model,
+  isGeminiModel,
+  isGeminiModelIdCheckDisabled
+} from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+function applyGoogleMapsGrounding(llmRequest) {
+  if (!llmRequest.model) {
+    return;
+  }
+  const modelCheckDisabled = isGeminiModelIdCheckDisabled();
+  llmRequest.config = llmRequest.config || {};
+  llmRequest.config.tools = llmRequest.config.tools || [];
+  if (isGemini1Model(llmRequest.model)) {
+    throw new Error(
+      "Google Maps grounding tool cannot be used with Gemini 1.x models."
+    );
+  }
+  if (isGeminiModel(llmRequest.model) || modelCheckDisabled) {
+    llmRequest.config.tools.push({
+      googleMaps: {}
+    });
+    return;
+  }
+  throw new Error(
+    "Google maps tool is not supported for model ".concat(llmRequest.model)
+  );
+}
+class GoogleMapsGroundingTool extends 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();
+export {
+  GOOGLE_MAPS_GROUNDING,
+  GoogleMapsGroundingTool,
+  applyGoogleMapsGrounding
+};

package/dist/web/tools/google_search_tool.js

@@ -0,0 +1,51 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isGemini1Model, isGeminiModel } from "../utils/model_name.js";
+import { BaseTool } from "./base_tool.js";
+class GoogleSearchTool extends BaseTool {
+  constructor() {
+    super({ name: "google_search", description: "Google Search Tool" });
+  }
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    if (!llmRequest.model) {
+      return;
+    }
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    if (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 (isGeminiModel(llmRequest.model)) {
+      llmRequest.config.tools.push({
+        googleSearch: {}
+      });
+      return;
+    }
+    throw new Error(
+      "Google search tool is not supported for model ".concat(llmRequest.model)
+    );
+  }
+}
+const GOOGLE_SEARCH = new GoogleSearchTool();
+export {
+  GOOGLE_SEARCH,
+  GoogleSearchTool
+};

package/dist/web/tools/load_artifacts_tool.js

@@ -0,0 +1,152 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import { getLogger } from "../utils/logger.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+const logger = getLogger();
+const GEMINI_SUPPORTED_INLINE_MIME_PREFIXES = ["image/", "audio/", "video/"];
+const GEMINI_SUPPORTED_INLINE_MIME_TYPES = /* @__PURE__ */ new Set(["application/pdf"]);
+const TEXT_LIKE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/csv",
+  "application/json",
+  "application/xml"
+]);
+function normalizeMimeType(mimeType) {
+  if (!mimeType) {
+    return void 0;
+  }
+  return mimeType.split(";")[0].trim();
+}
+function isInlineMimeTypeSupported(mimeType) {
+  const normalized = normalizeMimeType(mimeType);
+  if (!normalized) {
+    return false;
+  }
+  return GEMINI_SUPPORTED_INLINE_MIME_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  ) || GEMINI_SUPPORTED_INLINE_MIME_TYPES.has(normalized);
+}
+function asSafePartForLlm(artifact, artifactName) {
+  const inlineData = artifact.inlineData;
+  if (!inlineData) {
+    return artifact;
+  }
+  if (isInlineMimeTypeSupported(inlineData.mimeType)) {
+    return artifact;
+  }
+  const mimeType = normalizeMimeType(inlineData.mimeType) || "application/octet-stream";
+  const data = inlineData.data;
+  if (!data) {
+    return {
+      text: "[Artifact: ".concat(artifactName, ", type: ").concat(mimeType, ". No inline data was provided.]")
+    };
+  }
+  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 };
+    } catch (e) {
+    }
+  }
+  const sizeKb = decodedBuffer.length / 1024;
+  return {
+    text: "[Binary artifact: ".concat(artifactName, ", type: ").concat(mimeType, ", size: ").concat(sizeKb.toFixed(1), " KB. Content cannot be displayed inline.]")
+  };
+}
+class LoadArtifactsTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_artifacts",
+      description: "Loads artifacts into the session for this request.\n\nNOTE: Call when you need access to artifacts (for example, uploads saved by the web UI)."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          artifact_names: {
+            type: Type.ARRAY,
+            items: {
+              type: Type.STRING
+            },
+            description: "The names of the artifacts to load."
+          }
+        }
+      }
+    };
+  }
+  async runAsync({ args }) {
+    const artifactNames = args["artifact_names"] || [];
+    return {
+      artifact_names: artifactNames,
+      status: "artifact contents temporarily inserted and removed. to access these artifacts, call load_artifacts tool again."
+    };
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    await this.appendArtifactsToLlmRequest(
+      request.toolContext,
+      request.llmRequest
+    );
+  }
+  async appendArtifactsToLlmRequest(toolContext, llmRequest) {
+    if (!toolContext.invocationContext.artifactService) {
+      return;
+    }
+    const artifactNames = await toolContext.listArtifacts();
+    if (!artifactNames || artifactNames.length === 0) {
+      return;
+    }
+    appendInstructions(llmRequest, [
+      "You have a list of artifacts:\n  ".concat(JSON.stringify(
+        artifactNames
+      ), "\n\n  When the user asks questions about any of the artifacts, you should call the\n  `load_artifacts` function to load the artifact. Always call load_artifacts\n  before answering questions related to the artifacts, regardless of whether the\n  artifacts have been loaded before. Do not depend on prior answers about the\n  artifacts.")
+    ]);
+    const contents = llmRequest.contents;
+    if (contents && contents.length > 0) {
+      const lastContent = contents[contents.length - 1];
+      if (lastContent.role === "user" && lastContent.parts && lastContent.parts.length > 0) {
+        const functionResponsePart = lastContent.parts[0];
+        const functionResponse = functionResponsePart.functionResponse;
+        if (functionResponse && functionResponse.name === "load_artifacts") {
+          const response = functionResponse.response || {};
+          const namesToLoad = response["artifact_names"] || [];
+          for (const artifactName of namesToLoad) {
+            let artifact = await toolContext.loadArtifact(artifactName);
+            if (!artifact && !artifactName.startsWith("user:")) {
+              const prefixedName = "user:".concat(artifactName);
+              artifact = await toolContext.loadArtifact(prefixedName);
+            }
+            if (!artifact) {
+              logger.warn('Artifact "'.concat(artifactName, '" not found, skipping'));
+              continue;
+            }
+            const artifactPart = asSafePartForLlm(artifact, artifactName);
+            llmRequest.contents.push({
+              role: "user",
+              parts: [{ text: "Artifact ".concat(artifactName, " is:") }, artifactPart]
+            });
+          }
+        }
+      }
+    }
+  }
+}
+const LOAD_ARTIFACTS = new LoadArtifactsTool();
+export {
+  LOAD_ARTIFACTS,
+  LoadArtifactsTool
+};

package/dist/web/tools/load_memory_tool.js

@@ -0,0 +1,79 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Type } from "@google/genai";
+import { appendInstructions } from "../models/llm_request.js";
+import {
+  BaseTool
+} from "./base_tool.js";
+class LoadMemoryTool extends BaseTool {
+  constructor() {
+    super({
+      name: "load_memory",
+      description: "Loads the memory for the current user.\n\nNOTE: Currently this tool only uses text part from the memory."
+    });
+  }
+  _getDeclaration() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: {
+        type: Type.OBJECT,
+        properties: {
+          query: {
+            type: Type.STRING,
+            description: "The query to load the memory for."
+          }
+        },
+        required: ["query"]
+      }
+    };
+  }
+  async runAsync({
+    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);
+      return {
+        memories: searchMemoryResponse.memories.map((m) => {
+          var _a, _b;
+          return {
+            // Join all text parts by a space, or empty string if no text parts
+            content: (_b = (_a = m.content.parts) == null ? void 0 : _a.map((p) => {
+              var _a2;
+              return (_a2 = p.text) != null ? _a2 : "";
+            }).join(" ")) != null ? _b : "",
+            author: m.author,
+            timestamp: m.timestamp
+          };
+        })
+      };
+    } catch (e) {
+      console.error("ERROR in LoadMemoryTool runAsync:", e);
+      throw e;
+    }
+  }
+  async processLlmRequest(request) {
+    await super.processLlmRequest(request);
+    if (!request.toolContext.invocationContext.memoryService) {
+      return;
+    }
+    appendInstructions(request.llmRequest, [
+      "You have memory. You can use it to answer questions. If any questions need\nyou to look up the memory, you should call load_memory function with a query."
+    ]);
+  }
+}
+const LOAD_MEMORY = new LoadMemoryTool();
+export {
+  LOAD_MEMORY,
+  LoadMemoryTool
+};

package/dist/web/tools/long_running_tool.js

@@ -0,0 +1,54 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  FunctionTool
+} from "./function_tool.js";
+const LONG_RUNNING_INSTRUCTION = "\n\nNOTE: 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 FunctionTool {
+  /**
+   * The constructor acts as the user-friendly factory.
+   * @param options The configuration for the tool.
+   */
+  constructor(options) {
+    super(__spreadProps(__spreadValues({}, 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;
+  }
+}
+export {
+  LongRunningFunctionTool
+};

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

@@ -0,0 +1,53 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StdioClientTransport
+} from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  StreamableHTTPClientTransport
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+class MCPSessionManager {
+  constructor(connectionParams) {
+    this.connectionParams = connectionParams;
+  }
+  async createSession() {
+    var _a;
+    const client = new Client({ name: "MCPClient", version: "1.0.0" });
+    switch (this.connectionParams.type) {
+      case "StdioConnectionParams":
+        await client.connect(
+          new StdioClientTransport(this.connectionParams.serverParams)
+        );
+        break;
+      case "StreamableHTTPConnectionParams": {
+        const options = (_a = this.connectionParams.transportOptions) != null ? _a : {};
+        if (!options.requestInit && this.connectionParams.header !== void 0) {
+          options.requestInit = {
+            headers: this.connectionParams.header
+          };
+        }
+        await client.connect(
+          new StreamableHTTPClientTransport(
+            new URL(this.connectionParams.url),
+            options
+          )
+        );
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = this.connectionParams;
+        break;
+      }
+    }
+    return client;
+  }
+}
+export {
+  MCPSessionManager
+};