@google/adk 2.3.0 → 2.5.0

package/dist/cjs/telemetry/api/internal/common/accumulators.js

@@ -0,0 +1,169 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var accumulators_exports = {};
+__export(accumulators_exports, {
+  captureAccumulators: () => captureAccumulators,
+  claimEntrypointWorkflowFrame: () => claimEntrypointWorkflowFrame,
+  openAgentFrame: () => openAgentFrame,
+  openWorkflowFrame: () => openWorkflowFrame
+});
+module.exports = __toCommonJS(accumulators_exports);
+var import_api = require("@opentelemetry/api");
+var import_token_usage = require("./token_usage.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const AGENT_FRAME_KEY = (0, import_api.createContextKey)("adk_agent_frame");
+const WORKFLOW_FRAME_KEY = (0, import_api.createContextKey)("adk_workflow_frame");
+const AGENT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("adk.telemetry.agentFrame");
+const WORKFLOW_FRAME_SYMBOL = /* @__PURE__ */ Symbol("adk.telemetry.workflowFrame");
+function isAgentFrame(value) {
+  return typeof value === "object" && value !== null && AGENT_FRAME_SYMBOL in value;
+}
+__name(isAgentFrame, "isAgentFrame");
+function isWorkflowFrame(value) {
+  return typeof value === "object" && value !== null && WORKFLOW_FRAME_SYMBOL in value;
+}
+__name(isWorkflowFrame, "isWorkflowFrame");
+function getAgentFrame(ctx) {
+  const value = ctx.getValue(AGENT_FRAME_KEY);
+  return isAgentFrame(value) ? value : void 0;
+}
+__name(getAgentFrame, "getAgentFrame");
+function getWorkflowFrame(ctx) {
+  const value = ctx.getValue(WORKFLOW_FRAME_KEY);
+  return isWorkflowFrame(value) ? value : void 0;
+}
+__name(getWorkflowFrame, "getWorkflowFrame");
+function createTotals() {
+  return {
+    tokens: void 0,
+    inferenceCalls: 0,
+    toolCalls: 0,
+    skillLoads: 0,
+    compactions: 0
+  };
+}
+__name(createTotals, "createTotals");
+function openAgentFrame(parentContext = import_api.context.active()) {
+  const frame = {
+    [AGENT_FRAME_SYMBOL]: true,
+    totals: createTotals()
+  };
+  return {
+    frame,
+    context: parentContext.setValue(AGENT_FRAME_KEY, frame)
+  };
+}
+__name(openAgentFrame, "openAgentFrame");
+function openWorkflowFrame({
+  workflowName,
+  config,
+  entrypoint,
+  parentContext = import_api.context.active()
+}) {
+  var _a, _b;
+  const enclosing = getWorkflowFrame(parentContext);
+  const frame = {
+    [WORKFLOW_FRAME_SYMBOL]: true,
+    totals: createTotals(),
+    parent: enclosing,
+    rootAgentName: (_a = enclosing == null ? void 0 : enclosing.rootAgentName) != null ? _a : workflowName,
+    workflowName,
+    config: (_b = enclosing == null ? void 0 : enclosing.config) != null ? _b : config,
+    entrypoint
+  };
+  return {
+    frame,
+    context: parentContext.setValue(WORKFLOW_FRAME_KEY, frame)
+  };
+}
+__name(openWorkflowFrame, "openWorkflowFrame");
+function claimEntrypointWorkflowFrame(workflow, ctx = import_api.context.active()) {
+  const frame = getWorkflowFrame(ctx);
+  if (frame === void 0 || frame.entrypoint !== workflow) {
+    return void 0;
+  }
+  frame.entrypoint = void 0;
+  return ctx;
+}
+__name(claimEntrypointWorkflowFrame, "claimEntrypointWorkflowFrame");
+function captureAccumulators(ctx = import_api.context.active()) {
+  const agent = getAgentFrame(ctx);
+  const workflow = getWorkflowFrame(ctx);
+  const each = /* @__PURE__ */ __name((fn) => {
+    if (agent) {
+      fn(agent.totals);
+    }
+    let current = workflow;
+    while (current) {
+      fn(current.totals);
+      current = current.parent;
+    }
+  }, "each");
+  return {
+    addInferenceCall() {
+      each((t) => {
+        t.inferenceCalls += 1;
+      });
+    },
+    addToolCall() {
+      each((t) => {
+        t.toolCalls += 1;
+      });
+    },
+    addSkillLoad() {
+      each((t) => {
+        t.skillLoads += 1;
+      });
+    },
+    addCompaction() {
+      let current = workflow;
+      while (current) {
+        current.totals.compactions += 1;
+        current = current.parent;
+      }
+    },
+    addTokens(usage) {
+      each((t) => {
+        if (t.tokens === void 0) {
+          t.tokens = new import_token_usage.TokenUsage();
+        }
+        t.tokens.add(usage);
+      });
+    }
+  };
+}
+__name(captureAccumulators, "captureAccumulators");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureAccumulators,
+  claimEntrypointWorkflowFrame,
+  openAgentFrame,
+  openWorkflowFrame
+});

