om-memory-system 3.0.0

package/dist/services/ai/opencode-sdk-client.d.ts

@@ -0,0 +1,6 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
+export type HostTransport = {
+    readonly fetch?: typeof fetch;
+    readonly headers?: RequestInit["headers"];
+};
+export declare function createLazyV2Client(baseUrl: string, transport?: HostTransport): OpencodeClient;

package/dist/services/ai/opencode-sdk-client.js

@@ -0,0 +1,38 @@
+function getOpencodeSdkClientSpecifier() {
+    return ["@opencode-ai/sdk", "/v2/client"].join("");
+}
+async function createSdkClient(baseUrl, transport) {
+    const sdk = (await import(getOpencodeSdkClientSpecifier()));
+    return sdk.createOpencodeClient({
+        baseUrl,
+        ...(transport?.fetch ? { fetch: transport.fetch } : {}),
+        ...(transport?.headers ? { headers: transport.headers } : {}),
+    });
+}
+export function createLazyV2Client(baseUrl, transport) {
+    let sdkClientPromise;
+    const getSdkClient = () => {
+        sdkClientPromise ??= createSdkClient(baseUrl, transport);
+        return sdkClientPromise;
+    };
+    return {
+        session: {
+            create: async (...args) => {
+                const client = await getSdkClient();
+                return client.session.create(...args);
+            },
+            prompt: async (...args) => {
+                const client = await getSdkClient();
+                return client.session.prompt(...args);
+            },
+            delete: async (...args) => {
+                const client = await getSdkClient();
+                return client.session.delete(...args);
+            },
+            abort: async (...args) => {
+                const client = await getSdkClient();
+                return client.session.abort(...args);
+            },
+        },
+    };
+}

package/dist/services/ai/profile-llm-client.d.ts

@@ -0,0 +1,2 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
+export declare function getOpenCodeClient(): Promise<OpencodeClient>;

package/dist/services/ai/profile-llm-client.js

@@ -0,0 +1,27 @@
+import { CONFIG } from "../../config.js";
+import { loadOpencodeProvider } from "./opencode-provider-loader.js";
+let _cachedClient = null;
+let _cachedProvider = null;
+let _cachedModel = null;
+export async function getOpenCodeClient() {
+    const provider = CONFIG.opencodeProvider;
+    const model = CONFIG.opencodeModel;
+    if (!provider || !model) {
+        throw new Error("omms: opencodeProvider and opencodeModel must be configured");
+    }
+    if (_cachedClient && _cachedProvider === provider && _cachedModel === model) {
+        return _cachedClient;
+    }
+    const { isProviderConnected, getV2Client } = await loadOpencodeProvider();
+    if (!isProviderConnected(provider)) {
+        throw new Error(`opencode provider '${provider}' is not connected. Check your opencode provider configuration.`);
+    }
+    const client = getV2Client();
+    if (!client) {
+        throw new Error("omms: v2 client not initialized");
+    }
+    _cachedClient = client;
+    _cachedProvider = provider;
+    _cachedModel = model;
+    return client;
+}

package/dist/services/ai/provider-config.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderConfig } from "./providers/base-provider.js";
+interface MemoryProviderRuntimeConfig {
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+    memoryTemperature?: number | false;
+    memoryExtraParams?: Record<string, unknown>;
+    autoCaptureMaxIterations?: number;
+    autoCaptureIterationTimeout?: number;
+}
+interface ProviderConfigOverrides {
+    maxIterations?: number;
+    iterationTimeout?: number;
+}
+export declare function buildMemoryProviderConfig(config: MemoryProviderRuntimeConfig, overrides?: ProviderConfigOverrides): ProviderConfig;
+export {};

package/dist/services/ai/provider-config.js

@@ -0,0 +1,30 @@
+import { isPlaceholderApiKey } from "./api-key-placeholder.js";
+export function buildMemoryProviderConfig(config, overrides = {}) {
+    const memoryModel = config.memoryModel;
+    const memoryApiUrl = config.memoryApiUrl;
+    const memoryApiKey = config.memoryApiKey;
+    const issues = [];
+    // The orcarouter provider presets its own endpoint and default model, so
+    // memoryModel / memoryApiUrl are optional there. An API key is always required.
+    const isOrcaRouter = config.memoryProvider === "orcarouter";
+    if (!memoryModel && !isOrcaRouter)
+        issues.push("missing memoryModel");
+    if (!memoryApiUrl && !isOrcaRouter)
+        issues.push("missing memoryApiUrl");
+    if (!memoryApiKey)
+        issues.push("missing memoryApiKey");
+    if (isPlaceholderApiKey(memoryApiKey))
+        issues.push("replace the placeholder memoryApiKey value");
+    if (issues.length > 0) {
+        throw new Error(`External API not configured for memory provider: ${issues.join("; ")}`);
+    }
+    return {
+        model: memoryModel || "",
+        apiUrl: memoryApiUrl || "",
+        apiKey: memoryApiKey || "",
+        memoryTemperature: config.memoryTemperature,
+        extraParams: config.memoryExtraParams,
+        maxIterations: overrides.maxIterations ?? config.autoCaptureMaxIterations,
+        iterationTimeout: overrides.iterationTimeout ?? config.autoCaptureIterationTimeout,
+    };
+}

