@google/adk 2.2.1 → 2.4.0

package/dist/cjs/skills/loader.js

@@ -43,10 +43,12 @@ __export(loader_exports, {
 });
 module.exports = __toCommonJS(loader_exports);
 var import_adm_zip = __toESM(require("adm-zip"), 1);
-var import_js_yaml = __toESM(require("js-yaml"), 1);
+var yaml = __toESM(require("js-yaml"), 1);
 var import_node_buffer = require("node:buffer");
 var fs = __toESM(require("node:fs/promises"), 1);
 var path = __toESM(require("node:path"), 1);
+var import_input_validation_error = require("../errors/input_validation_error.js");
+var import_not_found_error = require("../errors/not_found_error.js");
 var import_logger = require("../utils/logger.js");
 var import_skill = require("./skill.js");
 /**
@@ -126,24 +128,37 @@ async function loadDir(directoryPath) {
   return files;
 }
 __name(loadDir, "loadDir");
+const FRONTMATTER_BOM = "\uFEFF";
+const FRONTMATTER_PATTERN = /^---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)??---[ \t]*(?:\r?\n|$)/;
 function parseFrontmatterYaml(content) {
-  if (!content.startsWith("---")) {
-    throw new Error("SKILL.md must start with YAML frontmatter (---)");
+  var _a;
+  const text = content.startsWith(FRONTMATTER_BOM) ? content.slice(FRONTMATTER_BOM.length) : content;
+  if (!text.startsWith("---")) {
+    throw new import_input_validation_error.InputValidationError(
+      "SKILL.md must start with YAML frontmatter (---)"
+    );
   }
-  const parts = content.split("---");
-  if (parts.length < 3) {
-    throw new Error("SKILL.md frontmatter not properly closed with ---");
+  const match = FRONTMATTER_PATTERN.exec(text);
+  if (!match) {
+    throw new import_input_validation_error.InputValidationError(
+      "SKILL.md frontmatter not properly closed with ---"
+    );
   }
-  const frontmatterStr = parts[1];
-  const body = parts.filter((_, i) => i >= 2).join("---").trim();
+  const frontmatterStr = (_a = match[1]) != null ? _a : "";
+  const body = text.slice(match[0].length).trim();
   try {
-    const parsed = import_js_yaml.default.load(frontmatterStr);
+    const parsed = yaml.load(frontmatterStr);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("SKILL.md frontmatter must be a YAML mapping");
+      throw new import_input_validation_error.InputValidationError(
+        "SKILL.md frontmatter must be a YAML mapping"
+      );
     }
     return { raw: parsed, body };
   } catch (e) {
-    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+    throw new import_input_validation_error.InputValidationError(
+      `Invalid YAML in frontmatter: ${e.message}`,
+      { cause: e }
+    );
   }
 }
 __name(parseFrontmatterYaml, "parseFrontmatterYaml");
@@ -151,7 +166,10 @@ function validateFrontmatter(raw) {
   try {
     return import_skill.FrontmatterSchema.parse(raw);
   } catch (e) {
-    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+    throw new import_input_validation_error.InputValidationError(
+      `Invalid YAML in frontmatter: ${e.message}`,
+      { cause: e }
+    );
   }
 }
 __name(validateFrontmatter, "validateFrontmatter");
@@ -198,6 +216,18 @@ __name(loadSkillFromDir, "loadSkillFromDir");
 async function validateSkillDir(skillDir) {
   const problems = [];
   const resolvedDir = path.resolve(skillDir);
+  try {
+    const stats = await fs.stat(resolvedDir);
+    if (!stats.isDirectory()) {
+      return [`'${resolvedDir}' is not a directory.`];
+    }
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return [`Directory '${resolvedDir}' does not exist.`];
+    }
+    return [`Failed to access '${resolvedDir}': ${e.message}`];
+  }
   let skill;
   try {
     skill = await loadSkillFile(resolvedDir);
@@ -247,7 +277,7 @@ async function loadSkillFile(skillDir) {
     );
   }
   if (!skillMdPath) {
-    throw new Error(
+    throw new import_not_found_error.NotFoundError(
       `SKILL.md (or any case variation like skill.md) not found in '${skillDir}'.`
     );
   }
@@ -255,7 +285,7 @@ async function loadSkillFile(skillDir) {
   const frontmatter = import_skill.FrontmatterSchema.parse(parsed);
   const dirName = path.basename(resolvedDir);
   if (dirName !== frontmatter.name) {
-    throw new Error(
+    throw new import_input_validation_error.InputValidationError(
       `Skill name '${frontmatter.name}' does not match directory name '${dirName}'.`
     );
   }
@@ -317,7 +347,9 @@ function loadSkillFromZipBuffer(zipBuffer) {
   const entries = zip.getEntries();
   for (const entry of entries) {
     if (isDangerousZipEntryName(entry.entryName)) {
-      throw new Error(`Dangerous zip entry ignored: ${entry.entryName}`);
+      throw new import_input_validation_error.InputValidationError(
+        `Dangerous zip entry ignored: ${entry.entryName}`
+      );
     }
   }
   let skillMdContent = "";
@@ -329,15 +361,17 @@ function loadSkillFromZipBuffer(zipBuffer) {
     }
   }
   if (!skillMdContent) {
-    throw new Error("SKILL.md not found in zipped filesystem.");
+    throw new import_not_found_error.NotFoundError("SKILL.md not found in zipped filesystem.");
   }
   const { raw, body } = parseFrontmatterYaml(skillMdContent);
   const skillName = raw["name"];
   if (!skillName) {
-    throw new Error("SKILL.md frontmatter must contain 'name'");
+    throw new import_input_validation_error.InputValidationError("SKILL.md frontmatter must contain 'name'");
   }
   if (typeof skillName !== "string" || !isBareSkillName(skillName)) {
-    throw new Error(`Invalid skill name in SKILL.md: ${String(skillName)}`);
+    throw new import_input_validation_error.InputValidationError(
+      `Invalid skill name in SKILL.md: ${String(skillName)}`
+    );
   }
   const frontmatter = validateFrontmatter(raw);
   const references = {};

package/dist/cjs/telemetry/setup.js

@@ -59,7 +59,6 @@ function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
       spanProcessors
     });
     tracerProvider.register();
-    import_api.trace.setGlobalTracerProvider(tracerProvider);
   }
   if (metricReaders.length > 0) {
     const meterProvider = new import_sdk_metrics.MeterProvider({

package/dist/cjs/telemetry/tracing.js

@@ -25,6 +25,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tracing_exports = {};
 __export(tracing_exports, {
+  resolveErrorType: () => resolveErrorType,
   runAsyncGeneratorWithOtelContext: () => runAsyncGeneratorWithOtelContext,
   traceAgentInvocation: () => traceAgentInvocation,
   traceCallLlm: () => traceCallLlm,
@@ -36,6 +37,7 @@ __export(tracing_exports, {
   tracer: () => tracer
 });
 module.exports = __toCommonJS(tracing_exports);
+var import_genai = require("@google/genai");
 var import_api = require("@opentelemetry/api");
 var import_version = require("../version.js");
 /**
@@ -43,21 +45,46 @@ var import_version = require("../version.js");
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-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 = import_api.trace.getTracer("gcp.vertex.agent", import_version.version);
+var GenAiAttr = /* @__PURE__ */ ((GenAiAttr2) => {
+  GenAiAttr2["AGENT_DESCRIPTION"] = "gen_ai.agent.description";
+  GenAiAttr2["AGENT_NAME"] = "gen_ai.agent.name";
+  GenAiAttr2["CONVERSATION_ID"] = "gen_ai.conversation.id";
+  GenAiAttr2["OPERATION_NAME"] = "gen_ai.operation.name";
+  GenAiAttr2["SYSTEM"] = "gen_ai.system";
+  GenAiAttr2["TOOL_CALL_ID"] = "gen_ai.tool.call.id";
+  GenAiAttr2["TOOL_DESCRIPTION"] = "gen_ai.tool.description";
+  GenAiAttr2["TOOL_NAME"] = "gen_ai.tool.name";
+  GenAiAttr2["TOOL_TYPE"] = "gen_ai.tool.type";
+  GenAiAttr2["REQUEST_MODEL"] = "gen_ai.request.model";
+  GenAiAttr2["REQUEST_TOP_P"] = "gen_ai.request.top_p";
+  GenAiAttr2["REQUEST_MAX_TOKENS"] = "gen_ai.request.max_tokens";
+  GenAiAttr2["USAGE_INPUT_TOKENS"] = "gen_ai.usage.input_tokens";
+  GenAiAttr2["USAGE_OUTPUT_TOKENS"] = "gen_ai.usage.output_tokens";
+  GenAiAttr2["RESPONSE_FINISH_REASONS"] = "gen_ai.response.finish_reasons";
+  return GenAiAttr2;
+})(GenAiAttr || {});
+var AdkAttr = /* @__PURE__ */ ((AdkAttr2) => {
+  AdkAttr2["WORKFLOW_NAME"] = "adk.workflow.name";
+  AdkAttr2["NODE_PATH"] = "adk.node.path";
+  AdkAttr2["NODE_RUN_ID"] = "adk.node.run_id";
+  AdkAttr2["NODE_ATTEMPT"] = "adk.node.attempt";
+  AdkAttr2["NODE_STATUS"] = "adk.node.status";
+  AdkAttr2["NODE_INTERRUPT_COUNT"] = "adk.node.interrupt_count";
+  return AdkAttr2;
+})(AdkAttr || {});
+var GcpAttr = /* @__PURE__ */ ((GcpAttr2) => {
+  GcpAttr2["INVOCATION_ID"] = "gcp.vertex.agent.invocation_id";
+  GcpAttr2["SESSION_ID"] = "gcp.vertex.agent.session_id";
+  GcpAttr2["EVENT_ID"] = "gcp.vertex.agent.event_id";
+  GcpAttr2["LLM_REQUEST"] = "gcp.vertex.agent.llm_request";
+  GcpAttr2["LLM_RESPONSE"] = "gcp.vertex.agent.llm_response";
+  GcpAttr2["TOOL_CALL_ARGS"] = "gcp.vertex.agent.tool_call_args";
+  GcpAttr2["TOOL_RESPONSE"] = "gcp.vertex.agent.tool_response";
+  GcpAttr2["DATA"] = "gcp.vertex.agent.data";
+  return GcpAttr2;
+})(GcpAttr || {});
+const GEN_AI_SYSTEM_VALUE = "gcp.vertex.agent";
+const tracer = import_api.trace.getTracer(GEN_AI_SYSTEM_VALUE, import_version.version);
 function safeJsonSerialize(obj) {
   try {
     return JSON.stringify(obj);
@@ -73,11 +100,11 @@ function traceAgentInvocation({
   const span = import_api.trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "invoke_agent",
+    ["gen_ai.operation.name" /* 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
+    ["gen_ai.agent.description" /* AGENT_DESCRIPTION */]: agent.description,
+    ["gen_ai.agent.name" /* AGENT_NAME */]: agent.name,
+    ["gen_ai.conversation.id" /* CONVERSATION_ID */]: invocationContext.session.id
   });
 }
 __name(traceAgentInvocation, "traceAgentInvocation");
@@ -89,10 +116,10 @@ function traceWorkflowInvocation({
   const span = import_api.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
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "invoke_workflow",
+    ["gen_ai.conversation.id" /* CONVERSATION_ID */]: sessionId,
+    ["adk.workflow.name" /* WORKFLOW_NAME */]: workflowName,
+    ["adk.node.path" /* NODE_PATH */]: nodePath
   });
 }
 __name(traceWorkflowInvocation, "traceWorkflowInvocation");
