@softactivate/adk 1.1.0

package/dist/web/telemetry/google_cloud.js

@@ -0,0 +1,54 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
+import { TraceExporter } from "@google-cloud/opentelemetry-cloud-trace-exporter";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import { detectResources } from "@opentelemetry/resources";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { GoogleAuth } from "google-auth-library";
+import { logger } from "../utils/logger.js";
+const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
+async function getGcpProjectId() {
+  try {
+    const auth = new GoogleAuth();
+    const projectId = await auth.getProjectId();
+    return projectId || void 0;
+  } catch (_e) {
+    return void 0;
+  }
+}
+async function getGcpExporters(config = {}) {
+  const {
+    enableTracing = false,
+    enableMetrics = false
+    // enableCloudLogging = false,
+  } = config;
+  const projectId = await getGcpProjectId();
+  if (!projectId) {
+    logger.warn(GCP_PROJECT_ERROR_MESSAGE);
+    return {};
+  }
+  return {
+    spanProcessors: enableTracing ? [new BatchSpanProcessor(new TraceExporter({ projectId }))] : [],
+    metricReaders: enableMetrics ? [
+      new PeriodicExportingMetricReader({
+        exporter: new MetricExporter({ projectId }),
+        exportIntervalMillis: 5e3
+      })
+    ] : [],
+    logRecordProcessors: []
+  };
+}
+function getGcpResource() {
+  return detectResources({ detectors: [gcpDetector] });
+}
+export {
+  getGcpExporters,
+  getGcpResource
+};

package/dist/web/telemetry/setup.js

@@ -0,0 +1,83 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { metrics, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { detectResources } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
+  const resource = otelResource || getOtelResource();
+  const allHooks = [...otelHooksToSetup, getOtelExporters()];
+  const spanProcessors = allHooks.flatMap(
+    (hooks) => hooks.spanProcessors || []
+  );
+  const metricReaders = allHooks.flatMap((hooks) => hooks.metricReaders || []);
+  const logRecordProcessors = allHooks.flatMap(
+    (hooks) => hooks.logRecordProcessors || []
+  );
+  if (spanProcessors.length > 0) {
+    const tracerProvider = new NodeTracerProvider({
+      resource,
+      spanProcessors
+    });
+    tracerProvider.register();
+    trace.setGlobalTracerProvider(tracerProvider);
+  }
+  if (metricReaders.length > 0) {
+    const meterProvider = new MeterProvider({
+      readers: metricReaders,
+      resource
+    });
+    metrics.setGlobalMeterProvider(meterProvider);
+  }
+  if (logRecordProcessors.length > 0) {
+    const loggerProvider = new LoggerProvider({
+      resource,
+      processors: logRecordProcessors
+    });
+    logs.setGlobalLoggerProvider(loggerProvider);
+  }
+}
+function getOtelResource() {
+  return detectResources({
+    detectors: []
+  });
+}
+function getOtelExportersConfig() {
+  return {
+    enableTracing: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT),
+    enableMetrics: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT),
+    enableLogging: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
+  };
+}
+function getOtelExporters(config = getOtelExportersConfig()) {
+  const { enableTracing, enableMetrics, enableLogging } = config;
+  return {
+    spanProcessors: enableTracing ? [new BatchSpanProcessor(new OTLPTraceExporter())] : [],
+    metricReaders: enableMetrics ? [
+      new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter()
+      })
+    ] : [],
+    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
+  };
+}
+export {
+  maybeSetOtelProviders
+};

package/dist/web/telemetry/tracing.js

@@ -0,0 +1,234 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 tracer = trace.getTracer("gcp.vertex.agent", version);
+function safeJsonSerialize(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (_e) {
+    return "<not serializable>";
+  }
+}
+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
+  });
+}
+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) : "{}"
+  });
+}
+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) : "{}"
+  );
+}
+function traceCallLlm({
+  invocationContext,
+  eventId,
+  llmRequest,
+  llmResponse
+}) {
+  var _a, _b, _c;
+  const span = trace.getActiveSpan();
+  if (!span) return;
+  span.setAttributes({
+    "gen_ai.system": "gcp.vertex.agent",
+    "gen_ai.request.model": llmRequest.model,
+    "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 ((_a = llmRequest.config) == null ? void 0 : _a.topP) {
+    span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
+  }
+  if (((_b = llmRequest.config) == null ? void 0 : _b.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 ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.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]);
+  }
+}
+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) : "{}"
+  );
+}
+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;
+}
+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]()
+      );
+    }
+  };
+}
+function runAsyncGeneratorWithOtelContext(otelContext, generatorFnContext, generatorFn) {
+  const generator = generatorFn.call(generatorFnContext);
+  return bindOtelContextToAsyncGenerator(otelContext, generator);
+}
+function shouldAddRequestResponseToSpans() {
+  const envValue = process.env.ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS || "true";
+  return envValue === "true" || envValue === "1";
+}
+export {
+  runAsyncGeneratorWithOtelContext,
+  traceAgentInvocation,
+  traceCallLlm,
+  traceMergedToolCalls,
+  traceSendData,
+  traceToolCall,
+  tracer
+};

