@google/adk 2.1.0 → 2.2.0

package/dist/cjs/utils/case_utils.js

@@ -25,7 +25,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var case_utils_exports = {};
 __export(case_utils_exports, {
-  camelCaseKeys: () => camelCaseKeys
+  camelCaseKeys: () => camelCaseKeys,
+  renameReservedKeywords: () => renameReservedKeywords,
+  toSnakeCaseName: () => toSnakeCaseName
 });
 module.exports = __toCommonJS(case_utils_exports);
 /**
@@ -49,7 +51,55 @@ function camelCaseKeys(val) {
   return val;
 }
 __name(camelCaseKeys, "camelCaseKeys");
+const PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+  "False",
+  "None",
+  "True",
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+const DEFAULT_RESERVED_WORD_PREFIX = "param_";
+function toSnakeCaseName(text) {
+  return text.replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(toSnakeCaseName, "toSnakeCaseName");
+function renameReservedKeywords(s, prefix = DEFAULT_RESERVED_WORD_PREFIX) {
+  return PYTHON_KEYWORDS.has(s) ? prefix + s : s;
+}
+__name(renameReservedKeywords, "renameReservedKeywords");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  camelCaseKeys
+  camelCaseKeys,
+  renameReservedKeywords,
+  toSnakeCaseName
 });

package/dist/cjs/utils/client_labels.js

@@ -26,6 +26,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var client_labels_exports = {};
 __export(client_labels_exports, {
   getClientLabels: () => getClientLabels,
+  getTrackingHeaders: () => getTrackingHeaders,
+  mergeTrackingHeaders: () => mergeTrackingHeaders,
   parseUserAgent: () => parseUserAgent,
   runWithClientLabel: () => runWithClientLabel
 });
@@ -42,6 +44,7 @@ const ADK_LABEL = "google-adk";
 const LANGUAGE_LABEL = "gl-typescript";
 const AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
 const AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+const TRACKING_HEADER_NAMES = ["x-goog-api-client", "user-agent"];
 const clientLabelLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
 const USER_AGENT_PATTERNS = [
   ["Edge", /(?:Edg|Edge|EdgA)\/([0-9.]+)/i],
@@ -91,9 +94,73 @@ function getClientLabels() {
   return labels;
 }
 __name(getClientLabels, "getClientLabels");
+function getTrackingHeaders() {
+  const headerValue = getClientLabels().join(" ");
+  return {
+    "x-goog-api-client": headerValue,
+    "user-agent": headerValue
+  };
+}
+__name(getTrackingHeaders, "getTrackingHeaders");
+function isTrackingHeaderName(name) {
+  return TRACKING_HEADER_NAMES.some((trackingName) => trackingName === name);
+}
+__name(isTrackingHeaderName, "isTrackingHeaderName");
+function isHeaders(headers) {
+  return typeof headers.forEach === "function";
+}
+__name(isHeaders, "isHeaders");
+function headerEntries(headers) {
+  if (!headers) {
+    return [];
+  }
+  if (Array.isArray(headers)) {
+    return headers.map(([name, value]) => [name, value]);
+  }
+  if (isHeaders(headers)) {
+    const entries = [];
+    headers.forEach((value, name) => {
+      entries.push([name, value]);
+    });
+    return entries;
+  }
+  return Object.entries(headers);
+}
+__name(headerEntries, "headerEntries");
+function mergeTrackingHeaders(headers) {
+  var _a, _b;
+  const merged = {};
+  const callerValues = /* @__PURE__ */ new Map();
+  for (const [name, value] of headerEntries(headers)) {
+    const lowerName = name.toLowerCase();
+    if (isTrackingHeaderName(lowerName)) {
+      callerValues.set(lowerName, [
+        ...(_a = callerValues.get(lowerName)) != null ? _a : [],
+        value
+      ]);
+    } else {
+      merged[name] = value;
+    }
+  }
+  for (const [name, trackingValue] of Object.entries(getTrackingHeaders())) {
+    const tokens = trackingValue.split(" ");
+    for (const value of (_b = callerValues.get(name)) != null ? _b : []) {
+      for (const token of value.split(/\s+/)) {
+        if (token && !tokens.includes(token)) {
+          tokens.push(token);
+        }
+      }
+    }
+    merged[name] = tokens.join(" ");
+  }
+  return merged;
+}
+__name(mergeTrackingHeaders, "mergeTrackingHeaders");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getClientLabels,
+  getTrackingHeaders,
+  mergeTrackingHeaders,
   parseUserAgent,
   runWithClientLabel
 });