package/dist/cjs/telemetry/api/internal/common/attributes.js

@@ -0,0 +1,131 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var attributes_exports = {};
+__export(attributes_exports, {
+  AdkAttr: () => AdkAttr,
+  ERROR_TYPE_ATTR: () => ERROR_TYPE_ATTR,
+  GEN_AI_SYSTEM_VALUE: () => GEN_AI_SYSTEM_VALUE,
+  GcpAttr: () => GcpAttr,
+  GenAiAttr: () => GenAiAttr,
+  HttpAttr: () => HttpAttr,
+  McpAttr: () => McpAttr,
+  SCHEMA_URL: () => SCHEMA_URL,
+  SUPPORT_ID_ATTR: () => SUPPORT_ID_ATTR,
+  USER_ID_ATTR: () => USER_ID_ATTR
+});
+module.exports = __toCommonJS(attributes_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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["PROVIDER_NAME"] = "gen_ai.provider.name";
+  GenAiAttr2["SYSTEM"] = "gen_ai.system";
+  GenAiAttr2["WORKFLOW_NAME"] = "gen_ai.workflow.name";
+  GenAiAttr2["WORKFLOW_NESTED"] = "gen_ai.workflow.nested";
+  GenAiAttr2["TOOL_CALL_ID"] = "gen_ai.tool.call.id";
+  GenAiAttr2["TOOL_CALL_ARGUMENTS"] = "gen_ai.tool.call.arguments";
+  GenAiAttr2["TOOL_CALL_RESULT"] = "gen_ai.tool.call.result";
+  GenAiAttr2["TOOL_DEFINITIONS"] = "gen_ai.tool.definitions";
+  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["RESPONSE_FINISH_REASONS"] = "gen_ai.response.finish_reasons";
+  GenAiAttr2["INPUT_MESSAGES"] = "gen_ai.input.messages";
+  GenAiAttr2["OUTPUT_MESSAGES"] = "gen_ai.output.messages";
+  GenAiAttr2["SYSTEM_INSTRUCTIONS"] = "gen_ai.system_instructions";
+  GenAiAttr2["USAGE_INPUT_TOKENS"] = "gen_ai.usage.input_tokens";
+  GenAiAttr2["USAGE_OUTPUT_TOKENS"] = "gen_ai.usage.output_tokens";
+  GenAiAttr2["USAGE_CACHE_READ_INPUT_TOKENS"] = "gen_ai.usage.cache_read.input_tokens";
+  GenAiAttr2["USAGE_REASONING_OUTPUT_TOKENS"] = "gen_ai.usage.reasoning.output_tokens";
+  GenAiAttr2["SKILL_NAME"] = "gen_ai.skill.name";
+  GenAiAttr2["SKILL_DESCRIPTION"] = "gen_ai.skill.description";
+  GenAiAttr2["SKILL_RESOURCE_NAME"] = "gen_ai.skill.resource.name";
+  GenAiAttr2["COMPACTION_TRIGGER"] = "gen_ai.compaction.trigger";
+  GenAiAttr2["COMPACTION_EVENT_COUNT"] = "gen_ai.compaction.event_count";
+  GenAiAttr2["COMPACTION_RESULT_EVENT_ID"] = "gen_ai.compaction.result_event_id";
+  GenAiAttr2["COMPACTION_START_TIMESTAMP"] = "gen_ai.compaction.start_timestamp";
+  GenAiAttr2["COMPACTION_END_TIMESTAMP"] = "gen_ai.compaction.end_timestamp";
+  return GenAiAttr2;
+})(GenAiAttr || {});
+var AdkAttr = /* @__PURE__ */ ((AdkAttr2) => {
+  AdkAttr2["SKILL_ADDITIONAL_TOOLS"] = "adk.skill.additional_tools";
+  AdkAttr2["EXPERIMENTAL_ROOT_AGENT_NAME"] = "adk.experimental.root_agent.name";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_QUERY_COUNT"] = "adk.experimental.grounding.query_count";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_CHUNK_COUNT"] = "adk.experimental.grounding.chunk_count";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_WEB_SEARCH_QUERIES"] = "adk.experimental.grounding.web_search_queries";
+  AdkAttr2["EXPERIMENTAL_GROUNDING_SOURCE_URIS"] = "adk.experimental.grounding.source_uris";
+  return AdkAttr2;
+})(AdkAttr || {});
+var GcpAttr = /* @__PURE__ */ ((GcpAttr2) => {
+  GcpAttr2["INVOCATION_ID"] = "gcp.vertex.agent.invocation_id";
+  GcpAttr2["EVENT_ID"] = "gcp.vertex.agent.event_id";
+  GcpAttr2["ASSOCIATED_EVENT_IDS"] = "gcp.vertex.agent.associated_event_ids";
+  GcpAttr2["DATA"] = "gcp.vertex.agent.data";
+  return GcpAttr2;
+})(GcpAttr || {});
+var HttpAttr = /* @__PURE__ */ ((HttpAttr2) => {
+  HttpAttr2["REQUEST_METHOD"] = "http.request.method";
+  HttpAttr2["RESPONSE_STATUS_CODE"] = "http.response.status_code";
+  HttpAttr2["REQUEST_BODY_CONTENT"] = "http.request.body.content";
+  HttpAttr2["RESPONSE_BODY_CONTENT"] = "http.response.body.content";
+  HttpAttr2["REQUEST_HEADER_PREFIX"] = "http.request.header.";
+  HttpAttr2["RESPONSE_HEADER_PREFIX"] = "http.response.header.";
+  HttpAttr2["URL_FULL"] = "url.full";
+  HttpAttr2["SERVER_ADDRESS"] = "server.address";
+  HttpAttr2["SERVER_PORT"] = "server.port";
+  return HttpAttr2;
+})(HttpAttr || {});
+var McpAttr = /* @__PURE__ */ ((McpAttr2) => {
+  McpAttr2["SESSION_ID"] = "mcp.session.id";
+  McpAttr2["PROTOCOL_VERSION"] = "mcp.protocol.version";
+  return McpAttr2;
+})(McpAttr || {});
+const ERROR_TYPE_ATTR = "error.type";
+const USER_ID_ATTR = "user.id";
+const SUPPORT_ID_ATTR = "supportID";
+const GEN_AI_SYSTEM_VALUE = "gcp.vertex.agent";
+const SCHEMA_URL = "https://opentelemetry.io/schemas/1.44.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdkAttr,
+  ERROR_TYPE_ATTR,
+  GEN_AI_SYSTEM_VALUE,
+  GcpAttr,
+  GenAiAttr,
+  HttpAttr,
+  McpAttr,
+  SCHEMA_URL,
+  SUPPORT_ID_ATTR,
+  USER_ID_ATTR
+});

