om-memory-system 3.0.0

package/dist/services/ai/providers/openai-responses.js

@@ -0,0 +1,182 @@
+import { BaseAIProvider, applySafeExtraParams } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { ToolSchemaConverter } from "../tools/tool-schema.js";
+import { log } from "../../logger.js";
+export class OpenAIResponsesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "openai-responses";
+    }
+    supportsSession() {
+        return true;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = await this.aiSessionManager.getSession(sessionId, "openai-responses");
+        if (!session) {
+            session = await this.aiSessionManager.createSession({
+                provider: "openai-responses",
+                sessionId,
+            });
+        }
+        let conversationId = session.conversationId;
+        let currentPrompt = userPrompt;
+        let iterations = 0;
+        const maxIterations = this.config.maxIterations ?? 5;
+        const iterationTimeout = this.config.iterationTimeout ?? 30000;
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const tool = ToolSchemaConverter.toResponsesAPI(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    input: currentPrompt,
+                    tools: [tool],
+                };
+                if (conversationId) {
+                    requestBody.conversation = conversationId;
+                }
+                else {
+                    requestBody.instructions = systemPrompt;
+                }
+                if (this.config.extraParams) {
+                    applySafeExtraParams(requestBody, this.config.extraParams);
+                }
+                const response = await fetch(`${this.config.apiUrl}/responses`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.config.apiKey}`,
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("OpenAI Responses API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                conversationId = data.conversation || conversationId;
+                if (iterations === 1) {
+                    const userSeq = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                    await this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: userSeq,
+                        role: "user",
+                        content: userPrompt,
+                    });
+                }
+                const toolCall = this.extractToolCall(data, toolSchema.function.name);
+                if (toolCall) {
+                    await this.aiSessionManager.updateSession(sessionId, "openai-responses", {
+                        conversationId,
+                    });
+                    return {
+                        success: true,
+                        data: this.validateResponse(toolCall),
+                        iterations,
+                    };
+                }
+                currentPrompt = this.buildRetryPrompt(data);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof Error && error.name === "AbortError") {
+                    return {
+                        success: false,
+                        error: `API request timeout (${this.config.iterationTimeout}ms)`,
+                        iterations,
+                    };
+                }
+                return {
+                    success: false,
+                    error: String(error),
+                    iterations,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `Max iterations (${this.config.maxIterations}) reached without tool call`,
+            iterations,
+        };
+    }
+    extractToolCall(data, expectedToolName) {
+        if (!data.output || !Array.isArray(data.output)) {
+            return null;
+        }
+        for (const item of data.output) {
+            if (item.type === "function_call" && item.name === expectedToolName) {
+                if (item.arguments) {
+                    try {
+                        const parsed = JSON.parse(item.arguments);
+                        return parsed;
+                    }
+                    catch (error) {
+                        log("Failed to parse function call arguments", {
+                            error: String(error),
+                            toolName: item.name,
+                            arguments: item.arguments,
+                        });
+                        return null;
+                    }
+                }
+                else {
+                    log("Function call found but no arguments", {
+                        toolName: item.name,
+                        callId: item.call_id,
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    buildRetryPrompt(data) {
+        let assistantResponse = "";
+        if (data.output && Array.isArray(data.output)) {
+            for (const item of data.output) {
+                if (item.type === "message" && item.content) {
+                    assistantResponse =
+                        typeof item.content === "string" ? item.content : JSON.stringify(item.content);
+                    break;
+                }
+            }
+        }
+        return `Previous response: ${assistantResponse}\n\nPlease use the save_memories tool to extract and save the memories from the conversation as instructed.`;
+    }
+    validateResponse(data) {
+        if (!data || typeof data !== "object") {
+            throw new Error("Response is not an object");
+        }
+        if (Array.isArray(data)) {
+            throw new Error("Response cannot be an array");
+        }
+        const keys = Object.keys(data);
+        if (keys.length === 0) {
+            throw new Error("Response object is empty");
+        }
+        for (const key of keys) {
+            if (data[key] === undefined || data[key] === null) {
+                throw new Error(`Response field '${key}' is null or undefined`);
+            }
+        }
+        return data;
+    }
+}

package/dist/services/ai/providers/orcarouter.d.ts

@@ -0,0 +1,51 @@
+import { OpenAIChatCompletionProvider } from "./openai-chat-completion.js";
+import type { ProviderConfig } from "./base-provider.js";
+import type { AISessionManager } from "../session/ai-session-manager.js";
+import type { AIProviderType } from "../session/session-types.js";
+/** OrcaRouter OpenAI-compatible endpoint used when `memoryApiUrl` is omitted. */
+export declare const ORCAROUTER_API_URL = "https://api.orcarouter.ai/v1";
+/**
+ * Default model when `memoryModel` is omitted. `orcarouter/auto` is the
+ * gateway's routing alias — it picks a capable upstream model per request
+ * (including structured / tool-call output, which auto-capture relies on).
+ */
+export declare const ORCAROUTER_DEFAULT_MODEL = "orcarouter/auto";
+/**
+ * OrcaRouter provider.
+ *
+ * [OrcaRouter](https://www.orcarouter.ai) is an OpenAI-compatible model
+ * gateway. It rejects bare model names, so the gateway requires namespaced
+ * model IDs such as `orcarouter/auto`, `deepseek/deepseek-v4-flash`, or
+ * `openai/gpt-5.5`. This provider reuses the OpenAI Chat Completions request
+ * handling and only overrides the resolved endpoint, the model resolution
+ * (validating the namespace), and the session provider tag, so OrcaRouter is
+ * distinguishable in the session store and diagnostics.
+ *
+ * Users configure it as:
+ *   "memoryProvider": "orcarouter"
+ *   "memoryApiKey": "<OrcaRouter API key>"
+ *
+ * `memoryApiUrl` and `memoryModel` are optional — they default to the gateway
+ * endpoint and `orcarouter/auto` respectively.
+ */
+export declare class OrcaRouterProvider extends OpenAIChatCompletionProvider {
+    constructor(config: ProviderConfig, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    protected sessionProviderTag(): AIProviderType;
+    /**
+     * Resolve the OpenAI-compatible endpoint.
+     *
+     * Defaults to the OrcaRouter gateway when `memoryApiUrl` is not configured,
+     * so a minimal config only needs `memoryProvider` + `memoryApiKey`.
+     */
+    resolveEndpoint(): string;
+    /**
+     * Resolve the model ID to send to the gateway.
+     *
+     * Defaults to the `orcarouter/auto` routing alias when `memoryModel` is not
+     * configured. OrcaRouter rejects bare model names (e.g. `gpt-4o-mini`), so a
+     * namespaced ID is required — fail with a helpful message instead of a
+     * gateway-side `model_not_found` error.
+     */
+    resolveModel(): string;
+}

package/dist/services/ai/providers/orcarouter.js

@@ -0,0 +1,66 @@
+import { OpenAIChatCompletionProvider } from "./openai-chat-completion.js";
+/** OrcaRouter OpenAI-compatible endpoint used when `memoryApiUrl` is omitted. */
+export const ORCAROUTER_API_URL = "https://api.orcarouter.ai/v1";
+/**
+ * Default model when `memoryModel` is omitted. `orcarouter/auto` is the
+ * gateway's routing alias — it picks a capable upstream model per request
+ * (including structured / tool-call output, which auto-capture relies on).
+ */
+export const ORCAROUTER_DEFAULT_MODEL = "orcarouter/auto";
+/**
+ * OrcaRouter provider.
+ *
+ * [OrcaRouter](https://www.orcarouter.ai) is an OpenAI-compatible model
+ * gateway. It rejects bare model names, so the gateway requires namespaced
+ * model IDs such as `orcarouter/auto`, `deepseek/deepseek-v4-flash`, or
+ * `openai/gpt-5.5`. This provider reuses the OpenAI Chat Completions request
+ * handling and only overrides the resolved endpoint, the model resolution
+ * (validating the namespace), and the session provider tag, so OrcaRouter is
+ * distinguishable in the session store and diagnostics.
+ *
+ * Users configure it as:
+ *   "memoryProvider": "orcarouter"
+ *   "memoryApiKey": "<OrcaRouter API key>"
+ *
+ * `memoryApiUrl` and `memoryModel` are optional — they default to the gateway
+ * endpoint and `orcarouter/auto` respectively.
+ */
+export class OrcaRouterProvider extends OpenAIChatCompletionProvider {
+    constructor(config, aiSessionManager) {
+        super(config, aiSessionManager);
+    }
+    getProviderName() {
+        return "orcarouter";
+    }
+    sessionProviderTag() {
+        return "orcarouter";
+    }
+    /**
+     * Resolve the OpenAI-compatible endpoint.
+     *
+     * Defaults to the OrcaRouter gateway when `memoryApiUrl` is not configured,
+     * so a minimal config only needs `memoryProvider` + `memoryApiKey`.
+     */
+    resolveEndpoint() {
+        const base = (this.config.apiUrl || "").trim().replace(/\/+$/, "");
+        return base || ORCAROUTER_API_URL;
+    }
+    /**
+     * Resolve the model ID to send to the gateway.
+     *
+     * Defaults to the `orcarouter/auto` routing alias when `memoryModel` is not
+     * configured. OrcaRouter rejects bare model names (e.g. `gpt-4o-mini`), so a
+     * namespaced ID is required — fail with a helpful message instead of a
+     * gateway-side `model_not_found` error.
+     */
+    resolveModel() {
+        const model = (this.config.model || "").trim();
+        if (!model) {
+            return ORCAROUTER_DEFAULT_MODEL;
+        }
+        if (!model.includes("/")) {
+            throw new Error(`OrcaRouter requires a namespaced memoryModel (e.g. "orcarouter/auto", "openai/gpt-5.5", "deepseek/deepseek-v4-flash"). Got: ${model}`);
+        }
+        return model;
+    }
+}

package/dist/services/ai/session/ai-session-manager.d.ts

@@ -0,0 +1,24 @@
+import type { AISession, SessionCreateParams, SessionUpdateParams, AIProviderType, AIMessage } from "./session-types.js";
+export declare class AISessionManager {
+    private db;
+    private dbPath;
+    private readonly sessionRetentionMs;
+    private initPromise;
+    constructor();
+    reset(): void;
+    private initialize;
+    private ready;
+    private initDatabase;
+    getSession(sessionId: string, provider: AIProviderType): Promise<AISession | null>;
+    createSession(params: SessionCreateParams): Promise<AISession>;
+    updateSession(sessionId: string, provider: AIProviderType, updates: SessionUpdateParams): Promise<void>;
+    cleanupExpiredSessions(): Promise<number>;
+    deleteSession(sessionId: string, provider: AIProviderType): Promise<void>;
+    addMessage(message: Omit<AIMessage, "id" | "createdAt">): Promise<void>;
+    getMessages(aiSessionId: string): Promise<AIMessage[]>;
+    getLastSequence(aiSessionId: string): Promise<number>;
+    clearMessages(aiSessionId: string): Promise<void>;
+    private rowToSession;
+    private rowToMessage;
+}
+export declare const aiSessionManager: AISessionManager;

package/dist/services/ai/session/ai-session-manager.js

@@ -0,0 +1,211 @@
+import { join } from "node:path";
+import { tursoConnectionManager } from "../../turso/connection-manager.js";
+import { CONFIG } from "../../../config.js";
+const AI_SESSIONS_DB_NAME = "ai-sessions.db";
+export class AISessionManager {
+    db = null;
+    dbPath;
+    sessionRetentionMs;
+    initPromise = null;
+    constructor() {
+        this.dbPath = join(CONFIG.storagePath, AI_SESSIONS_DB_NAME);
+        this.sessionRetentionMs = CONFIG.aiSessionRetentionDays * 24 * 60 * 60 * 1000;
+    }
+    reset() {
+        this.db = null;
+        this.initPromise = null;
+        this.dbPath = join(CONFIG.storagePath, AI_SESSIONS_DB_NAME);
+    }
+    async initialize() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.dbPath = join(CONFIG.storagePath, AI_SESSIONS_DB_NAME);
+        this.initPromise = (async () => {
+            try {
+                this.db = await tursoConnectionManager.getConnection(this.dbPath);
+                await this.initDatabase();
+            }
+            catch (error) {
+                this.initPromise = null;
+                this.db = null;
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    async ready() {
+        if (!this.db || !this.initPromise) {
+            await this.initialize();
+        }
+        else {
+            await this.initPromise;
+        }
+        if (!this.db) {
+            throw new Error("AISessionManager: database not initialized");
+        }
+        return this.db;
+    }
+    async initDatabase() {
+        const db = this.db;
+        await db.batch([
+            {
+                sql: `
+          CREATE TABLE IF NOT EXISTS ai_sessions (
+            id TEXT PRIMARY KEY,
+            provider TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            conversation_id TEXT,
+            metadata TEXT,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            expires_at INTEGER NOT NULL
+          )
+        `,
+            },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_ai_sessions_session_id ON ai_sessions(session_id)" },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_ai_sessions_expires_at ON ai_sessions(expires_at)" },
+            { sql: "CREATE INDEX IF NOT EXISTS idx_ai_sessions_provider ON ai_sessions(provider)" },
+            {
+                sql: `
+          CREATE TABLE IF NOT EXISTS ai_messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ai_session_id TEXT NOT NULL,
+            sequence INTEGER NOT NULL,
+            role TEXT NOT NULL,
+            content TEXT NOT NULL,
+            tool_calls TEXT,
+            tool_call_id TEXT,
+            content_blocks TEXT,
+            created_at INTEGER NOT NULL,
+            FOREIGN KEY (ai_session_id) REFERENCES ai_sessions(id) ON DELETE CASCADE
+          )
+        `,
+            },
+            {
+                sql: "CREATE INDEX IF NOT EXISTS idx_ai_messages_session ON ai_messages(ai_session_id, sequence)",
+            },
+            {
+                sql: "CREATE INDEX IF NOT EXISTS idx_ai_messages_role ON ai_messages(ai_session_id, role)",
+            },
+        ]);
+    }
+    async getSession(sessionId, provider) {
+        const db = await this.ready();
+        const row = await db.get(`
+      SELECT * FROM ai_sessions
+      WHERE session_id = ? AND provider = ? AND expires_at > ?
+    `, [sessionId, provider, Date.now()]);
+        return row ? this.rowToSession(row) : null;
+    }
+    async createSession(params) {
+        const db = await this.ready();
+        const id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const now = Date.now();
+        const expiresAt = now + this.sessionRetentionMs;
+        await db.run(`
+      INSERT INTO ai_sessions (
+        id, provider, session_id, conversation_id,
+        metadata, created_at, updated_at, expires_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+            id,
+            params.provider,
+            params.sessionId,
+            params.conversationId || null,
+            JSON.stringify(params.metadata || {}),
+            now,
+            now,
+            expiresAt,
+        ]);
+        return (await this.getSession(params.sessionId, params.provider));
+    }
+    async updateSession(sessionId, provider, updates) {
+        const db = await this.ready();
+        const fields = [];
+        const values = [];
+        if (updates.conversationId !== undefined) {
+            fields.push("conversation_id = ?");
+            values.push(updates.conversationId);
+        }
+        if (updates.metadata !== undefined) {
+            fields.push("metadata = ?");
+            values.push(JSON.stringify(updates.metadata));
+        }
+        fields.push("updated_at = ?");
+        values.push(Date.now());
+        values.push(sessionId, provider);
+        await db.run(`
+      UPDATE ai_sessions
+      SET ${fields.join(", ")}
+      WHERE session_id = ? AND provider = ?
+    `, values);
+    }
+    async cleanupExpiredSessions() {
+        const db = await this.ready();
+        return db.run(`DELETE FROM ai_sessions WHERE expires_at < ?`, [Date.now()]);
+    }
+    async deleteSession(sessionId, provider) {
+        const db = await this.ready();
+        await db.run(`DELETE FROM ai_sessions WHERE session_id = ? AND provider = ?`, [
+            sessionId,
+            provider,
+        ]);
+    }
+    async addMessage(message) {
+        const db = await this.ready();
+        await db.run(`INSERT INTO ai_messages (
+        ai_session_id, sequence, role, content,
+        tool_calls, tool_call_id, content_blocks, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+            message.aiSessionId,
+            message.sequence,
+            message.role,
+            message.content,
+            message.toolCalls ? JSON.stringify(message.toolCalls) : null,
+            message.toolCallId || null,
+            message.contentBlocks ? JSON.stringify(message.contentBlocks) : null,
+            Date.now(),
+        ]);
+    }
+    async getMessages(aiSessionId) {
+        const db = await this.ready();
+        const rows = await db.all("SELECT * FROM ai_messages WHERE ai_session_id = ? ORDER BY sequence ASC", [aiSessionId]);
+        return rows.map((row) => this.rowToMessage(row));
+    }
+    async getLastSequence(aiSessionId) {
+        const db = await this.ready();
+        const row = await db.get("SELECT MAX(sequence) as max_seq FROM ai_messages WHERE ai_session_id = ?", [aiSessionId]);
+        return row?.max_seq != null ? Number(row.max_seq) : -1;
+    }
+    async clearMessages(aiSessionId) {
+        const db = await this.ready();
+        await db.run("DELETE FROM ai_messages WHERE ai_session_id = ?", [aiSessionId]);
+    }
+    rowToSession(row) {
+        return {
+            id: String(row.id),
+            provider: row.provider,
+            sessionId: String(row.session_id),
+            conversationId: row.conversation_id ? String(row.conversation_id) : undefined,
+            metadata: row.metadata ? JSON.parse(String(row.metadata)) : undefined,
+            createdAt: Number(row.created_at),
+            updatedAt: Number(row.updated_at),
+            expiresAt: Number(row.expires_at),
+        };
+    }
+    rowToMessage(row) {
+        return {
+            id: Number(row.id),
+            aiSessionId: String(row.ai_session_id),
+            sequence: Number(row.sequence),
+            role: row.role,
+            content: String(row.content),
+            toolCalls: row.tool_calls ? JSON.parse(String(row.tool_calls)) : undefined,
+            toolCallId: row.tool_call_id ? String(row.tool_call_id) : undefined,
+            contentBlocks: row.content_blocks ? JSON.parse(String(row.content_blocks)) : undefined,
+            createdAt: Number(row.created_at),
+        };
+    }
+}
+export const aiSessionManager = new AISessionManager();

package/dist/services/ai/session/session-types.d.ts

@@ -0,0 +1,42 @@
+export type AIProviderType = "openai-chat" | "openai-responses" | "anthropic" | "minimax" | "google-gemini" | "orcarouter";
+export interface AIMessage {
+    id?: number;
+    aiSessionId: string;
+    sequence: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    toolCallId?: string;
+    contentBlocks?: Array<{
+        type: string;
+        [key: string]: any;
+    }>;
+    createdAt: number;
+}
+export interface AISession {
+    id: string;
+    provider: AIProviderType;
+    sessionId: string;
+    conversationId?: string;
+    metadata?: Record<string, any>;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt: number;
+}
+export interface SessionCreateParams {
+    provider: AIProviderType;
+    sessionId: string;
+    conversationId?: string;
+    metadata?: Record<string, any>;
+}
+export interface SessionUpdateParams {
+    conversationId?: string;
+    metadata?: Record<string, any>;
+}

package/dist/services/ai/session/session-types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/ai/tools/tool-schema.d.ts

@@ -0,0 +1,40 @@
+export interface ChatCompletionTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: Record<string, any>;
+            required: string[];
+        };
+    };
+}
+export interface ResponsesAPITool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export declare class ToolSchemaConverter {
+    static toResponsesAPI(chatCompletionTool: ChatCompletionTool): ResponsesAPITool;
+    static toAnthropic(chatCompletionTool: ChatCompletionTool): AnthropicTool;
+    static fromChatCompletion(tool: ChatCompletionTool): {
+        chatCompletion: ChatCompletionTool;
+        responsesAPI: ResponsesAPITool;
+        anthropic: AnthropicTool;
+    };
+}

package/dist/services/ai/tools/tool-schema.js

@@ -0,0 +1,24 @@
+export class ToolSchemaConverter {
+    static toResponsesAPI(chatCompletionTool) {
+        return {
+            type: "function",
+            name: chatCompletionTool.function.name,
+            description: chatCompletionTool.function.description,
+            parameters: chatCompletionTool.function.parameters,
+        };
+    }
+    static toAnthropic(chatCompletionTool) {
+        return {
+            name: chatCompletionTool.function.name,
+            description: chatCompletionTool.function.description,
+            input_schema: chatCompletionTool.function.parameters,
+        };
+    }
+    static fromChatCompletion(tool) {
+        return {
+            chatCompletion: tool,
+            responsesAPI: this.toResponsesAPI(tool),
+            anthropic: this.toAnthropic(tool),
+        };
+    }
+}

package/dist/services/ai/validators/user-profile-validator.d.ts

@@ -0,0 +1,12 @@
+import type { UserProfileData } from "../../user-profile/types.js";
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    data?: UserProfileData;
+}
+export declare class UserProfileValidator {
+    static validate(data: any): ValidationResult;
+    private static validatePreferences;
+    private static validatePatterns;
+    private static validateWorkflows;
+}