@google/adk 2.2.1 → 2.4.0

package/dist/esm/skills/loader.js

@@ -8,10 +8,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * SPDX-License-Identifier: Apache-2.0
  */
 import AdmZip from "adm-zip";
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import { isUtf8 } from "node:buffer";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { InputValidationError } from "../errors/input_validation_error.js";
+import { NotFoundError } from "../errors/not_found_error.js";
 import { logger } from "../utils/logger.js";
 import {
   FrontmatterSchema
@@ -88,24 +90,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 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 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 = 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 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 InputValidationError(
+      `Invalid YAML in frontmatter: ${e.message}`,
+      { cause: e }
+    );
   }
 }
 __name(parseFrontmatterYaml, "parseFrontmatterYaml");
@@ -113,7 +128,10 @@ function validateFrontmatter(raw) {
   try {
     return FrontmatterSchema.parse(raw);
   } catch (e) {
-    throw new Error(`Invalid YAML in frontmatter: ${e.message}`);
+    throw new InputValidationError(
+      `Invalid YAML in frontmatter: ${e.message}`,
+      { cause: e }
+    );
   }
 }
 __name(validateFrontmatter, "validateFrontmatter");
@@ -160,6 +178,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);
@@ -209,7 +239,7 @@ async function loadSkillFile(skillDir) {
     );
   }
   if (!skillMdPath) {
-    throw new Error(
+    throw new NotFoundError(
       `SKILL.md (or any case variation like skill.md) not found in '${skillDir}'.`
     );
   }
@@ -217,7 +247,7 @@ async function loadSkillFile(skillDir) {
   const frontmatter = FrontmatterSchema.parse(parsed);
   const dirName = path.basename(resolvedDir);
   if (dirName !== frontmatter.name) {
-    throw new Error(
+    throw new InputValidationError(
       `Skill name '${frontmatter.name}' does not match directory name '${dirName}'.`
     );
   }
@@ -279,7 +309,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 InputValidationError(
+        `Dangerous zip entry ignored: ${entry.entryName}`
+      );
     }
   }
   let skillMdContent = "";
@@ -291,15 +323,17 @@ function loadSkillFromZipBuffer(zipBuffer) {
     }
   }
   if (!skillMdContent) {
-    throw new Error("SKILL.md not found in zipped filesystem.");
+    throw new 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 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 InputValidationError(
+      `Invalid skill name in SKILL.md: ${String(skillName)}`
+    );
   }
   const frontmatter = validateFrontmatter(raw);
   const references = {};

package/dist/esm/telemetry/setup.js

@@ -7,7 +7,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { metrics, trace } from "@opentelemetry/api";
+import { metrics } 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";
@@ -39,7 +39,6 @@ function maybeSetOtelProviders(otelHooksToSetup = [], otelResource) {
       spanProcessors
     });
     tracerProvider.register();
