@xiaoxiamimengfb/my-opencode-mem 2.12.0

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;
+    }
+    addToolResponse(sessionId, messages, toolCallId, content) {
+        const sequence = this.aiSessionManager.getLastSequence(sessionId) + 1;
+        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 = this.aiSessionManager.getSession(sessionId, "google-gemini");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "google-gemini",
+                sessionId,
+            });
+        }
+        const existingMessages = 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 = this.aiSessionManager.getLastSequence(session.id) + 1;
+            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 = 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),
+                            },
+                        });
+                    }
+                }
+                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(", "));
+                                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)}`;
+                                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 = this.aiSessionManager.getLastSequence(session.id) + 1;
+                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 };
+    }
+}

package/dist/services/ai/providers/openai-chat-completion.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 OpenAIChatCompletionProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    private addToolResponse;
+    private filterIncompleteToolCallSequences;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}
+//# sourceMappingURL=openai-chat-completion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai-chat-completion.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/openai-chat-completion.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,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAqBlE,qBAAa,4BAA6B,SAAQ,cAAc;IAC9D,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAI1B,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,iCAAiC;IAoCnC,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;CAmR3B"}

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

@@ -0,0 +1,277 @@
+import { BaseAIProvider, applySafeExtraParams } 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";
+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.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") {
+                    if (toolCallIds.has(messages[j].toolCallId)) {
+                        toolResponses.push(messages[j]);
+                        toolCallIds.delete(messages[j].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 (data.status && data.msg) {
+                    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 (!data.choices || !data.choices[0]) {
+                    log("Invalid API response format", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        response: JSON.stringify(data).slice(0, 1000),
+                        hasChoices: !!data.choices,
+                        choicesLength: data.choices?.length,
+                    });
+                    return {
+                        success: false,
+                        error: "Invalid API response format",
+                        iterations,
+                    };
+                }
+                const choice = data.choices[0];
+                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(choice.message);
+                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 (${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,
+        };
+    }
+}

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"}