@google/adk 2.2.0 → 2.2.1

package/dist/cjs/a2a/event_converter_utils.js

@@ -32,6 +32,7 @@ module.exports = __toCommonJS(event_converter_utils_exports);
 var import_genai = require("@google/genai");
 var import_event = require("../events/event.js");
 var import_event_actions = require("../events/event_actions.js");
+var import_internal_metadata = require("../events/internal_metadata.js");
 var import_env_aware_utils = require("../utils/env_aware_utils.js");
 var import_a2a_event = require("./a2a_event.js");
 var import_metadata_converter_utils = require("./metadata_converter_utils.js");
@@ -201,7 +202,10 @@ function createAdkEventFromMetadata(a2aEvent) {
     citationMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.CITATION_METADATA],
     groundingMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.GROUNDING_METADATA],
     usageMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.USAGE_METADATA],
-    customMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.CUSTOM_METADATA],
+    // A remote peer cannot set ADK-internal keys on the events we emit for it.
+    customMetadata: (0, import_internal_metadata.withoutInternalMetadata)(
+      metadata[import_metadata_converter_utils.A2AMetadataKeys.CUSTOM_METADATA]
+    ),
     // Only fields in PEER_SETTABLE_ACTION_FIELDS may be restored from
     // metadata a remote A2A peer controls. Every other action field either
     // mutates the caller's own session or drives the caller's own control

package/dist/cjs/a2a/metadata_converter_utils.js

@@ -33,6 +33,7 @@ __export(metadata_converter_utils_exports, {
   getAdkEventMetadata: () => getAdkEventMetadata
 });
 module.exports = __toCommonJS(metadata_converter_utils_exports);
