@google/adk 1.5.0 → 2.0.0

package/dist/esm/utils/genai_schema_to_json.js

@@ -0,0 +1,80 @@
+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
+ */
+const NUMERIC_STRING_KEYS = [
+  "minItems",
+  "maxItems",
+  "minLength",
+  "maxLength",
+  "minProperties",
+  "maxProperties"
+];
+const NON_JSON_SCHEMA_KEYS = /* @__PURE__ */ new Set(["propertyOrdering", "example"]);
+const TYPE_NAMES = {
+  STRING: "string",
+  NUMBER: "number",
+  INTEGER: "integer",
+  BOOLEAN: "boolean",
+  ARRAY: "array",
+  OBJECT: "object",
+  NULL: "null"
+};
+function genaiSchemaToJsonSchema(schema) {
+  const source = schema;
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || NON_JSON_SCHEMA_KEYS.has(key)) {
+      continue;
+    }
+    switch (key) {
+      case "type":
+      case "nullable":
+        break;
+      case "items":
+        out["items"] = genaiSchemaToJsonSchema(value);
+        break;
+      case "properties": {
+        const properties = {};
+        for (const [name, property] of Object.entries(
+          value
+        )) {
+          properties[name] = genaiSchemaToJsonSchema(property);
+        }
+        out["properties"] = properties;
+        break;
+      }
+      case "anyOf":
+        out["anyOf"] = value.map(genaiSchemaToJsonSchema);
+        break;
+      case "format":
+        if (value !== "enum") {
+          out["format"] = value;
+        }
+        break;
+      default:
+        out[key] = NUMERIC_STRING_KEYS.includes(
+          key
+        ) ? Number(value) : value;
+    }
+  }
+  const typeName = typeof schema.type === "string" ? TYPE_NAMES[schema.type] : void 0;
+  if (typeName) {
+    out["type"] = schema.nullable ? [typeName, "null"] : typeName;
+  }
+  if (Array.isArray(out["enum"]) && (typeName === "integer" || typeName === "number")) {
+    out["enum"] = out["enum"].map(
+      (member) => typeof member === "string" && member.trim() !== "" && !isNaN(Number(member)) ? Number(member) : member
+    );
+  }
+  return out;
+}
+__name(genaiSchemaToJsonSchema, "genaiSchemaToJsonSchema");
+export {
+  genaiSchemaToJsonSchema
+};

package/dist/esm/utils/live_connection_utils.js

@@ -1,12 +1,14 @@
 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 { isGemini3xFlashLive } from "./model_name.js";
-class LiveResponseAggregator {
+const _LiveResponseAggregator = class _LiveResponseAggregator {
   constructor(modelVersion) {
     this.modelVersion = modelVersion;
     this.text = "";
@@ -250,7 +252,9 @@ class LiveResponseAggregator {
     }
     return response;
   }
-}
+};
+__name(_LiveResponseAggregator, "LiveResponseAggregator");
+let LiveResponseAggregator = _LiveResponseAggregator;
 export {
   LiveResponseAggregator
 };

package/dist/esm/utils/logger.js

@@ -1,5 +1,7 @@
 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 2025 Google LLC
@@ -13,7 +15,7 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   return LogLevel2;
 })(LogLevel || {});
