@google/adk 2.3.0 → 2.5.0

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

@@ -0,0 +1,118 @@
+/**
+  * @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 token_usage_exports = {};
+__export(token_usage_exports, {
+  CACHE_READ_INPUT_TOKENS_MEANING: () => CACHE_READ_INPUT_TOKENS_MEANING,
+  INPUT_TOKENS_MEANING: () => INPUT_TOKENS_MEANING,
+  OUTPUT_TOKENS_MEANING: () => OUTPUT_TOKENS_MEANING,
+  REASONING_OUTPUT_TOKENS_MEANING: () => REASONING_OUTPUT_TOKENS_MEANING,
+  TOOL_INPUT_TOKENS_MEANING: () => TOOL_INPUT_TOKENS_MEANING,
+  TOTAL_TOKENS_MEANING: () => TOTAL_TOKENS_MEANING,
+  TokenUsage: () => TokenUsage
+});
+module.exports = __toCommonJS(token_usage_exports);
+var import_attributes = require("./attributes.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const INPUT_TOKENS_MEANING = "Input (prompt) tokens, summing the prompt itself and the results of server-side tool calls. Prompt tokens served from a cache are part of the prompt count, so they are included here too.";
+const OUTPUT_TOKENS_MEANING = "Output (completion) tokens, summing candidate and reasoning tokens. The tokens a model spends emitting a tool call are candidate tokens, so they count here.";
+const TOTAL_TOKENS_MEANING = "Input plus output tokens, derived from those two rather than taken from the model-reported total.";
+const CACHE_READ_INPUT_TOKENS_MEANING = "Input tokens served from a provider-managed cache.";
+const REASONING_OUTPUT_TOKENS_MEANING = "Output tokens spent on reasoning (chain-of-thought / extended thinking).";
+const TOOL_INPUT_TOKENS_MEANING = "Input tokens from server-side tool results the model fed back to itself within one request, such as code execution or search grounding. Zero for client-side function tools, whose responses arrive as ordinary content on the next request and bill as plain prompt tokens.";
+function sumOrUndefined(a, b) {
+  return a === void 0 && b === void 0 ? void 0 : (a != null ? a : 0) + (b != null ? b : 0);
+}
+__name(sumOrUndefined, "sumOrUndefined");
+const _TokenUsage = class _TokenUsage {
+  constructor(usage) {
+    if (!usage) {
+      return;
+    }
+    this.input = sumOrUndefined(
+      usage.promptTokenCount,
+      usage.toolUsePromptTokenCount
+    );
+    this.output = sumOrUndefined(
+      usage.candidatesTokenCount,
+      usage.thoughtsTokenCount
+    );
+    this.cacheRead = usage.cachedContentTokenCount;
+    this.reasoning = usage.thoughtsTokenCount;
+    this.toolInput = usage.toolUsePromptTokenCount;
+  }
+  /** Folds another call's usage into these totals, bucket by bucket. */
+  add(other) {
+    this.input = sumOrUndefined(this.input, other.input);
+    this.output = sumOrUndefined(this.output, other.output);
+    this.cacheRead = sumOrUndefined(this.cacheRead, other.cacheRead);
+    this.reasoning = sumOrUndefined(this.reasoning, other.reasoning);
+    this.toolInput = sumOrUndefined(this.toolInput, other.toolInput);
+  }
+  /**
+   * Input plus output tokens, derived from those two rather than taken from
+   * the model-reported total.
+   */
+  totalTokenUsage() {
+    var _a, _b;
+    return ((_a = this.input) != null ? _a : 0) + ((_b = this.output) != null ? _b : 0);
+  }
+  /**
+   * Returns the GenAI token usage attributes for the reported buckets,
+   * omitting `undefined` buckets and preserving `0`.
+   */
+  asAttributes() {
+    const attributes = {};
+    if (this.input !== void 0) {
+      attributes[import_attributes.GenAiAttr.USAGE_INPUT_TOKENS] = this.input;
+    }
+    if (this.output !== void 0) {
+      attributes[import_attributes.GenAiAttr.USAGE_OUTPUT_TOKENS] = this.output;
+    }
+    if (this.cacheRead !== void 0) {
+      attributes[import_attributes.GenAiAttr.USAGE_CACHE_READ_INPUT_TOKENS] = this.cacheRead;
+    }
+    if (this.reasoning !== void 0) {
+      attributes[import_attributes.GenAiAttr.USAGE_REASONING_OUTPUT_TOKENS] = this.reasoning;
+    }
+    return attributes;
+  }
+};
+__name(_TokenUsage, "TokenUsage");
+let TokenUsage = _TokenUsage;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_READ_INPUT_TOKENS_MEANING,
+  INPUT_TOKENS_MEANING,
+  OUTPUT_TOKENS_MEANING,
+  REASONING_OUTPUT_TOKENS_MEANING,
+  TOOL_INPUT_TOKENS_MEANING,
+  TOTAL_TOKENS_MEANING,
+  TokenUsage
+});

