@google/adk 2.3.0 → 2.5.0

package/dist/esm/telemetry/api/internal/common/http_exchange.js

@@ -0,0 +1,142 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { resolveErrorType } from "./error.js";
+const MAX_BODY_LENGTH = 1e3;
+const TRUNCATED_SUFFIX = "... [truncated]";
+const SSE_BODY = "<SSE stream>";
+const REDACTED_HEADER_VALUE = "<redacted>";
+const REDACTED_QUERY_VALUE = "REDACTED";
+const CREDENTIAL_HEADERS = /* @__PURE__ */ new Set([
+  "api-key",
+  "authorization",
+  "cookie",
+  "proxy-authorization",
+  "set-cookie",
+  "x-api-key",
+  "x-goog-api-key"
+]);
+function captureHttpExchange({
+  url,
+  init,
+  response,
+  captureBodies
+}) {
+  var _a, _b;
+  const requestUrl = new URL(url);
+  const isEventStream = ((_a = response.headers.get("content-type")) != null ? _a : "").toLowerCase().includes("text/event-stream");
+  const responseCopy = captureBodies && !isEventStream ? response.clone() : void 0;
+  const requestBody = captureBodies ? readRequestBody(init == null ? void 0 : init.body) : void 0;
+  const exchange = {
+    method: ((_b = init == null ? void 0 : init.method) != null ? _b : "GET").toUpperCase(),
+    url: sanitizeUrl(requestUrl),
+    serverAddress: requestUrl.hostname.replace(/^\[(.*)\]$/, "$1"),
+    ...requestUrl.port ? { serverPort: Number(requestUrl.port) } : {},
+    querySessionId: firstNonEmpty(
+      requestUrl.searchParams.getAll("sessionId"),
+      requestUrl.searchParams.getAll("session_id")
+    ),
+    statusCode: response.status,
+    requestHeaders: redactHeaders(new Headers(init == null ? void 0 : init.headers)),
+    responseHeaders: redactHeaders(response.headers),
+    ...requestBody === void 0 ? {} : { requestBody }
+  };
+  return withResponseBody(exchange, {
+    captureBodies,
+    isEventStream,
+    responseCopy
+  });
+}
+__name(captureHttpExchange, "captureHttpExchange");
+async function withResponseBody(exchange, {
+  captureBodies,
+  isEventStream,
+  responseCopy
+}) {
+  if (isEventStream) {
+    return { ...exchange, responseBody: SSE_BODY };
+  }
+  if (!captureBodies || responseCopy === void 0) {
+    return exchange;
+  }
+  try {
+    return { ...exchange, responseBody: truncate(await responseCopy.text()) };
+  } catch (error) {
+    return {
+      ...exchange,
+      responseBody: `<failed to read body: ${resolveErrorType(error)}>`
+    };
+  }
+}
+__name(withResponseBody, "withResponseBody");
+function readRequestBody(body) {
+  if (typeof body === "string") {
+    return truncate(body);
+  }
+  if (body instanceof URLSearchParams) {
+    return truncate(body.toString());
+  }
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return truncate(new TextDecoder().decode(body));
+  }
+  return void 0;
+}
+__name(readRequestBody, "readRequestBody");
+function truncate(text) {
+  if (text.length <= MAX_BODY_LENGTH) {
+    return text;
+  }
+  let end = 0;
+  let count = 0;
+  for (const character of text) {
+    if (count === MAX_BODY_LENGTH) {
+      return text.slice(0, end) + TRUNCATED_SUFFIX;
+    }
+    end += character.length;
+    count++;
+  }
+  return text;
+}
+__name(truncate, "truncate");
+function sanitizeUrl(url) {
+  const sanitized = new URL(url);
+  sanitized.username = "";
+  sanitized.password = "";
+  if (sanitized.search) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, value] of sanitized.searchParams) {
+      if (value) {
+        keys.add(key);
+      }
+    }
+    sanitized.search = new URLSearchParams(
+      Array.from(keys, (key) => [key, REDACTED_QUERY_VALUE])
+    ).toString();
+  }
+  return sanitized.href;
+}
+__name(sanitizeUrl, "sanitizeUrl");
+function redactHeaders(headers) {
+  const redacted = /* @__PURE__ */ new Map();
+  headers.forEach((value, name) => {
+    redacted.set(
+      name,
+      CREDENTIAL_HEADERS.has(name) ? REDACTED_HEADER_VALUE : value
+    );
+  });
+  return redacted;
+}
+__name(redactHeaders, "redactHeaders");
+function firstNonEmpty(...candidates) {
+  return candidates.flat().find((value) => value !== "");
+}
+__name(firstNonEmpty, "firstNonEmpty");
+export {
+  captureHttpExchange
+};