package/dist/cjs/utils/gemini_schema_util.js

@@ -25,10 +25,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var gemini_schema_util_exports = {};
 __export(gemini_schema_util_exports, {
+  openApiSchemaToGeminiSchema: () => openApiSchemaToGeminiSchema,
   toGeminiSchema: () => toGeminiSchema
 });
 module.exports = __toCommonJS(gemini_schema_util_exports);
 var import_genai = require("@google/genai");
+var import_case_utils = require("./case_utils.js");
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -74,10 +76,18 @@ function toGeminiSchema(mcpSchema) {
     let isNullable = false;
     let nonNullTypes;
     if (Array.isArray(sourceType)) {
-      nonNullTypes = sourceType.filter(
+      const fromAnyOf = Boolean(mcp.anyOf);
+      const branches = sourceType.map(
+        (branch) => {
+          if (typeof branch !== "boolean") return branch;
+          return fromAnyOf ? { type: "object" } : "object";
+        }
+      );
+      mcp = fromAnyOf ? { ...mcp, anyOf: branches } : { ...mcp, type: branches };
+      nonNullTypes = branches.filter(
         (t) => getTypeFromArrayItem(t) !== "null"
       );
-      isNullable = sourceType.some(
+      isNullable = branches.some(
         (t) => getTypeFromArrayItem(t) === "null"
       );
       if (nonNullTypes.length === 1) {
@@ -134,7 +144,7 @@ function toGeminiSchema(mcpSchema) {
       geminiSchema.description = mcp.description;
     }
     if (mcp.enum) {
-      geminiSchema.enum = mcp.enum.map(String);
+      geminiSchema.enum = mcp.enum.filter((v) => v != null).map(String);
     }
     if (isNullable && mcp.type !== "null") {
       geminiSchema.nullable = true;
@@ -162,7 +172,97 @@ function toGeminiSchema(mcpSchema) {
   return recursiveConvert(mcpSchema);
 }
 __name(toGeminiSchema, "toGeminiSchema");
+const GEMINI_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "anyOf",
+  "default",
+  "description",
+  "enum",
+  "example",
+  "format",
+  "items",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "nullable",
+  "pattern",
+  "properties",
+  "propertyOrdering",
+  "required",
+  "title",
+  "type"
+]);
+const GEMINI_REJECTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "title",
+  "default",
+  "format"
+]);
+const EMPTY_OBJECT_PLACEHOLDER = "dummy_DO_NOT_GENERATE";
+function toGeminiSchemaField(key) {
+  return (0, import_case_utils.toSnakeCaseName)(key).replace(
+    /_([a-z0-9])/g,
+    (_match, letter) => letter.toUpperCase()
+  );
+}
+__name(toGeminiSchemaField, "toGeminiSchemaField");
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function convertSchemaField(field, value) {
+  if (field === "type") {
+    return toGeminiType(typeof value === "string" ? value : void 0);
+  }
+  if (field === "properties" && isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([name, property]) => [
+        name,
+        openApiSchemaToGeminiSchema(property)
+      ])
+    );
+  }
+  if (field === "items" && isPlainObject(value)) {
+    return openApiSchemaToGeminiSchema(value);
+  }
+  if (field === "anyOf" && Array.isArray(value)) {
+    return value.map((item) => openApiSchemaToGeminiSchema(item));
+  }
+  return value;
+}
+__name(convertSchemaField, "convertSchemaField");
+function openApiSchemaToGeminiSchema(openApiSchema) {
+  if (openApiSchema === void 0 || openApiSchema === null) {
+    return void 0;
+  }
+  if (!isPlainObject(openApiSchema)) {
+    throw new TypeError("openapi_schema must be a dictionary");
+  }
+  const source = { ...openApiSchema };
+  if (!source["type"]) {
+    source["type"] = "object";
+  }
+  const properties = source["properties"];
+  const hasProperties = isPlainObject(properties) && Object.keys(properties).length > 0;
+  if (source["type"] === "object" && !hasProperties) {
+    source["properties"] = { [EMPTY_OBJECT_PLACEHOLDER]: { type: "string" } };
+  }
+  const converted = {};
+  for (const [key, value] of Object.entries(source)) {
+    const field = toGeminiSchemaField(key);
+    if (!GEMINI_SCHEMA_FIELDS.has(field) || GEMINI_REJECTED_SCHEMA_FIELDS.has(field)) {
+      continue;
+    }
+    converted[field] = convertSchemaField(field, value);
+  }
+  return converted;
+}
+__name(openApiSchemaToGeminiSchema, "openApiSchemaToGeminiSchema");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  openApiSchemaToGeminiSchema,
   toGeminiSchema
 });

