@google/adk 2.0.0 → 2.2.0

package/dist/web/telemetry/tracing.js

@@ -1,304 +0,0 @@
-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));
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { context, trace } from "@opentelemetry/api";
-import { version } from "../version.js";
-const GEN_AI_AGENT_DESCRIPTION = "gen_ai.agent.description";
-const GEN_AI_AGENT_NAME = "gen_ai.agent.name";
-const GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
-const GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
-const GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
-const GEN_AI_TOOL_DESCRIPTION = "gen_ai.tool.description";
-const GEN_AI_TOOL_NAME = "gen_ai.tool.name";
-const GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
-const ADK_WORKFLOW_NAME = "adk.workflow.name";
-const ADK_NODE_PATH = "adk.node.path";
-const ADK_NODE_RUN_ID = "adk.node.run_id";
-const ADK_NODE_ATTEMPT = "adk.node.attempt";
-const ADK_NODE_STATUS = "adk.node.status";
-const ADK_NODE_INTERRUPT_COUNT = "adk.node.interrupt_count";
-const tracer = trace.getTracer("gcp.vertex.agent", version);
-function safeJsonSerialize(obj) {
-  try {
-    return JSON.stringify(obj);
-  } catch (_e) {
-    return "<not serializable>";
-  }
-}
-__name(safeJsonSerialize, "safeJsonSerialize");
-function traceAgentInvocation({
-  agent,
-  invocationContext
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_agent",
-    // Conditionally Required
-    [GEN_AI_AGENT_DESCRIPTION]: agent.description,
-    [GEN_AI_AGENT_NAME]: agent.name,
-    [GEN_AI_CONVERSATION_ID]: invocationContext.session.id
-  });
-}
-__name(traceAgentInvocation, "traceAgentInvocation");
-function traceWorkflowInvocation({
-  workflowName,
-  nodePath,
-  sessionId
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_workflow",
-    [GEN_AI_CONVERSATION_ID]: sessionId,
-    [ADK_WORKFLOW_NAME]: workflowName,
-    [ADK_NODE_PATH]: nodePath
-  });
-}
-__name(traceWorkflowInvocation, "traceWorkflowInvocation");
-function traceNodeExecution({
-  nodePath,
-  runId,
-  attempt,
-  status,
-  interruptCount
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_node",
-    [ADK_NODE_PATH]: nodePath,
-    [ADK_NODE_RUN_ID]: runId,
-    [ADK_NODE_ATTEMPT]: attempt,
-    [ADK_NODE_STATUS]: status,
-    [ADK_NODE_INTERRUPT_COUNT]: interruptCount
-  });
-}
-__name(traceNodeExecution, "traceNodeExecution");
-function traceToolCall({
-  tool,
-  args,
-  functionResponseEvent
-}) {
-  var _a, _b;
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_tool",
-    [GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
-    [GEN_AI_TOOL_NAME]: tool.name,
-    // e.g. FunctionTool
-    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
-    // Setting empty llm request and response (as UI expect these) while not
-    // applicable for tool_response.
-    "gcp.vertex.agent.llm_request": "{}",
-    "gcp.vertex.agent.llm_response": "{}",
-    "gcp.vertex.agent.tool_call_args": shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
-  });
-  let toolCallId = "<not specified>";
-  let toolResponse = "<not specified>";
-  if ((_a = functionResponseEvent.content) == null ? void 0 : _a.parts) {
-    const responseParts = functionResponseEvent.content.parts;
-    const functionResponse = (_b = responseParts[0]) == null ? void 0 : _b.functionResponse;
-    if (functionResponse == null ? void 0 : functionResponse.id) {
-      toolCallId = functionResponse.id;
-    }
-    if (functionResponse == null ? void 0 : functionResponse.response) {
-      toolResponse = functionResponse.response;
-    }
-  }
-  if (typeof toolResponse !== "object" || toolResponse === null) {
-    toolResponse = { result: toolResponse };
-  }
-  span.setAttributes({
-    [GEN_AI_TOOL_CALL_ID]: toolCallId,
-    "gcp.vertex.agent.event_id": functionResponseEvent.id,
-    "gcp.vertex.agent.tool_response": shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
-  });
-}
-__name(traceToolCall, "traceToolCall");
-function traceMergedToolCalls({
-  responseEventId,
-  functionResponseEvent
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_tool",
-    [GEN_AI_TOOL_NAME]: "(merged tools)",
-    [GEN_AI_TOOL_DESCRIPTION]: "(merged tools)",
-    [GEN_AI_TOOL_CALL_ID]: responseEventId,
-    "gcp.vertex.agent.tool_call_args": "N/A",
-    "gcp.vertex.agent.event_id": responseEventId,
-    // Setting empty llm request and response (as UI expect these) while not
-    // applicable for tool_response.
-    "gcp.vertex.agent.llm_request": "{}",
-    "gcp.vertex.agent.llm_response": "{}"
-  });
-  span.setAttribute(
-    "gcp.vertex.agent.tool_response",
-    shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
-  );
-}
-__name(traceMergedToolCalls, "traceMergedToolCalls");
-function traceCallLlm({
-  invocationContext,
-  eventId,
-  llmRequest,
-  llmResponse
-}) {
-  var _a, _b, _c, _d;
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes(__spreadProps(__spreadValues({
-    "gen_ai.system": "gcp.vertex.agent",
-    "gen_ai.request.model": llmRequest.model
-  }, ((_a = invocationContext.agent) == null ? void 0 : _a.name) ? { [GEN_AI_AGENT_NAME]: invocationContext.agent.name } : {}), {
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.session_id": invocationContext.session.id,
-    "gcp.vertex.agent.event_id": eventId,
-    // Consider removing once GenAI SDK provides a way to record this info.
-    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
-  }));
-  if ((_b = llmRequest.config) == null ? void 0 : _b.topP) {
-    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
-  }
-  if (((_c = llmRequest.config) == null ? void 0 : _c.maxOutputTokens) !== void 0) {
-    span.setAttribute(
-      "gen_ai.request.max_tokens",
-      llmRequest.config.maxOutputTokens
-    );
-  }
-  span.setAttribute(
-    "gcp.vertex.agent.llm_response",
-    shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}"
-  );
-  if (llmResponse.usageMetadata) {
-    span.setAttribute(
-      "gen_ai.usage.input_tokens",
-      llmResponse.usageMetadata.promptTokenCount || 0
-    );
-  }
-  if ((_d = llmResponse.usageMetadata) == null ? void 0 : _d.candidatesTokenCount) {
-    span.setAttribute(
-      "gen_ai.usage.output_tokens",
-      llmResponse.usageMetadata.candidatesTokenCount
-    );
-  }
-  if (llmResponse.finishReason) {
-    const finishReasonValue = typeof llmResponse.finishReason === "string" ? llmResponse.finishReason.toLowerCase() : String(llmResponse.finishReason).toLowerCase();
-    span.setAttribute("gen_ai.response.finish_reasons", [finishReasonValue]);
-  }
-}
-__name(traceCallLlm, "traceCallLlm");
-function traceSendData({
-  invocationContext,
-  eventId,
-  data
-}) {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-  span.setAttributes({
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.event_id": eventId
-  });
-  span.setAttribute(
-    "gcp.vertex.agent.data",
-    shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
-  );
-}
-__name(traceSendData, "traceSendData");
-function buildLlmRequestForTrace(llmRequest) {
-  const result = {
-    model: llmRequest.model,
-    contents: []
-  };
-  if (llmRequest.config) {
-    const _a = llmRequest.config, { responseSchema } = _a, cleanConfig = __objRest(_a, ["responseSchema"]);
-    result.config = cleanConfig;
-  }
-  result.contents = llmRequest.contents.map((content) => {
-    var _a2;
-    return {
-      role: content.role,
-      parts: ((_a2 = content.parts) == null ? void 0 : _a2.filter((part) => !part.inlineData)) || []
-    };
-  });
-  return result;
-}
-__name(buildLlmRequestForTrace, "buildLlmRequestForTrace");
-function bindOtelContextToAsyncGenerator(ctx, generator) {
-  return {
-    // Bind the next() method to execute within the provided context
-    next: context.bind(ctx, generator.next.bind(generator)),
-    // Bind the return() method to execute within the provided context
-    return: context.bind(ctx, generator.return.bind(generator)),
-    // Bind the throw() method to execute within the provided context
-    throw: context.bind(ctx, generator.throw.bind(generator)),
-    // Ensure the async iterator symbol also returns a context-bound generator
-    [Symbol.asyncIterator]() {
-      return bindOtelContextToAsyncGenerator(
-        ctx,
-        generator[Symbol.asyncIterator]()
-      );
-    }
-  };
-}
-__name(bindOtelContextToAsyncGenerator, "bindOtelContextToAsyncGenerator");
-function runAsyncGeneratorWithOtelContext(otelContext, generatorFnContext, generatorFn) {
-  const generator = generatorFn.call(generatorFnContext);
-  return bindOtelContextToAsyncGenerator(otelContext, generator);
-}
-__name(runAsyncGeneratorWithOtelContext, "runAsyncGeneratorWithOtelContext");
-function shouldAddRequestResponseToSpans() {
-  const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
-  return envValue === "true" || envValue === "1";
-}
-__name(shouldAddRequestResponseToSpans, "shouldAddRequestResponseToSpans");
-export {
-  runAsyncGeneratorWithOtelContext,
-  traceAgentInvocation,
-  traceCallLlm,
-  traceMergedToolCalls,
-  traceNodeExecution,
-  traceSendData,
-  traceToolCall,
-  traceWorkflowInvocation,
-  tracer
-};

