tuna-agent 0.1.36 → 0.1.38

package/dist/daemon/extension-handlers.d.ts

@@ -26,8 +26,8 @@ export interface VideoRecord {
     aspectRatio?: string;
 }
 export declare function handleGetHistory(ws: AgentWebSocketClient, code: string, taskId: string): void;
-export declare function handleGenerateIdeas(ws: AgentWebSocketClient, code: string, taskId: string, topic: string, styleName?: string, styleDesc?: string, language?: string, count?: number, ideasInstruction?: string): Promise<void>;
-export declare function handleGenerateScript(ws: AgentWebSocketClient, code: string, taskId: string, idea: string, topic: string, style?: string, duration?: number, language?: string, styleName?: string, styleGuidance?: string): Promise<void>;
+export declare function handleGenerateIdeas(ws: AgentWebSocketClient, code: string, taskId: string, topic: string, styleName?: string, styleDesc?: string, language?: string, count?: number, ideasInstruction?: string, provider?: string): Promise<void>;
+export declare function handleGenerateScript(ws: AgentWebSocketClient, code: string, taskId: string, idea: string, topic: string, style?: string, duration?: number, language?: string, styleName?: string, styleGuidance?: string, provider?: string): Promise<void>;
 export declare function handleRetryVideo(ws: AgentWebSocketClient, code: string, taskId: string, videoId: string): void;
 export declare function handleGenerateScene(ws: AgentWebSocketClient, code: string, taskId: string, sceneIdx: number, prompt: string, aspectRatio: string): Promise<void>;
 export declare function handleGenerateScenes(ws: AgentWebSocketClient, code: string, taskId: string, scenes: Array<{

package/dist/daemon/extension-handlers.js

@@ -15,6 +15,7 @@ import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { pipeline } from 'stream/promises';
 import { runClaude } from '../utils/claude-cli.js';
+import { runOpenAI } from '../utils/openai-api.js';
 const execFileAsync = promisify(execFile);
 // ─── Storage ──────────────────────────────────────────────────────────────────
 const VIDEOS_DIR = path.join(os.homedir(), '.tuna-content', 'videos');
@@ -64,8 +65,9 @@ function hasContentCreator() {
     }
 }
 // ─── Handler: generate_ideas ──────────────────────────────────────────────────
-export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, styleDesc, language, count, ideasInstruction) {
-    if (!hasContentCreator()) {
+export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, styleDesc, language, count, ideasInstruction, provider) {
+    console.log(`[generate_ideas] Received: topic="${topic}" count=${count} provider=${provider || 'claude-cli'} ideasInstruction=${ideasInstruction ? ideasInstruction.length + ' chars' : '(none)'} styleName=${styleName || '(none)'}`);
+    if (provider !== 'openai' && !hasContentCreator()) {
         const error = 'content-creator agent not found on this machine';
         console.error(`[generate_ideas] ${error}`);
         ws.sendExtensionEvent(code, { type: 'ideas_result', ideas: [], error });
@@ -108,21 +110,30 @@ export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, st
         `Example format: ["title 1","title 2","title 3","title 4","title 5"]`,
     ].join('\n');
     try {
-        const result = await runClaude({
-            prompt,
-            systemPrompt,
-            cwd: CONTENT_CREATOR_DIR,
-            maxTurns: 1,
-            outputFormat: 'json',
-            timeoutMs: 60000,
-        });
+        let resultText;
+        if (provider === 'openai') {
+            console.log(`[generate_ideas] Using OpenAI provider`);
+            const oaiResult = await runOpenAI({ prompt, systemPrompt, timeoutMs: 60000 });
+            resultText = oaiResult.result;
+        }
+        else {
+            const result = await runClaude({
+                prompt,
+                systemPrompt,
+                cwd: CONTENT_CREATOR_DIR,
+                maxTurns: 1,
+                outputFormat: 'json',
+                timeoutMs: 60000,
+            });
+            resultText = result.result;
+        }
         let ideas = [];
         try {
-            // Try all JSON arrays in the response and pick the one with 5 items
+            // Try all JSON arrays in the response and pick the one closest to n items
             const arrays = [];
             const re = /\[(?:[^\[\]]*(?:"(?:[^"\\]|\\.)*"[^\[\]]*)*)\]/g;
             let m;
-            while ((m = re.exec(result.result)) !== null) {
+            while ((m = re.exec(resultText)) !== null) {
                 try {
                     const parsed = JSON.parse(m[0]);
                     if (Array.isArray(parsed) && parsed.every(i => typeof i === 'string')) {
@@ -139,7 +150,7 @@ export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, st
         catch { /* fall through to fallback */ }
         // Fallback: split numbered/bulleted lines
         if (ideas.length === 0) {
-            ideas = result.result
+            ideas = resultText
                 .split('\n')
                 .map(l => l.replace(/^[\d\-\*\.\)\s]+/, '').replace(/^[""]|[""]$/g, '').trim())
                 .filter(l => l.length > 10 && !l.startsWith('[') && !l.toLowerCase().includes('json'))
@@ -167,8 +178,9 @@ export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, st
 //   2. Run `claude -p <prompt> --append-system-prompt <template>` in lightweight mode
 //   3. Stream text deltas back to extension
 //   4. Return full script on completion
-export async function handleGenerateScript(ws, code, taskId, idea, topic, style, duration, language, styleName, styleGuidance) {
-    if (!hasContentCreator()) {
+export async function handleGenerateScript(ws, code, taskId, idea, topic, style, duration, language, styleName, styleGuidance, provider) {
+    console.log(`[generate_script] provider=${provider || 'claude-cli'}`);
+    if (provider !== 'openai' && !hasContentCreator()) {
         const error = 'content-creator agent not found on this machine';
         console.error(`[generate_script] ${error}`);
         ws.sendExtensionDone(code, taskId, { error });
@@ -221,58 +233,76 @@ export async function handleGenerateScript(ws, code, taskId, idea, topic, style,
     const systemPrompt = expandedTemplate + styleContext + (characterContext
         ? `\n\n## AVAILABLE CHARACTERS\n${characterContext}`
         : '');
+    const userPrompt = `Viết script video theo hướng dẫn trên.\n\nIdea: ${idea}\nStyle: ${resolvedStyle}\nClips: ${Math.round(resolvedDuration / 8)} (each exactly 8s, total ~${resolvedDuration}s)\nLanguage: ${resolvedLanguage}`;
     try {
-        let streamChunks = 0;
-        let sentTextLen = 0; // track how much text we've already streamed
-        const result = await runClaude({
-            prompt: `Viết script video theo hướng dẫn trên.\n\nIdea: ${idea}\nStyle: ${resolvedStyle}\nClips: ${Math.round(resolvedDuration / 8)} (each exactly 8s, total ~${resolvedDuration}s)\nLanguage: ${resolvedLanguage}`,
-            systemPrompt,
-            cwd: CONTENT_CREATOR_DIR,
-            maxTurns: 4,
-            outputFormat: 'stream-json',
-            includePartialMessages: true,
-            timeoutMs: 180000,
-            onStreamLine: (data) => {
-                if (streamChunks < 5) {
-                    const sub = data.subtype || '';
-                    console.log(`[generate_script] stream #${streamChunks}: type=${data.type} sub=${sub}`);
-                }
-                streamChunks++;
-                // stream_event: raw API events (token-level deltas) — fast, smooth streaming
-                if (data.type === 'stream_event') {
-                    const evt = data.event;
-                    if (evt?.type === 'content_block_delta') {
-                        const delta = evt.delta;
-                        if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
-                            sentTextLen += delta.text.length;
-                            ws.sendExtensionStream(code, taskId, delta.text);
-                        }
+        if (provider === 'openai') {
+            console.log(`[generate_script] Using OpenAI provider (streaming)`);
+            let sentTextLen = 0;
+            const oaiResult = await runOpenAI({
+                prompt: userPrompt,
+                systemPrompt,
+                timeoutMs: 180000,
+                stream: true,
+                onChunk: (chunk) => {
+                    sentTextLen += chunk.length;
+                    ws.sendExtensionStream(code, taskId, chunk);
+                },
+            });
+            console.log(`[generate_script] OpenAI done: streamed=${sentTextLen} chars`);
+            const scriptText = oaiResult.result;
+            ws.sendExtensionDone(code, taskId, { script: scriptText, text: scriptText });
+        }
+        else {
+            let streamChunks = 0;
+            let sentTextLen = 0;
+            const result = await runClaude({
+                prompt: userPrompt,
+                systemPrompt,
+                cwd: CONTENT_CREATOR_DIR,
+                maxTurns: 4,
+                outputFormat: 'stream-json',
+                includePartialMessages: true,
+                timeoutMs: 180000,
+                onStreamLine: (data) => {
+                    if (streamChunks < 5) {
+                        const sub = data.subtype || '';
+                        console.log(`[generate_script] stream #${streamChunks}: type=${data.type} sub=${sub}`);
                     }
-                    return;
-                }
-                // assistant: partial message snapshots (fallback for coarser updates)
-                if (data.type === 'assistant') {
-                    const msg = data.message;
-                    const content = (msg?.content ?? data.content);
-                    if (Array.isArray(content)) {
-                        let fullText = '';
-                        for (const block of content) {
-                            if (block.type === 'text' && typeof block.text === 'string') {
-                                fullText += block.text;
+                    streamChunks++;
+                    if (data.type === 'stream_event') {
+                        const evt = data.event;
+                        if (evt?.type === 'content_block_delta') {
+                            const delta = evt.delta;
+                            if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                                sentTextLen += delta.text.length;
+                                ws.sendExtensionStream(code, taskId, delta.text);
                             }
                         }
-                        if (fullText.length > sentTextLen) {
-                            const delta = fullText.slice(sentTextLen);
-                            sentTextLen = fullText.length;
-                            ws.sendExtensionStream(code, taskId, delta);
+                        return;
+                    }
+                    if (data.type === 'assistant') {
+                        const msg = data.message;
+                        const content = (msg?.content ?? data.content);
+                        if (Array.isArray(content)) {
+                            let fullText = '';
+                            for (const block of content) {
+                                if (block.type === 'text' && typeof block.text === 'string') {
+                                    fullText += block.text;
+                                }
+                            }
+                            if (fullText.length > sentTextLen) {
+                                const delta = fullText.slice(sentTextLen);
+                                sentTextLen = fullText.length;
+                                ws.sendExtensionStream(code, taskId, delta);
+                            }
                         }
                     }
-                }
-            },
-        });
-        console.log(`[generate_script] Done: ${streamChunks} chunks, streamed=${sentTextLen} chars, result=${result.result?.length || 0} chars`);
-        const scriptText = result.result;
-        ws.sendExtensionDone(code, taskId, { script: scriptText, text: scriptText });
+                },
+            });
+            console.log(`[generate_script] Done: ${streamChunks} chunks, streamed=${sentTextLen} chars, result=${result.result?.length || 0} chars`);
+            const scriptText = result.result;
+            ws.sendExtensionDone(code, taskId, { script: scriptText, text: scriptText });
+        }
     }
     catch (err) {
         const error = err instanceof Error ? err.message : String(err);

package/dist/daemon/index.js

@@ -367,13 +367,13 @@ ${skillContent.slice(0, 15000)}`;
                 }
                 if (extTask === 'generate_ideas') {
                     (async () => {
-                        await handleGenerateIdeas(ws, extCode, extTaskId, msg.topic, msg.styleName, msg.styleDesc, msg.language, msg.count, msg.ideasInstruction);
+                        await handleGenerateIdeas(ws, extCode, extTaskId, msg.topic, msg.styleName, msg.styleDesc, msg.language, msg.count, msg.ideasInstruction, msg.provider);
                     })();
                     break;
                 }
                 if (extTask === 'generate_script') {
                     (async () => {
-                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style, msg.duration, msg.language, msg.styleName, (msg.scriptInstruction || msg.styleGuidance));
+                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style, msg.duration, msg.language, msg.styleName, (msg.scriptInstruction || msg.styleGuidance), msg.provider);
                     })();
                     break;
                 }

package/dist/utils/openai-api.d.ts

@@ -0,0 +1,19 @@
+export interface OpenAIRequest {
+    prompt: string;
+    systemPrompt?: string;
+    model?: string;
+    maxTokens?: number;
+    timeoutMs?: number;
+    stream?: boolean;
+    onChunk?: (chunk: string) => void;
+}
+export interface OpenAIResult {
+    result: string;
+    model: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export declare function runOpenAI(opts: OpenAIRequest): Promise<OpenAIResult>;

package/dist/utils/openai-api.js

@@ -0,0 +1,94 @@
+// OpenAI API utility — direct fetch, no SDK needed
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY || '';
+const OPENAI_MODEL = process.env.OPENAI_MODEL || 'gpt-4o';
+export async function runOpenAI(opts) {
+    const { prompt, systemPrompt, model = OPENAI_MODEL, maxTokens = 4096, timeoutMs = 120000, stream = false, onChunk, } = opts;
+    if (!OPENAI_API_KEY) {
+        throw new Error('OPENAI_API_KEY environment variable is not set');
+    }
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({ role: 'system', content: systemPrompt });
+    }
+    messages.push({ role: 'user', content: prompt });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        if (stream && onChunk) {
+            return await _streamRequest(messages, model, maxTokens, controller, onChunk);
+        }
+        else {
+            return await _normalRequest(messages, model, maxTokens, controller);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function _normalRequest(messages, model, maxTokens, controller) {
+    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${OPENAI_API_KEY}`,
+        },
+        body: JSON.stringify({ model, messages, max_tokens: maxTokens }),
+        signal: controller.signal,
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`OpenAI API error ${resp.status}: ${body}`);
+    }
+    const data = await resp.json();
+    const choice = data.choices?.[0];
+    return {
+        result: choice?.message?.content || '',
+        model: data.model,
+        usage: data.usage,
+    };
+}
+async function _streamRequest(messages, model, maxTokens, controller, onChunk) {
+    const resp = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${OPENAI_API_KEY}`,
+        },
+        body: JSON.stringify({ model, messages, max_tokens: maxTokens, stream: true }),
+        signal: controller.signal,
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        throw new Error(`OpenAI API error ${resp.status}: ${body}`);
+    }
+    let fullText = '';
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: '))
+                continue;
+            const payload = trimmed.slice(6);
+            if (payload === '[DONE]')
+                continue;
+            try {
+                const parsed = JSON.parse(payload);
+                const delta = parsed.choices?.[0]?.delta?.content;
+                if (delta) {
+                    fullText += delta;
+                    onChunk(delta);
+                }
+            }
+            catch { /* skip parse errors */ }
+        }
+    }
+    return { result: fullText, model };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"