+var import_internal_metadata = require("../events/internal_metadata.js");
 var import_a2a_event = require("./a2a_event.js");
 /**
  * @license
@@ -95,7 +96,7 @@ function getA2AEventMetadata(adkEvent, {
     [A2AMetadataKeys.CITATION_METADATA]: adkEvent.citationMetadata,
     [A2AMetadataKeys.GROUNDING_METADATA]: adkEvent.groundingMetadata,
     [A2AMetadataKeys.USAGE_METADATA]: adkEvent.usageMetadata,
-    [A2AMetadataKeys.CUSTOM_METADATA]: adkEvent.customMetadata,
+    [A2AMetadataKeys.CUSTOM_METADATA]: (0, import_internal_metadata.publicMetadata)(adkEvent.customMetadata),
     [A2AMetadataKeys.PARTIAL]: adkEvent.partial,
     [A2AMetadataKeys.IS_LONG_RUNNING]: (adkEvent.longRunningToolIds || []).length > 0
   };

package/dist/cjs/common.js

@@ -96,6 +96,7 @@ __export(common_exports, {
   GoogleSearchTool: () => import_google_search_tool.GoogleSearchTool,
   Graph: () => import_workflow.Graph,
   INTERACTIONS_REQUEST_PROCESSOR: () => import_interactions_request_processor.INTERACTIONS_REQUEST_PROCESSOR,
+  INTERNAL_METADATA_PREFIX: () => import_internal_metadata.INTERNAL_METADATA_PREFIX,
   InMemoryArtifactService: () => import_in_memory_artifact_service.InMemoryArtifactService,
   InMemoryCredentialService: () => import_in_memory_credential_service.InMemoryCredentialService,
   InMemoryMemoryService: () => import_in_memory_memory_service.InMemoryMemoryService,
@@ -144,6 +145,7 @@ __export(common_exports, {
   REQUEST_CREDENTIAL_FUNCTION_CALL_NAME: () => import_functions.REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
   REQUEST_INPUT_FUNCTION_CALL_NAME: () => import_functions.REQUEST_INPUT_FUNCTION_CALL_NAME,
   RESERVED_TOOL_CALL_ERROR_TYPE: () => import_reflect_retry_model_plugin.RESERVED_TOOL_CALL_ERROR_TYPE,
+  RESTORED_EVENT_KEY: () => import_internal_metadata.RESTORED_EVENT_KEY,
   ReadonlyContext: () => import_readonly_context.ReadonlyContext,
   ReflectAndRetryModelPlugin: () => import_reflect_retry_model_plugin.ReflectAndRetryModelPlugin,
   ReflectAndRetryToolPlugin: () => import_reflect_retry_tool_plugin.ReflectAndRetryToolPlugin,
@@ -164,6 +166,8 @@ __export(common_exports, {
   StreamingMode: () => import_run_config.StreamingMode,
   Task: () => import_task.Task,
   TokenBasedContextCompactor: () => import_token_based_context_compactor.TokenBasedContextCompactor,
+  ToolCallIntegrityError: () => import_tool_call_integrity_plugin.ToolCallIntegrityError,
+  ToolCallIntegrityPlugin: () => import_tool_call_integrity_plugin.ToolCallIntegrityPlugin,
   ToolConfirmation: () => import_tool_confirmation.ToolConfirmation,
   ToolContext: () => import_tool_context.ToolContext,
   ToolErrorType: () => import_tool_execution_error.ToolErrorType,
@@ -247,11 +251,15 @@ __export(common_exports, {
   isWebMCPSupported: () => import_webmcp_types.isWebMCPSupported,
   isWorkflow: () => import_workflow.isWorkflow,
   logger: () => import_logger.logger,
+  markRestored: () => import_internal_metadata.markRestored,
   node: () => import_workflow.node,
   normalizeRetryExceptions: () => import_workflow.normalizeRetryExceptions,
   populateClientFunctionCallId: () => import_event.populateClientFunctionCallId,
   prepareRetryConfig: () => import_workflow.prepareRetryConfig,
   pruneThoughts: () => import_event.pruneThoughts,
+  publicEvent: () => import_internal_metadata.publicEvent,
+  publicMetadata: () => import_internal_metadata.publicMetadata,
+  publicSession: () => import_internal_metadata.publicSession,
   renameReservedKeywords: () => import_case_utils.renameReservedKeywords,
   requestInputTool: () => import_request_input_tool.requestInputTool,
   requireAgent: () => import_invocation_context.requireAgent,
@@ -322,6 +330,7 @@ var import_tool_execution_error = require("./errors/tool_execution_error.js");
 var import_compacted_event = require("./events/compacted_event.js");
 var import_event = require("./events/event.js");
 var import_event_actions = require("./events/event_actions.js");
+var import_internal_metadata = require("./events/internal_metadata.js");
 var import_structured_events = require("./events/structured_events.js");
 var import_base_example_provider = require("./examples/base_example_provider.js");
 var import_example = require("./examples/example.js");
@@ -343,6 +352,7 @@ var import_plugin_manager = require("./plugins/plugin_manager.js");
 var import_reflect_retry_model_plugin = require("./plugins/reflect_retry_model_plugin.js");
 var import_reflect_retry_tool_plugin = require("./plugins/reflect_retry_tool_plugin.js");
 var import_security_plugin = require("./plugins/security_plugin.js");
+var import_tool_call_integrity_plugin = require("./plugins/tool_call_integrity_plugin.js");
 var import_in_memory_runner = require("./runner/in_memory_runner.js");
 var import_runner = require("./runner/runner.js");
 var import_base_session_service = require("./sessions/base_session_service.js");
@@ -480,6 +490,7 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   GoogleSearchTool,
   Graph,
   INTERACTIONS_REQUEST_PROCESSOR,
+  INTERNAL_METADATA_PREFIX,
   InMemoryArtifactService,
   InMemoryCredentialService,
   InMemoryMemoryService,
@@ -528,6 +539,7 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   REQUEST_CREDENTIAL_FUNCTION_CALL_NAME,
   REQUEST_INPUT_FUNCTION_CALL_NAME,
   RESERVED_TOOL_CALL_ERROR_TYPE,
+  RESTORED_EVENT_KEY,
   ReadonlyContext,
   ReflectAndRetryModelPlugin,
   ReflectAndRetryToolPlugin,
@@ -548,6 +560,8 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   StreamingMode,
   Task,
   TokenBasedContextCompactor,
+  ToolCallIntegrityError,
+  ToolCallIntegrityPlugin,
   ToolConfirmation,
   ToolContext,
   ToolErrorType,
@@ -631,11 +645,15 @@ __reExport(common_exports, require("./tools/base_tool.js"), module.exports);
   isWebMCPSupported,
   isWorkflow,
   logger,
+  markRestored,
   node,
   normalizeRetryExceptions,
   populateClientFunctionCallId,
   prepareRetryConfig,
   pruneThoughts,
+  publicEvent,
+  publicMetadata,
+  publicSession,
   renameReservedKeywords,
   requestInputTool,
   requireAgent,

package/dist/cjs/events/abort_events.js

@@ -0,0 +1,135 @@
+/**
+  * @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 abort_events_exports = {};
+__export(abort_events_exports, {
+  ABORT_MESSAGE: () => ABORT_MESSAGE,
+  INVOCATION_ABORTED: () => INVOCATION_ABORTED,
+  buildAbortEvents: () => buildAbortEvents,
+  isAbortEvent: () => isAbortEvent
+});
+module.exports = __toCommonJS(abort_events_exports);
+var import_event = require("./event.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const INVOCATION_ABORTED = "INVOCATION_ABORTED";
+const ABORT_MESSAGE = "Invocation was aborted by client.";
+function isAbortEvent(event) {
+  return event.errorCode === INVOCATION_ABORTED;
+}
+__name(isAbortEvent, "isAbortEvent");
+function isPausedTaskReply(event) {
+  return Boolean(event.isolationScope) && event.author !== "user" && (0, import_event.isFinalResponse)(event);
+}
+__name(isPausedTaskReply, "isPausedTaskReply");
+function buildAbortEvents({
+  events,
+  invocationId,
+  rootAgentName,
+  branch
+}) {
+  var _a, _b;
+  const invocationEvents = events.filter(
+    (e) => e.invocationId === invocationId
+  );
+  if (invocationEvents.length > 0 && isPausedTaskReply(invocationEvents[invocationEvents.length - 1])) {
+    return [];
+  }
+  const answeredCallIds = /* @__PURE__ */ new Set();
+  for (const event of invocationEvents) {
+    for (const fr of (0, import_event.getFunctionResponses)(event)) {
+      if (fr.id) {
+        answeredCallIds.add(fr.id);
+      }
+    }
+  }
+  const groupedCalls = /* @__PURE__ */ new Map();
+  for (const event of invocationEvents) {
+    for (const fc of (0, import_event.getFunctionCalls)(event)) {
+      if (!fc.id || answeredCallIds.has(fc.id)) {
+        continue;
+      }
+      const callBranch = event.branch || branch;
+      const key = JSON.stringify([
+        (_a = event.author) != null ? _a : null,
+        callBranch != null ? callBranch : null,
+        (_b = event.isolationScope) != null ? _b : null
+      ]);
+      let group = groupedCalls.get(key);
+      if (!group) {
+        group = {
+          author: event.author,
+          branch: callBranch,
+          isolationScope: event.isolationScope,
+          calls: []
+        };
+        groupedCalls.set(key, group);
+      }
+      group.calls.push(fc);
+    }
+  }
+  if (groupedCalls.size === 0) {
+    return [
+      (0, import_event.createEvent)({
+        invocationId,
+        author: rootAgentName,
+        branch,
+        errorCode: INVOCATION_ABORTED,
+        errorMessage: ABORT_MESSAGE
+      })
+    ];
+  }
+  return [...groupedCalls.values()].map(
+    (group) => (0, import_event.createEvent)({
+      invocationId,
+      author: group.author,
+      branch: group.branch,
+      isolationScope: group.isolationScope,
+      content: {
+        role: "user",
+        parts: group.calls.map((fc) => ({
+          functionResponse: {
+            id: fc.id,
+            name: fc.name,
+            response: { error: ABORT_MESSAGE }
+          }
+        }))
+      },
+      errorCode: INVOCATION_ABORTED,
+      errorMessage: ABORT_MESSAGE
+    })
+  );
+}
+__name(buildAbortEvents, "buildAbortEvents");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ABORT_MESSAGE,
+  INVOCATION_ABORTED,
+  buildAbortEvents,
+  isAbortEvent
+});

