@haisto/opencode-mem 2.14.3-beta.0

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

@@ -0,0 +1,318 @@
+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;
+}
+export class OpenAIChatCompletionProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "openai-chat";
+    }
+    supportsSession() {
+        return true;
+    }
+    addToolResponse(sessionId, messages, toolCallId, content) {
+        const sequence = this.aiSessionManager.getLastSequence(sessionId) + 1;
+        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 = this.aiSessionManager.getSession(sessionId, "openai-chat");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "openai-chat",
+                sessionId,
+            });
+        }
+        const existingMessages = 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 = this.aiSessionManager.getLastSequence(session.id) + 1;
+            this.aiSessionManager.addMessage({
+                aiSessionId: session.id,
+                sequence,
+                role: "system",
+                content: systemPrompt,
+            });
+            messages.push({ role: "system", content: systemPrompt });
+        }
+        const userSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+        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 requestBody = {
+                    model: this.config.model,
+                    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.config.apiUrl}/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 = 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;
+                }
+                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 = JSON.parse(toolCall.function.arguments);
+                                const result = UserProfileValidator.validate(parsed);
+                                if (!result.valid) {
+                                    throw new Error(result.errors.join(", "));
+                                }
+                                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)}`;
+                                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.`;
+                        this.addToolResponse(session.id, messages, toolCallId, JSON.stringify({ success: false, error: wrongToolMessage }));
+                        break;
+                    }
+                }
+                const retrySequence = 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.";
+                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,14 @@
+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;
+}
+//# sourceMappingURL=openai-responses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai-responses.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/openai-responses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAwB,MAAM,oBAAoB,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAsBvF,qBAAa,uBAAwB,SAAQ,cAAc;IACzD,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAIpB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IA0H1B,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,gBAAgB;CAsBzB"}

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 = this.aiSessionManager.getSession(sessionId, "openai-responses");
+        if (!session) {
+            session = 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 = this.aiSessionManager.getLastSequence(session.id) + 1;
+                    this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: userSeq,
+                        role: "user",
+                        content: userPrompt,
+                    });
+                }
+                const toolCall = this.extractToolCall(data, toolSchema.function.name);
+                if (toolCall) {
+                    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/session/ai-session-manager.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-session-manager.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/session/ai-session-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACV,MAAM,oBAAoB,CAAC;AAS5B,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;;IAS5C,OAAO,CAAC,YAAY;IAyCpB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI;IAYzE,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS;IA2BrD,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IA8B9F,sBAAsB,IAAI,MAAM;IAKhC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAOhE,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,IAAI;IAmB9D,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE;IAS7C,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAS5C,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIxC,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,YAAY;CAarB;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}