package/dist/services/ai/providers/anthropic-messages.d.ts

@@ -0,0 +1,34 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { type ChatCompletionTool } from "../tools/tool-schema.js";
+import type { AIProviderType } from "../session/session-types.js";
+/**
+ * Base implementation for providers that speak the Anthropic Messages API
+ * (Anthropic itself plus Anthropic-compatible gateways such as MiniMax).
+ *
+ * Subclasses override the session provider tag and the resolved endpoint URL so
+ * the session store and request routing reflect the upstream provider while the
+ * message/tool-call handling stays shared.
+ */
+export declare class AnthropicMessagesProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    /**
+     * Provider tag stored on AI sessions so a subclass (e.g. MiniMax) records its
+     * own tag instead of the literal "anthropic" value.
+     */
+    protected sessionProviderTag(): AIProviderType;
+    /**
+     * Resolve the Messages endpoint URL. The default appends `/messages` to the
+     * configured base URL, matching Anthropic's `https://api.anthropic.com/v1`
+     * base. Subclasses with a different path layout override this.
+     */
+    protected resolveEndpoint(): string;
+    protected apiErrorLogLabel(): string;
+    protected toolValidationErrorLogLabel(): string;
+    protected timeoutLabel(): string;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+    private extractToolUse;
+}

package/dist/services/ai/providers/anthropic-messages.js

@@ -0,0 +1,220 @@
+import { applySafeExtraParams, BaseAIProvider } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { ToolSchemaConverter } from "../tools/tool-schema.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+/**
+ * Base implementation for providers that speak the Anthropic Messages API
+ * (Anthropic itself plus Anthropic-compatible gateways such as MiniMax).
+ *
+ * Subclasses override the session provider tag and the resolved endpoint URL so
+ * the session store and request routing reflect the upstream provider while the
+ * message/tool-call handling stays shared.
+ */
+export class AnthropicMessagesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "anthropic";
+    }
+    supportsSession() {
+        return true;
+    }
+    /**
+     * Provider tag stored on AI sessions so a subclass (e.g. MiniMax) records its
+     * own tag instead of the literal "anthropic" value.
+     */
+    sessionProviderTag() {
+        return "anthropic";
+    }
+    /**
+     * Resolve the Messages endpoint URL. The default appends `/messages` to the
+     * configured base URL, matching Anthropic's `https://api.anthropic.com/v1`
+     * base. Subclasses with a different path layout override this.
+     */
+    resolveEndpoint() {
+        return `${this.config.apiUrl}/messages`;
+    }
+    apiErrorLogLabel() {
+        return "Anthropic Messages API error";
+    }
+    toolValidationErrorLogLabel() {
+        return "Anthropic tool response validation failed";
+    }
+    timeoutLabel() {
+        return "Anthropic API request timeout";
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        const providerTag = this.sessionProviderTag();
+        let session = await this.aiSessionManager.getSession(sessionId, providerTag);
+        if (!session) {
+            session = await this.aiSessionManager.createSession({
+                provider: providerTag,
+                sessionId,
+                metadata: { systemPrompt },
+            });
+        }
+        const storedMessages = await this.aiSessionManager.getMessages(session.id);
+        const messages = [];
+        for (const msg of storedMessages) {
+            if (msg.role === "system")
+                continue;
+            const anthropicMsg = {
+                role: msg.role,
+                content: msg.contentBlocks || msg.content,
+            };
+            messages.push(anthropicMsg);
+        }
+        const userSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+        await this.aiSessionManager.addMessage({
+            aiSessionId: session.id,
+            sequence: userSequence,
+            role: "user",
+            content: userPrompt,
+        });
+        messages.push({ role: "user", content: 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.toAnthropic(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    max_tokens: this.config.maxTokens ?? 4096,
+                    system: systemPrompt,
+                    messages,
+                    tools: [tool],
+                };
+                if (this.config.extraParams) {
+                    applySafeExtraParams(requestBody, this.config.extraParams);
+                }
+                const headers = {
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01",
+                };
+                if (this.config.apiKey) {
+                    headers["x-api-key"] = this.config.apiKey;
+                }
+                const response = await fetch(this.resolveEndpoint(), {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log(this.apiErrorLogLabel(), {
+                        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());
+                const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                await this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: JSON.stringify(data.content),
+                    contentBlocks: data.content,
+                });
+                messages.push({
+                    role: "assistant",
+                    content: data.content,
+                });
+                const toolUse = this.extractToolUse(data, toolSchema.function.name);
+                if (toolUse) {
+                    try {
+                        const result = UserProfileValidator.validate(toolUse);
+                        if (!result.valid) {
+                            throw new Error(result.errors.join(", "));
+                        }
+                        return {
+                            success: true,
+                            data: result.data,
+                            iterations,
+                        };
+                    }
+                    catch (validationError) {
+                        const errorStack = validationError instanceof Error ? validationError.stack : undefined;
+                        log(this.toolValidationErrorLogLabel(), {
+                            error: String(validationError),
+                            stack: errorStack,
+                            errorType: validationError instanceof Error
+                                ? validationError.constructor.name
+                                : typeof validationError,
+                            toolName: toolSchema.function.name,
+                            iteration: iterations,
+                            rawData: JSON.stringify(toolUse).slice(0, 500),
+                        });
+                        return {
+                            success: false,
+                            error: `Validation failed: ${String(validationError)}`,
+                            iterations,
+                        };
+                    }
+                }
+                if (data.stop_reason === "end_turn") {
+                    const retrySequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                    const retryPrompt = "Please use the save_memories tool to extract and save the memories from the conversation as instructed.";
+                    await this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: retrySequence,
+                        role: "user",
+                        content: retryPrompt,
+                    });
+                    messages.push({ role: "user", content: retryPrompt });
+                }
+                else {
+                    break;
+                }
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof Error && error.name === "AbortError") {
+                    return {
+                        success: false,
+                        error: `${this.timeoutLabel()} (${this.config.iterationTimeout}ms)`,
+                        iterations,
+                    };
+                }
+                return {
+                    success: false,
+                    error: String(error),
+                    iterations,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `Max iterations (${maxIterations}) reached without tool use`,
+            iterations,
+        };
+    }
+    extractToolUse(data, expectedToolName) {
+        if (!data.content || !Array.isArray(data.content)) {
+            return null;
+        }
+        for (const block of data.content) {
+            if (block.type === "tool_use" && block.name === expectedToolName && block.input) {
+                return block.input;
+            }
+        }
+        return null;
+    }
+}

