memories-lite 0.9.0

package/src/llms/google.ts

@@ -0,0 +1,56 @@
+import { GoogleGenAI } from "@google/genai";
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+
+export class GoogleLLM implements LLM {
+  private google: GoogleGenAI;
+  private model: string;
+
+  constructor(config: LLMConfig) {
+    this.google = new GoogleGenAI({ apiKey: config.apiKey });
+    this.model = config.model || "gemini-2.0-flash";
+  }
+
+  async generateResponse(
+    messages: Message[],
+    responseFormat?: { type: string },
+    tools?: any[],
+  ): Promise<string | LLMResponse> {
+    const completion = await this.google.models.generateContent({
+      contents: messages.map((msg) => ({
+        parts: [
+          {
+            text:
+              typeof msg.content === "string"
+                ? msg.content
+                : JSON.stringify(msg.content),
+          },
+        ],
+        role: msg.role === "system" ? "model" : "user",
+      })),
+
+      model: this.model,
+      // config: {
+      //   responseSchema: {}, // Add response schema if needed
+      // },
+    });
+
+    const text = completion.text
+      ?.replace(/^```json\n/, "")
+      .replace(/\n```$/, "");
+
+    return text || "";
+  }
+
+  async generateChat(messages: Message[]): Promise<LLMResponse> {
+    const completion = await this.google.models.generateContent({
+      contents: messages,
+      model: this.model,
+    });
+    const response = completion.candidates![0].content;
+    return {
+      content: response!.parts![0].text || "",
+      role: response!.role!,
+    };
+  }
+}

package/src/llms/openai.ts

@@ -0,0 +1,85 @@
+import OpenAI from "openai";
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+import { z } from "zod";
+
+export class OpenAILLM implements LLM {
+  private openai: OpenAI;
+  private model: string;
+
+  constructor(config: LLMConfig) {
+    this.openai = new OpenAI({ apiKey: config.apiKey });
+    this.model = config.model || "gpt-4.1-mini";
+  }
+
+  async generateResponse(
+    messages: Message[],
+    responseFormat?:any,
+    tools?: any[],structuredOutput: boolean=false, model?:string
+  ): Promise<string | LLMResponse> {
+    const msg = messages.map((msg) => {
+      const role = msg.role as "system" | "user" | "assistant";
+      return {
+        role,
+        content:
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content),
+      };
+    });
+
+    // DEPRECATED: use structured ouput message with `await openai.beta.chat.completions.parse(...)`
+    // https://platform.openai.com/docs/guides/structured-outputs?api-mode=chat&lang=javascript
+    // ⚠️ SyntaxError: Unexpected non-whitespace character after JSON at position 13
+    const fnCall = structuredOutput ? 
+          this.openai.beta.chat.completions.parse.bind(this.openai.beta.chat.completions) : this.openai.chat.completions.create.bind(this.openai.chat.completions);
+    const completion = await fnCall({
+      messages: msg,
+      model: model||this.model,
+      top_p:.8,temperature:.2,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
+      ...(structuredOutput && { logit_bias: { "1734": -100 } }),
+      response_format: responseFormat,
+      ...(tools && { tools, tool_choice: "auto" }),
+    });
+
+    const response:any = completion.choices[0].message;
+
+    if (response.tool_calls) {
+      return {
+        content: response.content || "",
+        role: response.role,
+        toolCalls: response.tool_calls.map((call:any) => ({
+          name: call.function.name,
+          arguments: call.function.arguments,
+        })),
+      };
+    }
+    const result = structuredOutput ? response.parsed : response.content;
+    //const result = response.content;
+    // console.log("--- DBG query:", msg);
+    // console.log("\n\n--- DBG result:", result);
+    
+    return result || "";
+  }
+
+  async generateChat(messages: Message[]): Promise<LLMResponse> {
+    const completion = await this.openai.chat.completions.create({
+      messages: messages.map((msg) => {
+        const role = msg.role as "system" | "user" | "assistant";
+        return {
+          role,
+          content:
+            typeof msg.content === "string"
+              ? msg.content
+              : JSON.stringify(msg.content),
+        };
+      }),
+      model: this.model,
+    });
+    const response = completion.choices[0].message;
+    return {
+      content: response.content || "",
+      role: response.role,
+    };
+  }
+}

package/src/llms/openai_structured.ts

@@ -0,0 +1,82 @@
+import OpenAI from "openai";
+import { LLM, LLMResponse } from "./base";
+import { LLMConfig, Message } from "../types";
+
+export class OpenAIStructuredLLM implements LLM {
+  private openai: OpenAI;
+  private model: string;
+
+  constructor(config: LLMConfig) {
+    this.openai = new OpenAI({ apiKey: config.apiKey });
+    this.model = config.model || "gpt-4-turbo-preview";
+  }
+
+  async generateResponse(
+    messages: Message[],
+    responseFormat?: { type: string } | null,
+    tools?: any[],
+  ): Promise<string | LLMResponse> {
+    const completion = await this.openai.chat.completions.create({
+      messages: messages.map((msg) => ({
+        role: msg.role as "system" | "user" | "assistant",
+        content:
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content),
+      })),
+      model: this.model,
+      ...(tools
+        ? {
+            tools: tools.map((tool) => ({
+              type: "function",
+              function: {
+                name: tool.function.name,
+                description: tool.function.description,
+                parameters: tool.function.parameters,
+              },
+            })),
+            tool_choice: "auto" as const,
+          }
+        : responseFormat
+          ? {
+              response_format: {
+                type: responseFormat.type as "text" | "json_object",
+              },
+            }
+          : {}),
+    });
+
+    const response = completion.choices[0].message;
+
+    if (response.tool_calls) {
+      return {
+        content: response.content || "",
+        role: response.role,
+        toolCalls: response.tool_calls.map((call) => ({
+          name: call.function.name,
+          arguments: call.function.arguments,
+        })),
+      };
+    }
+
+    return response.content || "";
+  }
+
+  async generateChat(messages: Message[]): Promise<LLMResponse> {
+    const completion = await this.openai.chat.completions.create({
+      messages: messages.map((msg) => ({
+        role: msg.role as "system" | "user" | "assistant",
+        content:
+          typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content),
+      })),
+      model: this.model,
+    });
+    const response = completion.choices[0].message;
+    return {
+      content: response.content || "",
+      role: response.role,
+    };
+  }
+}