package/dist/cjs/telemetry/api/internal/logs/inference.js

@@ -0,0 +1,50 @@
+/**
+  * @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 inference_exports = {};
+__export(inference_exports, {
+  emitInferenceOperationDetails: () => emitInferenceOperationDetails
+});
+module.exports = __toCommonJS(inference_exports);
+var import_api = require("@opentelemetry/api");
+var import_logger = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const INFERENCE_OPERATION_DETAILS_EVENT = "gen_ai.client.inference.operation.details";
+function emitInferenceOperationDetails(span, attributes) {
+  (0, import_logger.getTelemetryLogger)().emit({
+    eventName: INFERENCE_OPERATION_DETAILS_EVENT,
+    attributes,
+    context: import_api.trace.setSpan(import_api.context.active(), span)
+  });
+}
+__name(emitInferenceOperationDetails, "emitInferenceOperationDetails");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emitInferenceOperationDetails
+});

package/dist/cjs/telemetry/api/internal/logs/logger.js

@@ -0,0 +1,46 @@
+/**
+  * @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 logger_exports = {};
+__export(logger_exports, {
+  getTelemetryLogger: () => getTelemetryLogger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_version = require("../../../../version.js");
+var import_attributes = require("../common/attributes.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getTelemetryLogger() {
+  return import_api_logs.logs.getLogger(import_attributes.GEN_AI_SYSTEM_VALUE, import_version.version, { schemaUrl: import_attributes.SCHEMA_URL });
+}
+__name(getTelemetryLogger, "getTelemetryLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTelemetryLogger
+});

package/dist/cjs/telemetry/api/internal/logs/mcp.js

@@ -0,0 +1,141 @@
+/**
+  * @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 mcp_exports = {};
+__export(mcp_exports, {
+  readMcpHttpExchangeSettings: () => readMcpHttpExchangeSettings,
+  reportMcpHttpExchange: () => reportMcpHttpExchange
+});
+module.exports = __toCommonJS(mcp_exports);
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_env_aware_utils = require("../../../../utils/env_aware_utils.js");
+var import_logger = require("../../../../utils/logger.js");
+var import_attributes = require("../common/attributes.js");
+var import_config = require("../common/config.js");
+var import_http_exchange = require("../common/http_exchange.js");
+var import_logger2 = require("./logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MCP_HTTP_RESPONSE_END_EVENT = "adk.experimental.mcp.http.client.response.end";
+const CAPTURE_BODIES_ENV = "ADK_CAPTURE_MCP_HTTP_BODIES";
+const CAPTURE_REQUEST_HEADERS_ENV = "OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_CLIENT_REQUEST";
+const CAPTURE_RESPONSE_HEADERS_ENV = "OTEL_INSTRUMENTATION_HTTP_CAPTURE_HEADERS_CLIENT_RESPONSE";
+const ELIDED_BODY = "<elided>";
+function readHeaderPatterns(envName) {
+  var _a;
+  const patterns = [];
+  for (const entry of ((_a = (0, import_env_aware_utils.getEnvVar)(envName)) != null ? _a : "").split(",")) {
+    const pattern = entry.trim();
+    if (!pattern) {
+      continue;
+    }
+    try {
+      patterns.push(new RegExp(`^(?:${pattern})$`, "i"));
+    } catch {
+      import_logger.logger.warn(`Ignoring malformed header pattern in ${envName}.`);
+    }
+  }
+  return patterns;
+}
+__name(readHeaderPatterns, "readHeaderPatterns");
+function readMcpHttpExchangeSettings() {
+  return {
+    captureBodies: (0, import_config.isTruthyEnv)(CAPTURE_BODIES_ENV),
+    requestHeaderPatterns: readHeaderPatterns(CAPTURE_REQUEST_HEADERS_ENV),
+    responseHeaderPatterns: readHeaderPatterns(CAPTURE_RESPONSE_HEADERS_ENV)
+  };
+}
+__name(readMcpHttpExchangeSettings, "readMcpHttpExchangeSettings");
+function headerAttributes(headers, patterns, prefix) {
+  const attributes = {};
+  for (const [name, value] of headers) {
+    if (patterns.some((pattern) => pattern.test(name))) {
+      attributes[`${prefix}${name}`] = [value];
+    }
+  }
+  return attributes;
+}
+__name(headerAttributes, "headerAttributes");
+async function reportMcpHttpExchange({
+  url,
+  init,
+  response,
+  settings,
+  context
+}) {
+  const exchange = await (0, import_http_exchange.captureHttpExchange)({
+    url,
+    init,
+    response,
+    captureBodies: settings.captureBodies
+  });
+  const sessionId = exchange.querySessionId || exchange.responseHeaders.get("mcp-session-id") || exchange.requestHeaders.get("mcp-session-id");
+  const protocolVersion = exchange.responseHeaders.get("mcp-protocol-version") || exchange.requestHeaders.get("mcp-protocol-version");
+  const attributes = {
+    [import_attributes.HttpAttr.REQUEST_METHOD]: exchange.method,
+    [import_attributes.HttpAttr.URL_FULL]: exchange.url,
+    [import_attributes.HttpAttr.RESPONSE_STATUS_CODE]: exchange.statusCode,
+    ...exchange.serverAddress ? { [import_attributes.HttpAttr.SERVER_ADDRESS]: exchange.serverAddress } : {},
+    ...exchange.serverPort === void 0 ? {} : { [import_attributes.HttpAttr.SERVER_PORT]: exchange.serverPort },
+    ...sessionId ? { [import_attributes.McpAttr.SESSION_ID]: sessionId } : {},
+    ...protocolVersion ? { [import_attributes.McpAttr.PROTOCOL_VERSION]: protocolVersion } : {},
+    // HTTP semantic conventions name a failed response by its status code.
+    ...exchange.statusCode >= 400 ? { [import_attributes.ERROR_TYPE_ATTR]: String(exchange.statusCode) } : {},
+    ...headerAttributes(
+      exchange.requestHeaders,
+      settings.requestHeaderPatterns,
+      import_attributes.HttpAttr.REQUEST_HEADER_PREFIX
+    ),
+    ...headerAttributes(
+      exchange.responseHeaders,
+      settings.responseHeaderPatterns,
+      import_attributes.HttpAttr.RESPONSE_HEADER_PREFIX
+    )
+  };
+  const body = settings.captureBodies ? {
+    ...exchange.requestBody === void 0 ? {} : { [import_attributes.HttpAttr.REQUEST_BODY_CONTENT]: exchange.requestBody },
+    ...exchange.responseBody === void 0 ? {} : { [import_attributes.HttpAttr.RESPONSE_BODY_CONTENT]: exchange.responseBody }
+  } : {
+    [import_attributes.HttpAttr.REQUEST_BODY_CONTENT]: ELIDED_BODY,
+    [import_attributes.HttpAttr.RESPONSE_BODY_CONTENT]: ELIDED_BODY
+  };
+  (0, import_logger2.getTelemetryLogger)().emit({
+    eventName: MCP_HTTP_RESPONSE_END_EVENT,
+    severityNumber: import_api_logs.SeverityNumber.DEBUG,
+    severityText: "DEBUG",
+    body,
+    attributes,
+    context
+  });
+}
+__name(reportMcpHttpExchange, "reportMcpHttpExchange");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readMcpHttpExchangeSettings,
+  reportMcpHttpExchange
+});

package/dist/cjs/telemetry/api/internal/metrics/agent.js

@@ -0,0 +1,128 @@
+/**
+  * @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 agent_exports = {};
+__export(agent_exports, {
+  AGENT_DURATION_BUCKETS: () => AGENT_DURATION_BUCKETS,
+  recordAgentDuration: () => recordAgentDuration,
+  recordAgentTotals: () => recordAgentTotals
+});
+module.exports = __toCommonJS(agent_exports);
+var import_attributes = require("../common/attributes.js");
+var import_config = require("../common/config.js");
+var import_meters = require("./meters.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const PER_INVOCATION = "one agent invocation";
+const AGENT_DURATION_BUCKETS = Object.freeze([
+  0.1,
+  0.2,
+  0.4,
+  0.8,
+  1.6,
+  3.2,
+  6.4,
+  12.8,
+  25.6,
+  51.2,
+  102.4,
+  204.8,
+  409.6
+]);
+const getAgentInstruments = (0, import_meters.cachedInstruments)((meter) => ({
+  duration: (0, import_meters.createHistogram)({
+    meter,
+    name: "gen_ai.invoke_agent.duration",
+    unit: "s",
+    description: "Duration of agent invocations.",
+    buckets: AGENT_DURATION_BUCKETS
+  }),
+  inferenceCalls: (0, import_meters.createHistogram)({
+    meter,
+    name: "gen_ai.invoke_agent.inference_calls",
+    unit: "1",
+    description: "Number of inference (model) calls per agent invocation.",
+    buckets: import_meters.CALL_COUNT_BUCKETS
+  }),
+  toolCalls: (0, import_meters.createHistogram)({
+    meter,
+    name: "gen_ai.invoke_agent.tool_calls",
+    unit: "1",
+    description: "Number of tool calls per agent invocation.",
+    buckets: import_meters.CALL_COUNT_BUCKETS
+  }),
+  skillLoads: (0, import_meters.createHistogram)({
+    meter,
+    name: "adk.experimental.invoke_agent.skill.loads",
+    unit: "1",
+    description: `Number of skill loads over ${PER_INVOCATION}.`,
+    buckets: import_meters.CALL_COUNT_BUCKETS
+  }),
+  tokens: (0, import_meters.createTokenHistograms)(
+    meter,
+    "adk.experimental.invoke_agent",
+    PER_INVOCATION
+  )
+}));
+function recordAgentDuration({
+  agentName,
+  durationSeconds,
+  errorType
+}) {
+  const attributes = {
+    [import_attributes.GenAiAttr.AGENT_NAME]: agentName,
+    ...errorType === void 0 ? {} : { [import_attributes.ERROR_TYPE_ATTR]: errorType }
+  };
+  getAgentInstruments().duration.record(durationSeconds, attributes);
+}
+__name(recordAgentDuration, "recordAgentDuration");
+function recordAgentTotals({
+  agentName,
+  totals,
+  config
+}) {
+  const instruments = getAgentInstruments();
+  const attributes = {
+    [import_attributes.GenAiAttr.AGENT_NAME]: agentName
+  };
+  if (totals.tokens !== void 0 && (0, import_config.isExperimentalFeatureEnabled)(config, "token_usage")) {
+    (0, import_meters.recordTokenHistograms)(instruments.tokens, totals.tokens, attributes);
+  }
+  instruments.inferenceCalls.record(totals.inferenceCalls, attributes);
+  instruments.toolCalls.record(totals.toolCalls, attributes);
+  if ((0, import_config.isExperimentalFeatureEnabled)(config, "skills")) {
+    instruments.skillLoads.record(totals.skillLoads, attributes);
+  }
+}
+__name(recordAgentTotals, "recordAgentTotals");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_DURATION_BUCKETS,
+  recordAgentDuration,
+  recordAgentTotals
+});

package/dist/cjs/telemetry/api/internal/metrics/inference_start_hook.js

@@ -0,0 +1,56 @@
+/**
+  * @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 inference_start_hook_exports = {};
+__export(inference_start_hook_exports, {
+  notifyInferenceStart: () => notifyInferenceStart
+});
+module.exports = __toCommonJS(inference_start_hook_exports);
+var import_error_utils = require("../../../../utils/error_utils.js");
+var import_logger = require("../../../../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const INFERENCE_START_HOOK_KEY = /* @__PURE__ */ Symbol.for(
+  "google.adk.telemetry.inferenceStartHook"
+);
+function notifyInferenceStart() {
+  const hook = Reflect.get(globalThis, INFERENCE_START_HOOK_KEY);
+  if (typeof hook !== "function") {
+    return;
+  }
+  try {
+    hook();
+  } catch (error) {
+    import_logger.logger.warn(`Model-call metric hook failed: ${(0, import_error_utils.formatError)(error)}`);
+  }
+}
+__name(notifyInferenceStart, "notifyInferenceStart");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notifyInferenceStart
+});