@paean-ai/adk 0.2.19 → 0.2.21

package/dist/web/index_web.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./common.js";

package/dist/web/memory/base_memory_service.js

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/memory/in_memory_memory_service.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class InMemoryMemoryService {
+  constructor() {
+    this.memories = [];
+    this.sessionEvents = {};
+  }
+  async addSessionToMemory(session) {
+    const userKey = getUserKey(session.appName, session.userId);
+    if (!this.sessionEvents[userKey]) {
+      this.sessionEvents[userKey] = {};
+    }
+    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]+/)].map((match) => match[0].toLowerCase())
+  );
+}
+function formatTimestamp(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+export {
+  InMemoryMemoryService
+};

package/dist/web/memory/memory_entry.js

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/models/base_llm.js

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+import { getClientLabels } from "../utils/client_labels.js";
+const BASE_MODEL_SYMBOL = Symbol("baseModel");
+function isBaseLlm(obj) {
+  return typeof obj === "object" && obj !== null && BASE_MODEL_SYMBOL in obj && obj[BASE_MODEL_SYMBOL] === true;
+}
+_a = BASE_MODEL_SYMBOL;
+class BaseLlm {
+  /**
+   * Creates an instance of BaseLLM.
+   * @param params The parameters for creating a BaseLlm instance.
+   * @param params.model The name of the LLM, e.g. gemini-1.5-flash or
+   *     gemini-1.5-flash-001.
+   */
+  constructor({ model }) {
+    this[_a] = true;
+    this.model = model;
+  }
+  get trackingHeaders() {
+    const labels = getClientLabels();
+    const headerValue = labels.join(" ");
+    return {
+      "x-goog-api-client": headerValue,
+      "user-agent": headerValue
+    };
+  }
+  /**
+   * Appends a user content, so that model can continue to output.
+   *
+   * @param llmRequest LlmRequest, the request to send to the LLM.
+   */
+  maybeAppendUserContent(llmRequest) {
+    var _a2;
+    if (llmRequest.contents.length === 0) {
+      llmRequest.contents.push({
+        role: "user",
+        parts: [
+          { text: "Handle the requests as specified in the System Instruction." }
+        ]
+      });
+    }
+    if (((_a2 = llmRequest.contents[llmRequest.contents.length - 1]) == null ? void 0 : _a2.role) !== "user") {
+      llmRequest.contents.push({
+        role: "user",
+        parts: [{
+          text: "Continue processing previous requests as instructed. Exit or provide a summary if no more outputs are needed."
+        }]
+      });
+    }
+  }
+}
+/**
+ * List of supported models in regex for LlmRegistry.
+ */
+BaseLlm.supportedModels = [];
+export {
+  BaseLlm,
+  isBaseLlm
+};

package/dist/web/models/base_llm_connection.js

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/web/models/gemini_llm_connection.js

@@ -0,0 +1,120 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from "../utils/logger.js";
+class GeminiLlmConnection {
+  constructor(geminiSession) {
+    this.geminiSession = geminiSession;
+  }
+  /**
+   * Sends the conversation history to the gemini model.
+   *
+   * You call this method right after setting up the model connection.
+   * The model will respond if the last content is from user, otherwise it will
+   * wait for new user input before responding.
+   *
+   * @param history The conversation history to send to the model.
+   */
+  async sendHistory(history) {
+    const contents = history.filter(
+      (content) => {
+        var _a;
+        return content.parts && ((_a = content.parts[0]) == null ? void 0 : _a.text);
+      }
+    );
+    if (contents.length > 0) {
+      this.geminiSession.sendClientContent({
+        turns: contents,
+        turnComplete: contents[contents.length - 1].role === "user"
+      });
+    } else {
+      logger.info("no content is sent");
+    }
+  }
+  /**
+   * Sends a user content to the gemini model.
+   *
+   * The model will respond immediately upon receiving the content.
+   * If you send function responses, all parts in the content should be function
+   * responses.
+   *
+   * @param content The content to send to the model.
+   */
+  async sendContent(content) {
+    if (!content.parts) {
+      throw new Error("Content must have parts.");
+    }
+    if (content.parts[0].functionResponse) {
+      const functionResponses = content.parts.map((part) => part.functionResponse).filter((fr) => !!fr);
+      logger.debug("Sending LLM function response:", functionResponses);
+      this.geminiSession.sendToolResponse({
+        functionResponses
+      });
+    } else {
+      logger.debug("Sending LLM new content", content);
+      this.geminiSession.sendClientContent({
+        turns: [content],
+        turnComplete: true
+      });
+    }
+  }
+  /**
+   * Sends a chunk of audio or a frame of video to the model in realtime.
+   *
+   * @param blob The blob to send to the model.
+   */
+  async sendRealtime(blob) {
+    logger.debug("Sending LLM Blob:", blob);
+    this.geminiSession.sendRealtimeInput({ media: blob });
+  }
+  /**
+   * Builds a full text response.
+   *
+   * The text should not be partial and the returned LlmResponse is not be
+   * partial.
+   *
+   * @param text The text to be included in the response.
+   * @returns An LlmResponse containing the full text.
+   */
+  buildFullTextResponse(text) {
+    return {
+      content: {
+        role: "model",
+        parts: [{ text }]
+      }
+    };
+  }
+  // TODO(b/425992518): GenAI SDK inconsistent API, missing methods.
+  receive() {
+    return __asyncGenerator(this, null, function* () {
+      throw new Error("Not Implemented.");
+    });
+  }
+  /**
+   * Closes the llm server connection.
+   */
+  async close() {
+    this.geminiSession.close();
+  }
+}
+export {
+  GeminiLlmConnection
+};