package/dist/esm/telemetry/api/internal/common/provider_name.js

@@ -0,0 +1,59 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isEnterpriseModeEnabled } from "../../../../utils/env_aware_utils.js";
+import { extractModelName, isGeminiModel } from "../../../../utils/model_name.js";
+const ANTHROPIC_MODEL_PATTERN = /^claude[-.]/i;
+const RESOURCE_COLLECTION_SEGMENTS = /* @__PURE__ */ new Set([
+  "endpoints",
+  "locations",
+  "models",
+  "projects",
+  "publishers",
+  "tunedmodels"
+]);
+const PROVIDER_NAME_BY_SYSTEM_NAME = {
+  gemini: "gcp.gemini",
+  vertex_ai: "gcp.vertex_ai"
+};
+function guessGeminiSystemName() {
+  return isEnterpriseModeEnabled() ? "vertex_ai" : "gemini";
+}
+__name(guessGeminiSystemName, "guessGeminiSystemName");
+function systemNameFromModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  if (isGeminiModel(model)) {
+    return guessGeminiSystemName();
+  }
+  const modelName = extractModelName(model);
+  if (ANTHROPIC_MODEL_PATTERN.test(modelName)) {
+    return "anthropic";
+  }
+  const separator = modelName.indexOf("/");
+  if (separator > 0) {
+    const provider = modelName.slice(0, separator).toLowerCase();
+    if (!RESOURCE_COLLECTION_SEGMENTS.has(provider)) {
+      return provider;
+    }
+  }
+  return void 0;
+}
+__name(systemNameFromModel, "systemNameFromModel");
+function resolveProviderName(model) {
+  var _a, _b;
+  const systemName = (_a = systemNameFromModel(model)) != null ? _a : guessGeminiSystemName();
+  return (_b = PROVIDER_NAME_BY_SYSTEM_NAME[systemName]) != null ? _b : systemName;
+}
+__name(resolveProviderName, "resolveProviderName");
+export {
+  guessGeminiSystemName,
+  resolveProviderName
+};

package/dist/esm/telemetry/api/internal/common/redaction.js

