@google/adk 2.3.0 → 2.5.0

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

@@ -0,0 +1,217 @@
+/**
+  * @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 genai_messages_exports = {};
+__export(genai_messages_exports, {
+  buildOutputMessage: () => buildOutputMessage,
+  buildRequestOperationDetails: () => buildRequestOperationDetails,
+  withoutContent: () => withoutContent
+});
+module.exports = __toCommonJS(genai_messages_exports);
+var import_case_utils = require("../../../../utils/case_utils.js");
+var import_attributes = require("./attributes.js");
+var import_finish_reason = require("./finish_reason.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const FUNCTION_TOOL_DEFINITION_TYPE = "function";
+function toAnyValue(value, seen) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "object" || seen.has(value)) {
+    return "<not serializable>";
+  }
+  const nextSeen = new Set(seen).add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => toAnyValue(item, nextSeen));
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item !== void 0) {
+      result[key] = toAnyValue(item, nextSeen);
+    }
+  }
+  return result;
+}
+__name(toAnyValue, "toAnyValue");
+function toOptionalMapping(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const normalized = toAnyValue(value, /* @__PURE__ */ new Set());
+  return typeof normalized === "object" && normalized !== null && !Array.isArray(normalized) && !(normalized instanceof Uint8Array) ? normalized : { value: normalized };
+}
+__name(toOptionalMapping, "toOptionalMapping");
+function toRole(role) {
+  if (role === "user") {
+    return "user";
+  }
+  if (role === "model") {
+    return "assistant";
+  }
+  return "";
+}
+__name(toRole, "toRole");
+function toMessagePart(part, index) {
+  var _a, _b, _c, _d, _e, _f;
+  const fallbackId = /* @__PURE__ */ __name((name) => name ? `${name}_${index}` : `${index}`, "fallbackId");
+  if (part.text !== void 0) {
+    return { content: part.text, type: "text" };
+  }
+  if (part.inlineData) {
+    return { mime_type: (_a = part.inlineData.mimeType) != null ? _a : "", type: "blob" };
+  }
+  if (part.fileData) {
+    return {
+      mime_type: (_b = part.fileData.mimeType) != null ? _b : "",
+      uri: (_c = part.fileData.fileUri) != null ? _c : "",
+      type: "file_data"
+    };
+  }
+  if (part.functionCall) {
+    const call = part.functionCall;
+    return {
+      id: (_d = call.id) != null ? _d : fallbackId(call.name),
+      name: (_e = call.name) != null ? _e : "",
+      arguments: toOptionalMapping(call.args),
+      type: "tool_call"
+    };
+  }
+  if (part.functionResponse) {
+    const response = part.functionResponse;
+    return {
+      id: (_f = response.id) != null ? _f : fallbackId(response.name),
+      response: toOptionalMapping(response.response),
+      type: "tool_call_response"
+    };
+  }
+  return void 0;
+}
+__name(toMessagePart, "toMessagePart");
+function toMessageParts(parts) {
+  return (parts != null ? parts : []).flatMap((part, index) => {
+    const converted = toMessagePart(part, index);
+    return converted ? [converted] : [];
+  });
+}
+__name(toMessageParts, "toMessageParts");
+function toInputMessage(content) {
+  return { role: toRole(content.role), parts: toMessageParts(content.parts) };
+}
+__name(toInputMessage, "toInputMessage");
+function isContent(value) {
+  return "parts" in value || "role" in value;
+}
+__name(isContent, "isContent");
+function toParts(instruction) {
+  var _a;
+  if (typeof instruction === "string") {
+    return [{ text: instruction }];
+  }
+  if (Array.isArray(instruction)) {
+    return instruction.map(
+      (part) => typeof part === "string" ? { text: part } : part
+    );
+  }
+  return isContent(instruction) ? (_a = instruction.parts) != null ? _a : [] : [instruction];
+}
+__name(toParts, "toParts");
+function toSystemInstructions(config) {
+  if (!(config == null ? void 0 : config.systemInstruction)) {
+    return [];
+  }
+  return toMessageParts(toParts(config.systemInstruction));
+}
+__name(toSystemInstructions, "toSystemInstructions");
+function toToolDefinitions(tool) {
+  var _a, _b, _c;
+  if (!("functionDeclarations" in tool) && "callTool" in tool) {
+    return [{ name: "UnserializableTool", type: "CallableTool" }];
+  }
+  const definitions = [];
+  for (const declaration of (_a = tool.functionDeclarations) != null ? _a : []) {
+    const parameters = (_b = declaration.parameters) != null ? _b : declaration.parametersJsonSchema;
+    definitions.push({
+      name: (_c = declaration.name) != null ? _c : "FunctionDeclaration",
+      description: declaration.description,
+      parameters: parameters === void 0 ? null : toOptionalMapping(parameters),
+      type: FUNCTION_TOOL_DEFINITION_TYPE
+    });
+  }
+  for (const [key, value] of Object.entries(tool)) {
+    if (key !== "functionDeclarations" && value !== void 0) {
+      const toolType = (0, import_case_utils.toSnakeCaseName)(key);
+      definitions.push({ name: toolType, type: toolType });
+    }
+  }
+  return definitions;
+}
+__name(toToolDefinitions, "toToolDefinitions");
+function buildRequestOperationDetails(llmRequest) {
+  var _a, _b;
+  return {
+    [import_attributes.GenAiAttr.INPUT_MESSAGES]: llmRequest.contents.map(toInputMessage),
+    [import_attributes.GenAiAttr.SYSTEM_INSTRUCTIONS]: toSystemInstructions(llmRequest.config),
+    [import_attributes.GenAiAttr.TOOL_DEFINITIONS]: ((_b = (_a = llmRequest.config) == null ? void 0 : _a.tools) != null ? _b : []).flatMap(
+      toToolDefinitions
+    )
+  };
+}
+__name(buildRequestOperationDetails, "buildRequestOperationDetails");
+function buildOutputMessage(llmResponse) {
+  if (!llmResponse.content) {
+    return void 0;
+  }
+  return {
+    ...toInputMessage(llmResponse.content),
+    finish_reason: (0, import_finish_reason.toOutputMessageFinishReason)(llmResponse.finishReason)
+  };
+}
+__name(buildOutputMessage, "buildOutputMessage");
+function withoutContent(details) {
+  const toolDefinitions = details[import_attributes.GenAiAttr.TOOL_DEFINITIONS];
+  if (!(toolDefinitions == null ? void 0 : toolDefinitions.length)) {
+    return {};
+  }
+  return {
+    [import_attributes.GenAiAttr.TOOL_DEFINITIONS]: toolDefinitions.map((definition) => {
+      if (typeof definition !== "object" || definition === null || Array.isArray(definition) || definition instanceof Uint8Array || !("parameters" in definition)) {
+        return definition;
+      }
+      const { parameters: _parameters, ...rest } = definition;
+      return rest;
+    })
+  };
+}
+__name(withoutContent, "withoutContent");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildOutputMessage,
+  buildRequestOperationDetails,
+  withoutContent
+});