-class SimpleLogger {
+const _SimpleLogger = class _SimpleLogger {
   constructor() {
     this.logLevel = 1 /* INFO */;
     this.logger = winston.createLogger({
@@ -72,8 +74,10 @@ class SimpleLogger {
     }
     this.logger.error(messages.join(" "));
   }
-}
-class NoOpLogger {
+};
+__name(_SimpleLogger, "SimpleLogger");
+let SimpleLogger = _SimpleLogger;
+const _NoOpLogger = class _NoOpLogger {
   setLogLevel(_level) {
   }
   log(_level, ..._args) {
@@ -86,20 +90,26 @@ class NoOpLogger {
   }
   error(..._args) {
   }
-}
+};
+__name(_NoOpLogger, "NoOpLogger");
+let NoOpLogger = _NoOpLogger;
 let currentLogger = new SimpleLogger();
 function setLogger(customLogger) {
   currentLogger = customLogger != null ? customLogger : new NoOpLogger();
 }
+__name(setLogger, "setLogger");
 function getLogger() {
   return currentLogger;
 }
+__name(getLogger, "getLogger");
 function resetLogger() {
   currentLogger = new SimpleLogger();
 }
+__name(resetLogger, "resetLogger");
 function setLogLevel(level) {
   logger.setLogLevel(level);
 }
+__name(setLogLevel, "setLogLevel");
 const logger = {
   setLogLevel(level) {
     currentLogger.setLogLevel(level);

package/dist/esm/utils/model_name.js

@@ -1,5 +1,7 @@
 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 2025 Google LLC
@@ -14,10 +16,12 @@ function extractModelName(modelString) {
   }
   return modelString;
 }
+__name(extractModelName, "extractModelName");
 function isGeminiModel(modelString) {
   const modelName = extractModelName(modelString);
   return modelName.startsWith("gemini-");
 }
+__name(isGeminiModel, "isGeminiModel");
 function parseVersion(versionString) {
   if (!/^\d+(\.\d+)*$/.test(versionString)) {
     return { valid: false, major: 0, minor: 0, patch: 0 };
@@ -30,10 +34,12 @@ function parseVersion(versionString) {
     patch: parts.length > 2 ? parts[2] : 0
   };
 }
+__name(parseVersion, "parseVersion");
 function isGemini1Model(modelString) {
   const modelName = extractModelName(modelString);
   return modelName.startsWith("gemini-1");
 }
+__name(isGemini1Model, "isGemini1Model");
 function isGemini2OrAbove(modelString) {
   if (!modelString) {
     return false;
@@ -46,6 +52,7 @@ function isGemini2OrAbove(modelString) {
   const parsedVersion = parseVersion(versionString);
   return parsedVersion.valid && parsedVersion.major >= 2;
 }
+__name(isGemini2OrAbove, "isGemini2OrAbove");
 function isGemini3xFlashLive(modelString) {
   if (!modelString) {
     return false;
@@ -53,9 +60,11 @@ function isGemini3xFlashLive(modelString) {
   const modelName = extractModelName(modelString);
   return modelName.startsWith("gemini-3.") && modelName.includes("-flash-live");
 }
+__name(isGemini3xFlashLive, "isGemini3xFlashLive");
 function isGeminiModelIdCheckDisabled() {
   return getBooleanEnvVar("ADK_DISABLE_GEMINI_MODEL_ID_CHECK");
 }
+__name(isGeminiModelIdCheckDisabled, "isGeminiModelIdCheckDisabled");
 export {
   extractModelName,
   isGemini1Model,

package/dist/esm/utils/object_notation_utils.js

@@ -1,5 +1,7 @@
 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
@@ -8,14 +10,16 @@ const require = topLevelCreateRequire(import.meta.url);
 function toCamelCase(obj, preserveKeys = []) {
   return toNotation(obj, toCamelCaseKey, "", preserveKeys);
 }
+__name(toCamelCase, "toCamelCase");
 function toSnakeCase(obj, preserveKeys = []) {
   return toNotation(obj, toSnakeCaseKey, "", preserveKeys);
 }
-const toCamelCaseKey = (key) => key.replace(
+__name(toSnakeCase, "toSnakeCase");
+const toCamelCaseKey = /* @__PURE__ */ __name((key) => key.replace(
   /_([a-z])/g,
   (_match, letter) => letter.toUpperCase()
-);
-const toSnakeCaseKey = (key) => key.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase());
+), "toCamelCaseKey");
+const toSnakeCaseKey = /* @__PURE__ */ __name((key) => key.replace(/[A-Z]/g, (g) => "_" + g.toLowerCase()), "toSnakeCaseKey");
 function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
   if (Array.isArray(obj)) {
     return obj.map(
@@ -43,6 +47,7 @@ function toNotation(obj, converter, parentKey = "", preserveKeys = []) {
   }
   return obj;
 }
+__name(toNotation, "toNotation");
 export {
   toCamelCase,
   toSnakeCase

package/dist/esm/utils/optional_peer.js

@@ -0,0 +1,41 @@
+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
+ */
+const MODULE_NOT_FOUND_CODES = /* @__PURE__ */ new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "MODULE_NOT_FOUND"
+]);
+function isMissingModule(err, packageName) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  const code = err.code;
+  return code !== void 0 && MODULE_NOT_FOUND_CODES.has(code) && err.message.includes(packageName);
+}
+__name(isMissingModule, "isMissingModule");
+async function loadOptionalPeer(peer, load) {
+  try {
+    return await load();
+  } catch (err) {
+    if (!isMissingModule(err, peer.packageName)) {
+      throw err;
+    }
+    throw new Error(
+      `${peer.feature} requires the optional peer dependency "${peer.packageName}", which is not installed. It is optional so that applications that do not use ${peer.feature} are not made to download it. Install it with:
+
+  npm install ${peer.packageName}
+`,
+      { cause: err }
+    );
+  }
+}
+__name(loadOptionalPeer, "loadOptionalPeer");
+export {
+  loadOptionalPeer
+};

package/dist/esm/utils/output_schema_utils.js

@@ -0,0 +1,18 @@
+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 { isGemini2OrAbove } from "./model_name.js";
+import { getGoogleLlmVariant, GoogleLLMVariant } from "./variant_utils.js";
+function canUseOutputSchemaWithTools(modelString) {
+  return getGoogleLlmVariant() === GoogleLLMVariant.VERTEX_AI && isGemini2OrAbove(modelString);
+}
+__name(canUseOutputSchemaWithTools, "canUseOutputSchemaWithTools");
+export {
+  canUseOutputSchemaWithTools
+};

package/dist/esm/utils/partial_copy.js

@@ -1,5 +1,7 @@
 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
@@ -18,6 +20,7 @@ function partialCopy(source, targetKeys) {
   });
   return result;
 }
+__name(partialCopy, "partialCopy");
 export {
   partialCopy
 };

package/dist/esm/utils/redact_uri.js

@@ -0,0 +1,39 @@
+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
+ */
+const SECRET_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "pwd",
+  "sslpassword"
+]);
+function redactUriPassword(uri) {
+  try {
+    const url = new URL(uri);
+    let redacted = false;
+    if (url.password) {
+      url.password = "***";
+      redacted = true;
+    }
+    for (const name of [...url.searchParams.keys()]) {
+      if (SECRET_QUERY_PARAMS.has(name.toLowerCase())) {
+        url.searchParams.set(name, "***");
+        redacted = true;
+      }
+    }
+    return redacted ? url.toString() : uri;
+  } catch {
+    const schemeEnd = uri.indexOf("://");
+    return schemeEnd === -1 ? "<unparseable URI, redacted>" : `${uri.slice(0, schemeEnd)}://<unparseable URI, redacted>`;
+  }
+}
+__name(redactUriPassword, "redactUriPassword");
+export {
+  redactUriPassword
+};

package/dist/esm/utils/schema.js

@@ -0,0 +1,152 @@
+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 { zodToJsonSchema as toJSONSchemaV3 } from "zod-to-json-schema";
+import { toJSONSchema as toJSONSchemaV4, z as z4 } from "zod/v4";
+import { genaiSchemaToJsonSchema } from "./genai_schema_to_json.js";
+import {
+  isZodSchema,
+  isZodV3Schema,
+  isZodV4Schema
+} from "./simple_zod_to_json.js";
+const genaiValidators = /* @__PURE__ */ new WeakMap();
+function genaiSchemaValidator(schema) {
+  const cached = genaiValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let validator = null;
+  try {
+    validator = z4.fromJSONSchema(
+      genaiSchemaToJsonSchema(schema)
+    );
+  } catch {
+    validator = null;
+  }
+  genaiValidators.set(schema, validator);
+  return validator != null ? validator : void 0;
+}
+__name(genaiSchemaValidator, "genaiSchemaValidator");
+function parseWithSchema(schema, value) {
+  if (schema === void 0) {
+    return value;
+  }
+  if (isZodSchema(schema)) {
+    return schema.parse(value);
+  }
+  const validator = genaiSchemaValidator(schema);
+  return validator ? validator.parse(value) : value;
+}
+__name(parseWithSchema, "parseWithSchema");
+function toJsonSchema(schema) {
+  if (isZodV4Schema(schema)) {
+    return toJSONSchemaV4(schema);
+  }
+  if (isZodV3Schema(schema)) {
+    return toJSONSchemaV3(schema);
+  }
+  return genaiSchemaToJsonSchema(schema);
+}
+__name(toJsonSchema, "toJsonSchema");
+function compileJsonSchema(jsonSchema) {
+  if (jsonSchema === null || typeof jsonSchema !== "object") {
+    return void 0;
+  }
+  try {
+    return z4.fromJSONSchema(jsonSchema);
+  } catch {
+    return void 0;
+  }
+}
+__name(compileJsonSchema, "compileJsonSchema");
+const objectFieldValidators = /* @__PURE__ */ new WeakMap();
+function objectSchemaFields(schema) {
+  const cached = objectFieldValidators.get(schema);
+  if (cached !== void 0) {
+    return cached != null ? cached : void 0;
+  }
+  let fields = null;
+  try {
+    const document = toJsonSchema(schema);
+    const properties = document["properties"];
+    if (properties && typeof properties === "object") {
+      fields = new Map(
+        Object.entries(properties).map(
+          ([name, fieldSchema]) => [name, compileField(fieldSchema, document)]
+        )
+      );
+    }
+  } catch {
+    fields = null;
+  }
+  objectFieldValidators.set(schema, fields);
+  return fields != null ? fields : void 0;
+}
+__name(objectSchemaFields, "objectSchemaFields");
+const UNRESOLVABLE_REF = Symbol("unresolvable-ref");
+function compileField(fieldSchema, document) {
+  try {
+    return compileJsonSchema(inlineRefs(fieldSchema, document));
+  } catch {
+    return void 0;
+  }
+}
+__name(compileField, "compileField");
+function resolvePointer(document, ref) {
+  if (!ref.startsWith("#")) {
+    throw UNRESOLVABLE_REF;
+  }
+  let node = document;
+  for (const rawSegment of ref.slice(1).split("/").filter(Boolean)) {
+    const segment = decodeURIComponent(rawSegment).replaceAll("~1", "/").replaceAll("~0", "~");
+    if (node === null || typeof node !== "object") {
+      throw UNRESOLVABLE_REF;
+    }
+    node = node[segment];
+  }
+  if (node === void 0) {
+    throw UNRESOLVABLE_REF;
+  }
+  return node;
+}
+__name(resolvePointer, "resolvePointer");
+function inlineRefs(node, document, seen = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    return node.map((item) => inlineRefs(item, document, seen));
+  }
+  if (node === null || typeof node !== "object") {
+    return node;
+  }
+  const entries = Object.entries(node);
+  const ref = node["$ref"];
+  if (typeof ref === "string") {
+    if (seen.has(ref)) {
+      throw UNRESOLVABLE_REF;
+    }
+    const target = inlineRefs(
+      resolvePointer(document, ref),
+      document,
+      /* @__PURE__ */ new Set([...seen, ref])
+    );
+    const siblings = Object.fromEntries(
+      entries.filter(([key]) => key !== "$ref")
+    );
+    return { ...target, ...siblings };
+  }
+  return Object.fromEntries(
+    entries.map(([key, value]) => [key, inlineRefs(value, document, seen)])
+  );
+}
+__name(inlineRefs, "inlineRefs");
+export {
+  compileJsonSchema,
+  objectSchemaFields,
+  parseWithSchema,
+  toJsonSchema
+};

package/dist/esm/utils/simple_zod_to_json.js

@@ -1,5 +1,7 @@
 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 2025 Google LLC
@@ -13,12 +15,15 @@ import { toJSONSchema as toJSONSchemaV4 } from "zod/v4";
 function isZodSchema(obj) {
   return obj !== null && typeof obj === "object" && "parse" in obj && typeof obj.parse === "function" && "safeParse" in obj && typeof obj.safeParse === "function";
 }
+__name(isZodSchema, "isZodSchema");
 function isZodV3Schema(obj) {
   return isZodSchema(obj) && !("_zod" in obj);
 }
+__name(isZodV3Schema, "isZodV3Schema");
 function isZodV4Schema(obj) {
   return isZodSchema(obj) && "_zod" in obj;
 }
+__name(isZodV4Schema, "isZodV4Schema");
 function getZodTypeName(schema) {
   var _a, _b;
   const schemaAny = schema;
@@ -31,9 +36,11 @@ function getZodTypeName(schema) {
   }
   return void 0;
 }
+__name(getZodTypeName, "getZodTypeName");
 function isZodObject(obj) {
   return isZodSchema(obj) && getZodTypeName(obj) === "ZodObject";
 }
+__name(isZodObject, "isZodObject");
 function zodObjectToSchema(schema) {
   if (!isZodObject(schema)) {
     throw new Error("Expected a Zod Object");
@@ -42,7 +49,7 @@ function zodObjectToSchema(schema) {
     return toJSONSchemaV4(schema, {
       target: "openapi-3.0",
       io: "input",
-      override: (ctx) => {
+      override: /* @__PURE__ */ __name((ctx) => {
         var _a;
         const { jsonSchema } = ctx;
         if (jsonSchema.additionalProperties !== void 0) {
@@ -73,14 +80,14 @@ function zodObjectToSchema(schema) {
         if (jsonSchema.type !== void 0) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
-      }
+      }, "override")
     });
   }
   if (isZodV3Schema(schema)) {
     return toJSONSchemaV3(schema, {
       target: "openApi3",
       emailStrategy: "format:email",
-      postProcess: (jsonSchema) => {
+      postProcess: /* @__PURE__ */ __name((jsonSchema) => {
         var _a, _b, _c, _d, _e, _f, _g;
         if (!jsonSchema) {
           return;
@@ -112,12 +119,16 @@ function zodObjectToSchema(schema) {
           jsonSchema.type = jsonSchema.type.toUpperCase();
         }
         return jsonSchema;
-      }
+      }, "postProcess")
     });
   }
   throw new Error("Unsupported Zod schema version.");
 }
+__name(zodObjectToSchema, "zodObjectToSchema");
 export {
   isZodObject,
+  isZodSchema,
+  isZodV3Schema,
+  isZodV4Schema,
   zodObjectToSchema
 };

package/dist/esm/utils/streaming_utils.js

@@ -1,5 +1,7 @@
 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
@@ -13,7 +15,7 @@ import { generateClientFunctionCallId } from "../events/event.js";
 import { FeatureName, isFeatureEnabled } from "../features/feature_registry.js";
 import { createLlmResponse } from "../models/llm_response.js";
 const UNSAFE_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-class ProgressiveStrategy {
+const _ProgressiveStrategy = class _ProgressiveStrategy {
   constructor() {
     this.partsSequence = [];
     this.currentTextBuffer = "";
@@ -195,8 +197,10 @@ class ProgressiveStrategy {
     }
     return finalParts;
   }
-}
-class NonProgressiveStrategy {
+};
+__name(_ProgressiveStrategy, "ProgressiveStrategy");
+let ProgressiveStrategy = _ProgressiveStrategy;
+const _NonProgressiveStrategy = class _NonProgressiveStrategy {
   constructor() {
     this.text = "";
     this.thoughtText = "";
@@ -270,8 +274,10 @@ class NonProgressiveStrategy {
     }
     return void 0;
   }
-}
-class StreamingResponseAggregator {
+};
+__name(_NonProgressiveStrategy, "NonProgressiveStrategy");
+let NonProgressiveStrategy = _NonProgressiveStrategy;
+const _StreamingResponseAggregator = class _StreamingResponseAggregator {
   constructor(isProgressiveMode = isFeatureEnabled(
     FeatureName.PROGRESSIVE_SSE_STREAMING
   )) {
@@ -349,10 +355,13 @@ class StreamingResponseAggregator {
       partial: false
     };
   }
-}
+};
+__name(_StreamingResponseAggregator, "StreamingResponseAggregator");
+let StreamingResponseAggregator = _StreamingResponseAggregator;
 function isEmptyContentPart(part) {
   return !part.functionCall && !part.functionResponse && !part.fileData && !part.inlineData && !part.executableCode && !part.codeExecutionResult && (!part.text || part.text === "");
 }
+__name(isEmptyContentPart, "isEmptyContentPart");
 export {
   StreamingResponseAggregator,
   isEmptyContentPart