package/dist/web/tools/agent_tool.js

@@ -1,150 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a, _b;
-import { Type } from "@google/genai";
-import { isLlmAgent } from "../agents/llm_agent.js";
-import { InMemoryMemoryService } from "../memory/in_memory_memory_service.js";
-import { Runner } from "../runner/runner.js";
-import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
-import { GoogleLLMVariant } from "../utils/variant_utils.js";
-import { State } from "../sessions/state.js";
-import { BaseTool } from "./base_tool.js";
-import { ForwardingArtifactService } from "./forwarding_artifact_service.js";
-const AGENT_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.agentTool");
-function isAgentTool(obj) {
-  return typeof obj === "object" && obj !== null && AGENT_TOOL_SIGNATURE_SYMBOL in obj && obj[AGENT_TOOL_SIGNATURE_SYMBOL] === true;
-}
-__name(isAgentTool, "isAgentTool");
-const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
-  constructor(config) {
-    super({
-      name: config.agent.name,
-      description: config.agent.description || ""
-    });
-    /** A unique symbol to identify ADK agent tool class. */
-    this[_a] = true;
-    this.agent = config.agent;
-    this.skipSummarization = config.skipSummarization || false;
-  }
-  _getDeclaration() {
-    let declaration;
-    if (isLlmAgent(this.agent) && this.agent.inputSchema) {
-      declaration = {
-        name: this.name,
-        description: this.description,
-        // TODO(b/425992518): We should not use the agent's input schema as is.
-        // It should be validated and possibly transformed. Consider similar
-        // logic to one we have in Python ADK.
-        parameters: this.agent.inputSchema
-      };
-    } else {
-      declaration = {
-        name: this.name,
-        description: this.description,
-        parameters: {
-          type: Type.OBJECT,
-          properties: {
-            "request": {
-              type: Type.STRING
-            }
-          },
-          required: ["request"]
-        }
-      };
-    }
-    if (this.apiVariant !== GoogleLLMVariant.GEMINI_API) {
-      const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
-      declaration.response = hasOutputSchema ? { type: Type.OBJECT } : { type: Type.STRING };
-    }
-    return declaration;
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    var _a2, _b2, _c, _d, _e, _f;
-    const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
-    const content = {
-      role: "user",
-      parts: [
-        {
-          // TODO(b/425992518): Should be validated. Consider similar
-          // logic to one we have in Python ADK.
-          text: hasInputSchema ? JSON.stringify(args) : args["request"]
-        }
-      ]
-    };
-    const runner = new Runner({
-      appName: this.agent.name,
-      agent: this.agent,
-      artifactService: new ForwardingArtifactService(toolContext),
-      sessionService: (_a2 = toolContext.invocationContext.sessionService) != null ? _a2 : new InMemorySessionService(),
-      memoryService: (_b2 = toolContext.invocationContext.memoryService) != null ? _b2 : new InMemoryMemoryService(),
-      credentialService: toolContext.invocationContext.credentialService
-    });
-    const session = await runner.sessionService.getOrCreateSession({
-      appName: this.agent.name,
-      userId: toolContext.invocationContext.userId,
-      sessionId: toolContext.invocationContext.session.id,
-      state: toolContext.state.toRecord()
-    });
-    if ((_c = toolContext.abortSignal) == null ? void 0 : _c.aborted) {
-      return "";
-    }
-    let lastEvent;
-    try {
-      for (var iter = __forAwait(runner.runAsync({
-        userId: session.userId,
-        sessionId: session.id,
-        newMessage: content,
-        abortSignal: toolContext.abortSignal
-      })), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
-        const event = temp.value;
-        if ((_d = toolContext.abortSignal) == null ? void 0 : _d.aborted) {
-          return;
-        }
-        if (event.actions.stateDelta) {
-          const filteredDelta = Object.fromEntries(
-            Object.entries(event.actions.stateDelta).filter(
-              ([key]) => !key.startsWith(State.TEMP_PREFIX)
-            )
-          );
-          if (Object.keys(filteredDelta).length > 0) {
-            toolContext.state.update(filteredDelta);
-          }
-        }
-        lastEvent = event;
-      }
-    } catch (temp) {
-      error = [temp];
-    } finally {
-      try {
-        more && (temp = iter.return) && await temp.call(iter);
-      } finally {
-        if (error)
-          throw error[0];
-      }
-    }
-    if (!((_f = (_e = lastEvent == null ? void 0 : lastEvent.content) == null ? void 0 : _e.parts) == null ? void 0 : _f.length)) {
-      return "";
-    }
-    const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
-    const mergedText = lastEvent.content.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
-    return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
-  }
-};
-__name(_AgentTool, "AgentTool");
-let AgentTool = _AgentTool;
-export {
-  AgentTool,
-  isAgentTool
-};

