om-memory-system 3.0.0

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

@@ -0,0 +1,35 @@
+import { type ProviderConfig } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { AnthropicMessagesProvider } from "./anthropic-messages.js";
+import type { AIProviderType } from "../session/session-types.js";
+/**
+ * MiniMax provider.
+ *
+ * MiniMax exposes an Anthropic Messages-compatible endpoint for its text
+ * models. The global endpoint (https://api.minimax.io) and the China endpoint
+ * (https://api.minimaxi.com) both expose the same `/anthropic/v1/messages`
+ * path and authenticate with the `x-api-key` header. This provider reuses the
+ * Anthropic Messages request/response handling and only overrides the resolved
+ * request endpoint URL and the session provider tag, so MiniMax is
+ * distinguishable from Anthropic in the session store and diagnostics.
+ *
+ * Users configure the base URL as `memoryApiUrl`:
+ *   - global endpoint: "https://api.minimax.io"
+ *   - China endpoint:  "https://api.minimaxi.com"
+ */
+export declare class MiniMaxProvider extends AnthropicMessagesProvider {
+    constructor(config: ProviderConfig, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    /**
+     * Resolve the Anthropic Messages endpoint URL for MiniMax.
+     *
+     * MiniMax's Messages endpoint lives at `<base>/anthropic/v1/messages`. The
+     * base URL is normalized so users can supply the host with or without a
+     * trailing `/anthropic`, `/anthropic/v1`, or `/anthropic/v1/messages` suffix.
+     */
+    resolveEndpoint(): string;
+    sessionProviderTag(): AIProviderType;
+    protected apiErrorLogLabel(): string;
+    protected toolValidationErrorLogLabel(): string;
+    protected timeoutLabel(): string;
+}

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

@@ -0,0 +1,55 @@
+import {} from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { AnthropicMessagesProvider } from "./anthropic-messages.js";
+/**
+ * MiniMax provider.
+ *
+ * MiniMax exposes an Anthropic Messages-compatible endpoint for its text
+ * models. The global endpoint (https://api.minimax.io) and the China endpoint
+ * (https://api.minimaxi.com) both expose the same `/anthropic/v1/messages`
+ * path and authenticate with the `x-api-key` header. This provider reuses the
+ * Anthropic Messages request/response handling and only overrides the resolved
+ * request endpoint URL and the session provider tag, so MiniMax is
+ * distinguishable from Anthropic in the session store and diagnostics.
+ *
+ * Users configure the base URL as `memoryApiUrl`:
+ *   - global endpoint: "https://api.minimax.io"
+ *   - China endpoint:  "https://api.minimaxi.com"
+ */
+export class MiniMaxProvider extends AnthropicMessagesProvider {
+    constructor(config, aiSessionManager) {
+        super(config, aiSessionManager);
+    }
+    getProviderName() {
+        return "minimax";
+    }
+    /**
+     * Resolve the Anthropic Messages endpoint URL for MiniMax.
+     *
+     * MiniMax's Messages endpoint lives at `<base>/anthropic/v1/messages`. The
+     * base URL is normalized so users can supply the host with or without a
+     * trailing `/anthropic`, `/anthropic/v1`, or `/anthropic/v1/messages` suffix.
+     */
+    resolveEndpoint() {
+        let base = (this.config.apiUrl || "").trim().replace(/\/+$/, "");
+        if (!base) {
+            throw new Error("MiniMax provider requires a configured memoryApiUrl");
+        }
+        base = base.replace(/\/anthropic\/v1\/messages\/?$/, "");
+        base = base.replace(/\/anthropic\/v1\/?$/, "");
+        base = base.replace(/\/anthropic\/?$/, "");
+        return `${base}/anthropic/v1/messages`;
+    }
+    sessionProviderTag() {
+        return "minimax";
+    }
+    apiErrorLogLabel() {
+        return "MiniMax Messages API error";
+    }
+    toolValidationErrorLogLabel() {
+        return "MiniMax tool response validation failed";
+    }
+    timeoutLabel() {
+        return "MiniMax API request timeout";
+    }
+}

package/dist/services/ai/providers/openai-chat-completion.d.ts

@@ -0,0 +1,22 @@
+import { BaseAIProvider, type ProviderConfig, type ToolCallResult } from "./base-provider.js";
+import type { AISessionManager } from "../session/ai-session-manager.js";
+import type { AIMessage, AIProviderType } from "../session/session-types.js";
+import type { ChatCompletionTool } from "../tools/tool-schema.js";
+export declare class OpenAIChatCompletionProvider extends BaseAIProvider {
+    private readonly aiSessionManager;
+    constructor(config: ProviderConfig, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    /** Provider tag used for AI session storage and diagnostics. */
+    protected sessionProviderTag(): AIProviderType;
+    /**
+     * Resolve the OpenAI-compatible API base URL.
+     * Trailing slashes are stripped so `${base}/chat/completions` is well-formed.
+     */
+    protected resolveEndpoint(): string;
+    /** Resolve the model ID sent in the request body. */
+    protected resolveModel(): string;
+    private addToolResponse;
+    protected filterIncompleteToolCallSequences(messages: AIMessage[]): AIMessage[];
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}

package/dist/services/ai/providers/openai-chat-completion.js

@@ -0,0 +1,387 @@
+import { BaseAIProvider, applySafeExtraParams, } from "./base-provider.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+function isErrorResponseBody(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        typeof data.status === "string" &&
+        typeof data.msg === "string");
+}
+function hasNonEmptyChoices(data) {
+    if (typeof data !== "object" || data === null)
+        return false;
+    const { choices } = data;
+    if (!Array.isArray(choices) || choices.length === 0)
+        return false;
+    const first = choices[0];
+    if (typeof first !== "object" || first === null)
+        return false;
+    if (typeof first.message !== "object" || first.message === null)
+        return false;
+    const { content, tool_calls } = first.message;
+    if (content !== undefined && content !== null && typeof content !== "string")
+        return false;
+    if (tool_calls !== undefined && !Array.isArray(tool_calls))
+        return false;
+    return true;
+}
+function extractFirstJSON(raw) {
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < raw.length; i++) {
+        if (raw[i] === "{" || raw[i] === "[") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (raw[i] === "}" || raw[i] === "]") {
+            depth--;
+            if (depth === 0)
+                return raw.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+function repairInnerQuotes(json) {
+    let result = json.replace(/([\u4e00-\u9fff\u3000-\u303f\uff00-\uffef])"([\u4e00-\u9fff\u3000-\u303f\uff00-\uffef])/g, '$1\\"$2');
+    result = result.replace(/([\u4e00-\u9fff\u3000-\u303f\uff00-\uffef])"(?=\s*[,}\]])/g, '$1\\"');
+    return result;
+}
+export class OpenAIChatCompletionProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "openai-chat";
+    }
+    supportsSession() {
+        return true;
+    }
+    /** Provider tag used for AI session storage and diagnostics. */
+    sessionProviderTag() {
+        return "openai-chat";
+    }
+    /**
+     * Resolve the OpenAI-compatible API base URL.
+     * Trailing slashes are stripped so `${base}/chat/completions` is well-formed.
+     */
+    resolveEndpoint() {
+        return (this.config.apiUrl || "").trim().replace(/\/+$/, "");
+    }
+    /** Resolve the model ID sent in the request body. */
+    resolveModel() {
+        return this.config.model;
+    }
+    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,
+        });
+        messages.push({
+            role: "tool",
+            tool_call_id: toolCallId,
+            content,
+        });
+    }
+    filterIncompleteToolCallSequences(messages) {
+        const result = [];
+        let i = 0;
+        while (i < messages.length) {
+            const msg = messages[i];
+            if (!msg) {
+                break;
+            }
+            if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+                const toolCallIds = new Set(msg.toolCalls.map((tc) => tc.id));
+                const toolResponses = [];
+                let j = i + 1;
+                while (j < messages.length && messages[j]?.role === "tool") {
+                    const toolMessage = messages[j];
+                    if (toolMessage?.toolCallId && toolCallIds.has(toolMessage.toolCallId)) {
+                        toolResponses.push(toolMessage);
+                        toolCallIds.delete(toolMessage.toolCallId);
+                    }
+                    j++;
+                }
+                if (toolCallIds.size === 0) {
+                    result.push(msg);
+                    toolResponses.forEach((tr) => result.push(tr));
+                    i = j;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                result.push(msg);
+                i++;
+            }
+        }
+        return result;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = await this.aiSessionManager.getSession(sessionId, this.sessionProviderTag());
+        if (!session) {
+            session = await this.aiSessionManager.createSession({
+                provider: this.sessionProviderTag(),
+                sessionId,
+            });
+        }
+        const existingMessages = await this.aiSessionManager.getMessages(session.id);
+        const messages = [];
+        const validatedMessages = this.filterIncompleteToolCallSequences(existingMessages);
+        for (const msg of validatedMessages) {
+            const apiMsg = {
+                role: msg.role,
+                content: msg.content,
+            };
+            if (msg.toolCalls) {
+                apiMsg.tool_calls = msg.toolCalls;
+            }
+            if (msg.toolCallId) {
+                apiMsg.tool_call_id = msg.toolCallId;
+            }
+            messages.push(apiMsg);
+        }
+        if (messages.length === 0) {
+            const sequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+            await this.aiSessionManager.addMessage({
+                aiSessionId: session.id,
+                sequence,
+                role: "system",
+                content: systemPrompt,
+            });
+            messages.push({ role: "system", content: systemPrompt });
+        }
+        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;
+        let lastErrorMessage = "";
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const requestBody = {
+                    model: this.resolveModel(),
+                    messages,
+                    tools: [toolSchema],
+                    tool_choice: "auto",
+                };
+                if (this.config.memoryTemperature !== false) {
+                    requestBody.temperature = this.config.memoryTemperature ?? 0.3;
+                }
+                if (this.config.extraParams) {
+                    applySafeExtraParams(requestBody, this.config.extraParams);
+                }
+                const headers = {
+                    "Content-Type": "application/json",
+                };
+                if (this.config.apiKey) {
+                    headers.Authorization = `Bearer ${this.config.apiKey}`;
+                }
+                const response = await fetch(`${this.resolveEndpoint()}/chat/completions`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("OpenAI Chat Completion API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    let errorMessage = `API error: ${response.status} - ${errorText}`;
+                    if (response.status === 400 &&
+                        errorText.includes("unsupported_value") &&
+                        errorText.includes("temperature")) {
+                        errorMessage =
+                            'Your model does not support the temperature parameter. Add "memoryTemperature": false to your config file to disable it.';
+                    }
+                    return {
+                        success: false,
+                        error: errorMessage,
+                        iterations,
+                    };
+                }
+                const data = await response.json();
+                if (isErrorResponseBody(data)) {
+                    log("API returned error in response body", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: data.status,
+                        msg: data.msg,
+                    });
+                    return {
+                        success: false,
+                        error: `API error: ${data.status} - ${data.msg}`,
+                        iterations,
+                    };
+                }
+                if (!hasNonEmptyChoices(data)) {
+                    const choices = typeof data === "object" && data !== null
+                        ? data.choices
+                        : undefined;
+                    log("Invalid API response format", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        response: JSON.stringify(data).slice(0, 1000),
+                        hasChoices: Array.isArray(choices),
+                        choicesLength: Array.isArray(choices) ? choices.length : undefined,
+                    });
+                    return {
+                        success: false,
+                        error: "Invalid API response format",
+                        iterations,
+                    };
+                }
+                const choice = data.choices[0];
+                if (!choice) {
+                    return {
+                        success: false,
+                        error: "Invalid API response format",
+                        iterations,
+                    };
+                }
+                const assistantSequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                const assistantMsg = {
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: choice.message.content ?? "",
+                };
+                if (choice.message.tool_calls) {
+                    assistantMsg.toolCalls = choice.message.tool_calls;
+                }
+                await this.aiSessionManager.addMessage(assistantMsg);
+                messages.push({
+                    role: "assistant",
+                    content: choice.message.content ?? null,
+                    tool_calls: choice.message.tool_calls,
+                });
+                if (choice.message.tool_calls && choice.message.tool_calls.length > 0) {
+                    for (const toolCall of choice.message.tool_calls) {
+                        const toolCallId = toolCall.id;
+                        if (toolCall.function.name === toolSchema.function.name) {
+                            try {
+                                const parsed = (() => {
+                                    const raw = toolCall.function.arguments;
+                                    if (typeof raw !== "string") {
+                                        return JSON.parse(JSON.stringify(raw));
+                                    }
+                                    try {
+                                        return JSON.parse(raw);
+                                    }
+                                    catch (e1) {
+                                        const fixed = extractFirstJSON(raw);
+                                        if (fixed) {
+                                            try {
+                                                return JSON.parse(fixed);
+                                            }
+                                            catch {
+                                                const repaired = repairInnerQuotes(fixed);
+                                                if (repaired !== fixed) {
+                                                    try {
+                                                        return JSON.parse(repaired);
+                                                    }
+                                                    catch {
+                                                        // ignore and fall through to the original parse error
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        throw e1;
+                                    }
+                                })();
+                                const result = UserProfileValidator.validate(parsed);
+                                if (!result.valid) {
+                                    throw new Error(result.errors.join(", "));
+                                }
+                                await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: true }));
+                                return {
+                                    success: true,
+                                    data: result.data,
+                                    iterations,
+                                };
+                            }
+                            catch (validationError) {
+                                const errorStack = validationError instanceof Error ? validationError.stack : undefined;
+                                log("OpenAI tool response validation failed", {
+                                    error: String(validationError),
+                                    stack: errorStack,
+                                    errorType: validationError instanceof Error
+                                        ? validationError.constructor.name
+                                        : typeof validationError,
+                                    toolName: toolSchema.function.name,
+                                    iteration: iterations,
+                                    rawArguments: toolCall.function.arguments.slice(0, 500),
+                                });
+                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                lastErrorMessage = errorMessage;
+                                await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: false, error: errorMessage }));
+                                return {
+                                    success: false,
+                                    error: errorMessage,
+                                    iterations,
+                                };
+                            }
+                        }
+                        const wrongToolMessage = `Wrong tool called. Please use ${toolSchema.function.name} instead.`;
+                        await this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: false, error: wrongToolMessage }));
+                        break;
+                    }
+                }
+                const retrySequence = (await this.aiSessionManager.getLastSequence(session.id)) + 1;
+                const retryPrompt = lastErrorMessage
+                    ? `Your previous attempt failed. Error: ${lastErrorMessage}. Please fix the JSON in your tool call arguments and try again. Output ONLY valid JSON, no extra text outside the JSON structure.`
+                    : "Please use the tool to extract and save the data as instructed.";
+                await this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: retrySequence,
+                    role: "user",
+                    content: retryPrompt,
+                });
+                messages.push({ role: "user", content: retryPrompt });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof Error && error.name === "AbortError") {
+                    return {
+                        success: false,
+                        error: `API request timeout (${iterationTimeout}ms)`,
+                        iterations,
+                    };
+                }
+                return {
+                    success: false,
+                    error: String(error),
+                    iterations,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `Max iterations (${maxIterations}) reached without tool call`,
+            iterations,
+        };
+    }
+}

package/dist/services/ai/providers/openai-responses.d.ts

@@ -0,0 +1,13 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { type ChatCompletionTool } from "../tools/tool-schema.js";
+export declare class OpenAIResponsesProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+    private extractToolCall;
+    private buildRetryPrompt;
+    private validateResponse;
+}