package/dist/cjs/events/internal_metadata.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 __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 internal_metadata_exports = {};
+__export(internal_metadata_exports, {
+  INTERNAL_METADATA_PREFIX: () => INTERNAL_METADATA_PREFIX,
+  RESTORED_EVENT_KEY: () => RESTORED_EVENT_KEY,
+  internalMetadata: () => internalMetadata,
+  markRestored: () => markRestored,
+  publicEvent: () => publicEvent,
+  publicMetadata: () => publicMetadata,
+  publicSession: () => publicSession,
+  withoutInternalMetadata: () => withoutInternalMetadata
+});
+module.exports = __toCommonJS(internal_metadata_exports);
+var import_logger = require("../utils/logger.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const INTERNAL_METADATA_PREFIX = "__adk_internal_";
+const RESTORED_EVENT_KEY = `${INTERNAL_METADATA_PREFIX}restored_event`;
+function isMetadataObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isMetadataObject, "isMetadataObject");
+function isInternalKey(key) {
+  return key.startsWith(INTERNAL_METADATA_PREFIX);
+}
+__name(isInternalKey, "isInternalKey");
+function dropInternalKeys(metadata) {
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([key]) => !isInternalKey(key))
+  );
+}
+__name(dropInternalKeys, "dropInternalKeys");
+function hasInternalKeys(metadata) {
+  return isMetadataObject(metadata) && Object.keys(metadata).some(isInternalKey);
+}
+__name(hasInternalKeys, "hasInternalKeys");
+function withoutInternalMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return metadata;
+  }
+  const kept = dropInternalKeys(metadata);
+  const dropped = Object.keys(metadata).filter(isInternalKey);
+  if (dropped.length > 0) {
+    import_logger.logger.debug(
+      `Dropping ADK-internal customMetadata keys: ${JSON.stringify(dropped.sort())}`
+    );
+  }
+  return kept;
+}
+__name(withoutInternalMetadata, "withoutInternalMetadata");
+function publicMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return metadata;
+  }
+  const kept = dropInternalKeys(metadata);
+  return Object.keys(kept).length > 0 ? kept : void 0;
+}
+__name(publicMetadata, "publicMetadata");
+function internalMetadata(metadata) {
+  if (!isMetadataObject(metadata)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(metadata).filter(([key]) => isInternalKey(key))
+  );
+}
+__name(internalMetadata, "internalMetadata");
+function markRestored(event) {
+  var _a;
+  event.customMetadata = {
+    ...(_a = withoutInternalMetadata(event.customMetadata)) != null ? _a : {},
+    [RESTORED_EVENT_KEY]: true
+  };
+  return event;
+}
+__name(markRestored, "markRestored");
+function publicEvent(event) {
+  if (!hasInternalKeys(event.customMetadata)) {
+    return event;
+  }
+  return { ...event, customMetadata: publicMetadata(event.customMetadata) };
+}
+__name(publicEvent, "publicEvent");
+function publicSession(session) {
+  var _a;
+  const events = (_a = session.events) != null ? _a : [];
+  const publicEvents = events.map((event) => publicEvent(event));
+  if (publicEvents.every((event, i) => event === events[i])) {
+    return session;
+  }
+  return { ...session, events: publicEvents };
+}
+__name(publicSession, "publicSession");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERNAL_METADATA_PREFIX,
+  RESTORED_EVENT_KEY,
+  internalMetadata,
+  markRestored,
+  publicEvent,
+  publicMetadata,
+  publicSession,
+  withoutInternalMetadata
+});

