@google/adk 1.6.0 → 2.1.0

package/dist/web/memory/in_memory_memory_service.js

@@ -1,82 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-class InMemoryMemoryService {
-  constructor() {
-    this.memories = [];
-    /**
-     * A map from user key to a map from session ID to events.
-     *
-     * The inner map is keyed by `session.id`, which arrives off the request path
-     * and contains no `/`, so it can be exactly `__proto__`. On a plain object
-     * literal that key would reach the inherited `__proto__` setter and
-     * re-parent the map instead of creating an own property, silently dropping
-     * the session from the `Object.values` scan in `searchMemory`. The outer key
-     * always contains a `/` (see `getUserKey`) and cannot collide, but is
-     * created the same way for consistency.
-     */
-    this.sessionEvents = /* @__PURE__ */ Object.create(null);
-  }
-  async addSessionToMemory(session) {
-    const userKey = getUserKey(session.appName, session.userId);
-    if (!this.sessionEvents[userKey]) {
-      this.sessionEvents[userKey] = /* @__PURE__ */ Object.create(null);
-    }
-    this.sessionEvents[userKey][session.id] = session.events.filter(
-      (event) => {
-        var _a, _b, _c;
-        return ((_c = (_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length) != null ? _c : 0) > 0;
-      }
-    );
-  }
-  async searchMemory(req) {
-    var _a, _b;
-    const userKey = getUserKey(req.appName, req.userId);
-    if (!this.sessionEvents[userKey]) {
-      return Promise.resolve({ memories: [] });
-    }
-    const wordsInQuery = req.query.toLowerCase().split(/\s+/);
-    const response = { memories: [] };
-    for (const sessionEvents of Object.values(this.sessionEvents[userKey])) {
-      for (const event of sessionEvents) {
-        if (!((_b = (_a = event.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
-          continue;
-        }
-        const joinedText = event.content.parts.map((part) => part.text).filter((text) => !!text).join(" ");
-        const wordsInEvent = extractWordsLower(joinedText);
-        if (!wordsInEvent.size) {
-          continue;
-        }
-        const matchQuery = wordsInQuery.some(
-          (queryWord) => wordsInEvent.has(queryWord)
-        );
-        if (matchQuery) {
-          response.memories.push({
-            content: event.content,
-            author: event.author,
-            timestamp: formatTimestamp(event.timestamp)
-          });
-        }
-      }
-    }
-    return response;
-  }
-}
-function getUserKey(appName, userId) {
-  return "".concat(appName, "/").concat(userId);
-}
-function extractWordsLower(text) {
-  return new Set(
-    [...text.matchAll(/[A-Za-z]+/g)].map((match) => match[0].toLowerCase())
-  );
-}
-function formatTimestamp(timestamp) {
-  return new Date(timestamp).toISOString();
-}
-export {
-  InMemoryMemoryService
-};

package/dist/web/memory/memory_entry.js

@@ -1,7 +0,0 @@
-import {createRequire as topLevelCreateRequire} from 'module';
-const require = topLevelCreateRequire(import.meta.url);
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */

package/dist/web/memory/vertex_ai_memory_bank_service.js

@@ -1,481 +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;
-};
-/**
- * @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
-  );
-}
-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) };
-}
-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))
-      );
-    }
-  }
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-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");
-}
-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;
-}
-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;
-}
-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;
-}
-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;
-}
-export {
-  VertexAiMemoryBankService
-};