osborn 0.8.10 → 0.8.12

package/dist/claude-llm.js

@@ -12,7 +12,11 @@ import { EventEmitter } from 'events';
 import { saveSessionMetadata, getSessionWorkspace } from './config.js';
 import { getResearchSystemPrompt, getDirectModeResearchPrompt } from './prompts.js';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Directory of this module — used to locate co-located prompt files (e.g., turn-shape reminder).
+const __claudeLlmDir = dirname(fileURLToPath(import.meta.url));
+const TURN_SHAPE_REMINDER_PATH = join(__claudeLlmDir, 'prompts', 'turn-shape-reminder.md');
 /**
  * Strip markdown formatting for TTS (text-to-speech)
  * Removes **bold**, ##headers, ```code```, etc. so TTS doesn't read them literally
@@ -617,7 +621,7 @@ export class ClaudeLLM extends llm.LLM {
                             callbacks.eventEmitter.emit('assistant_text', { text: block.text });
                             const ttsChunk = stripMarkdownForTTS(block.text);
                             if (ttsChunk.trim()) {
-                                console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
                                 callbacks.eventEmitter.emit('tts_say', { text: ttsChunk });
                             }
                         }
@@ -732,7 +736,7 @@ class ClaudeLLMStream extends llm.LLMStream {
                 });
                 return;
             }
-            console.log(`🎤 User: "${userText.substring(0, 100)}${userText.length > 100 ? '...' : ''}"`);
+            console.log(`🎤 User (${userText.length} chars): "${userText}"`);
             // Build Claude Agent SDK options
             const resumeSessionId = this.#opts.resumeSessionId;
             const continueSession = this.#opts.continueSession;
@@ -746,7 +750,8 @@ class ClaudeLLMStream extends llm.LLMStream {
                 cwd: this.#opts.workingDirectory,
                 permissionMode: this.#opts.permissionMode,
                 allowedTools,
-                model: this.#opts.model || 'claude-sonnet-4-6', // Sonnet orchestrator with named sub-agents (Haiku tested but ignored delegation rules)
+                model: this.#opts.model || 'haiku', // haiku for speed with limited tools, sonnet for full research capabilities (including tool use trace in response)
+                // model: this.#opts.model || 'claude-sonnet-4-6', // Sonnet orchestrator with named sub-agents (Haiku tested but ignored delegation rules)
                 enableFileCheckpointing: true,
                 extraArgs: { 'replay-user-messages': null },
                 ...(this.#abortController && { abortController: this.#abortController }),
@@ -852,6 +857,35 @@ class ClaudeLLMStream extends llm.LLMStream {
                                     this.#eventEmitter.emit('tool_result', { name: toolName, input: toolInput, response: toolResponse });
                                     return {};
                                 }]
+                        }],
+                    // Per-turn behavioral re-anchor. Fires on EVERY user message that reaches Claude
+                    // (initial requests, follow-ups, mid-flight steering, resumed-session messages).
+                    // Reads the reminder text from disk every call, so it's hot-editable just like the
+                    // main prompt — edit agent/src/prompts/turn-shape-reminder.md, reconnect, next message
+                    // sees the new reminder. The SDK injects `additionalContext` alongside the user's actual
+                    // message so the model sees both the literal user input AND the reminder, weighing them
+                    // together. This is what fights JSONL-history-overrides-system-prompt drift on resumed
+                    // sessions: the conductor pattern gets re-asserted on every turn instead of being
+                    // anchored only at session-init time.
+                    UserPromptSubmit: [{
+                            matcher: '.*',
+                            hooks: [async (input) => {
+                                    try {
+                                        const reminder = readFileSync(TURN_SHAPE_REMINDER_PATH, 'utf-8');
+                                        const promptPreview = String(input?.prompt || '').substring(0, 60).replace(/\n/g, ' ');
+                                        console.log(`📌 UserPromptSubmit: injected turn-shape reminder (${reminder.length} chars) for prompt="${promptPreview}..."`);
+                                        return {
+                                            hookSpecificOutput: {
+                                                hookEventName: 'UserPromptSubmit',
+                                                additionalContext: reminder,
+                                            },
+                                        };
+                                    }
+                                    catch (err) {
+                                        console.error('⚠️ UserPromptSubmit: failed to load turn-shape-reminder.md:', err instanceof Error ? err.message : err);
+                                        return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } };
+                                    }
+                                }]
                         }]
                 },
                 // Named sub-agents — Haiku overseer delegates to these specialists.
@@ -1076,12 +1110,12 @@ class ClaudeLLMStream extends llm.LLMStream {
                                 if (this.#opts.skipTTSQueue) {
                                     // Direct mode: emit event for session.say() — bypasses LiveKit's
                                     // BufferedTokenStream which causes stuck/delayed/out-of-order audio
-                                    console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    console.log(`🔊 TTS say (${ttsChunk.length} chars): "${ttsChunk}"`);
                                     this.#eventEmitter.emit('tts_say', { text: ttsChunk });
                                 }
                                 else {
                                     // Realtime mode: use LLM stream queue (framework handles TTS)
-                                    console.log(`🔊 TTS stream (${ttsChunk.length} chars): "${ttsChunk.substring(0, 60)}..."`);
+                                    console.log(`🔊 TTS stream (${ttsChunk.length} chars): "${ttsChunk}"`);
                                     this.queue.put({
                                         id: requestId,
                                         delta: { role: 'assistant', content: ttsChunk },
@@ -1101,11 +1135,11 @@ class ClaudeLLMStream extends llm.LLMStream {
                         const ttsText = stripMarkdownForTTS(rawResult);
                         if (ttsText.trim()) {
                             if (this.#opts.skipTTSQueue) {
-                                console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS say result (${ttsText.length} chars): "${ttsText}"`);
                                 this.#eventEmitter.emit('tts_say', { text: ttsText });
                             }
                             else {
-                                console.log(`🔊 TTS result (${ttsText.length} chars): "${ttsText.substring(0, 60)}..."`);
+                                console.log(`🔊 TTS result (${ttsText.length} chars): "${ttsText}"`);
                                 this.queue.put({
                                     id: requestId,
                                     delta: { role: 'assistant', content: ttsText },

package/dist/codex-llm.js

@@ -97,7 +97,7 @@ class CodexLLMStream extends llm.LLMStream {
                 });
                 return;
             }
-            console.log(`🎤 User: "${userText.substring(0, 100)}${userText.length > 100 ? '...' : ''}"`);
+            console.log(`🎤 User (${userText.length} chars): "${userText}"`);
             // Create or reuse thread
             if (!this.#thread) {
                 console.log('🆕 Starting new Codex thread');

package/dist/conversation-brain.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Conversation Brain - Gemini 2.5 Pro powered conversation manager
+ *
+ * This is the "smart brain" that:
+ * 1. Keeps conversation alive with relevant questions
+ * 2. Builds context until we understand what user wants
+ * 3. Dispatches background research agents
+ * 4. Receives progress updates and decides when to execute
+ * 5. Handles direct commands immediately
+ */
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: Date;
+}
+export interface ResearchTask {
+    id: string;
+    query: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    result?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+export interface BrainDecision {
+    action: 'speak' | 'research' | 'execute' | 'clarify' | 'direct_command';
+    speech?: string;
+    researchQueries?: string[];
+    executeTask?: string;
+    directCommand?: string;
+    reasoning?: string;
+}
+export interface BrainState {
+    conversationHistory: ConversationMessage[];
+    userGoal: string | null;
+    userGoalConfidence: number;
+    pendingResearch: ResearchTask[];
+    completedResearch: ResearchTask[];
+    readyToExecute: boolean;
+    executionPlan: string | null;
+}
+export declare class ConversationBrain {
+    private llm;
+    private state;
+    private workingDir;
+    private onSpeak;
+    private onStateChange;
+    constructor(config: {
+        workingDir: string;
+        onSpeak: (text: string) => Promise<void>;
+        onStateChange: (state: string) => Promise<void>;
+    });
+    /**
+     * Process user input and decide what to do
+     */
+    processUserInput(input: string): Promise<BrainDecision>;
+    /**
+     * Receive research results from background agents
+     */
+    receiveResearchResult(taskId: string, result: string, success: boolean): void;
+    /**
+     * Check if we should provide a status update
+     */
+    shouldProvideUpdate(): boolean;
+    /**
+     * Generate a status update based on completed research
+     */
+    generateStatusUpdate(): Promise<string | null>;
+    /**
+     * Get current state for debugging/display
+     */
+    getState(): BrainState;
+    /**
+     * Reset conversation state
+     */
+    reset(): void;
+    private buildAnalysisPrompt;
+    private parseDecision;
+    private updateState;
+    /**
+     * Create research tasks for background agents
+     */
+    getPendingResearchTasks(): ResearchTask[];
+    /**
+     * Mark a research task as running
+     */
+    markResearchRunning(taskId: string): void;
+}
+export declare function createConversationBrain(config: {
+    workingDir: string;
+    onSpeak: (text: string) => Promise<void>;
+    onStateChange: (state: string) => Promise<void>;
+}): ConversationBrain;

package/dist/conversation-brain.js

@@ -0,0 +1,360 @@
+/**
+ * Conversation Brain - Gemini 2.5 Pro powered conversation manager
+ *
+ * This is the "smart brain" that:
+ * 1. Keeps conversation alive with relevant questions
+ * 2. Builds context until we understand what user wants
+ * 3. Dispatches background research agents
+ * 4. Receives progress updates and decides when to execute
+ * 5. Handles direct commands immediately
+ */
+import { llm } from '@livekit/agents';
+import * as google from '@livekit/agents-plugin-google';
+// ============================================================
+// Conversation Brain Class
+// ============================================================
+export class ConversationBrain {
+    llm;
+    state;
+    workingDir;
+    onSpeak;
+    onStateChange;
+    constructor(config) {
+        // Use Gemini 2.0 Flash for brain decisions - it's faster and less likely to conflict
+        // with the Gemini Realtime voice session which uses a different model
+        this.llm = new google.LLM({
+            model: 'gemini-2.0-flash',
+            // Set lower temperature for more consistent decisions
+            temperature: 0.3,
+        });
+        // Add error handler to prevent unhandled rejection crashes
+        this.llm.on('error', (err) => {
+            const errorMsg = err.error?.message || String(err);
+            // Only log non-abort errors
+            if (!errorMsg.includes('aborted') && !errorMsg.includes('AbortError')) {
+                console.error('🧠 [Brain LLM] Error:', errorMsg);
+            }
+        });
+        this.workingDir = config.workingDir;
+        this.onSpeak = config.onSpeak;
+        this.onStateChange = config.onStateChange;
+        this.state = {
+            conversationHistory: [],
+            userGoal: null,
+            userGoalConfidence: 0,
+            pendingResearch: [],
+            completedResearch: [],
+            readyToExecute: false,
+            executionPlan: null,
+        };
+    }
+    /**
+     * Process user input and decide what to do
+     */
+    async processUserInput(input) {
+        // Add to conversation history
+        this.state.conversationHistory.push({
+            role: 'user',
+            content: input,
+            timestamp: new Date(),
+        });
+        // Build the analysis prompt
+        const prompt = this.buildAnalysisPrompt(input);
+        let stream = null;
+        let streamError = null;
+        try {
+            // Call Gemini 2.5 Pro for decision
+            const chatCtx = new llm.ChatContext();
+            chatCtx.addMessage({ role: 'user', content: prompt });
+            let response = '';
+            stream = this.llm.chat({ chatCtx });
+            // Create a promise that wraps the stream iteration with proper error handling
+            const collectResponse = async () => {
+                let result = '';
+                try {
+                    for await (const chunk of stream) {
+                        if (chunk.delta?.content) {
+                            result += chunk.delta.content;
+                        }
+                    }
+                }
+                catch (e) {
+                    streamError = e;
+                    throw e;
+                }
+                return result;
+            };
+            // Race the stream against a timeout to prevent hanging
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Brain timeout after 30s')), 30000);
+            });
+            response = await Promise.race([collectResponse(), timeoutPromise]);
+            // Parse the decision
+            const decision = this.parseDecision(response);
+            // Update state based on decision
+            this.updateState(decision);
+            // Add assistant response to history
+            if (decision.speech) {
+                this.state.conversationHistory.push({
+                    role: 'assistant',
+                    content: decision.speech,
+                    timestamp: new Date(),
+                });
+            }
+            return decision;
+        }
+        catch (err) {
+            const errorMsg = err.message || String(err);
+            // Only log if not an abort (which is expected when user interrupts)
+            if (!errorMsg.includes('aborted')) {
+                console.error('🧠 [Brain] Stream error:', errorMsg);
+            }
+            // Close stream if it exists to prevent further errors
+            if (stream) {
+                try {
+                    stream.close();
+                }
+                catch { }
+            }
+            return {
+                action: 'speak',
+                speech: "I'm having trouble processing that. Could you try again?",
+            };
+        }
+    }
+    /**
+     * Receive research results from background agents
+     */
+    receiveResearchResult(taskId, result, success) {
+        const task = this.state.pendingResearch.find(t => t.id === taskId);
+        if (task) {
+            task.status = success ? 'completed' : 'failed';
+            task.result = result;
+            task.completedAt = new Date();
+            // Move to completed
+            this.state.pendingResearch = this.state.pendingResearch.filter(t => t.id !== taskId);
+            this.state.completedResearch.push(task);
+            console.log(`🧠 Research completed: ${taskId.substring(0, 8)}... (${this.state.completedResearch.length} done)`);
+        }
+    }
+    /**
+     * Check if we should provide a status update
+     */
+    shouldProvideUpdate() {
+        // Provide update if research just completed
+        return this.state.completedResearch.length > 0 &&
+            this.state.pendingResearch.length === 0 &&
+            !this.state.readyToExecute;
+    }
+    /**
+     * Generate a status update based on completed research
+     */
+    async generateStatusUpdate() {
+        if (this.state.completedResearch.length === 0)
+            return null;
+        const researchSummary = this.state.completedResearch
+            .map(r => `- ${r.query}: ${r.result?.substring(0, 200) || 'No result'}`)
+            .join('\n');
+        const prompt = `Based on completed research, provide a brief conversational status update.
+
+RESEARCH RESULTS:
+${researchSummary}
+
+USER GOAL (so far): ${this.state.userGoal || 'Still understanding...'}
+
+Generate a 1-2 sentence update that:
+1. Summarizes what you learned
+2. Either asks a clarifying question OR proposes next steps
+3. Sounds natural and conversational
+
+Just the update text, no JSON.`;
+        let stream = null;
+        try {
+            const chatCtx = new llm.ChatContext();
+            chatCtx.addMessage({ role: 'user', content: prompt });
+            let response = '';
+            stream = this.llm.chat({ chatCtx });
+            for await (const chunk of stream) {
+                if (chunk.delta?.content) {
+                    response += chunk.delta.content;
+                }
+            }
+            return response.trim();
+        }
+        catch (err) {
+            console.error('🧠 [Brain] Status update error:', err.message || err);
+            if (stream) {
+                try {
+                    stream.close();
+                }
+                catch { }
+            }
+            return null;
+        }
+    }
+    /**
+     * Get current state for debugging/display
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Reset conversation state
+     */
+    reset() {
+        this.state = {
+            conversationHistory: [],
+            userGoal: null,
+            userGoalConfidence: 0,
+            pendingResearch: [],
+            completedResearch: [],
+            readyToExecute: false,
+            executionPlan: null,
+        };
+    }
+    // ============================================================
+    // Private Methods
+    // ============================================================
+    buildAnalysisPrompt(userInput) {
+        const recentHistory = this.state.conversationHistory.slice(-6)
+            .map(m => `${m.role.toUpperCase()}: ${m.content}`)
+            .join('\n');
+        const researchContext = this.state.completedResearch.length > 0
+            ? `\nCOMPLETED RESEARCH:\n${this.state.completedResearch.map(r => `- ${r.query}: ${r.result?.substring(0, 300)}`).join('\n')}`
+            : '';
+        const pendingContext = this.state.pendingResearch.length > 0
+            ? `\nPENDING RESEARCH: ${this.state.pendingResearch.map(r => r.query).join(', ')}`
+            : '';
+        return `You are the brain of a voice AI coding assistant. Analyze this input and decide what to do.
+
+WORKING DIRECTORY: ${this.workingDir}
+
+CAPABILITIES:
+- Full internet access (web search, fetch URLs, API calls)
+- Read/write files in the working directory
+- Run shell commands (npm, git, etc.)
+- Search and analyze codebases
+
+CONVERSATION HISTORY:
+${recentHistory}
+
+CURRENT USER INPUT: "${userInput}"
+
+CURRENT UNDERSTANDING:
+- User Goal: ${this.state.userGoal || 'Unknown - still gathering context'}
+- Confidence: ${Math.round(this.state.userGoalConfidence * 100)}%
+- Ready to Execute: ${this.state.readyToExecute}
+${researchContext}
+${pendingContext}
+
+DECIDE WHAT TO DO:
+
+1. DIRECT_COMMAND - If user gives a simple, clear command:
+   - "read file X" → direct_command
+   - "run npm test" → direct_command
+   - "show me the package.json" → direct_command
+   - "search the web for X" → direct_command
+   - "look up X online" → direct_command
+
+2. CLARIFY - If request is ambiguous, ask a specific question to understand better
+
+3. RESEARCH - If we need more info, start background research (2-3 queries max)
+   - Search codebase, read docs, explore files
+   - Search the web for information
+   - Keep conversation going while research runs
+
+4. EXECUTE - ONLY if we have HIGH confidence (>80%) about what user wants
+   - Must have clear plan
+   - Only ONE execution task at a time
+
+5. SPEAK - Just respond conversationally (greetings, status, etc.)
+
+IMPORTANT: Keep speech SHORT and conversational. No markdown formatting.
+
+Respond in JSON:
+{
+  "action": "speak" | "research" | "execute" | "clarify" | "direct_command",
+  "speech": "What to say to user RIGHT NOW (keep it short, conversational, NO markdown)",
+  "researchQueries": ["query1", "query2"],  // Only if action=research
+  "executeTask": "detailed task description",  // Only if action=execute
+  "directCommand": "simple command to run",  // Only if action=direct_command
+  "updatedGoal": "What we think user wants now",
+  "goalConfidence": 0.0-1.0,
+  "reasoning": "Brief explanation"
+}`;
+    }
+    parseDecision(response) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return {
+                    action: 'speak',
+                    speech: response.substring(0, 200),
+                };
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            // Update goal tracking
+            if (parsed.updatedGoal) {
+                this.state.userGoal = parsed.updatedGoal;
+            }
+            if (typeof parsed.goalConfidence === 'number') {
+                this.state.userGoalConfidence = parsed.goalConfidence;
+            }
+            return {
+                action: parsed.action || 'speak',
+                speech: parsed.speech,
+                researchQueries: parsed.researchQueries,
+                executeTask: parsed.executeTask,
+                directCommand: parsed.directCommand,
+                reasoning: parsed.reasoning,
+            };
+        }
+        catch (err) {
+            console.error('Failed to parse brain decision:', err);
+            return {
+                action: 'speak',
+                speech: "Let me think about that...",
+            };
+        }
+    }
+    updateState(decision) {
+        // Track research tasks
+        if (decision.action === 'research' && decision.researchQueries) {
+            for (const query of decision.researchQueries) {
+                this.state.pendingResearch.push({
+                    id: `research-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+                    query,
+                    status: 'pending',
+                });
+            }
+        }
+        // Mark ready to execute
+        if (decision.action === 'execute') {
+            this.state.readyToExecute = true;
+            this.state.executionPlan = decision.executeTask || null;
+        }
+    }
+    /**
+     * Create research tasks for background agents
+     */
+    getPendingResearchTasks() {
+        return this.state.pendingResearch.filter(t => t.status === 'pending');
+    }
+    /**
+     * Mark a research task as running
+     */
+    markResearchRunning(taskId) {
+        const task = this.state.pendingResearch.find(t => t.id === taskId);
+        if (task) {
+            task.status = 'running';
+            task.startedAt = new Date();
+        }
+    }
+}
+// ============================================================
+// Factory function
+// ============================================================
+export function createConversationBrain(config) {
+    return new ConversationBrain(config);
+}

package/dist/fast-llm.d.ts

@@ -0,0 +1,15 @@
+interface AcknowledgmentResult {
+    acknowledgment: string;
+    isCodingTask: boolean;
+    intent: 'code' | 'chat' | 'question' | 'permission';
+}
+/**
+ * Fast LLM for immediate acknowledgment and intent classification
+ * Target: < 200ms response time
+ */
+export declare function getAcknowledgment(userInput: string): Promise<AcknowledgmentResult>;
+/**
+ * Summarize Claude's response for voice output
+ */
+export declare function summarizeForVoice(claudeResponse: string): Promise<string>;
+export {};

package/dist/fast-llm.js

@@ -0,0 +1,81 @@
+import Groq from 'groq-sdk';
+const groq = new Groq({
+    apiKey: process.env.GROQ_API_KEY,
+});
+/**
+ * Fast LLM for immediate acknowledgment and intent classification
+ * Target: < 200ms response time
+ */
+export async function getAcknowledgment(userInput) {
+    const response = await groq.chat.completions.create({
+        model: 'llama-3.3-70b-versatile', // Fast model
+        messages: [
+            {
+                role: 'system',
+                content: `You are Osborn, a voice-enabled coding assistant. Classify user requests:
+
+CODING TASKS (isCodingTask: true) - Anything involving:
+- Files: read, write, create, edit, list, find, search
+- Directories: what directory, current folder, list files, project structure
+- Code: fix bugs, refactor, explain code, run tests
+- Terminal: run commands, install packages, git operations
+- Project: what's in this project, show me files, analyze codebase
+
+NOT CODING (isCodingTask: false):
+- General chat: hi, how are you, tell me a joke
+- Off-topic: weather, news, recipes
+- Permission responses: yes, no, approve, deny
+
+Respond in JSON:
+{
+  "acknowledgment": "brief friendly response",
+  "isCodingTask": true/false,
+  "intent": "code|chat|question|permission"
+}
+
+Examples:
+- "What directory are we in?" → {"acknowledgment": "Let me check", "isCodingTask": true, "intent": "code"}
+- "What files are in this project?" → {"acknowledgment": "I'll list them", "isCodingTask": true, "intent": "code"}
+- "Read package.json" → {"acknowledgment": "On it", "isCodingTask": true, "intent": "code"}
+- "Fix the bug" → {"acknowledgment": "Let me look", "isCodingTask": true, "intent": "code"}
+- "Hello" → {"acknowledgment": "Hi there!", "isCodingTask": false, "intent": "chat"}
+- "Yes, do it" → {"acknowledgment": "Got it", "isCodingTask": false, "intent": "permission"}`,
+            },
+            {
+                role: 'user',
+                content: userInput,
+            },
+        ],
+        temperature: 0.3,
+        max_tokens: 150,
+        response_format: { type: 'json_object' },
+    });
+    const content = response.choices[0]?.message?.content || '{}';
+    return JSON.parse(content);
+}
+/**
+ * Summarize Claude's response for voice output
+ */
+export async function summarizeForVoice(claudeResponse) {
+    if (claudeResponse.length < 200) {
+        return claudeResponse;
+    }
+    const response = await groq.chat.completions.create({
+        model: 'llama-3.3-70b-versatile',
+        messages: [
+            {
+                role: 'system',
+                content: `Summarize this coding assistant response for voice output.
+Keep it under 2 sentences. Focus on what was done and the result.
+Don't include code - just describe what happened.`,
+            },
+            {
+                role: 'user',
+                content: claudeResponse,
+            },
+        ],
+        temperature: 0.3,
+        max_tokens: 100,
+    });
+    return response.choices[0]?.message?.content || claudeResponse;
+}