package/dist/cjs/models/gemini_continuation.js

@@ -0,0 +1,232 @@
+/**
+  * @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 gemini_continuation_exports = {};
+__export(gemini_continuation_exports, {
+  GeminiContinuation: () => GeminiContinuation,
+  MAX_RESUMES: () => MAX_RESUMES,
+  resumeToken: () => resumeToken
+});
+module.exports = __toCommonJS(gemini_continuation_exports);
+var import_genai = require("@google/genai");
+var import_content_processor_utils = require("../agents/processors/content_processor_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_llm_response = require("./llm_response.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const MAX_RESUMES = 256;
+function resumeToken(response) {
+  var _a;
+  const candidate = (_a = response.candidates) == null ? void 0 : _a[0];
+  if ((candidate == null ? void 0 : candidate.finishReason) !== import_genai.FinishReason.CONTINUATION) {
+    return void 0;
+  }
+  if (!candidate.continuationToken) {
+    import_logger.logger.warn(
+      "The model paused the generation for continuation, but the response carries no continuation token, so the partial output is returned."
+    );
+    return void 0;
+  }
+  return candidate.continuationToken;
+}
+__name(resumeToken, "resumeToken");
+const _GeminiContinuation = class _GeminiContinuation {
+  constructor(contents, config) {
+    this.config = config;
+    this.parts = [];
+    this.resumes = 0;
+    this.contents = [...contents];
+  }
+  /**
+   * Adds one request's output to the generation: its parts to the content and
+   * its usage to the total.
+   */
+  addOutput(newParts, newUsage) {
+    this.usage = addUsage(this.usage, newUsage);
+    this.appendParts(newParts);
+  }
+  /**
+   * Returns the request that resumes the generation after a request that
+   * ended with `nextToken`. Returns undefined if the request did not pause,
+   * returned the previous token again, or the generation was already resumed
+   * {@link MAX_RESUMES} times.
+   */
+  resumeRequest(nextToken) {
+    if (nextToken === void 0) {
+      return void 0;
+    }
+    if (!this.willResume(nextToken)) {
+      if (nextToken === this.token) {
+        import_logger.logger.warn(
+          "The model returned the same continuation token twice; returning the output generated so far."
+        );
+      } else {
+        import_logger.logger.warn(
+          `The model paused the generation ${MAX_RESUMES} times; returning the output generated so far.`
+        );
+      }
+      return void 0;
+    }
+    this.token = nextToken;
+    this.resumes++;
+    import_logger.logger.debug("The model paused the generation; resuming it.");
+    return this.buildResumeRequest(nextToken);
+  }
+  /** Returns `response` with the content and usage of all requests, if resumed. */
+  complete(response) {
+    var _a;
+    if (!this.resumed) {
+      return (0, import_llm_response.createLlmResponse)(response);
+    }
+    const candidate = (_a = response.candidates) == null ? void 0 : _a[0];
+    return (0, import_llm_response.createLlmResponse)({
+      ...response,
+      usageMetadata: this.usage,
+      candidates: candidate && this.parts.length > 0 ? [{ ...candidate, content: this.content() }] : response.candidates
+    });
+  }
+  /**
+   * Returns the final streamed `response`, with usage summed across all
+   * requests if resumed.
+   */
+  withSummedUsage(response) {
+    return this.resumed ? { ...response, usageMetadata: this.usage } : response;
+  }
+  /** Returns whether a request that ended with `nextToken` is resumed. */
+  willResume(nextToken) {
+    return nextToken !== this.token && this.resumes < MAX_RESUMES;
+  }
+  /** Whether the generation took more than one request. */
+  get resumed() {
+    return this.token !== void 0;
+  }
+  content() {
+    return { role: "model", parts: [...this.parts] };
+  }
+  buildResumeRequest(nextToken) {
+    const contents = [...this.contents];
+    if (this.parts.length > 0) {
+      const content = structuredClone(this.content());
+      (0, import_content_processor_utils.removeClientFunctionCallId)(content);
+      contents.push(content);
+    }
+    return {
+      contents,
+      config: { ...this.config, continuationToken: nextToken }
+    };
+  }
+  /** Appends `newParts`, joining text as the streaming aggregator does. */
+  appendParts(newParts) {
+    for (const part of newParts) {
+      const last = this.parts.length - 1;
+      const previous = last >= 0 ? this.parts[last] : void 0;
+      if (previous && canJoin(previous, part)) {
+        const joined = { text: previous.text + part.text };
+        if (previous.thought !== void 0) {
+          joined.thought = previous.thought;
+        }
+        const signature = previous.thoughtSignature || part.thoughtSignature;
+        if (signature !== void 0) {
+          joined.thoughtSignature = signature;
+        }
+        this.parts[last] = joined;
+      } else {
+        this.parts.push(part);
+      }
+    }
+  }
+};
+__name(_GeminiContinuation, "GeminiContinuation");
+let GeminiContinuation = _GeminiContinuation;
+function canJoin(first, second) {
+  var _a, _b;
+  return isText(first) && isText(second) && ((_a = first.thought) != null ? _a : false) === ((_b = second.thought) != null ? _b : false);
+}
+__name(canJoin, "canJoin");
+function isText(part) {
+  if (!part.text) {
+    return false;
+  }
+  return Object.entries(part).every(
+    ([key, value]) => value === void 0 || key === "text" || key === "thought" || key === "thoughtSignature"
+  );
+}
+__name(isText, "isText");
+const COUNT_FIELDS = [
+  "promptTokenCount",
+  "candidatesTokenCount",
+  "totalTokenCount",
+  "cachedContentTokenCount",
+  "thoughtsTokenCount",
+  "toolUsePromptTokenCount"
+];
+const MODALITY_FIELDS = [
+  "promptTokensDetails",
+  "candidatesTokensDetails",
+  "cacheTokensDetails",
+  "toolUsePromptTokensDetails"
+];
+function addUsage(total, next) {
+  var _a, _b;
+  if (!total || !next) {
+    return total != null ? total : next;
+  }
+  const combined = { ...next };
+  for (const field of COUNT_FIELDS) {
+    if (total[field] !== void 0 || next[field] !== void 0) {
+      combined[field] = ((_a = total[field]) != null ? _a : 0) + ((_b = next[field]) != null ? _b : 0);
+    }
+  }
+  for (const field of MODALITY_FIELDS) {
+    if (total[field] !== void 0 || next[field] !== void 0) {
+      combined[field] = addModalityCounts(total[field], next[field]);
+    }
+  }
+  return combined;
+}
+__name(addUsage, "addUsage");
+function addModalityCounts(first, second) {
+  var _a, _b;
+  const totals = /* @__PURE__ */ new Map();
+  for (const count of [...first != null ? first : [], ...second != null ? second : []]) {
+    totals.set(
+      count.modality,
+      ((_a = totals.get(count.modality)) != null ? _a : 0) + ((_b = count.tokenCount) != null ? _b : 0)
+    );
+  }
+  return [...totals].map(
+    ([modality, tokenCount]) => modality === void 0 ? { tokenCount } : { modality, tokenCount }
+  );
+}
+__name(addModalityCounts, "addModalityCounts");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GeminiContinuation,
+  MAX_RESUMES,
+  resumeToken
+});