-    trace.setGlobalTracerProvider(tracerProvider);
   }
   if (metricReaders.length > 0) {
     const meterProvider = new MeterProvider({

package/dist/esm/telemetry/tracing.js

@@ -7,23 +7,53 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { context, trace } from "@opentelemetry/api";
+import { ApiError } from "@google/genai";
+import {
+  context,
+  SpanStatusCode,
+  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);
+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 = trace.getTracer(GEN_AI_SYSTEM_VALUE, version);
 function safeJsonSerialize(obj) {
   try {
     return JSON.stringify(obj);
@@ -39,11 +69,11 @@ function traceAgentInvocation({
   const span = 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");
@@ -55,10 +85,10 @@ function traceWorkflowInvocation({
   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
+    ["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");
@@ -72,40 +102,83 @@ function traceNodeExecution({
   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
+    ["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 = 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 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 : 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: 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;
     }
@@ -117,32 +190,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 = 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) : "{}"
   );
 }
@@ -157,43 +233,43 @@ function traceCallLlm({
   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,
+    ["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");
@@ -205,11 +281,11 @@ function traceSendData({
   const span = 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) : "{}"
   );
 }
@@ -272,6 +348,7 @@ function shouldAddRequestResponseToSpans() {
 }
 __name(shouldAddRequestResponseToSpans, "shouldAddRequestResponseToSpans");
 export {
+  resolveErrorType,
   runAsyncGeneratorWithOtelContext,
   traceAgentInvocation,
   traceCallLlm,

package/dist/esm/tools/agent_tool.js

@@ -17,6 +17,44 @@ 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";
+import { parseWithSchema } from "../utils/schema.js";
+import { isZodSchema } from "../utils/simple_zod_to_json.js";
+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 = isZodSchema(agent.inputSchema) ? agent.inputSchema : (_a2 = agent.inputSchemaSource) != null ? _a2 : agent.inputSchema;
+  const validated = 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) : parseWithSchema(
+    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;
@@ -70,6 +108,9 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
   }) {
     var _a2, _b2, _c, _d, _e, _f;
     const hasInputSchema = isLlmAgent(this.agent) && this.agent.inputSchema;
+    if (hasInputSchema && isLlmAgent(this.agent)) {
+      args = validateAndStripAgentInput(this.agent, args);
+    }
     const content = {
       role: "user",
       parts: [
@@ -124,6 +165,9 @@ const _AgentTool = class _AgentTool extends (_b = BaseTool, _a = AGENT_TOOL_SIGN
     }
     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");
+    if (hasOutputSchema && isLlmAgent(this.agent)) {
+      return validateAndStripAgentOutput(this.agent, mergedText);
+    }
     return hasOutputSchema ? JSON.parse(mergedText) : mergedText;
   }
 };

package/dist/esm/tools/apihub_tool/apihub_toolset.js

@@ -0,0 +1,101 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as yaml from "js-yaml";
+import { toSnakeCaseName } from "../../utils/case_utils.js";
+import { experimental } from "../../utils/experimental.js";
+import { BaseToolset } from "../base_toolset.js";
+import { OpenAPIToolset } from "../openapi_tool/openapi_toolset.js";
+import { APIHubClient } from "./clients/apihub_client.js";
+let APIHubToolset = class extends BaseToolset {
+  constructor(options) {
+    var _a, _b, _c, _d, _e;
+    super((_a = options.toolFilter) != null ? _a : []);
+    this.name = (_b = options.name) != null ? _b : "";
+    this.description = (_c = options.description) != null ? _c : "";
+    this.apihubResourceName = options.apihubResourceName;
+    this.lazyLoadSpec = (_d = options.lazyLoadSpec) != null ? _d : false;
+    this.authScheme = options.authScheme;
+    this.authCredential = options.authCredential;
+    this.apihubClient = (_e = options.apihubClient) != null ? _e : new APIHubClient({
+      accessToken: options.accessToken,
+      serviceAccountJson: options.serviceAccountJson
+    });
+    if (!this.lazyLoadSpec) {
+      this.toolsetPromise = this.prepareTools();
+      this.toolsetPromise.catch(() => void 0);
+    }
+  }
+  /**
+   * Returns one tool per operation in the spec, or an empty array when the
+   * spec is empty.
+   *
+   * @throws When the spec cannot be fetched or is not valid YAML or JSON.
+   */
+  async getTools(context) {
+    const toolset = await this.loadToolset();
+    return toolset ? toolset.getTools(context) : [];
+  }
+  async close() {
+    if (!this.toolsetPromise) {
+      return;
+    }
+    const toolset = await this.toolsetPromise.catch(() => void 0);
+    await (toolset == null ? void 0 : toolset.close());
+  }
+  loadToolset() {
+    if (!this.toolsetPromise) {
+      const promise = this.prepareTools();
+      this.toolsetPromise = promise;
+      promise.catch(() => {
+        if (this.toolsetPromise === promise) {
+          this.toolsetPromise = void 0;
+        }
+      });
+    }
+    return this.toolsetPromise;
+  }
+  async prepareTools() {
+    var _a, _b, _c, _d;
+    const spec = await this.apihubClient.getSpecContent(
+      this.apihubResourceName
+    );
+    if (!spec.trim()) {
+      return void 0;
+    }
+    const specDict = yaml.load(spec);
+    if (!specDict) {
+      return void 0;
+    }
+    this.name || (this.name = toSnakeCaseName((_b = (_a = specDict.info) == null ? void 0 : _a.title) != null ? _b : "unnamed"));
+    this.description || (this.description = (_d = (_c = specDict.info) == null ? void 0 : _c.description) != null ? _d : "");
+    return new OpenAPIToolset({
+      specDict,
+      authScheme: this.authScheme,
+      authCredential: this.authCredential,
+      toolFilter: this.toolFilter
+    });
+  }
+};
+__name(APIHubToolset, "APIHubToolset");
+APIHubToolset = __decorateClass([
+  experimental
+], APIHubToolset);
+export {
+  APIHubToolset
+};