@@ -0,0 +1,121 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { REQUEST_CREDENTIAL_FUNCTION_CALL_NAME } from "../../../../agents/framework_function_calls.js";
+import { AuthCredentialTypes } from "../../../../auth/auth_credential.js";
+const CREDENTIAL_SECRET_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "token",
+  "additionalHeaders",
+  "additional_headers",
+  "clientSecret",
+  "client_secret",
+  "authResponseUri",
+  "auth_response_uri",
+  "authCode",
+  "auth_code",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token",
+  "idToken",
+  "id_token",
+  "codeVerifier",
+  "code_verifier",
+  "privateKeyId",
+  "private_key_id",
+  "privateKey",
+  "private_key",
+  "apiKey",
+  "api_key"
+]);
+const CREDENTIAL_CARRIER_KEYS = /* @__PURE__ */ new Set([
+  "requestedAuthConfigs",
+  "requested_auth_configs",
+  "rawAuthCredential",
+  "raw_auth_credential",
+  "exchangedAuthCredential",
+  "exchanged_auth_credential"
+]);
+const AUTH_TYPE_VALUES = new Set(
+  Object.entries(AuthCredentialTypes).flatMap(([name, value]) => [
+    value,
+    name,
+    name.toLowerCase()
+  ])
+);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function redactAuthConfigSecrets(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactAuthConfigSecrets);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([key]) => !CREDENTIAL_SECRET_KEYS.has(key)).map(([key, item]) => [key, redactAuthConfigSecrets(item)])
+  );
+}
+__name(redactAuthConfigSecrets, "redactAuthConfigSecrets");
+function isAuthCredential(value) {
+  return ["authType", "auth_type"].some((key) => {
+    const authType = value[key];
+    return typeof authType === "string" && AUTH_TYPE_VALUES.has(authType);
+  });
+}
+__name(isAuthCredential, "isAuthCredential");
+function redactCredentialRequest(value) {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => {
+      if (key === "args" && isRecord(item)) {
+        return [
+          key,
+          Object.fromEntries(
+            Object.entries(item).map(([argKey, arg]) => [
+              argKey,
+              argKey === "authConfig" || argKey === "auth_config" ? redactAuthConfigSecrets(arg) : arg
+            ])
+          )
+        ];
+      }
+      if (key === "response") {
+        return [key, redactAuthConfigSecrets(item)];
+      }
+      return [key, redactCredentialSecrets(item)];
+    })
+  );
+}
+__name(redactCredentialRequest, "redactCredentialRequest");
+function redactCredentialSecrets(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactCredentialSecrets);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  if (isAuthCredential(value)) {
+    return redactAuthConfigSecrets(value);
+  }
+  if (value["name"] === REQUEST_CREDENTIAL_FUNCTION_CALL_NAME) {
+    return redactCredentialRequest(value);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      key,
+      CREDENTIAL_CARRIER_KEYS.has(key) ? redactAuthConfigSecrets(item) : redactCredentialSecrets(item)
+    ])
+  );
+}
+__name(redactCredentialSecrets, "redactCredentialSecrets");
+export {
+  redactCredentialSecrets
+};

package/dist/esm/telemetry/api/internal/common/serialization.js

@@ -0,0 +1,30 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getEnvVar } from "../../../../utils/env_aware_utils.js";
+function safeJsonSerialize(obj) {
+  try {
+    return JSON.stringify(
+      obj,
+      (_key, value) => typeof value === "bigint" ? "<not serializable>" : value
+    );
+  } catch (_e) {
+    return "<not serializable>";
+  }
+}
+__name(safeJsonSerialize, "safeJsonSerialize");
+function shouldAddRequestResponseToSpans() {
+  const envValue = getEnvVar("ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS") || "true";
+  return envValue === "true" || envValue === "1";
+}
+__name(shouldAddRequestResponseToSpans, "shouldAddRequestResponseToSpans");
+export {
+  safeJsonSerialize,
+  shouldAddRequestResponseToSpans
+};

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

@@ -0,0 +1,85 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GenAiAttr } from "./attributes.js";
+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[GenAiAttr.USAGE_INPUT_TOKENS] = this.input;
+    }
+    if (this.output !== void 0) {
+      attributes[GenAiAttr.USAGE_OUTPUT_TOKENS] = this.output;
+    }
+    if (this.cacheRead !== void 0) {
+      attributes[GenAiAttr.USAGE_CACHE_READ_INPUT_TOKENS] = this.cacheRead;
+    }
+    if (this.reasoning !== void 0) {
+      attributes[GenAiAttr.USAGE_REASONING_OUTPUT_TOKENS] = this.reasoning;
+    }
+    return attributes;
+  }
+};
+__name(_TokenUsage, "TokenUsage");
+let TokenUsage = _TokenUsage;
+export {
+  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/esm/telemetry/api/internal/logs/inference.js

@@ -0,0 +1,23 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { context, trace } from "@opentelemetry/api";
+import { getTelemetryLogger } from "./logger.js";
+const INFERENCE_OPERATION_DETAILS_EVENT = "gen_ai.client.inference.operation.details";
+function emitInferenceOperationDetails(span, attributes) {
+  getTelemetryLogger().emit({
+    eventName: INFERENCE_OPERATION_DETAILS_EVENT,
+    attributes,
+    context: trace.setSpan(context.active(), span)
+  });
+}
+__name(emitInferenceOperationDetails, "emitInferenceOperationDetails");
+export {
+  emitInferenceOperationDetails
+};

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

@@ -0,0 +1,19 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logs } from "@opentelemetry/api-logs";
+import { version } from "../../../../version.js";
+import { GEN_AI_SYSTEM_VALUE, SCHEMA_URL } from "../common/attributes.js";
+function getTelemetryLogger() {
+  return logs.getLogger(GEN_AI_SYSTEM_VALUE, version, { schemaUrl: SCHEMA_URL });
+}
+__name(getTelemetryLogger, "getTelemetryLogger");
+export {
+  getTelemetryLogger
+};

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