package/dist/web/tools/base_tool.js

@@ -1,116 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-var _a;
-import { getGoogleLlmVariant } from "../utils/variant_utils.js";
-const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
-function isBaseTool(obj) {
-  return typeof obj === "object" && obj !== null && BASE_TOOL_SIGNATURE_SYMBOL in obj && obj[BASE_TOOL_SIGNATURE_SYMBOL] === true;
-}
-__name(isBaseTool, "isBaseTool");
-_a = BASE_TOOL_SIGNATURE_SYMBOL;
-const _BaseTool = class _BaseTool {
-  /**
-   * Base constructor for a tool.
-   *
-   * @param params The parameters for `BaseTool`.
-   */
-  constructor(params) {
-    /** A unique symbol to identify ADK base tool class. */
-    this[_a] = true;
-    var _a2;
-    this.name = params.name;
-    this.description = params.description;
-    this.isLongRunning = (_a2 = params.isLongRunning) != null ? _a2 : false;
-  }
-  /**
-   * Gets the OpenAPI specification of this tool in the form of a
-   * FunctionDeclaration.
-   *
-   * NOTE
-   * - Required if subclass uses the default implementation of
-   *   `processLlmRequest` to add function declaration to LLM request.
-   * - Otherwise, can be skipped, e.g. for a built-in GoogleSearch tool for
-   *   Gemini.
-   *
-   * @return The FunctionDeclaration of this tool, or undefined if it doesn't
-   *     need to be added to LlmRequest.config.
-   */
-  _getDeclaration() {
-    return void 0;
-  }
-  /**
-   * Whether this tool needs a human to approve `args` before it runs.
-   *
-   * The gate itself lives in the tool that owns it (see `FunctionTool`), but
-   * the resume path has to ask the same question a turn later, to check that an
-   * approval it is about to honour belongs to a tool that gates at all. A tool
-   * that never gates returns false here, which is the safe default: an approval
-   * naming it is meaningless and gets rejected rather than executed. Mirrors
-   * Python's `BaseTool.check_require_confirmation`.
-   *
-   * @param _args The arguments the tool would run with.
-   * @param _toolContext The context of the call, when there is one.
-   * @return Whether the call requires confirmation.
-   */
-  async checkRequireConfirmation(_args, _toolContext) {
-    return false;
-  }
-  /**
-   * Processes the outgoing LLM request for this tool.
-   *
-   * Use cases:
-   * - Most common use case is adding this tool to the LLM request.
-   * - Some tools may just preprocess the LLM request before it's sent out.
-   *
-   * @param request The request to process the LLM request.
-   */
-  async processLlmRequest({ llmRequest }) {
-    const functionDeclaration = this._getDeclaration();
-    if (!functionDeclaration) {
-      return;
-    }
-    if (this.name in llmRequest.toolsDict) {
-      throw new Error("Duplicate tool name: ".concat(this.name));
-    }
-    llmRequest.toolsDict[this.name] = this;
-    const tool = findToolWithFunctionDeclarations(llmRequest);
-    if (tool) {
-      if (!tool.functionDeclarations) {
-        tool.functionDeclarations = [];
-      }
-      tool.functionDeclarations.push(functionDeclaration);
-    } else {
-      llmRequest.config = llmRequest.config || {};
-      llmRequest.config.tools = llmRequest.config.tools || [];
-      llmRequest.config.tools.push({
-        functionDeclarations: [functionDeclaration]
-      });
-    }
-  }
-  /**
-   * The Google API LLM variant to use.
-   */
-  get apiVariant() {
-    return getGoogleLlmVariant();
-  }
-};
-__name(_BaseTool, "BaseTool");
-let BaseTool = _BaseTool;
-function findToolWithFunctionDeclarations(llmRequest) {
-  var _a2;
-  return (((_a2 = llmRequest.config) == null ? void 0 : _a2.tools) || []).find(
-    (tool) => "functionDeclarations" in tool
-  );
-}
-__name(findToolWithFunctionDeclarations, "findToolWithFunctionDeclarations");
-export {
-  BaseTool,
-  isBaseTool
-};