@@ -106,40 +133,83 @@ function traceNodeExecution({
   const span = import_api.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
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_node",
+    ["adk.node.path" /* NODE_PATH */]: nodePath,
+    ["adk.node.run_id" /* NODE_RUN_ID */]: runId,
+    ["adk.node.attempt" /* NODE_ATTEMPT */]: attempt,
+    ["adk.node.status" /* NODE_STATUS */]: status,
+    ["adk.node.interrupt_count" /* NODE_INTERRUPT_COUNT */]: interruptCount
   });
 }
 __name(traceNodeExecution, "traceNodeExecution");
-function traceToolCall({
-  tool,
-  args,
-  functionResponseEvent
-}) {
+function resolveErrorType(error) {
   var _a, _b;
-  const span = import_api.trace.getActiveSpan();
+  if (error !== null && (typeof error === "object" || typeof error === "function")) {
+    try {
+      const errorObject = error;
+      const customErrorType = (_a = errorObject.errorType) != null ? _a : errorObject.error_type;
+      if (typeof customErrorType === "string" || typeof customErrorType === "number") {
+        return String(customErrorType);
+      }
+      if (error instanceof import_genai.ApiError) {
+        return String(error.status);
+      }
+      const constructorName = (_b = errorObject.constructor) == null ? void 0 : _b.name;
+      if (typeof constructorName === "string" && constructorName.length > 0) {
+        return constructorName;
+      }
+    } catch {
+    }
+  }
+  return typeof error;
+}
+__name(resolveErrorType, "resolveErrorType");
+function traceToolCall(params) {
+  var _a, _b, _c;
+  const {
+    tool,
+    args,
+    functionResponseEvent,
+    invocationContext,
+    error,
+    errorType
+  } = params;
+  const span = (_a = params.span) != null ? _a : import_api.trace.getActiveSpan();
   if (!span) return;
+  const hasError = Object.hasOwn(params, "error");
+  const failureType = hasError ? resolveErrorType(error) : errorType;
+  if (hasError) {
+    let exception;
+    try {
+      exception = error instanceof Error ? error : resolveErrorType(error);
+    } catch {
+      exception = resolveErrorType(error);
+    }
+    span.recordException(exception);
+  }
+  if (failureType !== void 0) {
+    span.setAttribute("error.type", failureType);
+    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: failureType });
+  }
   span.setAttributes({
-    [GEN_AI_OPERATION_NAME]: "execute_tool",
-    [GEN_AI_TOOL_DESCRIPTION]: tool.description || "",
-    [GEN_AI_TOOL_NAME]: tool.name,
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_tool",
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.tool.description" /* TOOL_DESCRIPTION */]: tool.description || "",
+    ["gen_ai.tool.name" /* TOOL_NAME */]: tool.name,
     // e.g. FunctionTool
-    [GEN_AI_TOOL_TYPE]: tool.constructor.name,
+    ["gen_ai.tool.type" /* TOOL_TYPE */]: tool.constructor.name,
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
     // 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) : "{}"
+    ["gcp.vertex.agent.llm_request" /* LLM_REQUEST */]: "{}",
+    ["gcp.vertex.agent.llm_response" /* LLM_RESPONSE */]: "{}",
+    ["gcp.vertex.agent.tool_call_args" /* TOOL_CALL_ARGS */]: shouldAddRequestResponseToSpans() ? safeJsonSerialize(args) : "{}"
   });
   let toolCallId = "<not specified>";
   let toolResponse = "<not specified>";
