opencode-mem 1.0.0 → 2.0.0

package/dist/config.js

@@ -44,11 +44,9 @@ const DEFAULTS = {
     containerTagPrefix: "opencode",
     keywordPatterns: [],
     autoCaptureEnabled: true,
-    autoCaptureTokenThreshold: 10000,
-    autoCaptureMinTokens: 20000,
-    autoCaptureMaxMemories: 10,
-    autoCaptureSummaryMaxLength: 0,
-    autoCaptureContextWindow: 3,
+    autoCaptureMaxIterations: 5,
+    autoCaptureIterationTimeout: 30000,
+    aiSessionRetentionDays: 7,
     webServerEnabled: true,
     webServerPort: 4747,
     webServerHost: "127.0.0.1",
@@ -57,6 +55,7 @@ const DEFAULTS = {
     autoCleanupRetentionDays: 30,
     deduplicationEnabled: true,
     deduplicationSimilarityThreshold: 0.9,
+    userMemoryAnalysisInterval: 10,
 };
 function isValidRegex(pattern) {
     try {
@@ -146,29 +145,56 @@ const CONFIG_TEMPLATE = `{
   
   "autoCaptureEnabled": true,
   
+  // Provider type: "openai-chat" | "openai-responses" | "anthropic"
+  "memoryProvider": "openai-chat",
+  
   // REQUIRED for auto-capture (all 3 must be set):
   "memoryModel": "gpt-4o-mini",
   "memoryApiUrl": "https://api.openai.com/v1",
   "memoryApiKey": "sk-...",
   
-  // Examples for other providers:
-  // Anthropic: 
+  // Examples for different providers:
+  // OpenAI Chat Completion (default, backward compatible):
+  //   "memoryProvider": "openai-chat"
+  //   "memoryModel": "gpt-4o-mini"
+  //   "memoryApiUrl": "https://api.openai.com/v1"
+  //   "memoryApiKey": "sk-..."
+  
+  // OpenAI Responses API (recommended, with session support):
+  //   "memoryProvider": "openai-responses"
+  //   "memoryModel": "gpt-4o"
+  //   "memoryApiUrl": "https://api.openai.com/v1"
+  //   "memoryApiKey": "sk-..."
+  
+  // Anthropic (with session support):
+  //   "memoryProvider": "anthropic"
   //   "memoryModel": "claude-3-5-haiku-20241022"
   //   "memoryApiUrl": "https://api.anthropic.com/v1"
   //   "memoryApiKey": "sk-ant-..."
-  // Groq (fast & cheap): 
+  
+  // Groq (OpenAI-compatible, use openai-chat provider):
+  //   "memoryProvider": "openai-chat"
   //   "memoryModel": "llama-3.3-70b-versatile"
   //   "memoryApiUrl": "https://api.groq.com/openai/v1"
   //   "memoryApiKey": "gsk_..."
   
-  // Token thresholds
-  "autoCaptureTokenThreshold": 10000,
-  "autoCaptureMinTokens": 20000,
-  "autoCaptureMaxMemories": 10,
-  "autoCaptureContextWindow": 3,
+  // Multi-iteration settings (for openai-responses and anthropic)
+  "autoCaptureMaxIterations": 5,
+  "autoCaptureIterationTimeout": 30000,
+  
+  // Session management
+  "aiSessionRetentionDays": 7,
+  
+  // ============================================
+  // User Memory Learning
+  // ============================================
   
-  // Summary length: 0 = AI decides optimal length, >0 = character limit
-  "autoCaptureSummaryMaxLength": 0,
+  // Analyze user prompts every N prompts to learn patterns and preferences
+  // When N uncaptured prompts accumulate, AI will analyze them to identify:
+  // - User preferences (code style, communication style)
+  // - User patterns (recurring topics, problem domains)
+  // - User workflows (development habits, sequences)
+  "userMemoryAnalysisInterval": 10,
   
   // ============================================
   // Search Settings
@@ -236,14 +262,13 @@ export const CONFIG = {
         ...(fileConfig.keywordPatterns ?? []).filter(isValidRegex),
     ],
     autoCaptureEnabled: fileConfig.autoCaptureEnabled ?? DEFAULTS.autoCaptureEnabled,
-    autoCaptureTokenThreshold: fileConfig.autoCaptureTokenThreshold ?? DEFAULTS.autoCaptureTokenThreshold,
-    autoCaptureMinTokens: fileConfig.autoCaptureMinTokens ?? DEFAULTS.autoCaptureMinTokens,
-    autoCaptureMaxMemories: fileConfig.autoCaptureMaxMemories ?? DEFAULTS.autoCaptureMaxMemories,
-    autoCaptureSummaryMaxLength: fileConfig.autoCaptureSummaryMaxLength ?? DEFAULTS.autoCaptureSummaryMaxLength,
-    autoCaptureContextWindow: fileConfig.autoCaptureContextWindow ?? DEFAULTS.autoCaptureContextWindow,
+    autoCaptureMaxIterations: fileConfig.autoCaptureMaxIterations ?? DEFAULTS.autoCaptureMaxIterations,
+    autoCaptureIterationTimeout: fileConfig.autoCaptureIterationTimeout ?? DEFAULTS.autoCaptureIterationTimeout,
+    memoryProvider: (fileConfig.memoryProvider ?? "openai-chat"),
     memoryModel: fileConfig.memoryModel,
     memoryApiUrl: fileConfig.memoryApiUrl,
     memoryApiKey: fileConfig.memoryApiKey,
+    aiSessionRetentionDays: fileConfig.aiSessionRetentionDays ?? DEFAULTS.aiSessionRetentionDays,
     webServerEnabled: fileConfig.webServerEnabled ?? DEFAULTS.webServerEnabled,
     webServerPort: fileConfig.webServerPort ?? DEFAULTS.webServerPort,
     webServerHost: fileConfig.webServerHost ?? DEFAULTS.webServerHost,
@@ -252,6 +277,7 @@ export const CONFIG = {
     autoCleanupRetentionDays: fileConfig.autoCleanupRetentionDays ?? DEFAULTS.autoCleanupRetentionDays,
     deduplicationEnabled: fileConfig.deduplicationEnabled ?? DEFAULTS.deduplicationEnabled,
     deduplicationSimilarityThreshold: fileConfig.deduplicationSimilarityThreshold ?? DEFAULTS.deduplicationSimilarityThreshold,
+    userMemoryAnalysisInterval: fileConfig.userMemoryAnalysisInterval ?? DEFAULTS.userMemoryAnalysisInterval,
 };
 export function isConfigured() {
     return true;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAuC/D,eAAO,MAAM,iBAAiB,EAAE,MAkpB/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAyC/D,eAAO,MAAM,iBAAiB,EAAE,MA+kB/B,CAAC"}

package/dist/index.js

@@ -3,7 +3,9 @@ import { memoryClient } from "./services/client.js";
 import { formatContextForPrompt } from "./services/context.js";
 import { getTags } from "./services/tags.js";
 import { stripPrivateContent, isFullyPrivate } from "./services/privacy.js";
-import { AutoCaptureService, performAutoCapture } from "./services/auto-capture.js";
+import { performAutoCapture } from "./services/auto-capture.js";
+import { performUserMemoryLearning } from "./services/user-memory-learning.js";
+import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
 import { startWebServer, WebServer } from "./services/web-server.js";
 import { isConfigured, CONFIG } from "./config.js";
 import { log } from "./services/logger.js";
@@ -30,14 +32,7 @@ export const OpenCodeMemPlugin = async (ctx) => {
     const { directory } = ctx;
     const tags = getTags(directory);
     const injectedSessions = new Set();
-    const autoCaptureService = new AutoCaptureService();
     let webServer = null;
-    log("Plugin loaded", {
-        directory,
-        tags,
-        configured: isConfigured(),
-        autoCaptureEnabled: autoCaptureService.isEnabled(),
-    });
     if (!isConfigured()) {
         log("Plugin disabled - memory system not configured");
     }
@@ -51,7 +46,6 @@ export const OpenCodeMemPlugin = async (ctx) => {
             webServer = server;
             const url = webServer.getUrl();
             if (webServer.isServerOwner()) {
-                log("Web server started (owner)", { url });
                 if (ctx.client?.tui) {
                     ctx.client.tui
                         .showToast({
@@ -66,7 +60,6 @@ export const OpenCodeMemPlugin = async (ctx) => {
                 }
             }
             else {
-                log("Web server already running (joined)", { url });
                 if (ctx.client?.tui) {
                     ctx.client.tui
                         .showToast({
@@ -98,13 +91,20 @@ export const OpenCodeMemPlugin = async (ctx) => {
         });
     }
     const shutdownHandler = async () => {
-        if (webServer) {
-            await webServer.stop();
+        try {
+            if (webServer) {
+                await webServer.stop();
+            }
+            memoryClient.close();
+            process.exit(0);
+        }
+        catch (error) {
+            log("Shutdown error", { error: String(error) });
+            process.exit(1);
         }
     };
     process.on("SIGINT", shutdownHandler);
     process.on("SIGTERM", shutdownHandler);
-    process.on("exit", shutdownHandler);
     return {
         "chat.message": async (input, output) => {
             if (!isConfigured())
@@ -117,6 +117,7 @@ export const OpenCodeMemPlugin = async (ctx) => {
                 const userMessage = textParts.map((p) => p.text).join("\n");
                 if (!userMessage.trim())
                     return;
+                userPromptManager.savePrompt(input.sessionID, output.message.id, directory, userMessage);
                 if (detectMemoryKeyword(userMessage)) {
                     const nudgePart = {
                         id: `memory-nudge-${Date.now()}`,
@@ -148,15 +149,18 @@ export const OpenCodeMemPlugin = async (ctx) => {
                         try {
                             await memoryClient.warmup();
                             if (ctx.client?.tui) {
-                                const autoCaptureStatus = autoCaptureService.isEnabled()
+                                const autoCaptureStatus = CONFIG.autoCaptureEnabled &&
+                                    CONFIG.memoryModel &&
+                                    CONFIG.memoryApiUrl &&
+                                    CONFIG.memoryApiKey
                                     ? "Auto-capture: enabled"
-                                    : autoCaptureService.getDisabledReason() || "Auto-capture: disabled";
+                                    : "Auto-capture: disabled";
                                 await ctx.client.tui
                                     .showToast({
                                     body: {
                                         title: "Memory System Ready!",
                                         message: autoCaptureStatus,
-                                        variant: autoCaptureService.isEnabled() ? "success" : "warning",
+                                        variant: CONFIG.autoCaptureEnabled ? "success" : "warning",
                                         duration: 3000,
                                     },
                                 })
@@ -236,17 +240,7 @@ export const OpenCodeMemPlugin = async (ctx) => {
                 description: "Manage and query the local persistent memory system. Use 'search' to find relevant memories, 'add' to store new knowledge, 'profile' to view user profile, 'list' to see recent memories, 'forget' to remove a memory.",
                 args: {
                     mode: tool.schema
-                        .enum([
-                        "add",
-                        "search",
-                        "profile",
-                        "list",
-                        "forget",
-                        "help",
-                        "capture-now",
-                        "auto-capture-toggle",
-                        "auto-capture-stats",
-                    ])
+                        .enum(["add", "search", "profile", "list", "forget", "help", "capture-now"])
                         .optional(),
                     content: tool.schema.string().optional(),
                     query: tool.schema.string().optional(),
@@ -307,16 +301,6 @@ export const OpenCodeMemPlugin = async (ctx) => {
                                             description: "Manually trigger memory capture for current session",
                                             args: [],
                                         },
-                                        {
-                                            command: "auto-capture-toggle",
-                                            description: "Enable/disable automatic memory capture",
-                                            args: [],
-                                        },
-                                        {
-                                            command: "auto-capture-stats",
-                                            description: "View auto-capture statistics for current session",
-                                            args: [],
-                                        },
                                     ],
                                     scopes: {
                                         user: "Cross-project user behaviors, preferences, patterns, requests",
@@ -485,39 +469,13 @@ export const OpenCodeMemPlugin = async (ctx) => {
                                 });
                             }
                             case "capture-now": {
-                                await performAutoCapture(ctx, autoCaptureService, toolCtx.sessionID, directory);
+                                const sessionID = toolCtx.sessionID;
+                                await performAutoCapture(ctx, sessionID, directory);
                                 return JSON.stringify({
                                     success: true,
                                     message: "Manual capture triggered",
                                 });
                             }
-                            case "auto-capture-toggle": {
-                                const enabled = autoCaptureService.toggle();
-                                return JSON.stringify({
-                                    success: true,
-                                    message: `Auto-capture ${enabled ? "enabled" : "disabled"}`,
-                                    enabled,
-                                });
-                            }
-                            case "auto-capture-stats": {
-                                const stats = autoCaptureService.getStats(toolCtx.sessionID);
-                                if (!stats) {
-                                    return JSON.stringify({
-                                        success: true,
-                                        message: "No capture data for this session",
-                                    });
-                                }
-                                return JSON.stringify({
-                                    success: true,
-                                    stats: {
-                                        lastCaptureTokens: stats.lastCaptureTokens,
-                                        minutesSinceCapture: Math.floor(stats.timeSinceCapture / 60000),
-                                        tokenThreshold: CONFIG.autoCaptureTokenThreshold,
-                                        minTokens: CONFIG.autoCaptureMinTokens,
-                                        enabled: autoCaptureService.isEnabled(),
-                                    },
-                                });
-                            }
                             default:
                                 return JSON.stringify({
                                     success: false,
@@ -537,32 +495,14 @@ export const OpenCodeMemPlugin = async (ctx) => {
         event: async (input) => {
             const event = input.event;
             const props = event.properties;
-            if (event.type === "message.updated") {
-                if (!autoCaptureService.isEnabled())
-                    return;
-                const info = props?.info;
-                if (!info)
-                    return;
-                const sessionID = info.sessionID;
-                if (!sessionID)
-                    return;
-                if (info.role !== "assistant" || !info.finish)
-                    return;
-                const tokens = info.tokens;
-                if (!tokens)
-                    return;
-                const totalUsed = tokens.input + tokens.cache.read + tokens.output;
-                const shouldCapture = autoCaptureService.checkTokenThreshold(sessionID, totalUsed);
-                if (shouldCapture) {
-                    performAutoCapture(ctx, autoCaptureService, sessionID, directory).catch((err) => log("Auto-capture failed", { error: String(err) }));
-                }
-            }
-            if (event.type === "session.deleted" && props?.sessionID) {
-                autoCaptureService.cleanup(props.sessionID);
-            }
             if (event.type === "session.idle") {
                 if (!isConfigured())
                     return;
+                const sessionID = props?.sessionID;
+                if (sessionID) {
+                    await performAutoCapture(ctx, sessionID, directory);
+                }
+                await performUserMemoryLearning(ctx, directory);
                 const { cleanupService } = await import("./services/cleanup-service.js");
                 const shouldRun = await cleanupService.shouldRunCleanup();
                 if (!shouldRun)

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":";AAgBA,QAAA,MAAQ,iBAAiB,sCAA+B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":";AAOA,QAAA,MAAQ,iBAAiB,sCAA+B,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC7B,eAAe,iBAAiB,CAAC"}

package/dist/plugin.js

@@ -1,15 +1,8 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const projectRoot = join(__dirname, "..");
-if (!existsSync(join(projectRoot, "node_modules"))) {
-    console.error("Error: node_modules not found. Run 'bun install' first.");
-    process.exit(1);
-}
-process.chdir(projectRoot);
 const { OpenCodeMemPlugin } = await import("./index.js");
 export { OpenCodeMemPlugin };
 export default OpenCodeMemPlugin;

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

@@ -0,0 +1,8 @@
+import { BaseAIProvider, type ProviderConfig } from "./providers/base-provider.js";
+import type { AIProviderType } from "./session/session-types.js";
+export declare class AIProviderFactory {
+    static createProvider(providerType: AIProviderType, config: ProviderConfig): BaseAIProvider;
+    static getSupportedProviders(): AIProviderType[];
+    static cleanupExpiredSessions(): number;
+}
+//# sourceMappingURL=ai-provider-factory.d.ts.map

package/dist/services/ai/ai-provider-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-provider-factory.d.ts","sourceRoot":"","sources":["../../../src/services/ai/ai-provider-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAKnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,cAAc,CAAC,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,GAAG,cAAc;IAgB3F,MAAM,CAAC,qBAAqB,IAAI,cAAc,EAAE;IAIhD,MAAM,CAAC,sBAAsB,IAAI,MAAM;CAGxC"}

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

@@ -0,0 +1,25 @@
+import { BaseAIProvider } from "./providers/base-provider.js";
+import { OpenAIChatCompletionProvider } from "./providers/openai-chat-completion.js";
+import { OpenAIResponsesProvider } from "./providers/openai-responses.js";
+import { AnthropicMessagesProvider } from "./providers/anthropic-messages.js";
+import { aiSessionManager } from "./session/ai-session-manager.js";
+export class AIProviderFactory {
+    static createProvider(providerType, config) {
+        switch (providerType) {
+            case "openai-chat":
+                return new OpenAIChatCompletionProvider(config, aiSessionManager);
+            case "openai-responses":
+                return new OpenAIResponsesProvider(config, aiSessionManager);
+            case "anthropic":
+                return new AnthropicMessagesProvider(config, aiSessionManager);
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    }
+    static getSupportedProviders() {
+        return ["openai-chat", "openai-responses", "anthropic"];
+    }
+    static cleanupExpiredSessions() {
+        return aiSessionManager.cleanupExpiredSessions();
+    }
+}

package/dist/services/ai/providers/anthropic-messages.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 AnthropicMessagesProvider 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 extractToolUse;
+    private validateResponse;
+}
+//# sourceMappingURL=anthropic-messages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AA2BvF,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,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;IAmJ1B,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,gBAAgB;CA+BzB"}

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

@@ -0,0 +1,176 @@
+import { 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";
+export class AnthropicMessagesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "anthropic";
+    }
+    supportsSession() {
+        return true;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = this.aiSessionManager.getSession(sessionId, "anthropic");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "anthropic",
+                sessionId,
+                metadata: { systemPrompt },
+            });
+        }
+        const storedMessages = 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 = 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;
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.config.iterationTimeout);
+            try {
+                const tool = ToolSchemaConverter.toAnthropic(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    system: systemPrompt,
+                    messages,
+                    tools: [tool],
+                };
+                const response = await fetch(`${this.config.apiUrl}/messages`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": this.config.apiKey,
+                        "anthropic-version": "2023-06-01",
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("Anthropic Messages API error", {
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                const assistantSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                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) {
+                    return {
+                        success: true,
+                        data: this.validateResponse(toolUse),
+                        iterations,
+                    };
+                }
+                if (data.stop_reason === "end_turn") {
+                    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 });
+                }
+                else {
+                    break;
+                }
+            }
+            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 (${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;
+    }
+    validateResponse(data) {
+        if (!data || typeof data !== "object") {
+            throw new Error("Response is not an object");
+        }
+        if (data.memories && Array.isArray(data.memories)) {
+            const validMemories = data.memories.filter((m) => {
+                return (m &&
+                    typeof m === "object" &&
+                    typeof m.summary === "string" &&
+                    m.summary.trim().length > 0 &&
+                    (m.scope === "user" || m.scope === "project") &&
+                    typeof m.type === "string" &&
+                    m.type.trim().length > 0);
+            });
+            if (validMemories.length === 0) {
+                throw new Error("No valid memories in response");
+            }
+            return { memories: validMemories };
+        }
+        if (data.summary && typeof data.summary === "string" && data.summary.trim().length > 0) {
+            return data;
+        }
+        throw new Error("Invalid response format: missing summary or memories field");
+    }
+}

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

@@ -0,0 +1,21 @@
+export interface ToolCallResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    iterations?: number;
+}
+export interface ProviderConfig {
+    model: string;
+    apiUrl: string;
+    apiKey: string;
+    maxIterations: number;
+    iterationTimeout: number;
+}
+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;
+}
+//# sourceMappingURL=base-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-provider.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/base-provider.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,8BAAsB,cAAc;IAClC,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,EAAE,cAAc;IAIlC,QAAQ,CAAC,eAAe,CACtB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,GAAG,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IAE1B,QAAQ,CAAC,eAAe,IAAI,MAAM;IAElC,QAAQ,CAAC,eAAe,IAAI,OAAO;CACpC"}

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

@@ -0,0 +1,6 @@
+export class BaseAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}

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

@@ -0,0 +1,12 @@
+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;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+    private validateResponse;
+}
+//# 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,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAkBlE,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;IAIpB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IA2K1B,OAAO,CAAC,gBAAgB;CA+BzB"}