refactor(ux): consolidate BMAD skills, update design system, and clean up Prisma generated client

keep-notes/lib/ai/providers/custom-openai.ts

@@ -1,11 +1,13 @@
 import { createOpenAI } from '@ai-sdk/openai';
-import { generateObject, generateText, embed } from 'ai';
+import { generateObject, generateText as aiGenerateText, embed, stepCountIs } from 'ai';
 import { z } from 'zod';
-import { AIProvider, TagSuggestion, TitleSuggestion } from '../types';
+import { AIProvider, TagSuggestion, TitleSuggestion, ToolUseOptions, ToolCallResult } from '../types';
 
 export class CustomOpenAIProvider implements AIProvider {
   private model: any;
   private embeddingModel: any;
+  private apiKey: string;
+  private baseUrl: string;
 
   constructor(
     apiKey: string,
@@ -13,13 +15,22 @@ export class CustomOpenAIProvider implements AIProvider {
     modelName: string = 'gpt-4o-mini',
     embeddingModelName: string = 'text-embedding-3-small'
   ) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
     // Create OpenAI-compatible client with custom base URL
+    // Use .chat() to force /chat/completions endpoint (avoids Responses API)
     const customClient = createOpenAI({
       baseURL: baseUrl,
       apiKey: apiKey,
+      fetch: async (url, options) => {
+        const headers = new Headers(options?.headers);
+        headers.set('HTTP-Referer', 'https://localhost:3000');
+        headers.set('X-Title', 'Memento AI');
+        return fetch(url, { ...options, headers });
+      }
     });
 
-    this.model = customClient(modelName);
+    this.model = customClient.chat(modelName);
     this.embeddingModel = customClient.embedding(embeddingModelName);
   }
 
@@ -79,7 +90,7 @@ export class CustomOpenAIProvider implements AIProvider {
 
   async generateText(prompt: string): Promise<string> {
     try {
-      const { text } = await generateText({
+      const { text } = await aiGenerateText({
         model: this.model,
         prompt: prompt,
       });
@@ -90,4 +101,47 @@ export class CustomOpenAIProvider implements AIProvider {
       throw e;
     }
   }
+
+  async chat(messages: any[], systemPrompt?: string): Promise<any> {
+    try {
+      const { text } = await aiGenerateText({
+        model: this.model,
+        system: systemPrompt,
+        messages: messages,
+      });
+
+      return { text: text.trim() };
+    } catch (e) {
+      console.error('Erreur chat Custom OpenAI:', e);
+      throw e;
+    }
+  }
+
+  async generateWithTools(options: ToolUseOptions): Promise<ToolCallResult> {
+    const { tools, maxSteps = 10, systemPrompt, messages, prompt } = options
+    const opts: Record<string, any> = {
+      model: this.model,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+    }
+    if (systemPrompt) opts.system = systemPrompt
+    if (messages) opts.messages = messages
+    else if (prompt) opts.prompt = prompt
+
+    const result = await aiGenerateText(opts as any)
+    return {
+      toolCalls: result.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+      toolResults: result.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || [],
+      text: result.text,
+      steps: result.steps?.map((step: any) => ({
+        text: step.text,
+        toolCalls: step.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+        toolResults: step.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || []
+      })) || []
+    }
+  }
+
+  getModel() {
+    return this.model;
+  }
 }

keep-notes/lib/ai/providers/deepseek.ts

@@ -1,7 +1,7 @@
 import { createOpenAI } from '@ai-sdk/openai';
-import { generateObject, generateText, embed } from 'ai';
+import { generateObject, generateText as aiGenerateText, embed, stepCountIs } from 'ai';
 import { z } from 'zod';
-import { AIProvider, TagSuggestion, TitleSuggestion } from '../types';
+import { AIProvider, TagSuggestion, TitleSuggestion, ToolUseOptions, ToolCallResult } from '../types';
 
 export class DeepSeekProvider implements AIProvider {
   private model: any;
@@ -14,7 +14,7 @@ export class DeepSeekProvider implements AIProvider {
       apiKey: apiKey,
     });
 
-    this.model = deepseek(modelName);
+    this.model = deepseek.chat(modelName);
     this.embeddingModel = deepseek.embedding(embeddingModelName);
   }
 
@@ -74,7 +74,7 @@ export class DeepSeekProvider implements AIProvider {
 
   async generateText(prompt: string): Promise<string> {
     try {
-      const { text } = await generateText({
+      const { text } = await aiGenerateText({
         model: this.model,
         prompt: prompt,
       });
@@ -85,4 +85,47 @@ export class DeepSeekProvider implements AIProvider {
       throw e;
     }
   }
+
+  async chat(messages: any[], systemPrompt?: string): Promise<any> {
+    try {
+      const { text } = await aiGenerateText({
+        model: this.model,
+        system: systemPrompt,
+        messages: messages,
+      });
+
+      return { text: text.trim() };
+    } catch (e) {
+      console.error('Erreur chat DeepSeek:', e);
+      throw e;
+    }
+  }
+
+  async generateWithTools(options: ToolUseOptions): Promise<ToolCallResult> {
+    const { tools, maxSteps = 10, systemPrompt, messages, prompt } = options
+    const opts: Record<string, any> = {
+      model: this.model,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+    }
+    if (systemPrompt) opts.system = systemPrompt
+    if (messages) opts.messages = messages
+    else if (prompt) opts.prompt = prompt
+
+    const result = await aiGenerateText(opts as any)
+    return {
+      toolCalls: result.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+      toolResults: result.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || [],
+      text: result.text,
+      steps: result.steps?.map((step: any) => ({
+        text: step.text,
+        toolCalls: step.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+        toolResults: step.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || []
+      })) || []
+    }
+  }
+
+  getModel() {
+    return this.model;
+  }
 }

keep-notes/lib/ai/providers/ollama.ts

@@ -1,9 +1,12 @@
-import { AIProvider, TagSuggestion, TitleSuggestion } from '../types';
+import { createOpenAI } from '@ai-sdk/openai';
+import { generateText as aiGenerateText, stepCountIs } from 'ai';
+import { AIProvider, TagSuggestion, TitleSuggestion, ToolUseOptions, ToolCallResult } from '../types';
 
 export class OllamaProvider implements AIProvider {
   private baseUrl: string;
   private modelName: string;
   private embeddingModelName: string;
+  private model: any;
 
   constructor(baseUrl: string, modelName: string = 'llama3', embeddingModelName?: string) {
     if (!baseUrl) {
@@ -13,6 +16,15 @@ export class OllamaProvider implements AIProvider {
     this.baseUrl = baseUrl.endsWith('/api') ? baseUrl : `${baseUrl}/api`;
     this.modelName = modelName;
     this.embeddingModelName = embeddingModelName || modelName;
+
+    // Create OpenAI-compatible model for streaming support
+    // Ollama exposes /v1/chat/completions which is compatible with the OpenAI SDK
+    const cleanUrl = this.baseUrl.replace(/\/api$/, '');
+    const ollamaClient = createOpenAI({
+      baseURL: `${cleanUrl}/v1`,
+      apiKey: 'ollama',
+    });
+    this.model = ollamaClient.chat(modelName);
   }
 
   async generateTags(content: string, language: string = "en"): Promise<TagSuggestion[]> {
@@ -148,4 +160,63 @@ Note content: "${content}"`;
       throw e;
     }
   }
+
+  async chat(messages: any[], systemPrompt?: string): Promise<any> {
+    try {
+      const ollamaMessages = messages.map(m => ({
+        role: m.role,
+        content: m.content
+      }));
+
+      if (systemPrompt) {
+        ollamaMessages.unshift({ role: 'system', content: systemPrompt });
+      }
+
+      const response = await fetch(`${this.baseUrl}/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: this.modelName,
+          messages: ollamaMessages,
+          stream: false,
+        }),
+      });
+
+      if (!response.ok) throw new Error(`Ollama error: ${response.statusText}`);
+
+      const data = await response.json();
+      return { text: data.message?.content?.trim() || '' };
+    } catch (e) {
+      console.error('Erreur chat Ollama:', e);
+      throw e;
+    }
+  }
+
+  getModel() {
+    return this.model;
+  }
+
+  async generateWithTools(options: ToolUseOptions): Promise<ToolCallResult> {
+    const { tools, maxSteps = 10, systemPrompt, messages, prompt } = options
+    const opts: Record<string, any> = {
+      model: this.model,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+    }
+    if (systemPrompt) opts.system = systemPrompt
+    if (messages) opts.messages = messages
+    else if (prompt) opts.prompt = prompt
+
+    const result = await aiGenerateText(opts as any)
+    return {
+      toolCalls: result.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+      toolResults: result.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || [],
+      text: result.text,
+      steps: result.steps?.map((step: any) => ({
+        text: step.text,
+        toolCalls: step.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+        toolResults: step.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || []
+      })) || []
+    }
+  }
 }

keep-notes/lib/ai/providers/openai.ts

@@ -1,7 +1,7 @@
 import { createOpenAI } from '@ai-sdk/openai';
-import { generateObject, generateText, embed } from 'ai';
+import { generateObject, generateText as aiGenerateText, embed, stepCountIs } from 'ai';
 import { z } from 'zod';
-import { AIProvider, TagSuggestion, TitleSuggestion } from '../types';
+import { AIProvider, TagSuggestion, TitleSuggestion, ToolUseOptions, ToolCallResult } from '../types';
 
 export class OpenAIProvider implements AIProvider {
   private model: any;
@@ -9,11 +9,12 @@ export class OpenAIProvider implements AIProvider {
 
   constructor(apiKey: string, modelName: string = 'gpt-4o-mini', embeddingModelName: string = 'text-embedding-3-small') {
     // Create OpenAI client with API key
+    // Use .chat() to force /chat/completions endpoint (avoids Responses API)
     const openaiClient = createOpenAI({
       apiKey: apiKey,
     });
 
-    this.model = openaiClient(modelName);
+    this.model = openaiClient.chat(modelName);
     this.embeddingModel = openaiClient.embedding(embeddingModelName);
   }
 
@@ -73,7 +74,7 @@ export class OpenAIProvider implements AIProvider {
 
   async generateText(prompt: string): Promise<string> {
     try {
-      const { text } = await generateText({
+      const { text } = await aiGenerateText({
         model: this.model,
         prompt: prompt,
       });
@@ -84,4 +85,47 @@ export class OpenAIProvider implements AIProvider {
       throw e;
     }
   }
+
+  async chat(messages: any[], systemPrompt?: string): Promise<any> {
+    try {
+      const { text } = await aiGenerateText({
+        model: this.model,
+        system: systemPrompt,
+        messages: messages,
+      });
+
+      return { text: text.trim() };
+    } catch (e) {
+      console.error('Erreur chat OpenAI:', e);
+      throw e;
+    }
+  }
+
+  async generateWithTools(options: ToolUseOptions): Promise<ToolCallResult> {
+    const { tools, maxSteps = 10, systemPrompt, messages, prompt } = options
+    const opts: Record<string, any> = {
+      model: this.model,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+    }
+    if (systemPrompt) opts.system = systemPrompt
+    if (messages) opts.messages = messages
+    else if (prompt) opts.prompt = prompt
+
+    const result = await aiGenerateText(opts as any)
+    return {
+      toolCalls: result.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+      toolResults: result.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || [],
+      text: result.text,
+      steps: result.steps?.map((step: any) => ({
+        text: step.text,
+        toolCalls: step.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+        toolResults: step.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || []
+      })) || []
+    }
+  }
+
+  getModel() {
+    return this.model;
+  }
 }

keep-notes/lib/ai/providers/openrouter.ts

@@ -1,7 +1,7 @@
 import { createOpenAI } from '@ai-sdk/openai';
-import { generateObject, generateText, embed } from 'ai';
+import { generateObject, generateText as aiGenerateText, embed, stepCountIs } from 'ai';
 import { z } from 'zod';
-import { AIProvider, TagSuggestion, TitleSuggestion } from '../types';
+import { AIProvider, TagSuggestion, TitleSuggestion, ToolUseOptions, ToolCallResult } from '../types';
 
 export class OpenRouterProvider implements AIProvider {
   private model: any;
@@ -14,7 +14,7 @@ export class OpenRouterProvider implements AIProvider {
       apiKey: apiKey,
     });
 
-    this.model = openrouter(modelName);
+    this.model = openrouter.chat(modelName);
     this.embeddingModel = openrouter.embedding(embeddingModelName);
   }
 
@@ -74,7 +74,7 @@ export class OpenRouterProvider implements AIProvider {
 
   async generateText(prompt: string): Promise<string> {
     try {
-      const { text } = await generateText({
+      const { text } = await aiGenerateText({
         model: this.model,
         prompt: prompt,
       });
@@ -85,4 +85,47 @@ export class OpenRouterProvider implements AIProvider {
       throw e;
     }
   }
+
+  async chat(messages: any[], systemPrompt?: string): Promise<any> {
+    try {
+      const { text } = await aiGenerateText({
+        model: this.model,
+        system: systemPrompt,
+        messages: messages,
+      });
+
+      return { text: text.trim() };
+    } catch (e) {
+      console.error('Erreur chat OpenRouter:', e);
+      throw e;
+    }
+  }
+
+  async generateWithTools(options: ToolUseOptions): Promise<ToolCallResult> {
+    const { tools, maxSteps = 10, systemPrompt, messages, prompt } = options
+    const opts: Record<string, any> = {
+      model: this.model,
+      tools,
+      stopWhen: stepCountIs(maxSteps),
+    }
+    if (systemPrompt) opts.system = systemPrompt
+    if (messages) opts.messages = messages
+    else if (prompt) opts.prompt = prompt
+
+    const result = await aiGenerateText(opts as any)
+    return {
+      toolCalls: result.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+      toolResults: result.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || [],
+      text: result.text,
+      steps: result.steps?.map((step: any) => ({
+        text: step.text,
+        toolCalls: step.toolCalls?.map((tc: any) => ({ toolName: tc.toolName, input: tc.input })) || [],
+        toolResults: step.toolResults?.map((tr: any) => ({ toolName: tr.toolName, input: tr.input, output: tr.output })) || []
+      })) || []
+    }
+  }
+
+  getModel() {
+    return this.model;
+  }
 }