package/dist/web/tools/agent_tool.js

@@ -0,0 +1,233 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+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 { 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;
+}
+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;
+  }
+  /**
+   * Sets up the Runner and Session for sub-agent execution.
+   *
+   * Shared by {@link runAsync} and {@link runAsyncWithEvents}.
+   */
+  async setupRunnerAndSession({
+    args,
+    toolContext
+  }) {
+    var _a2, _b2;
+    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()
+    });
+    return {
+      runner,
+      content,
+      sessionUserId: session.userId,
+      sessionId: session.id
+    };
+  }
+  /**
+   * Builds the tool result from the last content event of the sub-agent.
+   *
+   * Excludes thought parts and applies the output schema (if any).
+   */
+  buildToolResultFromContent(lastContent) {
+    var _a2;
+    if (!((_a2 = lastContent == null ? void 0 : lastContent.parts) == null ? void 0 : _a2.length)) {
+      return "";
+    }
+    const hasOutputSchema = isLlmAgent(this.agent) && this.agent.outputSchema;
+    const mergedText = lastContent.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
+    return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
+  }
+  async runAsync({
+    args,
+    toolContext
+  }) {
+    var _a2, _b2;
+    if (this.skipSummarization) {
+      toolContext.actions.skipSummarization = true;
+    }
+    const { runner, content, sessionUserId, sessionId } = await this.setupRunnerAndSession({ args, toolContext });
+    if ((_a2 = toolContext.abortSignal) == null ? void 0 : _a2.aborted) {
+      return "";
+    }
+    let lastEvent;
+    try {
+      for (var iter = __forAwait(runner.runAsync({
+        userId: sessionUserId,
+        sessionId,
+        newMessage: content,
+        runConfig: toolContext.invocationContext.runConfig,
+        abortSignal: toolContext.abortSignal
+      })), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const event = temp.value;
+        if ((_b2 = toolContext.abortSignal) == null ? void 0 : _b2.aborted) {
+          return;
+        }
+        if (event.actions.stateDelta) {
+          toolContext.state.update(event.actions.stateDelta);
+        }
+        lastEvent = event;
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return this.buildToolResultFromContent(lastEvent == null ? void 0 : lastEvent.content);
+  }
+  /**
+   * Runs the wrapped agent and yields the sub-agent's events as they are
+   * produced, providing real-time visibility into sub-agent progress.
+   *
+   * Counterpart to {@link runAsync}; the caller is responsible for tracking
+   * the last content event and building the final tool result via
+   * {@link buildToolResultFromContent}.
+   */
+  runAsyncWithEvents(_0) {
+    return __asyncGenerator(this, arguments, function* ({
+      args,
+      toolContext
+    }) {
+      var _a2, _b2;
+      if (this.skipSummarization) {
+        toolContext.actions.skipSummarization = true;
+      }
+      const { runner, content, sessionUserId, sessionId } = yield new __await(this.setupRunnerAndSession({ args, toolContext }));
+      if ((_a2 = toolContext.abortSignal) == null ? void 0 : _a2.aborted) {
+        return;
+      }
+      try {
+        for (var iter = __forAwait(runner.runAsync({
+          userId: sessionUserId,
+          sessionId,
+          newMessage: content,
+          runConfig: toolContext.invocationContext.runConfig,
+          abortSignal: toolContext.abortSignal
+        })), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const event = temp.value;
+          if ((_b2 = toolContext.abortSignal) == null ? void 0 : _b2.aborted) {
+            return;
+          }
+          if (event.actions.stateDelta) {
+            toolContext.state.update(event.actions.stateDelta);
+          }
+          yield event;
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+}
+export {
+  AgentTool,
+  isAgentTool
+};

package/dist/web/tools/base_tool.js

@@ -0,0 +1,93 @@
+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;
+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;
+}
+_a = BASE_TOOL_SIGNATURE_SYMBOL;
+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;
+  }
+  /**
+   * 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();
+  }
+}
+function findToolWithFunctionDeclarations(llmRequest) {
+  var _a2;
+  return (((_a2 = llmRequest.config) == null ? void 0 : _a2.tools) || []).find(
+    (tool) => "functionDeclarations" in tool
+  );
+}
+export {
+  BaseTool,
+  isBaseTool
+};