package/dist/web/tools/base_toolset.js

@@ -1,62 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @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;
-}
-__name(isBaseToolset, "isBaseToolset");
-_a = BASE_TOOLSET_SIGNATURE_SYMBOL;
-const _BaseToolset = 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 || Array.isArray(this.toolFilter) && this.toolFilter.length === 0) {
-      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) {
-  }
-};
-__name(_BaseToolset, "BaseToolset");
-let BaseToolset = _BaseToolset;
-export {
-  BaseToolset,
-  isBaseToolset
-};

package/dist/web/tools/consolidate_context_tool.js

@@ -1,55 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Type } from "@google/genai";
-import { BaseTool } from "./base_tool.js";
-const _ConsolidateContextTool = class _ConsolidateContextTool extends BaseTool {
-  constructor() {
-    super({
-      name: "consolidate_context",
-      description: "Requests context consolidation (compaction) to manage history size. Use this when a subtask is complete and you want to summarize progress and clear detailed history."
-    });
-  }
-  _getDeclaration() {
-    return {
-      name: this.name,
-      description: this.description,
-      parameters: {
-        type: Type.OBJECT,
-        properties: {
-          detail: {
-            type: Type.STRING,
-            description: "Optional description of what has been accomplished so far. This detail will be used to guide the summarization of the history."
-          }
-        }
-      }
-    };
-  }
-  async runAsync({
-    args,
-    toolContext
-  }) {
-    toolContext.state.set("temp:consolidate_context", true);
-    if (args["detail"] !== void 0) {
-      toolContext.state.set(
-        "temp:consolidate_context_detail",
-        args["detail"]
-      );
-    }
-    return {
-      status: "success",
-      message: "Context consolidation requested."
-    };
-  }
-};
-__name(_ConsolidateContextTool, "ConsolidateContextTool");
-let ConsolidateContextTool = _ConsolidateContextTool;
-export {
-  ConsolidateContextTool
-};