package/dist/services/ai/providers/base-provider.d.ts

@@ -0,0 +1,24 @@
+export interface ToolCallResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    iterations?: number;
+}
+export interface ProviderConfig {
+    model: string;
+    apiUrl: string;
+    apiKey?: string;
+    maxIterations?: number;
+    iterationTimeout?: number;
+    maxTokens?: number;
+    memoryTemperature?: number | false;
+    extraParams?: Record<string, unknown>;
+}
+export declare function applySafeExtraParams(requestBody: Record<string, any>, extraParams: Record<string, unknown>): void;
+export declare abstract class BaseAIProvider {
+    protected config: ProviderConfig;
+    constructor(config: ProviderConfig);
+    abstract executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: any, sessionId: string): Promise<ToolCallResult>;
+    abstract getProviderName(): string;
+    abstract supportsSession(): boolean;
+}

package/dist/services/ai/providers/base-provider.js

@@ -0,0 +1,24 @@
+const PROTECTED_KEYS = new Set([
+    "model",
+    "messages",
+    "tools",
+    "tool_choice",
+    "temperature",
+    "input",
+    "instructions",
+    "conversation",
+    "stream",
+]);
+export function applySafeExtraParams(requestBody, extraParams) {
+    for (const [key, value] of Object.entries(extraParams)) {
+        if (!PROTECTED_KEYS.has(key)) {
+            requestBody[key] = value;
+        }
+    }
+}
+export class BaseAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}

package/dist/services/ai/providers/google-gemini.d.ts

@@ -0,0 +1,15 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import type { ChatCompletionTool } from "../tools/tool-schema.js";
+/**
+ * Google Gemini Provider
+ * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
+ */
+export declare class GoogleGeminiProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    private addToolResponse;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}

package/dist/services/ai/providers/google-gemini.js