package/dist/cjs/telemetry/api/internal/common/config.js

@@ -0,0 +1,159 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  isExperimentalFeatureEnabled: () => isExperimentalFeatureEnabled,
+  isTruthyEnv: () => isTruthyEnv,
+  resolveTelemetryConfig: () => resolveTelemetryConfig,
+  shouldAddContentToLogs: () => shouldAddContentToLogs,
+  shouldAddContentToSpans: () => shouldAddContentToSpans
+});
+module.exports = __toCommonJS(config_exports);
+var import_env_aware_utils = require("../../../../utils/env_aware_utils.js");
+var import_logger = require("../../../../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const CAPTURE_MESSAGE_CONTENT_ENV = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+const EXPERIMENTAL_TELEMETRY_ENV = "ADK_EXPERIMENTAL_TELEMETRY";
+const EXPERIMENTAL_TELEMETRY_FEATURES_ENV = "ADK_EXPERIMENTAL_TELEMETRY_FEATURES";
+const IGNORE_RUN_CONFIG_ENV = "ADK_TELEMETRY_IGNORE_RUN_CONFIG";
+const TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true"]);
+const CONTENT_CAPTURING_MODES = /* @__PURE__ */ new Set([
+  "NO_CONTENT",
+  "EVENT_ONLY",
+  "SPAN_ONLY",
+  "SPAN_AND_EVENT"
+]);
+const EXPERIMENTAL_FEATURES = /* @__PURE__ */ new Set(
+  [
+    "skills",
+    "workflow",
+    "context_cache",
+    "grounding",
+    "mcp",
+    "token_usage",
+    "compaction"
+  ]
+);
+const warnedFeatures = /* @__PURE__ */ new Set();
+function isExperimentalFeature(value) {
+  return EXPERIMENTAL_FEATURES.has(value);
+}
+__name(isExperimentalFeature, "isExperimentalFeature");
+function isContentCapturingMode(value) {
+  return CONTENT_CAPTURING_MODES.has(value);
+}
+__name(isContentCapturingMode, "isContentCapturingMode");
+function readContentCapturingMode() {
+  var _a;
+  const value = ((_a = (0, import_env_aware_utils.getEnvVar)(CAPTURE_MESSAGE_CONTENT_ENV)) != null ? _a : "").trim();
+  if (TRUTHY_ENV_VALUES.has(value.toLowerCase())) {
+    return "EVENT_ONLY";
+  }
+  const mode = value.toUpperCase();
+  return isContentCapturingMode(mode) ? mode : "NO_CONTENT";
+}
+__name(readContentCapturingMode, "readContentCapturingMode");
+function isTruthyEnv(name) {
+  var _a;
+  return TRUTHY_ENV_VALUES.has(((_a = (0, import_env_aware_utils.getEnvVar)(name)) != null ? _a : "").trim().toLowerCase());
+}
+__name(isTruthyEnv, "isTruthyEnv");
+function normalizeExperimentalFeatures(names) {
+  const features = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const feature = name.trim().toLowerCase();
+    if (!feature) {
+      continue;
+    }
+    if (isExperimentalFeature(feature)) {
+      features.add(feature);
+    } else if (!warnedFeatures.has(feature)) {
+      warnedFeatures.add(feature);
+      import_logger.logger.warn(
+        `Ignoring unrecognized experimental telemetry feature: ${feature}`
+      );
+    }
+  }
+  return features;
+}
+__name(normalizeExperimentalFeatures, "normalizeExperimentalFeatures");
+function resolveTelemetryConfig(overrides) {
+  var _a, _b, _c;
+  const env = {
+    contentCapturingMode: readContentCapturingMode(),
+    experimentalTelemetry: isTruthyEnv(EXPERIMENTAL_TELEMETRY_ENV),
+    experimentalFeatures: normalizeExperimentalFeatures(
+      ((_a = (0, import_env_aware_utils.getEnvVar)(EXPERIMENTAL_TELEMETRY_FEATURES_ENV)) != null ? _a : "").split(",")
+    )
+  };
+  if (overrides === void 0 || isTruthyEnv(IGNORE_RUN_CONFIG_ENV)) {
+    return env;
+  }
+  const contentCapturingMode = (_b = overrides.captureMessageContent) != null ? _b : env.contentCapturingMode;
+  if (overrides.adkExperimentalTelemetryOptIn !== void 0) {
+    return {
+      contentCapturingMode,
+      experimentalTelemetry: overrides.adkExperimentalTelemetryOptIn,
+      experimentalFeatures: /* @__PURE__ */ new Set()
+    };
+  }
+  const features = normalizeExperimentalFeatures(
+    (_c = overrides.experimentalFeaturesOptIn) != null ? _c : []
+  );
+  if (features.size > 0) {
+    return {
+      contentCapturingMode,
+      experimentalTelemetry: false,
+      experimentalFeatures: features
+    };
+  }
+  return { ...env, contentCapturingMode };
+}
+__name(resolveTelemetryConfig, "resolveTelemetryConfig");
+function shouldAddContentToLogs(config) {
+  return config.contentCapturingMode === "EVENT_ONLY" || config.contentCapturingMode === "SPAN_AND_EVENT";
+}
+__name(shouldAddContentToLogs, "shouldAddContentToLogs");
+function shouldAddContentToSpans(config) {
+  return config.contentCapturingMode === "SPAN_ONLY" || config.contentCapturingMode === "SPAN_AND_EVENT";
+}
+__name(shouldAddContentToSpans, "shouldAddContentToSpans");
+function isExperimentalFeatureEnabled(config, feature) {
+  return config.experimentalTelemetry || config.experimentalFeatures.has(feature);
+}
+__name(isExperimentalFeatureEnabled, "isExperimentalFeatureEnabled");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isExperimentalFeatureEnabled,
+  isTruthyEnv,
+  resolveTelemetryConfig,
+  shouldAddContentToLogs,
+  shouldAddContentToSpans
+});