@@ -0,0 +1,113 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { getEnvVar } from "../../../../utils/env_aware_utils.js";
+import { logger } from "../../../../utils/logger.js";
+import { ERROR_TYPE_ATTR, HttpAttr, McpAttr } from "../common/attributes.js";
+import { isTruthyEnv } from "../common/config.js";
+import { captureHttpExchange } from "../common/http_exchange.js";
+import { getTelemetryLogger } from "./logger.js";
+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 = getEnvVar(envName)) != null ? _a : "").split(",")) {
+    const pattern = entry.trim();
+    if (!pattern) {
+      continue;
+    }
+    try {
+      patterns.push(new RegExp(`^(?:${pattern})$`, "i"));
+    } catch {
+      logger.warn(`Ignoring malformed header pattern in ${envName}.`);
+    }
+  }
+  return patterns;
+}
+__name(readHeaderPatterns, "readHeaderPatterns");
+function readMcpHttpExchangeSettings() {
+  return {
+    captureBodies: 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 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 = {
+    [HttpAttr.REQUEST_METHOD]: exchange.method,
+    [HttpAttr.URL_FULL]: exchange.url,
+    [HttpAttr.RESPONSE_STATUS_CODE]: exchange.statusCode,
+    ...exchange.serverAddress ? { [HttpAttr.SERVER_ADDRESS]: exchange.serverAddress } : {},
+    ...exchange.serverPort === void 0 ? {} : { [HttpAttr.SERVER_PORT]: exchange.serverPort },
+    ...sessionId ? { [McpAttr.SESSION_ID]: sessionId } : {},
+    ...protocolVersion ? { [McpAttr.PROTOCOL_VERSION]: protocolVersion } : {},
+    // HTTP semantic conventions name a failed response by its status code.
+    ...exchange.statusCode >= 400 ? { [ERROR_TYPE_ATTR]: String(exchange.statusCode) } : {},
+    ...headerAttributes(
+      exchange.requestHeaders,
+      settings.requestHeaderPatterns,
+      HttpAttr.REQUEST_HEADER_PREFIX
+    ),
+    ...headerAttributes(
+      exchange.responseHeaders,
+      settings.responseHeaderPatterns,
+      HttpAttr.RESPONSE_HEADER_PREFIX
+    )
+  };
+  const body = settings.captureBodies ? {
+    ...exchange.requestBody === void 0 ? {} : { [HttpAttr.REQUEST_BODY_CONTENT]: exchange.requestBody },
+    ...exchange.responseBody === void 0 ? {} : { [HttpAttr.RESPONSE_BODY_CONTENT]: exchange.responseBody }
+  } : {
+    [HttpAttr.REQUEST_BODY_CONTENT]: ELIDED_BODY,
+    [HttpAttr.RESPONSE_BODY_CONTENT]: ELIDED_BODY
+  };
+  getTelemetryLogger().emit({
+    eventName: MCP_HTTP_RESPONSE_END_EVENT,
+    severityNumber: SeverityNumber.DEBUG,
+    severityText: "DEBUG",
+    body,
+    attributes,
+    context
+  });
+}
+__name(reportMcpHttpExchange, "reportMcpHttpExchange");
+export {
+  readMcpHttpExchangeSettings,
+  reportMcpHttpExchange
+};