@google/adk 1.6.0 → 2.1.0

package/dist/esm/memory/rag_memory_transcript.js

@@ -0,0 +1,106 @@
+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 SOURCE_DISPLAY_NAME_PREFIX = "adk-memory-v1.";
+const SOURCE_DISPLAY_NAME_SEGMENTS = 3;
+const MILLISECONDS_PER_SECOND = 1e3;
+function encodeSegment(value) {
+  return Buffer.from(value, "utf-8").toString("base64url");
+}
+__name(encodeSegment, "encodeSegment");
+function decodeSegment(segment) {
+  if (!segment) {
+    return void 0;
+  }
+  const decoded = Buffer.from(segment, "base64url").toString("utf-8");
+  return encodeSegment(decoded) === segment ? decoded : void 0;
+}
+__name(decodeSegment, "decodeSegment");
+function buildSourceDisplayName(appName, userId, sessionId) {
+  const segments = [appName, userId, sessionId].map(encodeSegment);
+  return SOURCE_DISPLAY_NAME_PREFIX + segments.join(".");
+}
+__name(buildSourceDisplayName, "buildSourceDisplayName");
+function parseSourceDisplayName(displayName) {
+  const isPrefixed = displayName.startsWith(SOURCE_DISPLAY_NAME_PREFIX);
+  const raw = isPrefixed ? displayName.slice(SOURCE_DISPLAY_NAME_PREFIX.length) : displayName;
+  const parts = raw.split(".");
+  if (parts.length !== SOURCE_DISPLAY_NAME_SEGMENTS) {
+    return void 0;
+  }
+  if (!isPrefixed) {
+    return { appName: parts[0], userId: parts[1], sessionId: parts[2] };
+  }
+  const [appName, userId, sessionId] = parts.map(decodeSegment);
+  if (appName === void 0 || userId === void 0 || sessionId === void 0) {
+    return void 0;
+  }
+  return { appName, userId, sessionId };
+}
+__name(parseSourceDisplayName, "parseSourceDisplayName");
+function serializeSessionTranscript(session) {
+  var _a, _b, _c;
+  const lines = [];
+  for (const event of session.events) {
+    const texts = [];
+    for (const part of (_b = (_a = event.content) == null ? void 0 : _a.parts) != null ? _b : []) {
+      if (part.text) {
+        texts.push(part.text.replaceAll("\n", " "));
+      }
+    }
+    if (texts.length === 0) {
+      continue;
+    }
+    lines.push(
+      JSON.stringify({
+        author: (_c = event.author) != null ? _c : "",
+        timestamp: event.timestamp / MILLISECONDS_PER_SECOND,
+        text: texts.join(".")
+      })
+    );
+  }
+  return lines.join("\n");
+}
+__name(serializeSessionTranscript, "serializeSessionTranscript");
+function parseTranscriptLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return void 0;
+  }
+  const record = parsed;
+  const seconds = typeof record["timestamp"] === "number" ? record["timestamp"] : 0;
+  return {
+    author: typeof record["author"] === "string" ? record["author"] : "",
+    timestamp: seconds * MILLISECONDS_PER_SECOND,
+    text: typeof record["text"] === "string" ? record["text"] : ""
+  };
+}
+__name(parseTranscriptLine, "parseTranscriptLine");
+function parseTranscriptEvents(text) {
+  const events = [];
+  for (const line of text.split("\n")) {
+    const event = parseTranscriptLine(line);
+    if (event) {
+      events.push(event);
+    }
+  }
+  return events;
+}
+__name(parseTranscriptEvents, "parseTranscriptEvents");
+export {
+  buildSourceDisplayName,
+  parseSourceDisplayName,
+  parseTranscriptEvents,
+  serializeSessionTranscript
+};

package/dist/esm/memory/vertex_ai_memory_bank_service.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
@@ -41,6 +43,7 @@ function shouldFilterOutEvent(content) {
     (p) => p.text || p.inlineData || p.fileData
   );
 }