package/dist/cjs/telemetry/api/internal/common/error.js

@@ -0,0 +1,98 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  getToolResponseErrorType: () => getToolResponseErrorType,
+  normalizeErrorClassification: () => normalizeErrorClassification,
+  resolveErrorType: () => resolveErrorType
+});
+module.exports = __toCommonJS(error_exports);
+var import_genai = require("@google/genai");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function normalizeErrorClassification(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return void 0;
+}
+__name(normalizeErrorClassification, "normalizeErrorClassification");
+function resolveErrorType(error) {
+  var _a, _b;
+  if (error !== null && (typeof error === "object" || typeof error === "function")) {
+    try {
+      const errorObject = error;
+      const customErrorType = (_a = normalizeErrorClassification(errorObject.errorType)) != null ? _a : normalizeErrorClassification(errorObject.error_type);
+      if (customErrorType !== void 0) {
+        return customErrorType;
+      }
+      if (error instanceof import_genai.ApiError) {
+        const apiStatus = normalizeErrorClassification(error.status);
+        if (apiStatus !== void 0) {
+          return apiStatus;
+        }
+      }
+      const constructorName = normalizeErrorClassification(
+        (_b = errorObject.constructor) == null ? void 0 : _b.name
+      );
+      if (constructorName !== void 0) {
+        return constructorName;
+      }
+    } catch {
+    }
+  }
+  return typeof error;
+}
+__name(resolveErrorType, "resolveErrorType");
+function getToolResponseErrorType(result) {
+  var _a, _b, _c;
+  if (result === null || typeof result !== "object" || Array.isArray(result)) {
+    return void 0;
+  }
+  try {
+    if (!Object.hasOwn(result, "error")) {
+      return void 0;
+    }
+    const response = result;
+    return (_c = (_b = (_a = normalizeErrorClassification(response.errorType)) != null ? _a : normalizeErrorClassification(response.error_type)) != null ? _b : normalizeErrorClassification(response.errorCode)) != null ? _c : normalizeErrorClassification(response.error_code);
+  } catch {
+    return void 0;
+  }
+}
+__name(getToolResponseErrorType, "getToolResponseErrorType");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getToolResponseErrorType,
+  normalizeErrorClassification,
+  resolveErrorType
+});