-  if ((_a = functionResponseEvent.content) == null ? void 0 : _a.parts) {
+  if ((_b = functionResponseEvent == null ? void 0 : functionResponseEvent.content) == null ? void 0 : _b.parts) {
     const responseParts = functionResponseEvent.content.parts;
-    const functionResponse = (_b = responseParts[0]) == null ? void 0 : _b.functionResponse;
+    const functionResponse = (_c = responseParts[0]) == null ? void 0 : _c.functionResponse;
     if (functionResponse == null ? void 0 : functionResponse.id) {
       toolCallId = functionResponse.id;
     }
@@ -151,32 +221,35 @@ function traceToolCall({
     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) : "{}"
+    ["gen_ai.tool.call.id" /* TOOL_CALL_ID */]: toolCallId,
+    ...functionResponseEvent ? { ["gcp.vertex.agent.event_id" /* EVENT_ID */]: functionResponseEvent.id } : {},
+    ["gcp.vertex.agent.tool_response" /* TOOL_RESPONSE */]: shouldAddRequestResponseToSpans() ? safeJsonSerialize(toolResponse) : "{}"
   });
 }
 __name(traceToolCall, "traceToolCall");
 function traceMergedToolCalls({
   responseEventId,
-  functionResponseEvent
+  functionResponseEvent,
+  invocationContext
 }) {
   const span = import_api.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,
+    ["gen_ai.operation.name" /* OPERATION_NAME */]: "execute_tool",
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.tool.name" /* TOOL_NAME */]: "(merged tools)",
+    ["gen_ai.tool.description" /* TOOL_DESCRIPTION */]: "(merged tools)",
+    ["gen_ai.tool.call.id" /* TOOL_CALL_ID */]: responseEventId,
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.tool_call_args" /* TOOL_CALL_ARGS */]: "N/A",
+    ["gcp.vertex.agent.event_id" /* 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": "{}"
+    ["gcp.vertex.agent.llm_request" /* LLM_REQUEST */]: "{}",
+    ["gcp.vertex.agent.llm_response" /* LLM_RESPONSE */]: "{}"
   });
   span.setAttribute(
-    "gcp.vertex.agent.tool_response",
+    "gcp.vertex.agent.tool_response" /* TOOL_RESPONSE */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(functionResponseEvent) : "{}"
   );
 }