@@ -0,0 +1,228 @@
+import { BaseAIProvider } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+/**
+ * Google Gemini Provider
+ * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
+ */
+export class GoogleGeminiProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "google-gemini";
+    }
+    supportsSession() {
+        return true;
+    }
+    async addToolResponse(sessionId, messages, toolCallId, content) {
+        const sequence = (await this.aiSessionManager.getLastSequence(sessionId)) + 1;
+        await this.aiSessionManager.addMessage({
+            aiSessionId: sessionId,
+            sequence,
+            role: "tool",
+            content,
+            toolCallId,
+        });
+        // Gemini tool response format
+        messages.push({
+            role: "function",
+            parts: [
+                {
+                    functionResponse: {
+                        name: toolCallId.split(":")[0], // Gemini expects the name of the function
+                        response: JSON.parse(content),
+                    },
+                },
+            ],
+        });
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = await this.aiSessionManager.getSession(sessionId, "google-gemini");
+        if (!session) {
+            session = await this.aiSessionManager.createSession({
+                provider: "google-gemini",
+                sessionId,
+            });
+        }
+        const existingMessages = await this.aiSessionManager.getMessages(session.id);
+        const contents = [];
+        // System instruction is separate in Gemini API
+        const geminiSystemInstruction = {
+            parts: [{ text: systemPrompt }],
+        };
+        // Convert existing messages to Gemini format
+        for (const msg of existingMessages) {
+            if (msg.role === "system")
+                continue; // Skip system as it's passed separately
+            const role = msg.role === "assistant" ? "model" : "user";
+            const parts = [];
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.function.name,
+                            args: JSON.parse(tc.function.arguments),
+                        },
+                    });
+                }
+            }
+            if (msg.role === "tool") {
+                contents.push({
+                    role: "function",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: (msg.toolCallId || "").split(":")[0],
+                                response: JSON.parse(msg.content),
+                            },
+                        },
+                    ],
+                });
+                continue;
+            }
+            contents.push({ role, parts });
+        }
+        if (contents.length === 0 || contents[contents.length - 1].role !== "user") {
+            const userSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+            await this.aiSessionManager.addMessage({
+                aiSessionId: session.id,
+                sequence: userSequence,
+                role: "user",
+                content: userPrompt,
+            });
+            contents.push({ role: "user", parts: [{ text: userPrompt }] });
+        }
+        let iterations = 0;
+        const maxIterations = this.config.maxIterations ?? 5;
+        const iterationTimeout = this.config.iterationTimeout ?? 30000;
+        // Gemini API expects the tool name as a function declaration
+        const tools = [
+            {
+                functionDeclarations: [
+                    {
+                        name: toolSchema.function.name,
+                        description: toolSchema.function.description,
+                        parameters: toolSchema.function.parameters,
+                    },
+                ],
+            },
+        ];
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const baseUrl = this.config.apiUrl || "https://generativelanguage.googleapis.com/v1beta";
+                const url = `${baseUrl}/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
+                const requestBody = {
+                    contents,
+                    systemInstruction: geminiSystemInstruction,
+                    tools,
+                    toolConfig: {
+                        functionCallingConfig: {
+                            mode: "ANY", // Force function calling
+                            allowedFunctionNames: [toolSchema.function.name],
+                        },
+                    },
+                    generationConfig: {
+                        temperature: this.config.memoryTemperature ?? 0.3,
+                    },
+                };
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("Gemini API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `Gemini API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                const candidate = data.candidates?.[0];
+                if (!candidate || !candidate.content) {
+                    return { success: false, error: "Invalid Gemini API response format", iterations };
+                }
+                const modelMsg = candidate.content;
+                const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                // Map Gemini response back to our internal message format
+                const assistantMsg = {
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: "",
+                    toolCalls: [],
+                };
+                for (const part of modelMsg.parts) {
+                    if (part.text)
+                        assistantMsg.content += part.text;
+                    if (part.functionCall) {
+                        assistantMsg.toolCalls.push({
+                            id: `${part.functionCall.name}:${Date.now()}`,
+                            type: "function",
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                        });
+                    }
+                }
+                await this.aiSessionManager.addMessage(assistantMsg);
+                contents.push(modelMsg);
+                if (assistantMsg.toolCalls.length > 0) {
+                    for (const toolCall of assistantMsg.toolCalls) {
+                        if (toolCall.function.name === toolSchema.function.name) {
+                            try {
+                                const parsed = JSON.parse(toolCall.function.arguments);
+                                const result = UserProfileValidator.validate(parsed);
+                                if (!result.valid)
+                                    throw new Error(result.errors.join(", "));
+                                await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: true }));
+                                return { success: true, data: result.data, iterations };
+                            }
+                            catch (validationError) {
+                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                await this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: false, error: errorMessage }));
+                                return { success: false, error: errorMessage, iterations };
+                            }
+                        }
+                    }
+                }
+                // Retry if no tool call was made
+                const retryPrompt = "Please use the save_memories tool as instructed.";
+                const retrySequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                await this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: retrySequence,
+                    role: "user",
+                    content: retryPrompt,
+                });
+                contents.push({ role: "user", parts: [{ text: retryPrompt }] });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                return { success: false, error: String(error), iterations };
+            }
+        }
+        return { success: false, error: `Max iterations (${maxIterations}) reached`, iterations };
+    }
+}