package/dist/cjs/telemetry/api/internal/common/finish_reason.js

@@ -0,0 +1,63 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var finish_reason_exports = {};
+__export(finish_reason_exports, {
+  isReportedFinishReason: () => isReportedFinishReason,
+  toOutputMessageFinishReason: () => toOutputMessageFinishReason
+});
+module.exports = __toCommonJS(finish_reason_exports);
+var import_genai = require("@google/genai");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function isReportedFinishReason(finishReason) {
+  return finishReason !== void 0 && finishReason !== import_genai.FinishReason.FINISH_REASON_UNSPECIFIED;
+}
+__name(isReportedFinishReason, "isReportedFinishReason");
+function toOutputMessageFinishReason(finishReason) {
+  if (!isReportedFinishReason(finishReason)) {
+    return "";
+  }
+  switch (finishReason) {
+    // The output message schema has no value for OTHER.
+    case import_genai.FinishReason.OTHER:
+      return "error";
+    case import_genai.FinishReason.STOP:
+      return "stop";
+    case import_genai.FinishReason.MAX_TOKENS:
+      return "length";
+    default:
+      return String(finishReason).toLowerCase();
+  }
+}
+__name(toOutputMessageFinishReason, "toOutputMessageFinishReason");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isReportedFinishReason,
+  toOutputMessageFinishReason
+});