@google/adk 1.1.0 → 1.3.0

package/dist/cjs/tools/skill/skill_toolset.js

@@ -38,6 +38,7 @@ module.exports = __toCommonJS(skill_toolset_exports);
 var import_llm_request = require("../../models/llm_request.js");
 var import_prompt = require("../../skills/prompt.js");
 var import_experimental = require("../../utils/experimental.js");
+var import_logger = require("../../utils/logger.js");
 var import_base_tool = require("../base_tool.js");
 var import_base_toolset = require("../base_toolset.js");
 var import_list_skills_tool = require("./list_skills_tool.js");
@@ -45,6 +46,7 @@ var import_load_skill_resource_tool = require("./load_skill_resource_tool.js");
 var import_load_skill_tool = require("./load_skill_tool.js");
 var import_run_skill_inline_script_tool = require("./run_skill_inline_script_tool.js");
 var import_run_skill_script_tool = require("./run_skill_script_tool.js");
+var import_search_skills_tool = require("./search_skills_tool.js");
 /**
  * @license
  * Copyright 2026 Google LLC
@@ -69,9 +71,11 @@ let SkillToolset = class extends import_base_toolset.BaseToolset {
   constructor(skills, options = {}) {
     super([], "adk_skill_toolset");
     this.toolCache = /* @__PURE__ */ new Map();
+    this.fetchedSkillCache = /* @__PURE__ */ new Map();
     this.skills = Array.isArray(skills) ? Object.fromEntries(skills.map((s) => [s.frontmatter.name, s])) : skills;
     this.codeExecutor = options.codeExecutor;
     this.additionalTools = options.additionalTools || [];
+    this.registry = options.registry;
     this.tools = [
       new import_list_skills_tool.ListSkillsTool(this),
       new import_load_skill_tool.LoadSkillTool(this),
@@ -79,24 +83,55 @@ let SkillToolset = class extends import_base_toolset.BaseToolset {
       new import_run_skill_script_tool.RunSkillScriptTool(this),
       new import_run_skill_inline_script_tool.RunSkillInlineScriptTool(this)
     ];
+    if (this.registry) {
+      this.tools.push(new import_search_skills_tool.SearchSkillsTool(this));
+    }
   }
   async getTools(context) {
     const dynamicTools = await this.resolveAdditionalTools(context);
     return [...this.tools, ...dynamicTools];
   }
   async close() {
+    this.fetchedSkillCache.clear();
   }
   getSkill(name) {
     return this.skills[name];
   }
