@google/adk 2.0.0 → 2.2.0

package/dist/web/memory/vertex_ai_memory_bank_service.js

@@ -1,496 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-/**
- * @license
- * Copyright 2026 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Client } from "@google-cloud/vertexai";
-import { createUserContent } from "@google/genai";
-import { logger } from "../utils/logger.js";
-import {
-  EXPRESS_MODE_UNSUPPORTED_MESSAGE,
-  getExpressModeApiKey
-} from "../utils/vertex_ai_utils.js";
-const GENERATE_MEMORIES_KNOWN_FIELDS = [
-  "disableConsolidation",
-  "waitForCompletion",
-  "revisionLabels",
-  "revisionExpireTime",
-  "revisionTtl",
-  "disableMemoryRevisions",
-  "metadataMergeStrategy",
-  "allowedTopics"
-];
-const CREATE_MEMORY_KNOWN_FIELDS = [
-  "displayName",
-  "description",
-  "waitForCompletion",
-  "ttl",
-  "expireTime",
-  "revisionExpireTime",
-  "revisionTtl",
-  "disableMemoryRevisions",
-  "topics",
-  "memoryId"
-];
-const ENABLE_CONSOLIDATION_KEY = "enable_consolidation";
-const MAX_DIRECT_MEMORIES_PER_GENERATE_CALL = 5;
-function shouldFilterOutEvent(content) {
-  return !((content == null ? void 0 : content.parts) || []).some(
-    (p) => p.text || p.inlineData || p.fileData
-  );
-}
-__name(shouldFilterOutEvent, "shouldFilterOutEvent");
-function toVertexMetadataValue(key, value) {
-  if (typeof value === "boolean") {
-    return { boolValue: value };
-  }
-  if (typeof value === "number") {
-    return { doubleValue: value };
-  }
-  if (typeof value === "string") {
-    return { stringValue: value };
-  }
-  if (value instanceof Date) {
-    return { timestampValue: value.toISOString() };
-  }
-  if (typeof value === "object" && value !== null) {
-    const v = value;
-    if (v.boolValue !== void 0 || v.doubleValue !== void 0 || v.stringValue !== void 0 || v.timestampValue !== void 0) {
-      return v;
-    }
-    return { stringValue: JSON.stringify(value) };
-  }
-  if (value === null || value === void 0) {
-    logger.warn(
-      "Ignoring custom metadata key ".concat(key, " because its value is null or undefined.")
-    );
-    return void 0;
-  }
-  return { stringValue: String(value) };
-}
-__name(toVertexMetadataValue, "toVertexMetadataValue");
-const _VertexAiMemoryBankService = class _VertexAiMemoryBankService {
-  constructor(options) {
-    if (!options.agentEngineId) {
-      throw new Error(
-        "agentEngineId is required for VertexAiMemoryBankService."
-      );
-    }
-    this.projectId = options.projectId;
-    this.location = options.location;
-    this.agentEngineId = options.agentEngineId;
-    this.expressModeApiKey = getExpressModeApiKey(
-      options.projectId,
-      options.location,
-      options.expressModeApiKey
-    );
-    if (options.agentEngineId.includes("/")) {
-      logger.warn(
-        "agentEngineId appears to be a full resource path: '".concat(options.agentEngineId, "'. ") + "Expected just the ID (e.g., '456'). Extract the ID using: agentEngine.apiResource.name.split('/').pop()"
-      );
-    }
-    if (options.client) {
-      this.memories = options.client.agentEnginesInternal.memories;
-    } else {
-      if (this.expressModeApiKey && (!this.projectId || !this.location)) {
-        throw new Error(EXPRESS_MODE_UNSUPPORTED_MESSAGE);
-      }
-      const client = new Client({
-        project: this.projectId,
-        location: this.location
-      });
-      this.memories = client.agentEnginesInternal.memories;
-    }
-  }
-  async addSessionToMemory(session) {
-    await this.addEventsToMemoryFromEvents({
-      appName: session.appName,
-      userId: session.userId,
-      eventsToProcess: session.events
-    });
-  }
-  /**
-   * Adds events to Vertex AI Memory Bank via memories.generate.
-   */
-  async addEventsToMemory(request) {
-    await this.addEventsToMemoryFromEvents({
-      appName: request.appName,
-      userId: request.userId,
-      eventsToProcess: request.events,
-      customMetadata: request.customMetadata
-    });
-  }
-  /**
-   * Adds explicit memory items using Vertex Memory Bank.
-   */
-  async addMemory(request) {
-    if (isConsolidationEnabled(request.customMetadata)) {
-      return this.addMemoriesViaGenerateDirectMemoriesSource(request);
-    }
-    await this.addMemoriesViaCreate(request);
-  }
-  async searchMemory(request) {
-    const params = {
-      name: "reasoningEngines/".concat(this.agentEngineId),
-      scope: {
-        app_name: request.appName,
-        user_id: request.userId
-      },
-      similaritySearchParams: {
-        searchQuery: request.query
-      }
-    };
-    const retrievedMemoriesResponse = await this.memories.retrieveInternal(params);
-    logger.debug("Search memory response received.");
-    const memoryEvents = [];
-    const retrievedMemories = retrievedMemoriesResponse.retrievedMemories || [];
-    for (const retrievedMemory of retrievedMemories) {
-      logger.debug("Retrieved memory: ".concat(JSON.stringify(retrievedMemory)));
-      if (retrievedMemory.memory && retrievedMemory.memory.fact) {
-        const content = createUserContent(retrievedMemory.memory.fact);
-        memoryEvents.push({
-          author: "user",
-          content,
-          timestamp: retrievedMemory.memory.updateTime
-        });
-      }
-    }
-    return { memories: memoryEvents };
-  }
-  async addEventsToMemoryFromEvents(request) {
-    const directEvents = [];
-    for (const event of request.eventsToProcess) {
-      if (shouldFilterOutEvent(event.content)) {
-        continue;
-      }
-      directEvents.push({
-        content: JSON.parse(JSON.stringify(event.content))
-      });
-    }
-    if (directEvents.length > 0) {
-      const config = buildGenerateMemoriesConfig(request.customMetadata);
-      const params = {
-        name: "reasoningEngines/".concat(this.agentEngineId),
-        directContentsSource: { events: directEvents },
-        scope: {
-          app_name: request.appName,
-          user_id: request.userId
-        },
-        config
-      };
-      const operation = await this.memories.generateInternal(params);
-      logger.debug("Generate memory response received.");
-      logger.debug("Generate memory response: ".concat(JSON.stringify(operation)));
-    } else {
-      logger.info("No events to add to memory.");
-    }
-  }
-  async addMemoriesViaCreate(request) {
-    const validatedMemories = normalizeMemoriesForCreate(request.memories);
-    for (let index = 0; index < validatedMemories.length; index++) {
-      const memory = validatedMemories[index];
-      const memoryFact = memoryEntryToFact(memory, index);
-      const memoryMetadata = mergeCustomMetadataForMemory({
-        customMetadata: request.customMetadata,
-        memory
-      });
-      const memoryRevisionLabels = revisionLabelsForMemory(memory);
-      const config = buildCreateMemoryConfig({
-        customMetadata: memoryMetadata,
-        memoryRevisionLabels
-      });
-      const params = {
-        name: "reasoningEngines/".concat(this.agentEngineId),
-        fact: memoryFact,
-        scope: {
-          app_name: request.appName,
-          user_id: request.userId
-        },
-        config
-      };
-      const operation = await this.memories.createInternal(params);
-      logger.info("Create memory response received.");
-      logger.debug("Create memory response: ".concat(JSON.stringify(operation)));
-    }
-  }
-  async addMemoriesViaGenerateDirectMemoriesSource(request) {
-    const validatedMemories = normalizeMemoriesForCreate(request.memories);
-    const memoryTexts = validatedMemories.map(
-      (m, i) => memoryEntryToFact(m, i)
-    );
-    const config = buildGenerateMemoriesConfig(request.customMetadata);
-    const memoryBatches = iterMemoryBatches(memoryTexts);
-    for (const memoryBatch of memoryBatches) {
-      const params = {
-        name: "reasoningEngines/".concat(this.agentEngineId),
-        directMemoriesSource: {
-          directMemories: memoryBatch.map((fact) => ({ fact }))
-        },
-        scope: {
-          app_name: request.appName,
-          user_id: request.userId
-        },
-        config
-      };
-      const operation = await this.memories.generateInternal(params);
-      logger.info("Generate direct memory response received.");
-      logger.debug(
-        "Generate direct memory response: ".concat(JSON.stringify(operation))
-      );
-    }
-  }
-};
-__name(_VertexAiMemoryBankService, "VertexAiMemoryBankService");
-let VertexAiMemoryBankService = _VertexAiMemoryBankService;
-function buildCreateMemoryConfig(params) {
-  const config = { waitForCompletion: false };
-  if (params.customMetadata) {
-    logger.debug(
-      "Memory creation metadata: ".concat(JSON.stringify(params.customMetadata))
-    );
-  }
-  const metadataByKey = {};
-  const customRevisionLabels = {};
-  for (const [key, value] of Object.entries(params.customMetadata || {})) {
-    if (key === ENABLE_CONSOLIDATION_KEY) {
-      continue;
-    }
-    if (key === "metadata") {
-      if (value === null || value === void 0) continue;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        config["metadata"] = buildVertexMetadata(
-          value
-        );
-      } else {
-        logger.warn(
-          'Ignoring metadata because customMetadata["metadata"] is not an object.'
-        );
-      }
-      continue;
-    }
-    if (key === "revisionLabels") {
-      if (value === null || value === void 0) continue;
-      const extractedLabels = extractRevisionLabels(
-        value,
-        'customMetadata["revisionLabels"]'
-      );
-      if (extractedLabels) {
-        Object.assign(customRevisionLabels, extractedLabels);
-      }
-      continue;
-    }
-    if (CREATE_MEMORY_KNOWN_FIELDS.includes(key)) {
-      if (value !== null && value !== void 0) {
-        config[key] = value;
-      }
-    } else {
-      metadataByKey[key] = value;
-    }
-  }
-  if (Object.keys(metadataByKey).length > 0) {
-    const existingMetadata = config["metadata"];
-    if (!existingMetadata) {
-      config["metadata"] = buildVertexMetadata(metadataByKey);
-    } else {
-      config["metadata"] = __spreadValues(__spreadValues({}, existingMetadata), buildVertexMetadata(metadataByKey));
-    }
-  }
-  const revisionLabels = __spreadValues(__spreadValues({}, customRevisionLabels), params.memoryRevisionLabels);
-  if (Object.keys(revisionLabels).length > 0) {
-    config["revisionLabels"] = revisionLabels;
-  }
-  return config;
-}
-__name(buildCreateMemoryConfig, "buildCreateMemoryConfig");
-function extractRevisionLabels(value, source) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    logger.warn("Ignoring ".concat(source, " because it is not an object."));
-    return void 0;
-  }
-  const revisionLabels = {};
-  for (const [key, labelValue] of Object.entries(value)) {
-    if (typeof labelValue !== "string") {
-      logger.warn(
-        "Ignoring revision label ".concat(key, " from ").concat(source, " because its value is not a string.")
-      );
-      continue;
-    }
-    revisionLabels[key] = labelValue;
-  }
-  if (Object.keys(revisionLabels).length === 0) {
-    return void 0;
-  }
-  return revisionLabels;
-}
-__name(extractRevisionLabels, "extractRevisionLabels");
-function buildVertexMetadata(metadataByKey) {
-  const vertexMetadata = {};
-  for (const [key, value] of Object.entries(metadataByKey)) {
-    const convertedValue = toVertexMetadataValue(key, value);
-    if (convertedValue !== void 0) {
-      vertexMetadata[key] = convertedValue;
-    }
-  }
-  return vertexMetadata;
-}
-__name(buildVertexMetadata, "buildVertexMetadata");
-function buildGenerateMemoriesConfig(customMetadata) {
-  const config = { waitForCompletion: false };
-  if (!customMetadata) {
-    return config;
-  }
-  logger.debug("Memory generation metadata: ".concat(JSON.stringify(customMetadata)));
-  const metadataByKey = {};
-  for (const [key, value] of Object.entries(customMetadata)) {
-    if (key === ENABLE_CONSOLIDATION_KEY) {
-      continue;
-    }
-    if (key === "ttl") {
-      if (value === null || value === void 0) continue;
-      if (customMetadata["revisionTtl"] === void 0) {
-        config["revisionTtl"] = value;
-      }
-      continue;
-    }
-    if (key === "metadata") {
-      if (value === null || value === void 0) continue;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        config["metadata"] = buildVertexMetadata(
-          value
-        );
-      } else {
-        logger.warn(
-          'Ignoring metadata because customMetadata["metadata"] is not an object.'
-        );
-      }
-      continue;
-    }
-    if (GENERATE_MEMORIES_KNOWN_FIELDS.includes(key)) {
-      if (value !== null && value !== void 0) {
-        config[key] = value;
-      }
-    } else {
-      metadataByKey[key] = value;
-    }
-  }
-  if (Object.keys(metadataByKey).length > 0) {
-    const existingMetadata = config["metadata"];
-    if (!existingMetadata) {
-      config["metadata"] = buildVertexMetadata(metadataByKey);
-    } else {
-      config["metadata"] = __spreadValues(__spreadValues({}, existingMetadata), buildVertexMetadata(metadataByKey));
-    }
-  }
-  return config;
-}
-__name(buildGenerateMemoriesConfig, "buildGenerateMemoriesConfig");
-function normalizeMemoriesForCreate(memories) {
-  if (!Array.isArray(memories)) {
-    throw new TypeError("memories must be a sequence of memory items.");
-  }
-  if (memories.length === 0) {
-    throw new Error("memories must contain at least one entry.");
-  }
-  return memories;
-}
-__name(normalizeMemoriesForCreate, "normalizeMemoriesForCreate");
-function memoryEntryToFact(memory, index) {
-  const textParts = [];
-  if (memory.content && memory.content.parts) {
-    for (const part of memory.content.parts) {
-      if (part.inlineData || part.fileData) {
-        throw new Error(
-          "memories[".concat(index, "] must include text only; inlineData and fileData are not supported.")
-        );
-      }
-      if (part.text) {
-        const strippedText = part.text.trim();
-        if (strippedText) {
-          textParts.push(strippedText);
-        }
-      }
-    }
-  }
-  if (textParts.length === 0) {
-    throw new Error("memories[".concat(index, "] must include non-whitespace text."));
-  }
-  return textParts.join("\n");
-}
-__name(memoryEntryToFact, "memoryEntryToFact");
-function mergeCustomMetadataForMemory(params) {
-  const mergedMetadata = {};
-  if (params.customMetadata) {
-    Object.assign(mergedMetadata, params.customMetadata);
-  }
-  const memoryWithMetadata = params.memory;
-  if (memoryWithMetadata.customMetadata) {
-    Object.assign(mergedMetadata, memoryWithMetadata.customMetadata);
-  }
-  if (Object.keys(mergedMetadata).length === 0) {
-    return void 0;
-  }
-  return mergedMetadata;
-}
-__name(mergeCustomMetadataForMemory, "mergeCustomMetadataForMemory");
-function revisionLabelsForMemory(memory) {
-  const revisionLabels = {};
-  if (memory.author) {
-    revisionLabels["author"] = memory.author;
-  }
-  if (memory.timestamp) {
-    revisionLabels["timestamp"] = memory.timestamp;
-  }
-  if (Object.keys(revisionLabels).length === 0) {
-    return void 0;
-  }
-  return revisionLabels;
-}
-__name(revisionLabelsForMemory, "revisionLabelsForMemory");
-function isConsolidationEnabled(customMetadata) {
-  if (!customMetadata) {
-    return false;
-  }
-  const enableConsolidation = customMetadata[ENABLE_CONSOLIDATION_KEY];
-  if (enableConsolidation === void 0) {
-    return false;
-  }
-  if (typeof enableConsolidation !== "boolean") {
-    throw new TypeError(
-      'customMetadata["'.concat(ENABLE_CONSOLIDATION_KEY, '"] must be a bool.')
-    );
-  }
-  return enableConsolidation;
-}
-__name(isConsolidationEnabled, "isConsolidationEnabled");
-function iterMemoryBatches(memories) {
-  const memoryBatches = [];
-  for (let index = 0; index < memories.length; index += MAX_DIRECT_MEMORIES_PER_GENERATE_CALL) {
-    memoryBatches.push(
-      memories.slice(index, index + MAX_DIRECT_MEMORIES_PER_GENERATE_CALL)
-    );
-  }
-  return memoryBatches;
-}
-__name(iterMemoryBatches, "iterMemoryBatches");
-export {
-  VertexAiMemoryBankService
-};