@google/adk 1.6.0 → 2.1.0

package/dist/esm/skills/loader.js

@@ -1,5 +1,7 @@
 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
@@ -7,6 +9,7 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 import AdmZip from "adm-zip";
 import yaml from "js-yaml";
+import { isUtf8 } from "node:buffer";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { logger } from "../utils/logger.js";
@@ -46,6 +49,10 @@ const IGNORED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".tsbuildinfo",
   ".DS_Store"
 ]);
+function decodeSkillFileContent(data) {
+  return isUtf8(data) ? data.toString("utf-8") : data;
+}
+__name(decodeSkillFileContent, "decodeSkillFileContent");
 async function loadDir(directoryPath) {
   const files = {};
   async function walk(dir) {
@@ -63,14 +70,11 @@ async function loadDir(directoryPath) {
           continue;
         }
         const fileData = await fs.readFile(fullPath);
-        try {
-          files[relativePath] = fileData.toString("utf-8");
-        } catch (_e) {
-          files[relativePath] = fileData;
-        }
+        files[relativePath] = decodeSkillFileContent(fileData);
       }
     }
   }
+  __name(walk, "walk");
   try {
     const stats = await fs.stat(directoryPath);
     if (stats.isDirectory()) {
@@ -83,6 +87,7 @@ async function loadDir(directoryPath) {
   }
   return files;
 }
+__name(loadDir, "loadDir");
 function parseFrontmatterYaml(content) {
   if (!content.startsWith("---")) {
     throw new Error("SKILL.md must start with YAML frontmatter (---)");
@@ -103,6 +108,7 @@ function parseFrontmatterYaml(content) {
     throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
   }
 }
+__name(parseFrontmatterYaml, "parseFrontmatterYaml");
 function validateFrontmatter(raw) {
   try {
     return FrontmatterSchema.parse(raw);
@@ -110,19 +116,23 @@ function validateFrontmatter(raw) {
     throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
   }
 }
+__name(validateFrontmatter, "validateFrontmatter");
 function parseSkillMdContent(content) {
   const { raw, body } = parseFrontmatterYaml(content);
   return { frontmatter: validateFrontmatter(raw), body };
 }
+__name(parseSkillMdContent, "parseSkillMdContent");
 function isDangerousZipEntryName(entryName) {
   if (path.posix.isAbsolute(entryName) || path.win32.isAbsolute(entryName)) {
     return true;
   }
   return entryName.split(/[/\\]/).some((segment) => segment === "..");
 }
+__name(isDangerousZipEntryName, "isDangerousZipEntryName");
 function isBareSkillName(name) {
   return name !== "." && name !== ".." && path.basename(name) === name;
 }
+__name(isBareSkillName, "isBareSkillName");
 async function loadSkillFromDir(skillDir) {
   const resolvedDir = path.resolve(skillDir);
   const skill = await loadSkillFile(skillDir);
@@ -146,6 +156,7 @@ async function loadSkillFromDir(skillDir) {
     resources
   };
 }
+__name(loadSkillFromDir, "loadSkillFromDir");
 async function validateSkillDir(skillDir) {
   const problems = [];
   const resolvedDir = path.resolve(skillDir);
@@ -174,6 +185,7 @@ async function validateSkillDir(skillDir) {
   }
   return problems;
 }
+__name(validateSkillDir, "validateSkillDir");
 async function loadSkillFile(skillDir) {
   const resolvedDir = path.resolve(skillDir);
   let skillMdPath = "";
@@ -214,6 +226,7 @@ async function loadSkillFile(skillDir) {
     instructions: body
   };
 }
+__name(loadSkillFile, "loadSkillFile");
 async function loadAllSkillsInDir(skillsBasePath) {
   const resolvedPath = path.resolve(skillsBasePath);
   const skills = {};
@@ -251,6 +264,7 @@ async function loadAllSkillsInDir(skillsBasePath) {
       }
     }
   }
+  __name(scanDir, "scanDir");
   try {
     await fs.readdir(resolvedPath);
     await scanDir(resolvedPath);
@@ -259,6 +273,7 @@ async function loadAllSkillsInDir(skillsBasePath) {
   }
   return skills;
 }
+__name(loadAllSkillsInDir, "loadAllSkillsInDir");
 function loadSkillFromZipBuffer(zipBuffer) {
   const zip = new AdmZip(zipBuffer);
   const entries = zip.getEntries();
@@ -300,15 +315,12 @@ function loadSkillFromZipBuffer(zipBuffer) {
         const relativePath = entry.entryName.substring(normPrefix.length);
         if (!relativePath) continue;
         const data = entry.getData();
-        try {
-          res[relativePath] = data.toString("utf-8");
-        } catch (_e) {
-          res[relativePath] = data;
-        }
+        res[relativePath] = decodeSkillFileContent(data);
       }
     }
     return res;
   }
+  __name(loadZipDir, "loadZipDir");
   const refFiles = loadZipDir("references");
   for (const [key, val] of Object.entries(refFiles)) {
     references[key] = val;
@@ -333,6 +345,7 @@ function loadSkillFromZipBuffer(zipBuffer) {
     }
   };
 }
