@google/adk 2.2.0 → 2.2.1

package/dist/esm/events/internal_metadata.js

@@ -0,0 +1,97 @@
+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 { logger } from "../utils/logger.js";
+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) {
+    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");
+export {
+  INTERNAL_METADATA_PREFIX,
+  RESTORED_EVENT_KEY,
+  internalMetadata,
+  markRestored,
+  publicEvent,
+  publicMetadata,
+  publicSession,
+  withoutInternalMetadata
+};

package/dist/esm/models/gemini_continuation.js

@@ -0,0 +1,205 @@
+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 {
+  FinishReason
+} from "@google/genai";
+import { removeClientFunctionCallId } from "../agents/processors/content_processor_utils.js";
+import { logger } from "../utils/logger.js";
+import { createLlmResponse } from "./llm_response.js";
+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) !== FinishReason.CONTINUATION) {
+    return void 0;
+  }
+  if (!candidate.continuationToken) {
+    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) {
+        logger.warn(
+          "The model returned the same continuation token twice; returning the output generated so far."
+        );
+      } else {
+        logger.warn(
+          `The model paused the generation ${MAX_RESUMES} times; returning the output generated so far.`
+        );
+      }
+      return void 0;
+    }
+    this.token = nextToken;
+    this.resumes++;
+    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 createLlmResponse(response);
+    }
+    const candidate = (_a = response.candidates) == null ? void 0 : _a[0];
+    return 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());
+      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");
+export {
+  GeminiContinuation,
+  MAX_RESUMES,
+  resumeToken
+};