package/dist/cjs/utils/hash_utils.js

@@ -0,0 +1,73 @@
+/**
+  * @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 hash_utils_exports = {};
+__export(hash_utils_exports, {
+  stableHash: () => stableHash,
+  stableStringify: () => stableStringify
+});
+module.exports = __toCommonJS(hash_utils_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+function stableStringify(value) {
+  var _a;
+  return (_a = JSON.stringify(sortKeysDeep(value))) != null ? _a : "undefined";
+}
+__name(stableStringify, "stableStringify");
+function stableHash(value) {
+  const text = stableStringify(value);
+  let hash = FNV_OFFSET_BASIS;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, FNV_PRIME);
+  }
+  return (hash >>> 0).toString(16);
+}
+__name(stableHash, "stableHash");
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const source = value;
+  const sorted = {};
+  for (const key of Object.keys(source).sort()) {
+    sorted[key] = sortKeysDeep(source[key]);
+  }
+  return sorted;
+}
+__name(sortKeysDeep, "sortKeysDeep");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stableHash,
+  stableStringify
+});

package/dist/cjs/utils/live_connection_utils.js

@@ -95,18 +95,19 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
         yield llmResponse;
       }
       if (serverContent.inputTranscription) {
-        if (serverContent.inputTranscription.text) {
-          this.inputTranscriptionText += serverContent.inputTranscription.text;
+        const isGemini3x = (0, import_model_name.isGemini3xLive)(this.modelVersion);
+        const { text, finished } = serverContent.inputTranscription;
+        if (text) {
+          if (!isGemini3x) {
+            this.inputTranscriptionText += text;
+          }
           yield {
-            inputTranscription: {
-              text: serverContent.inputTranscription.text,
-              finished: false
-            },
-            partial: true,
+            inputTranscription: { text, finished: isGemini3x },
+            partial: !isGemini3x,
             ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
           };
         }
-        if (serverContent.inputTranscription.finished) {
+        if (finished && !isGemini3x) {
           yield {
             inputTranscription: {
               text: this.inputTranscriptionText,
@@ -224,7 +225,7 @@ const _LiveResponseAggregator = class _LiveResponseAggregator {
           }))
         );
       }
-      const isGemini3x = (0, import_model_name.isGemini3xFlashLive)(this.modelVersion);
+      const isGemini3x = (0, import_model_name.isGemini3xLive)(this.modelVersion);
       if (isGemini3x && this.toolCallParts.length > 0) {
         yield {
           content: { role: "model", parts: this.toolCallParts },

package/dist/cjs/utils/model_name.js

@@ -28,7 +28,9 @@ __export(model_name_exports, {
   extractModelName: () => extractModelName,
   isGemini1Model: () => isGemini1Model,
   isGemini2OrAbove: () => isGemini2OrAbove,
+  isGemini35LiveTranslate: () => isGemini35LiveTranslate,
   isGemini3xFlashLive: () => isGemini3xFlashLive,
+  isGemini3xLive: () => isGemini3xLive,
   isGeminiModel: () => isGeminiModel,
   isGeminiModelIdCheckDisabled: () => isGeminiModelIdCheckDisabled
 });
@@ -84,12 +86,23 @@ function isGemini2OrAbove(modelString) {
   return parsedVersion.valid && parsedVersion.major >= 2;
 }
 __name(isGemini2OrAbove, "isGemini2OrAbove");
-function isGemini3xFlashLive(modelString) {
+function isGemini3xLive(modelString) {
   if (!modelString) {
     return false;
   }
   const modelName = extractModelName(modelString);
-  return modelName.startsWith("gemini-3.") && modelName.includes("-flash-live");
+  return modelName.startsWith("gemini-3.") && modelName.includes("-live") && !isGemini35LiveTranslate(modelString);
+}
+__name(isGemini3xLive, "isGemini3xLive");
+function isGemini35LiveTranslate(modelString) {
+  if (!modelString) {
+    return false;
+  }
+  return extractModelName(modelString).startsWith("gemini-3.5-live-translate");
+}
+__name(isGemini35LiveTranslate, "isGemini35LiveTranslate");
+function isGemini3xFlashLive(modelString) {
+  return isGemini3xLive(modelString);
 }
 __name(isGemini3xFlashLive, "isGemini3xFlashLive");
 function isGeminiModelIdCheckDisabled() {
@@ -101,7 +114,9 @@ __name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
   extractModelName,
   isGemini1Model,
   isGemini2OrAbove,
+  isGemini35LiveTranslate,
   isGemini3xFlashLive,
+  isGemini3xLive,
   isGeminiModel,
   isGeminiModelIdCheckDisabled
 });

package/dist/cjs/utils/simple_zod_to_json.js

@@ -114,6 +114,11 @@ function zodObjectToSchema(schema) {
   if (isZodV3Schema(schema)) {
     return (0, import_zod_to_json_schema.zodToJsonSchema)(schema, {
       target: "openApi3",
+      // The genai `Schema` type has no `$ref`, so a pointer back at an earlier
+      // occurrence of a reused sub-schema reaches the model as an untyped
+      // parameter. Inline every occurrence instead. A cycle has no finite
+      // inlining and degrades to an unconstrained schema.
+      $refStrategy: "none",
       emailStrategy: "format:email",
       postProcess: /* @__PURE__ */ __name((jsonSchema) => {
         var _a, _b, _c, _d, _e, _f, _g;

package/dist/cjs/version.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(version_exports);
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const version = "2.1.0";
+const version = "2.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/esm/a2a/agent_card.js

@@ -182,6 +182,14 @@ async function buildLLMAgentSkills(agent) {
       }
     }
   }