@@ -191,43 +264,43 @@ function traceCallLlm({
   const span = import_api.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,
+    ["gen_ai.system" /* SYSTEM */]: GEN_AI_SYSTEM_VALUE,
+    ["gen_ai.request.model" /* REQUEST_MODEL */]: llmRequest.model,
+    ...((_a = invocationContext.agent) == null ? void 0 : _a.name) ? { ["gen_ai.agent.name" /* AGENT_NAME */]: invocationContext.agent.name } : {},
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.session_id" /* SESSION_ID */]: invocationContext.session.id,
+    ["gcp.vertex.agent.event_id" /* EVENT_ID */]: eventId,
     // Consider removing once GenAI SDK provides a way to record this info.
-    "gcp.vertex.agent.llm_request": shouldAddRequestResponseToSpans() ? safeJsonSerialize(buildLlmRequestForTrace(llmRequest)) : "{}"
+    ["gcp.vertex.agent.llm_request" /* 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);
+    span.setAttribute("gen_ai.request.top_p" /* REQUEST_TOP_P */, llmRequest.config.topP);
   }
   if (((_c = llmRequest.config) == null ? void 0 : _c.maxOutputTokens) !== void 0) {
     span.setAttribute(
-      "gen_ai.request.max_tokens",
+      "gen_ai.request.max_tokens" /* REQUEST_MAX_TOKENS */,
       llmRequest.config.maxOutputTokens
     );
   }
   span.setAttribute(
-    "gcp.vertex.agent.llm_response",
+    "gcp.vertex.agent.llm_response" /* LLM_RESPONSE */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(llmResponse) : "{}"
   );
   if (llmResponse.usageMetadata) {
     span.setAttribute(
-      "gen_ai.usage.input_tokens",
+      "gen_ai.usage.input_tokens" /* USAGE_INPUT_TOKENS */,
       llmResponse.usageMetadata.promptTokenCount || 0
     );
   }
   if ((_d = llmResponse.usageMetadata) == null ? void 0 : _d.candidatesTokenCount) {
     span.setAttribute(
-      "gen_ai.usage.output_tokens",
+      "gen_ai.usage.output_tokens" /* 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]);
+    span.setAttribute("gen_ai.response.finish_reasons" /* RESPONSE_FINISH_REASONS */, [finishReasonValue]);
   }
 }
 __name(traceCallLlm, "traceCallLlm");