+__name(shouldFilterOutEvent, "shouldFilterOutEvent");
 function toVertexMetadataValue(key, value) {
   if (typeof value === "boolean") {
     return { boolValue: value };
@@ -69,7 +72,8 @@ function toVertexMetadataValue(key, value) {
   }
   return { stringValue: String(value) };
 }
-class VertexAiMemoryBankService {
+__name(toVertexMetadataValue, "toVertexMetadataValue");
+const _VertexAiMemoryBankService = class _VertexAiMemoryBankService {
   constructor(options) {
     if (!options.agentEngineId) {
       throw new Error(
@@ -209,7 +213,7 @@ class VertexAiMemoryBankService {
         config
       };
       const operation = await this.memories.createInternal(params);
-      logger.info("Create memory response received.");
+      logger.debug("Create memory response received.");
       logger.debug(`Create memory response: ${JSON.stringify(operation)}`);
     }
   }
@@ -233,13 +237,15 @@ class VertexAiMemoryBankService {
         config
       };
       const operation = await this.memories.generateInternal(params);
-      logger.info("Generate direct memory response received.");
+      logger.debug("Generate direct memory response received.");
       logger.debug(
         `Generate direct memory response: ${JSON.stringify(operation)}`
       );
     }
   }
-}
+};
+__name(_VertexAiMemoryBankService, "VertexAiMemoryBankService");
+let VertexAiMemoryBankService = _VertexAiMemoryBankService;
 function buildCreateMemoryConfig(params) {
   const config = { waitForCompletion: false };
   if (params.customMetadata) {
@@ -305,6 +311,7 @@ function buildCreateMemoryConfig(params) {
   }
   return config;
 }
+__name(buildCreateMemoryConfig, "buildCreateMemoryConfig");
 function extractRevisionLabels(value, source) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     logger.warn(`Ignoring ${source} because it is not an object.`);
@@ -325,6 +332,7 @@ function extractRevisionLabels(value, source) {
   }
   return revisionLabels;
 }