package/dist/cjs/telemetry/api/internal/common/http_exchange.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 http_exchange_exports = {};
+__export(http_exchange_exports, {
+  captureHttpExchange: () => captureHttpExchange
+});
+module.exports = __toCommonJS(http_exchange_exports);
+var import_error = require("./error.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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: ${(0, import_error.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureHttpExchange
+});

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

@@ -0,0 +1,87 @@
+/**
+  * @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 provider_name_exports = {};
+__export(provider_name_exports, {
+  guessGeminiSystemName: () => guessGeminiSystemName,
+  resolveProviderName: () => resolveProviderName
+});
+module.exports = __toCommonJS(provider_name_exports);
+var import_env_aware_utils = require("../../../../utils/env_aware_utils.js");
+var import_model_name = require("../../../../utils/model_name.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 (0, import_env_aware_utils.isEnterpriseModeEnabled)() ? "vertex_ai" : "gemini";
+}
+__name(guessGeminiSystemName, "guessGeminiSystemName");
+function systemNameFromModel(model) {
+  if (!model) {
+    return void 0;
+  }
+  if ((0, import_model_name.isGeminiModel)(model)) {
+    return guessGeminiSystemName();
+  }
+  const modelName = (0, import_model_name.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  guessGeminiSystemName,
+  resolveProviderName
+});

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

@@ -0,0 +1,148 @@
+/**
+  * @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 redaction_exports = {};
+__export(redaction_exports, {
+  redactCredentialSecrets: () => redactCredentialSecrets
+});
+module.exports = __toCommonJS(redaction_exports);
+var import_framework_function_calls = require("../../../../agents/framework_function_calls.js");
+var import_auth_credential = require("../../../../auth/auth_credential.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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(import_auth_credential.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"] === import_framework_function_calls.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redactCredentialSecrets
+});

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

@@ -0,0 +1,58 @@
+/**
+  * @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 serialization_exports = {};
+__export(serialization_exports, {
+  safeJsonSerialize: () => safeJsonSerialize,
+  shouldAddRequestResponseToSpans: () => shouldAddRequestResponseToSpans
+});
+module.exports = __toCommonJS(serialization_exports);
+var import_env_aware_utils = require("../../../../utils/env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 = (0, import_env_aware_utils.getEnvVar)("ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS") || "true";
+  return envValue === "true" || envValue === "1";
+}
+__name(shouldAddRequestResponseToSpans, "shouldAddRequestResponseToSpans");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeJsonSerialize,
+  shouldAddRequestResponseToSpans
+});