+__name(loadSkillFromZipBuffer, "loadSkillFromZipBuffer");
 export {
   loadAllSkillsInDir,
   loadSkillFromDir,

package/dist/esm/skills/prompt.js

@@ -1,5 +1,7 @@
 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
@@ -8,6 +10,7 @@ const require = topLevelCreateRequire(import.meta.url);
 function escapeHtml(unsafe) {
   return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
+__name(escapeHtml, "escapeHtml");
 function formatSkillsAsXml(skills) {
   if (!skills || skills.length === 0) {
     return "<available_skills>\n</available_skills>";
@@ -25,6 +28,7 @@ function formatSkillsAsXml(skills) {
   lines.push("</available_skills>");
   return lines.join("\n");
 }
+__name(formatSkillsAsXml, "formatSkillsAsXml");
 export {
   formatSkillsAsXml
 };

package/dist/esm/telemetry/google_cloud.js

@@ -1,18 +1,40 @@
 import {createRequire as topLevelCreateRequire} from 'module';
 const require = topLevelCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 /**
  * @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";
+import { loadOptionalPeer } from "../utils/optional_peer.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 {
@@ -23,6 +45,32 @@ async function getGcpProjectId() {
     return void 0;
   }
 }
+__name(getGcpProjectId, "getGcpProjectId");
+async function createCloudTraceProcessor(projectId) {
+  const { TraceExporter } = await loadOptionalPeer(
+    {
+      packageName: "@google-cloud/opentelemetry-cloud-trace-exporter",
+      feature: "getGcpExporters({enableTracing: true})"
+    },
+    () => Promise.resolve().then(() => __toESM(require("@google-cloud/opentelemetry-cloud-trace-exporter"), 1))
+  );
+  return new BatchSpanProcessor(new TraceExporter({ projectId }));
+}
+__name(createCloudTraceProcessor, "createCloudTraceProcessor");
+async function createCloudMetricReader(projectId) {
+  const { MetricExporter } = await loadOptionalPeer(
+    {
+      packageName: "@google-cloud/opentelemetry-cloud-monitoring-exporter",
+      feature: "getGcpExporters({enableMetrics: true})"
+    },
+    () => Promise.resolve().then(() => __toESM(require("@google-cloud/opentelemetry-cloud-monitoring-exporter"), 1))
+  );
+  return new PeriodicExportingMetricReader({
+    exporter: new MetricExporter({ projectId }),
+    exportIntervalMillis: 5e3
+  });
+}
+__name(createCloudMetricReader, "createCloudMetricReader");
 async function getGcpExporters(config = {}) {
   const {
     enableTracing = false,
@@ -35,19 +83,16 @@ async function getGcpExporters(config = {}) {
     return {};
   }
   return {
-    spanProcessors: enableTracing ? [new BatchSpanProcessor(new TraceExporter({ projectId }))] : [],
-    metricReaders: enableMetrics ? [
-      new PeriodicExportingMetricReader({
-        exporter: new MetricExporter({ projectId }),
-        exportIntervalMillis: 5e3
-      })
-    ] : [],
+    spanProcessors: enableTracing ? [await createCloudTraceProcessor(projectId)] : [],
+    metricReaders: enableMetrics ? [await createCloudMetricReader(projectId)] : [],
     logRecordProcessors: []
   };
 }
+__name(getGcpExporters, "getGcpExporters");
 function getGcpResource() {
   return detectResources({ detectors: [gcpDetector] });
 }
+__name(getGcpResource, "getGcpResource");
 export {
   getGcpExporters,
   getGcpResource

package/dist/esm/telemetry/setup.js

@@ -1,5 +1,7 @@
 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
@@ -54,11 +56,13 @@ function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
     logs.setGlobalLoggerProvider(loggerProvider);
   }
 }
+__name(maybeSetOtelProviders, "maybeSetOtelProviders");
 function getOtelResource() {
   return detectResources({
     detectors: []
   });
 }
+__name(getOtelResource, "getOtelResource");
 function getOtelExportersConfig() {
   return {
     enableTracing: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT),
@@ -66,6 +70,7 @@ function getOtelExportersConfig() {
     enableLogging: !!(process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
   };
 }
+__name(getOtelExportersConfig, "getOtelExportersConfig");
 function getOtelExporters(config = getOtelExportersConfig()) {
   const { enableTracing, enableMetrics, enableLogging } = config;
   return {
@@ -75,9 +80,10 @@ function getOtelExporters(config = getOtelExportersConfig()) {
         exporter: new OTLPMetricExporter()
       })
     ] : [],
-    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor(new OTLPLogExporter())] : []
+    logRecordProcessors: enableLogging ? [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter() })] : []
   };
 }
+__name(getOtelExporters, "getOtelExporters");
 export {
   maybeSetOtelProviders
 };

package/dist/esm/telemetry/tracing.js

@@ -1,5 +1,7 @@
 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
@@ -15,6 +17,12 @@ 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 {
@@ -23,6 +31,7 @@ function safeJsonSerialize(obj) {
     return "<not serializable>";
   }
 }
+__name(safeJsonSerialize, "safeJsonSerialize");
 function traceAgentInvocation({
   agent,
   invocationContext
@@ -37,6 +46,41 @@ function traceAgentInvocation({
     [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,
@@ -78,6 +122,7 @@ function traceToolCall({
     "gcp.vertex.agent.tool_response": shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
   });
 }
+__name(traceToolCall, "traceToolCall");
 function traceMergedToolCalls({
   responseEventId,
   functionResponseEvent
@@ -101,28 +146,30 @@ function traceMergedToolCalls({
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
   );
 }
+__name(traceMergedToolCalls, "traceMergedToolCalls");
 function traceCallLlm({
   invocationContext,
   eventId,
   llmRequest,
   llmResponse
 }) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const span = trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
     "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 ((_a = llmRequest.config) == null ? void 0 : _a.topP) {
+  if ((_b = llmRequest.config) == null ? void 0 : _b.topP) {
     span.setAttribute("gen_ai.request.top_p", llmRequest.config.topP);
   }
-  if (((_b = llmRequest.config) == null ? void 0 : _b.maxOutputTokens) !== void 0) {
+  if (((_c = llmRequest.config) == null ? void 0 : _c.maxOutputTokens) !== void 0) {
     span.setAttribute(
       "gen_ai.request.max_tokens",
       llmRequest.config.maxOutputTokens
@@ -138,7 +185,7 @@ function traceCallLlm({
       llmResponse.usageMetadata.promptTokenCount || 0
     );
   }
-  if ((_c = llmResponse.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) {
+  if ((_d = llmResponse.usageMetadata) == null ? void 0 : _d.candidatesTokenCount) {
     span.setAttribute(
       "gen_ai.usage.output_tokens",
       llmResponse.usageMetadata.candidatesTokenCount
@@ -149,6 +196,7 @@ function traceCallLlm({
     span.setAttribute("gen_ai.response.finish_reasons", [finishReasonValue]);
   }
 }
+__name(traceCallLlm, "traceCallLlm");
 function traceSendData({
   invocationContext,
   eventId,
@@ -165,13 +213,24 @@ function traceSendData({
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
   );
 }
+__name(traceSendData, "traceSendData");
+function redactHttpOptions(httpOptions) {
+  const redacted = { ...httpOptions };
+  delete redacted.headers;
+  delete redacted.extraBody;
+  return redacted;
+}
+__name(redactHttpOptions, "redactHttpOptions");
 function buildLlmRequestForTrace(llmRequest) {
   const result = {
     model: llmRequest.model,
     contents: []
   };
   if (llmRequest.config) {
-    const { responseSchema, ...cleanConfig } = llmRequest.config;
+    const { responseSchema: _responseSchema, ...cleanConfig } = llmRequest.config;
+    if (cleanConfig.httpOptions) {
+      cleanConfig.httpOptions = redactHttpOptions(cleanConfig.httpOptions);
+    }
     result.config = cleanConfig;
   }
   result.contents = llmRequest.contents.map((content) => {
@@ -183,6 +242,7 @@ function buildLlmRequestForTrace(llmRequest) {
   });
   return result;
 }
+__name(buildLlmRequestForTrace, "buildLlmRequestForTrace");
 function bindOtelContextToAsyncGenerator(ctx, generator) {
   return {
     // Bind the next() method to execute within the provided context
@@ -200,20 +260,25 @@ function bindOtelContextToAsyncGenerator(ctx, generator) {
     }
   };
 }
+__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/esm/tools/agent_tool.js

@@ -1,5 +1,7 @@
 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
@@ -15,11 +17,12 @@ 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");
+const AGENT_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ 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) {
+__name(isAgentTool, "isAgentTool");
+const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
   constructor(config) {
     super({
       name: config.agent.name,
@@ -37,8 +40,7 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
         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.
+        // It should be validated and possibly transformed first.
         parameters: this.agent.inputSchema
       };
     } else {
@@ -72,8 +74,8 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
       role: "user",
       parts: [
         {
-          // TODO(b/425992518): Should be validated. Consider similar
-          // logic to one we have in Python ADK.
+          // TODO(b/425992518): Args should be validated against the agent's
+          // input schema before being forwarded.
           text: hasInputSchema ? JSON.stringify(args) : args["request"]
         }
       ]
@@ -124,7 +126,9 @@ class AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGNATURE_SYMBOL, _b) {
     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/esm/tools/base_tool.js

@@ -1,5 +1,7 @@
 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
@@ -7,12 +9,18 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 var _a;
 import { getGoogleLlmVariant } from "../utils/variant_utils.js";
-const BASE_TOOL_SIGNATURE_SYMBOL = Symbol.for("google.adk.baseTool");
+const BASE_TOOL_SIGNATURE_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseTool");
+const IN_MODEL_TOOL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.inModelTool");
+function isInModelTool(tool) {
+  return typeof tool === "object" && tool !== null && tool[IN_MODEL_TOOL_SYMBOL] === true;
+}
+__name(isInModelTool, "isInModelTool");
 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;
-class BaseTool {
+const _BaseTool = class _BaseTool {
   /**
    * Base constructor for a tool.
    *
@@ -42,6 +50,23 @@ class BaseTool {
   _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.
    *
@@ -56,7 +81,8 @@ class BaseTool {
     if (!functionDeclaration) {
       return;
     }
-    if (this.name in llmRequest.toolsDict) {
+    const registered = Object.hasOwn(llmRequest.toolsDict, this.name) ? llmRequest.toolsDict[this.name] : void 0;
+    if (registered && !isInModelTool(registered)) {
       throw new Error(`Duplicate tool name: ${this.name}`);
     }
     llmRequest.toolsDict[this.name] = this;
@@ -80,14 +106,19 @@ class BaseTool {
   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
+  IN_MODEL_TOOL_SYMBOL,
+  isBaseTool,
+  isInModelTool
 };

package/dist/esm/tools/base_toolset.js

@@ -1,17 +1,20 @@
 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");
+const BASE_TOOLSET_SIGNATURE_SYMBOL = /* @__PURE__ */ 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;
-class BaseToolset {
+const _BaseToolset = class _BaseToolset {
   constructor(toolFilter, prefix) {
     this.toolFilter = toolFilter;
     this.prefix = prefix;
@@ -45,12 +48,14 @@ class BaseToolset {
    *   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.
+   * @param _toolContext The context of the tool.
+   * @param _llmRequest The outgoing LLM request, mutable this method.
    */
-  async processLlmRequest(toolContext, llmRequest) {
+  async processLlmRequest(_toolContext, _llmRequest) {
   }
-}
+};
+__name(_BaseToolset, "BaseToolset");
+let BaseToolset = _BaseToolset;
 export {
   BaseToolset,
   isBaseToolset