+  async getOrFetchSkill(name, invocationId) {
+    if (this.skills[name]) {
+      return this.skills[name];
+    }
+    if (!this.registry) {
+      return void 0;
+    }
+    const contextKey = invocationId || "default";
+    if (!this.fetchedSkillCache.has(contextKey)) {
+      this.fetchedSkillCache.set(contextKey, /* @__PURE__ */ new Map());
+    }
+    const cache = this.fetchedSkillCache.get(contextKey);
+    if (cache.has(name)) {
+      return cache.get(name);
+    }
+    try {
+      const skill = await this.registry.getSkill(name);
+      cache.set(name, skill);
+      return skill;
+    } catch (e) {
+      import_logger.logger.warn(`Failed to fetch skill '${name}' from registry: ${e}`);
+      throw e;
+    }
+  }
   async processLlmRequest(toolContext, llmRequest) {
     await super.processLlmRequest(toolContext, llmRequest);
     const skills = Object.values(this.skills);
     const skillsXml = (0, import_prompt.formatSkillsAsXml)(skills);
-    (0, import_llm_request.appendInstructions)(llmRequest, [
-      DEFAULT_SKILL_SYSTEM_INSTRUCTION,
-      skillsXml
-    ]);
+    const instructions = [DEFAULT_SKILL_SYSTEM_INSTRUCTION, skillsXml];
+    if (this.registry) {
+      instructions.push(
+        "\nIf the locally available skills are not sufficient to complete your task, you can use the `search_skills` tool to discover additional skills from the registry."
+      );
+    }
+    (0, import_llm_request.appendInstructions)(llmRequest, instructions);
   }
   async resolveAdditionalTools(context) {
     if (!context) return [];
@@ -110,7 +145,7 @@ let SkillToolset = class extends import_base_toolset.BaseToolset {
     }
     const additionalToolNames = /* @__PURE__ */ new Set();
     for (const skillName of activatedSkills) {
-      const skill = this.skills[skillName];
+      const skill = await this.getOrFetchSkill(skillName, context.invocationId);
       if (skill && skill.frontmatter.metadata) {
         const tools = skill.frontmatter.metadata["adk_additional_tools"];
         if (tools) {

package/dist/cjs/tools/vertex_rag_retrieval_tool.js

@@ -0,0 +1,64 @@
+/**
+  * @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 __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 vertex_rag_retrieval_tool_exports = {};
+__export(vertex_rag_retrieval_tool_exports, {
+  VertexRagRetrievalTool: () => VertexRagRetrievalTool
+});
+module.exports = __toCommonJS(vertex_rag_retrieval_tool_exports);
+var import_base_tool = require("./base_tool.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class VertexRagRetrievalTool extends import_base_tool.BaseTool {
+  constructor(config) {
+    super({
+      name: "vertex_rag_retrieval",
+      description: "Vertex AI RAG Retrieval Tool"
+    });
+    this.vertexRagStore = config;
+  }
+  /**
+   * This tool is executed server-side by the Vertex AI RAG Engine.
+   * Local execution is not required.
+   */
+  runAsync() {
+    return Promise.resolve();
+  }
+  async processLlmRequest({
+    llmRequest
+  }) {
+    llmRequest.config = llmRequest.config || {};
+    llmRequest.config.tools = llmRequest.config.tools || [];
+    llmRequest.config.tools.push({
+      retrieval: { vertexRagStore: this.vertexRagStore }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VertexRagRetrievalTool
+});

package/dist/cjs/utils/async_queue.js

@@ -0,0 +1,88 @@
+/**
+  * @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 __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 async_queue_exports = {};
+__export(async_queue_exports, {
+  AsyncQueue: () => AsyncQueue
+});
+module.exports = __toCommonJS(async_queue_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class AsyncQueue {
+  constructor() {
+    this.queue = [];
+    this.resolvers = [];
+    this.closed = false;
+  }
+  push(value) {
+    if (this.closed) return;
+    if (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value, done: false });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  error(err) {
+    this.errorVal = err;
+    while (this.resolvers.length > 0) {
+      const { reject } = this.resolvers.shift();
+      reject(err);
+    }
+  }
+  close() {
+    this.closed = true;
+    while (this.resolvers.length > 0) {
+      const { resolve } = this.resolvers.shift();
+      resolve({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.errorVal) {
+          const err = this.errorVal;
+          this.errorVal = void 0;
+          return Promise.reject(err);
+        }
+        if (this.queue.length > 0) {
+          return Promise.resolve({ value: this.queue.shift(), done: false });
+        }
+        if (this.closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve, reject) => {
+          this.resolvers.push({ resolve, reject });
+        });
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncQueue
+});

package/dist/cjs/utils/case_utils.js

@@ -0,0 +1,53 @@
+/**
+  * @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 __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 case_utils_exports = {};
+__export(case_utils_exports, {
+  camelCaseKeys: () => camelCaseKeys
+});
+module.exports = __toCommonJS(case_utils_exports);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function camelCaseKeys(val) {
+  if (Array.isArray(val)) {
+    return val.map(camelCaseKeys);
+  }
+  if (val !== null && typeof val === "object" && val.constructor === Object) {
+    const obj = val;
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+      const camelKey = key.replace(/_([a-z])/g, (_, g) => g.toUpperCase());
+      newObj[camelKey] = camelCaseKeys(obj[key]);
+    }
+    return newObj;
+  }
+  return val;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  camelCaseKeys
+});

package/dist/cjs/utils/env_aware_utils.js

@@ -42,6 +42,10 @@ function isBrowser() {
 }
 const UUID_MASK = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
 function randomUUID() {
+  var _a;
+  if ((_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
   let uuid = "";
   for (let i = 0; i < UUID_MASK.length; i++) {
     const randomValue = Math.random() * 16 | 0;

package/dist/cjs/utils/file_utils.js

@@ -34,6 +34,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var file_utils_exports = {};
 __export(file_utils_exports, {
+  EXTENSION_TO_MIME_TYPE: () => EXTENSION_TO_MIME_TYPE,
+  guessMimeType: () => guessMimeType,
   materializeFiles: () => materializeFiles
 });
 module.exports = __toCommonJS(file_utils_exports);
@@ -88,7 +90,33 @@ async function materializeFiles(files, dir = process.cwd()) {
   }
   return createdFiles;
 }
+const EXTENSION_TO_MIME_TYPE = {
+  "pdf": "application/pdf",
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "png": "image/png",
+  "gif": "image/gif",
+  "csv": "text/csv",
+  "json": "application/json",
+  "xml": "application/xml",
+  "sh": "text/x-shellscript",
+  "bash": "text/x-shellscript",
+  "py": "text/x-python",
+  "js": "text/javascript",
+  "cjs": "text/javascript",
+  "mjs": "text/javascript",
+  "ts": "text/javascript",
+  "cts": "text/javascript",
+  "mts": "text/javascript"
+};
+function guessMimeType(filePath) {
+  var _a;
+  const ext = ((_a = filePath.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+  return EXTENSION_TO_MIME_TYPE[ext] || "application/octet-stream";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EXTENSION_TO_MIME_TYPE,
+  guessMimeType,
   materializeFiles
 });

package/dist/cjs/utils/gemini_schema_util.js

@@ -108,6 +108,21 @@ function toGeminiSchema(mcpSchema) {
         mcp.type = "array";
       } else if (isNullable) {
         mcp.type = "null";
+      } else if (mcp.enum) {
+        const enumTypes = new Set(mcp.enum.map((v) => typeof v));
+        if (enumTypes.size === 1) {
+          const jsType = [...enumTypes][0];
+          if (jsType === "string") mcp.type = "string";
+          else if (jsType === "number") mcp.type = "number";
+          else if (jsType === "boolean") mcp.type = "boolean";
+        }
+      } else if (mcp.const !== void 0) {
+        const jsType = typeof mcp.const;
+        let inferredType;
+        if (jsType === "string") inferredType = "string";
+        else if (jsType === "number") inferredType = "number";
+        else if (jsType === "boolean") inferredType = "boolean";
+        mcp = { ...mcp, type: inferredType, enum: [mcp.const] };
       }
     }
     const geminiType = toGeminiType(mcp.type);
@@ -122,6 +137,9 @@ function toGeminiSchema(mcpSchema) {
     if (mcp.description) {
       geminiSchema.description = mcp.description;
     }
+    if (mcp.enum) {
+      geminiSchema.enum = mcp.enum.map(String);
+    }
     if (isNullable && mcp.type !== "null") {
       geminiSchema.nullable = true;
     }

package/dist/cjs/utils/live_connection_utils.js

@@ -0,0 +1,284 @@
+/**
+  * @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 __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 live_connection_utils_exports = {};
+__export(live_connection_utils_exports, {
+  LiveResponseAggregator: () => LiveResponseAggregator
+});
+module.exports = __toCommonJS(live_connection_utils_exports);
+var import_model_name = require("./model_name.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class LiveResponseAggregator {
+  constructor(modelVersion) {
+    this.modelVersion = modelVersion;
+    this.text = "";
+    this.isThought = false;
+    this.toolCallParts = [];
+    this.pendingGroundingMetadata = void 0;
+    this.inputTranscriptionText = "";
+    this.outputTranscriptionText = "";
+  }
+  *processMessage(message) {
+    if (message.usageMetadata) {
+      yield {
+        usageMetadata: message.usageMetadata,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+    if (message.serverContent) {
+      const serverContent = message.serverContent;
+      const content = serverContent.modelTurn;
+      if (serverContent.groundingMetadata) {
+        this.pendingGroundingMetadata = serverContent.groundingMetadata;
+      }
+      if (!(content && content.parts) && serverContent.groundingMetadata && !serverContent.turnComplete) {
+        yield {
+          groundingMetadata: serverContent.groundingMetadata,
+          ...serverContent.interrupted !== void 0 ? { interrupted: serverContent.interrupted } : {},
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+      }
+      if (content && content.parts) {
+        const llmResponse = {
+          content,
+          ...serverContent.interrupted !== void 0 ? { interrupted: serverContent.interrupted } : {},
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        if (!serverContent.turnComplete && serverContent.groundingMetadata) {
+          llmResponse.groundingMetadata = serverContent.groundingMetadata;
+        }
+        const hasInlineData = content.parts.some((p) => p.inlineData);
+        for (const part of content.parts) {
+          if (part.text) {
+            const currentIsThought = !!part.thought;
+            if (this.text && currentIsThought !== this.isThought) {
+              yield this.buildFullTextResponse(this.text, this.isThought);
+              this.text = "";
+              this.isThought = false;
+            }
+            this.text += part.text;
+            this.isThought = currentIsThought;
+            llmResponse.partial = true;
+          }
+        }
+        if (this.text && !content.parts.some((p) => p.text) && !hasInlineData) {
+          yield this.buildFullTextResponse(this.text, this.isThought);
+          this.text = "";
+          this.isThought = false;
+        }
+        yield llmResponse;
+      }
+      if (serverContent.inputTranscription) {
+        if (serverContent.inputTranscription.text) {
+          this.inputTranscriptionText += serverContent.inputTranscription.text;
+          yield {
+            inputTranscription: {
+              text: serverContent.inputTranscription.text,
+              finished: false
+            },
+            partial: true,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+        if (serverContent.inputTranscription.finished) {
+          yield {
+            inputTranscription: {
+              text: this.inputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.inputTranscriptionText = "";
+        }
+      }
+      if (serverContent.outputTranscription) {
+        if (serverContent.outputTranscription.text) {
+          this.outputTranscriptionText += serverContent.outputTranscription.text;
+          yield {
+            outputTranscription: {
+              text: serverContent.outputTranscription.text,
+              finished: false
+            },
+            partial: true,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+        if (serverContent.outputTranscription.finished) {
+          yield {
+            outputTranscription: {
+              text: this.outputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.outputTranscriptionText = "";
+        }
+      }
+      if (serverContent.interrupted || serverContent.turnComplete || serverContent.generationComplete) {
+        if (this.inputTranscriptionText) {
+          yield {
+            inputTranscription: {
+              text: this.inputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.inputTranscriptionText = "";
+        }
+        if (this.outputTranscriptionText) {
+          yield {
+            outputTranscription: {
+              text: this.outputTranscriptionText,
+              finished: true
+            },
+            partial: false,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.outputTranscriptionText = "";
+        }
+      }
+      if (serverContent.turnComplete) {
+        let gMetadataToYield = this.pendingGroundingMetadata;
+        if (this.text) {
+          yield this.buildFullTextResponse(
+            this.text,
+            this.isThought,
+            gMetadataToYield
+          );
+          this.text = "";
+          this.isThought = false;
+          gMetadataToYield = void 0;
+        }
+        if (this.toolCallParts.length > 0) {
+          yield {
+            content: { role: "model", parts: this.toolCallParts },
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+          this.toolCallParts = [];
+        }
+        const finalResponse = {
+          turnComplete: true,
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        if (serverContent.interrupted !== void 0) {
+          finalResponse.interrupted = serverContent.interrupted;
+        }
+        const finalGrounding = serverContent.groundingMetadata || gMetadataToYield;
+        if (finalGrounding !== void 0 && finalGrounding !== null) {
+          finalResponse.groundingMetadata = finalGrounding;
+        }
+        yield finalResponse;
+      }
+      if (serverContent.interrupted) {
+        if (this.text) {
+          yield this.buildFullTextResponse(this.text, this.isThought);
+          this.text = "";
+          this.isThought = false;
+        } else {
+          yield {
+            interrupted: serverContent.interrupted,
+            ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+          };
+        }
+      }
+    }
+    if (message.toolCall) {
+      if (this.text) {
+        yield this.buildFullTextResponse(this.text, this.isThought);
+        this.text = "";
+        this.isThought = false;
+      }
+      if (message.toolCall.functionCalls) {
+        this.toolCallParts.push(
+          ...message.toolCall.functionCalls.map((fc) => ({
+            functionCall: fc
+          }))
+        );
+      }
+      const isGemini3x = (0, import_model_name.isGemini3xFlashLive)(this.modelVersion);
+      if (isGemini3x && this.toolCallParts.length > 0) {
+        yield {
+          content: { role: "model", parts: this.toolCallParts },
+          ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+        };
+        this.toolCallParts = [];
+      }
+    }
+    if (message.sessionResumptionUpdate) {
+      yield {
+        liveSessionResumptionUpdate: message.sessionResumptionUpdate,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+    if (message.goAway) {
+      yield {
+        goAway: message.goAway,
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+    }
+  }
+  /**
+   * Flushes any remaining aggregated components when the connection is closed.
+   */
+  *close() {
+    if (this.toolCallParts.length > 0) {
+      yield {
+        content: { role: "model", parts: this.toolCallParts },
+        ...this.modelVersion ? { modelVersion: this.modelVersion } : {}
+      };
+      this.toolCallParts = [];
+    }
+  }
+  buildFullTextResponse(text, isThought, groundingMetadata) {
+    const part = { text };
+    if (isThought) {
+      part.thought = true;
+    }
+    const response = {
+      content: {
+        role: "model",
+        parts: [part]
+      },
+      partial: false
+    };
+    if (groundingMetadata !== void 0 && groundingMetadata !== null) {
+      response.groundingMetadata = groundingMetadata;
+    }
+    if (this.modelVersion) {
+      response.modelVersion = this.modelVersion;
+    }
+    return response;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LiveResponseAggregator
+});