@@ -239,11 +312,11 @@ function traceSendData({
   const span = import_api.trace.getActiveSpan();
   if (!span) return;
   span.setAttributes({
-    "gcp.vertex.agent.invocation_id": invocationContext.invocationId,
-    "gcp.vertex.agent.event_id": eventId
+    ["gcp.vertex.agent.invocation_id" /* INVOCATION_ID */]: invocationContext.invocationId,
+    ["gcp.vertex.agent.event_id" /* EVENT_ID */]: eventId
   });
   span.setAttribute(
-    "gcp.vertex.agent.data",
+    "gcp.vertex.agent.data" /* DATA */,
     shouldAddRequestResponseToSpans() ? safeJsonSerialize(data) : "{}"
   );
 }
@@ -307,6 +380,7 @@ function shouldAddRequestResponseToSpans() {
 __name(shouldAddRequestResponseToSpans, "shouldAddRequestResponseToSpans");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  resolveErrorType,
   runAsyncGeneratorWithOtelContext,
   traceAgentInvocation,
   traceCallLlm,

package/dist/cjs/tools/agent_tool.js

@@ -38,12 +38,50 @@ var import_variant_utils = require("../utils/variant_utils.js");
 var import_state = require("../sessions/state.js");
 var import_base_tool = require("./base_tool.js");
 var import_forwarding_artifact_service = require("./forwarding_artifact_service.js");
+var import_schema = require("../utils/schema.js");
+var import_simple_zod_to_json = require("../utils/simple_zod_to_json.js");
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 var _a, _b;
+function excludeNone(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => excludeNone(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (val !== null && val !== void 0) {
+        result[key] = excludeNone(val);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+__name(excludeNone, "excludeNone");
+function validateAndStripAgentInput(agent, args) {
+  var _a2;
+  if (typeof args !== "object" || args === null || Array.isArray(args)) {
+    throw new Error("AgentTool input args must be a plain object.");
+  }
+  const schema = (0, import_simple_zod_to_json.isZodSchema)(agent.inputSchema) ? agent.inputSchema : (_a2 = agent.inputSchemaSource) != null ? _a2 : agent.inputSchema;
+  const validated = (0, import_schema.parseWithSchema)(schema, args);
+  return excludeNone(validated);
+}
+__name(validateAndStripAgentInput, "validateAndStripAgentInput");
+function validateAndStripAgentOutput(agent, mergedText) {
+  var _a2;
+  const parsed = JSON.parse(mergedText);
+  const validated = typeof agent.validateOutput === "function" ? agent.validateOutput(parsed) : (0, import_schema.parseWithSchema)(
+    (0, import_simple_zod_to_json.isZodSchema)(agent.outputSchema) ? agent.outputSchema : (_a2 = agent.outputSchemaSource) != null ? _a2 : agent.outputSchema,
+    parsed
+  );
+  return excludeNone(validated);
+}
+__name(validateAndStripAgentOutput, "validateAndStripAgentOutput");
 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;
@@ -97,6 +135,9 @@ const _AgentTool = class _AgentTool extends (_b = import_base_tool.BaseTool, _a
   }) {
     var _a2, _b2, _c, _d, _e, _f;
     const hasInputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.inputSchema;
+    if (hasInputSchema && (0, import_llm_agent.isLlmAgent)(this.agent)) {
+      args = validateAndStripAgentInput(this.agent, args);
+    }
     const content = {
       role: "user",
       parts: [
@@ -151,6 +192,9 @@ const _AgentTool = class _AgentTool extends (_b = import_base_tool.BaseTool, _a
     }
     const hasOutputSchema = (0, import_llm_agent.isLlmAgent)(this.agent) && this.agent.outputSchema;
     const mergedText = lastEvent.content.parts.filter((part) => !part.thought).map((part) => part.text).filter((text) => text).join("\n");
+    if (hasOutputSchema && (0, import_llm_agent.isLlmAgent)(this.agent)) {
+      return validateAndStripAgentOutput(this.agent, mergedText);
+    }
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 };