+__name(extractRevisionLabels, "extractRevisionLabels");
 function buildVertexMetadata(metadataByKey) {
   const vertexMetadata = {};
   for (const [key, value] of Object.entries(metadataByKey)) {
@@ -335,6 +343,7 @@ function buildVertexMetadata(metadataByKey) {
   }
   return vertexMetadata;
 }
+__name(buildVertexMetadata, "buildVertexMetadata");
 function buildGenerateMemoriesConfig(customMetadata) {
   const config = { waitForCompletion: false };
   if (!customMetadata) {
@@ -387,6 +396,7 @@ function buildGenerateMemoriesConfig(customMetadata) {
   }
   return config;
 }
+__name(buildGenerateMemoriesConfig, "buildGenerateMemoriesConfig");
 function normalizeMemoriesForCreate(memories) {
   if (!Array.isArray(memories)) {
     throw new TypeError("memories must be a sequence of memory items.");
@@ -396,6 +406,7 @@ function normalizeMemoriesForCreate(memories) {
   }
   return memories;
 }
+__name(normalizeMemoriesForCreate, "normalizeMemoriesForCreate");
 function memoryEntryToFact(memory, index) {
   const textParts = [];
   if (memory.content && memory.content.parts) {
@@ -418,6 +429,7 @@ function memoryEntryToFact(memory, index) {
   }
   return textParts.join("\n");
 }
+__name(memoryEntryToFact, "memoryEntryToFact");
 function mergeCustomMetadataForMemory(params) {
   const mergedMetadata = {};
   if (params.customMetadata) {
@@ -432,6 +444,7 @@ function mergeCustomMetadataForMemory(params) {
   }
   return mergedMetadata;
 }
+__name(mergeCustomMetadataForMemory, "mergeCustomMetadataForMemory");
 function revisionLabelsForMemory(memory) {
   const revisionLabels = {};
   if (memory.author) {
@@ -445,6 +458,7 @@ function revisionLabelsForMemory(memory) {
   }
   return revisionLabels;
 }
+__name(revisionLabelsForMemory, "revisionLabelsForMemory");
 function isConsolidationEnabled(customMetadata) {
   if (!customMetadata) {
     return false;
@@ -460,6 +474,7 @@ function isConsolidationEnabled(customMetadata) {
   }
   return enableConsolidation;
 }
+__name(isConsolidationEnabled, "isConsolidationEnabled");
 function iterMemoryBatches(memories) {
   const memoryBatches = [];
   for (let index = 0; index < memories.length; index += MAX_DIRECT_MEMORIES_PER_GENERATE_CALL) {
@@ -469,6 +484,7 @@ function iterMemoryBatches(memories) {
   }
   return memoryBatches;
 }
+__name(iterMemoryBatches, "iterMemoryBatches");
 export {
   VertexAiMemoryBankService
 };

package/dist/esm/memory/vertex_ai_rag_api.js

@@ -0,0 +1,93 @@
+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 { GoogleAuth } from "google-auth-library";
+const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+const _VertexRagApiClient = class _VertexRagApiClient {
+  constructor(options) {
+    this.host = `https://${options.location}-aiplatform.googleapis.com`;
+    this.auth = new GoogleAuth({ scopes: [CLOUD_PLATFORM_SCOPE] });
+  }
+  /** Lists one page of the files in a corpus. */
+  async listRagFiles(params) {
+    const query = new URLSearchParams({ pageSize: String(params.pageSize) });
+    if (params.pageToken) {
+      query.set("pageToken", params.pageToken);
+    }
+    const url = `${this.host}/v1/${params.ragCorpus}/ragFiles?${query.toString()}`;
+    return this.send(url, {
+      method: "GET",
+      headers: await this.authHeaders(url)
+    });
+  }
+  /** Uploads `content` into a corpus as one RAG file. */
+  async uploadRagFile(params) {
+    const url = `${this.host}/upload/v1/${params.ragCorpus}/ragFiles:upload`;
+    const metadata = JSON.stringify({
+      ragFile: { displayName: params.displayName },
+      // Empty message: the corpus default chunking applies. The reference SDK
+      // omits this key unless chunking is configured, so it is optional here.
+      uploadRagFileConfig: {}
+    });
+    const body = new FormData();
+    body.append(
+      "metadata",
+      new Blob([metadata], { type: "application/json; charset=UTF-8" })
+    );
+    body.append(
+      "file",
+      new Blob([params.content], { type: "text/plain; charset=UTF-8" }),
+      "content.txt"
+    );
+    const headers = await this.authHeaders(url);
+    headers.set("X-Goog-Upload-Protocol", "multipart");
+    const response = await this.send(url, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (response.error) {
+      throw new Error(
+        `Vertex AI RAG file upload was rejected: ${JSON.stringify(response.error)}`
+      );
+    }
+  }
+  /** Runs a retrieval query over a corpus. */
+  async retrieveContexts(params) {
+    const url = `${this.host}/v1/${params.parent}:retrieveContexts`;
+    const headers = await this.authHeaders(url);
+    headers.set("Content-Type", "application/json");
+    return this.send(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        vertexRagStore: params.vertexRagStore,
+        query: params.query
+      })
+    });
+  }
+  async authHeaders(url) {
+    const client = await this.auth.getClient();
+    return client.getRequestHeaders(url);
+  }
+  async send(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      throw new Error(
+        `Vertex AI RAG request failed with status ${response.status}: ${await response.text()}`
+      );
+    }
+    return await response.json();
+  }
+};
+__name(_VertexRagApiClient, "VertexRagApiClient");
+let VertexRagApiClient = _VertexRagApiClient;
+export {
+  VertexRagApiClient
+};

package/dist/esm/memory/vertex_ai_rag_memory_service.js

@@ -0,0 +1,208 @@
+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 { formatError } from "../utils/error_utils.js";
+import { logger } from "../utils/logger.js";
+import {
+  buildSourceDisplayName,
+  parseSourceDisplayName,
+  parseTranscriptEvents,
+  serializeSessionTranscript
+} from "./rag_memory_transcript.js";
+import {
+  VertexRagApiClient
+} from "./vertex_ai_rag_api.js";
+const RAG_FILE_PAGE_SIZE = 100;
+const MAX_RAG_FILE_PAGES = 10;
+const DEFAULT_VECTOR_DISTANCE_THRESHOLD = 10;
+function resolveRagCorpus(options) {
+  var _a, _b, _c;
+  const ragCorpus = (_a = options.ragCorpus) == null ? void 0 : _a.trim();
+  if (!ragCorpus) {
+    throw new Error("ragCorpus is required for VertexAiRagMemoryService.");
+  }
+  const segments = ragCorpus.split("/");
+  const isResourceName = segments.length >= 4 && segments[0] === "projects" && segments[2] === "locations";
+  const projectId = (_b = options.projectId) != null ? _b : isResourceName ? segments[1] : process.env["GOOGLE_CLOUD_PROJECT"];
+  const location = (_c = options.location) != null ? _c : isResourceName ? segments[3] : process.env["GOOGLE_CLOUD_LOCATION"];
+  if (!projectId) {
+    throw new Error(
+      "projectId is required for VertexAiRagMemoryService: pass projectId, set GOOGLE_CLOUD_PROJECT, or give ragCorpus as a full resource name."
+    );
+  }
+  if (!location) {
+    throw new Error(
+      "location is required for VertexAiRagMemoryService: pass location, set GOOGLE_CLOUD_LOCATION, or give ragCorpus as a full resource name."
+    );
+  }
+  return {
+    projectId,
+    location,
+    ragCorpus: isResourceName ? ragCorpus : `projects/${projectId}/locations/${location}/ragCorpora/${ragCorpus}`
+  };
+}
+__name(resolveRagCorpus, "resolveRagCorpus");
+function tenantSource(displayName, appName, userId) {
+  if (!displayName) {
+    return void 0;
+  }
+  const source = parseSourceDisplayName(displayName);
+  if (!source || source.appName !== appName || source.userId !== userId) {
+    return void 0;
+  }
+  return source;
+}
+__name(tenantSource, "tenantSource");
+function toMemoryEntries(contexts, request) {
+  var _a;
+  const eventsBySession = /* @__PURE__ */ new Map();
+  for (const context of contexts) {
+    const source = tenantSource(
+      context.sourceDisplayName,
+      request.appName,
+      request.userId
+    );
+    if (!source) {
+      continue;
+    }
+    let events = eventsBySession.get(source.sessionId);
+    if (!events) {
+      events = /* @__PURE__ */ new Map();
+      eventsBySession.set(source.sessionId, events);
+    }
+    for (const event of parseTranscriptEvents((_a = context.text) != null ? _a : "")) {
+      if (!events.has(event.timestamp)) {
+        events.set(event.timestamp, event);
+      }
+    }
+  }
+  const memories = [];
+  for (const events of eventsBySession.values()) {
+    const sorted = [...events.values()].sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    for (const event of sorted) {
+      memories.push({
+        author: event.author,
+        content: { parts: [{ text: event.text }] },
+        timestamp: new Date(event.timestamp).toISOString()
+      });
+    }
+  }
+  return memories;
+}
+__name(toMemoryEntries, "toMemoryEntries");
+const _VertexAiRagMemoryService = class _VertexAiRagMemoryService {
+  /**
+   * @param ragApiClient An internal seam for tests to substitute a fake REST
+   *     client. Production callers omit it and get a client for the resolved
+   *     location.
+   * @internal
+   */
+  constructor(options, ragApiClient) {
+    var _a;
+    const resolved = resolveRagCorpus(options);
+    this.ragCorpus = resolved.ragCorpus;
+    this.projectId = resolved.projectId;
+    this.location = resolved.location;
+    this.similarityTopK = options.similarityTopK;
+    this.vectorDistanceThreshold = (_a = options.vectorDistanceThreshold) != null ? _a : DEFAULT_VECTOR_DISTANCE_THRESHOLD;
+    this.ragApiClient = ragApiClient != null ? ragApiClient : new VertexRagApiClient({ location: this.location });
+  }
+  /** Uploads the session's transcript into the corpus as one RAG file. */
+  async addSessionToMemory(session) {
+    return this.ragApiClient.uploadRagFile({
+      ragCorpus: this.ragCorpus,
+      displayName: buildSourceDisplayName(
+        session.appName,
+        session.userId,
+        session.id
+      ),
+      content: serializeSessionTranscript(session)
+    });
+  }
+  async searchMemory(request) {
+    var _a, _b;
+    const ragFileIds = await this.listTenantRagFileIds(request);
+    if ((ragFileIds == null ? void 0 : ragFileIds.length) === 0) {
+      return { memories: [] };
+    }
+    const response = await this.ragApiClient.retrieveContexts({
+      parent: `projects/${this.projectId}/locations/${this.location}`,
+      vertexRagStore: {
+        ragResources: [{ ragCorpus: this.ragCorpus, ragFileIds }]
+      },
+      query: {
+        text: request.query,
+        // Top-k belongs on the query: retrieveContexts ignores
+        // VertexRagStore.similarityTopK.
+        ragRetrievalConfig: {
+          topK: this.similarityTopK,
+          filter: { vectorDistanceThreshold: this.vectorDistanceThreshold }
+        }
+      }
+    });
+    return {
+      memories: toMemoryEntries((_b = (_a = response.contexts) == null ? void 0 : _a.contexts) != null ? _b : [], request)
+    };
+  }
+  /**
+   * Returns the ids of the corpus files owned by the requesting app and user,
+   * or `undefined` when the corpus could not be listed within the page budget.
+   *
+   * An `undefined` result retrieves over the whole corpus. Narrowing only
+   * improves ranking and transfer size, and every returned context is filtered
+   * by tenant anyway. Scoping to a partial listing would instead hide the
+   * caller's own memories.
+   */
+  async listTenantRagFileIds(request) {
+    var _a;
+    const ragFileIds = [];
+    let pageToken;
+    try {
+      for (let page = 0; page < MAX_RAG_FILE_PAGES; page++) {
+        const response = await this.ragApiClient.listRagFiles({
+          ragCorpus: this.ragCorpus,
+          pageSize: RAG_FILE_PAGE_SIZE,
+          pageToken
+        });
+        for (const ragFile of (_a = response.ragFiles) != null ? _a : []) {
+          const source = tenantSource(
+            ragFile.displayName,
+            request.appName,
+            request.userId
+          );
+          if (source && ragFile.name) {
+            ragFileIds.push(
+              ragFile.name.slice(ragFile.name.lastIndexOf("/") + 1)
+            );
+          }
+        }
+        pageToken = response.nextPageToken;
+        if (!pageToken) {
+          return ragFileIds;
+        }
+      }
+    } catch (e) {
+      logger.warn(
+        `Listing the corpus failed, so retrieval is not scoped to the requesting app and user: ${formatError(e)}`
+      );
+      return void 0;
+    }
+    logger.warn(
+      `Listing ${this.ragCorpus} did not finish within ${MAX_RAG_FILE_PAGES} pages, so retrieval is not scoped to the requesting app and user.`
+    );
+    return void 0;
+  }
+};
+__name(_VertexAiRagMemoryService, "VertexAiRagMemoryService");
+let VertexAiRagMemoryService = _VertexAiRagMemoryService;
+export {
+  VertexAiRagMemoryService
+};

package/dist/esm/models/apigee_llm.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
@@ -9,7 +11,7 @@ import { isBrowser } from "../utils/env_aware_utils.js";
 import { logger } from "../utils/logger.js";
 import { Gemini, geminiInitParams } from "./google_llm.js";
 const APIGEE_PROXY_URL_ENV_VARIABLE_NAME = "APIGEE_PROXY_URL";
-class ApigeeLlm extends Gemini {
+const _ApigeeLlm = class _ApigeeLlm extends Gemini {
   constructor({
     model,
     proxyUrl,
@@ -80,15 +82,17 @@ class ApigeeLlm extends Gemini {
     llmRequest.model = getModelId(modelToUse);
     return super.connect(llmRequest);
   }
-}
+};
+__name(_ApigeeLlm, "ApigeeLlm");
 /**
  * A list of model name patterns that are supported by this LLM.
  *
  * @returns A list of supported models.
  */
-ApigeeLlm.supportedModels = [
+_ApigeeLlm.supportedModels = [
   /apigee\/.*/
 ];
+let ApigeeLlm = _ApigeeLlm;
 function apigeeToGeminiInitParams({
   model,
   vertexai,
@@ -110,6 +114,7 @@ function apigeeToGeminiInitParams({
   }
   return params;
 }
+__name(apigeeToGeminiInitParams, "apigeeToGeminiInitParams");
 function getModelId(model) {
   if (!validateModel(model)) {
     throw new Error(
@@ -119,6 +124,7 @@ function getModelId(model) {
   const components = model.split("/");
   return components[components.length - 1];
 }
+__name(getModelId, "getModelId");
 function validateModel(model) {
   const validProviders = ["vertex_ai", "gemini"];
   if (!model.startsWith("apigee/")) {
@@ -128,7 +134,7 @@ function validateModel(model) {
   if (modelPart.length === 0) {
     return false;
   }
-  const components = modelPart.split("/", -1);
+  const components = modelPart.split("/");
   if (components[components.length - 1].length === 0) {
     return false;
   }
@@ -149,6 +155,7 @@ function validateModel(model) {
   }
   return false;
 }
+__name(validateModel, "validateModel");
 export {
   ApigeeLlm
 };

package/dist/esm/models/base_llm.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
@@ -7,12 +9,13 @@ const require = topLevelCreateRequire(import.meta.url);
  */
 var _a;
 import { getClientLabels } from "../utils/client_labels.js";
-const BASE_MODEL_SYMBOL = Symbol.for("google.adk.baseModel");
+const BASE_MODEL_SYMBOL = /* @__PURE__ */ Symbol.for("google.adk.baseModel");
 function isBaseLlm(obj) {
   return typeof obj === "object" && obj !== null && BASE_MODEL_SYMBOL in obj && obj[BASE_MODEL_SYMBOL] === true;
 }
+__name(isBaseLlm, "isBaseLlm");
 _a = BASE_MODEL_SYMBOL;
-class BaseLlm {
+const _BaseLlm = class _BaseLlm {
   /**
    * Creates an instance of BaseLLM.
    * @param params The parameters for creating a BaseLlm instance.
@@ -62,11 +65,13 @@ class BaseLlm {
       });
     }
   }
-}
+};
+__name(_BaseLlm, "BaseLlm");
 /**
  * List of supported models in regex for LlmRegistry.
  */
-BaseLlm.supportedModels = [];
+_BaseLlm.supportedModels = [];
+let BaseLlm = _BaseLlm;
 export {
   BaseLlm,
   isBaseLlm