+  if (agent.codeExecutor) {
+    skills.push({
+      id: `${agent.name}-code-executor`,
+      name: "code-execution",
+      description: "Can execute code",
+      tags: ["llm", "code_execution"]
+    });
+  }
   return skills;
 }
 __name(buildLLMAgentSkills, "buildLLMAgentSkills");

package/dist/esm/a2a/agent_executor.js

@@ -70,7 +70,10 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
         await this.publishFinalTaskStatus({
           executorContext,
           eventBus,
-          event: unansweredRequestEvent
+          event: {
+            ...unansweredRequestEvent,
+            metadata: getA2ASessionMetadata(executorContext)
+          }
         });
         return;
       }
@@ -79,14 +82,16 @@ const _A2AAgentExecutor = class _A2AAgentExecutor {
           createTask({
             taskId: ctx.taskId,
             contextId: ctx.contextId,
-            message: a2aUserMessage
+            message: a2aUserMessage,
+            metadata: getA2ASessionMetadata(executorContext)
           })
         );
       }
       eventBus.publish(
         createTaskWorkingEvent({
           taskId: ctx.taskId,
-          contextId: ctx.contextId
+          contextId: ctx.contextId,
+          metadata: getA2ASessionMetadata(executorContext)
         })
       );
       const adkEvents = [];

package/dist/esm/agents/llm_agent.js

@@ -26,6 +26,7 @@ import {
 import { isDefaultEventActions } from "../events/event_actions.js";
 import { isBaseLlm } from "../models/base_llm.js";
 import { LLMRegistry } from "../models/registry.js";
+import { isBuiltInPlanner } from "../planners/built_in_planner.js";
 import { isBaseTool } from "../tools/base_tool.js";
 import { logger } from "../utils/logger.js";
 import { canUseOutputSchemaWithTools } from "../utils/output_schema_utils.js";
@@ -54,6 +55,10 @@ import { ContextCompactorRequestProcessor } from "./processors/context_compactor
 import { IDENTITY_LLM_REQUEST_PROCESSOR } from "./processors/identity_llm_request_processor.js";
 import { INSTRUCTIONS_LLM_REQUEST_PROCESSOR } from "./processors/instructions_llm_request_processor.js";
 import { INTERACTIONS_REQUEST_PROCESSOR } from "./processors/interactions_request_processor.js";
+import {
+  NL_PLANNING_REQUEST_PROCESSOR,
+  NL_PLANNING_RESPONSE_PROCESSOR
+} from "./processors/nl_planning_processor.js";
 import { REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR } from "./processors/request_confirmation_llm_request_processor.js";
 import { REQUEST_INPUT_LLM_REQUEST_PROCESSOR } from "./processors/request_input_llm_request_processor.js";
 import { TOOL_FILTER_REQUEST_PROCESSOR } from "./processors/tool_filter_request_processor.js";
@@ -155,6 +160,7 @@ const _LlmAgent = class _LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNAT
     this.beforeToolCallback = config.beforeToolCallback;
     this.afterToolCallback = config.afterToolCallback;
     this.codeExecutor = config.codeExecutor;
+    this.planner = config.planner;
     this.requestProcessors = (_i = config.requestProcessors) != null ? _i : [
       BASIC_LLM_REQUEST_PROCESSOR,
       AUTH_PREPROCESSOR,
@@ -163,6 +169,10 @@ const _LlmAgent = class _LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNAT
       REQUEST_CONFIRMATION_LLM_REQUEST_PROCESSOR,
       REQUEST_INPUT_LLM_REQUEST_PROCESSOR,
       CONTENT_REQUEST_PROCESSOR,
+      // Planning clears the thought flags that the planning response
+      // processor sets, so it must run after the contents are built and
+      // before code execution rewrites them.
+      NL_PLANNING_REQUEST_PROCESSOR,
       INTERACTIONS_REQUEST_PROCESSOR,
       CODE_EXECUTION_REQUEST_PROCESSOR,
       TOOL_FILTER_REQUEST_PROCESSOR
@@ -183,7 +193,9 @@ const _LlmAgent = class _LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNAT
         );
       }
     }
-    this.responseProcessors = (_j = config.responseProcessors) != null ? _j : [];
+    this.responseProcessors = (_j = config.responseProcessors) != null ? _j : [
+      NL_PLANNING_RESPONSE_PROCESSOR
+    ];
     const agentTransferDisabled = this.disallowTransferToParent && this.disallowTransferToPeers && !((_k = this.subAgents) == null ? void 0 : _k.length);
     if (!agentTransferDisabled) {
       this.requestProcessors.push(AGENT_TRANSFER_LLM_REQUEST_PROCESSOR);
@@ -202,6 +214,11 @@ const _LlmAgent = class _LlmAgent extends (_b = BaseAgent, _a = LLM_AGENT_SIGNAT
           "Response schema must be set via LlmAgent.output_schema."
         );
       }
+      if (config.generateContentConfig.thinkingConfig && isBuiltInPlanner(this.planner) && this.planner.thinkingConfig) {
+        logger.warn(
+          `Agent ${this.name}: both generateContentConfig.thinkingConfig and planner.thinkingConfig are set. The planner's thinkingConfig takes precedence.`
+        );
+      }
     } else {
       this.generateContentConfig = {};
     }

package/dist/esm/agents/processors/content_processor_utils.js

@@ -25,6 +25,7 @@ import {
   REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
   REQUEST_INPUT_FUNCTION_CALL_NAME
 } from "../functions.js";
+const UNSTRINGIFIABLE_VALUE = "<unstringifiable value>";
 function removeClientFunctionCallId(content) {
   var _a, _b, _c, _d, _e;
   for (const part of (_a = content == null ? void 0 : content.parts) != null ? _a : []) {
@@ -388,9 +389,16 @@ function safeStringify(obj) {
     return obj;
   }
   try {
-    return JSON.stringify(obj);
-  } catch (_e) {
+    const json = JSON.stringify(obj);
+    if (typeof json === "string") {
+      return json;
+    }
+  } catch {
+  }
+  try {
     return String(obj);
+  } catch {
+    return UNSTRINGIFIABLE_VALUE;
   }
 }
 __name(safeStringify, "safeStringify");