discoclaw 0.2.4 → 0.3.0

package/dist/runtime/openai-compat.js

@@ -1,3 +1,30 @@
+import { buildToolSchemas, OPENAI_TO_DISCO_NAME } from './openai-tool-schemas.js';
+import { executeToolCall } from './openai-tool-exec.js';
+const TOOL_LOOP_CAP = 25;
+const SYSTEM_SENTINEL = '---\nThe sections above are internal system context.';
+/**
+ * Split a combined prompt into system + user messages.
+ * If `params.systemPrompt` is explicitly set, use that directly.
+ * Otherwise, auto-detect by scanning for the sentinel delimiter.
+ */
+export function splitSystemPrompt(params) {
+    if (params.systemPrompt) {
+        return { system: params.systemPrompt, user: params.prompt };
+    }
+    const idx = params.prompt.indexOf(SYSTEM_SENTINEL);
+    if (idx === -1) {
+        return { system: undefined, user: params.prompt };
+    }
+    const splitPoint = idx + SYSTEM_SENTINEL.length;
+    // Skip a single trailing newline after the sentinel if present
+    const afterSentinel = splitPoint < params.prompt.length && params.prompt[splitPoint] === '\n'
+        ? splitPoint + 1
+        : splitPoint;
+    return {
+        system: params.prompt.slice(0, splitPoint),
+        user: params.prompt.slice(afterSentinel),
+    };
+}
 /**
  * Returns true for models that require `max_completion_tokens` instead of `max_tokens`.
  * Strips any provider namespace (e.g. "openai/") before matching.
@@ -20,7 +47,41 @@ function parseSSEData(line) {
     return undefined;
 }
 export function createOpenAICompatRuntime(opts) {
-    const capabilities = new Set(['streaming_text']);
+    const caps = ['streaming_text'];
+    if (opts.enableTools) {
+        caps.push('tools_fs', 'tools_exec');
+    }
+    const capabilities = new Set(caps);
+    /** Shared fetch with OAuth 401 retry logic. Used by both streaming and tool-loop paths. */
+    async function fetchWithAuth(url, body, signal) {
+        let bearerToken = opts.auth === 'chatgpt_oauth'
+            ? await opts.tokenProvider.getAccessToken()
+            : opts.apiKey;
+        let response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            body,
+            signal,
+        });
+        // On 401 with OAuth, force-refresh the token and retry once
+        if (!response.ok && response.status === 401 && opts.auth === 'chatgpt_oauth') {
+            opts.log?.debug('openai-compat: 401 received, force-refreshing OAuth token');
+            bearerToken = await opts.tokenProvider.getAccessToken(true);
+            response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${bearerToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body,
+                signal,
+            });
+        }
+        return response;
+    }
     return {
         id: opts.id ?? 'openai',
         capabilities,
@@ -34,12 +95,10 @@ export function createOpenAICompatRuntime(opts) {
                         ? { max_completion_tokens: params.maxTokens }
                         : { max_tokens: params.maxTokens })
                     : {};
-                const body = JSON.stringify({
-                    model,
-                    messages: [{ role: 'user', content: params.prompt }],
-                    stream: true,
-                    ...tokenField,
-                });
+                // Determine whether to enter the tool loop
+                const toolsRequested = opts.enableTools && params.tools && params.tools.length > 0;
+                const toolSchemas = toolsRequested ? buildToolSchemas(params.tools) : [];
+                const useTools = toolSchemas.length > 0;
                 const controller = new AbortController();
                 let timer;
                 if (params.timeoutMs) {
@@ -50,83 +109,169 @@ export function createOpenAICompatRuntime(opts) {
                 params.signal?.addEventListener('abort', onCallerAbort, { once: true });
                 if (params.signal?.aborted)
                     controller.abort();
-                let accumulated = '';
+                const { system: sysContent, user: userContent } = splitSystemPrompt(params);
                 try {
                     opts.log?.debug({ url, model }, 'openai-compat: request');
-                    // Resolve bearer token: static key or dynamic OAuth
-                    let bearerToken = opts.auth === 'chatgpt_oauth'
-                        ? await opts.tokenProvider.getAccessToken()
-                        : opts.apiKey;
-                    let response = await fetch(url, {
-                        method: 'POST',
-                        headers: {
-                            'Authorization': `Bearer ${bearerToken}`,
-                            'Content-Type': 'application/json',
-                        },
-                        body,
-                        signal: controller.signal,
-                    });
-                    // On 401 with OAuth, force-refresh the token and retry once
-                    if (!response.ok && response.status === 401 && opts.auth === 'chatgpt_oauth') {
-                        opts.log?.debug('openai-compat: 401 received, force-refreshing OAuth token');
-                        bearerToken = await opts.tokenProvider.getAccessToken(true);
-                        response = await fetch(url, {
-                            method: 'POST',
-                            headers: {
-                                'Authorization': `Bearer ${bearerToken}`,
-                                'Content-Type': 'application/json',
-                            },
-                            body,
-                            signal: controller.signal,
-                        });
-                    }
-                    if (!response.ok) {
-                        yield { type: 'error', message: `OpenAI API error: ${response.status} ${response.statusText}` };
-                        yield { type: 'done' };
-                        return;
-                    }
-                    if (!response.body) {
-                        yield { type: 'error', message: 'OpenAI API returned no response body' };
+                    if (useTools) {
+                        // ── Tool-loop path (non-streaming rounds) ──────────────────
+                        const allowedRoots = [params.cwd, ...(params.addDirs ?? [])].filter(s => s !== '');
+                        const messages = [];
+                        if (sysContent)
+                            messages.push({ role: 'system', content: sysContent });
+                        messages.push({ role: 'user', content: userContent });
+                        for (let round = 0; round < TOOL_LOOP_CAP; round++) {
+                            const body = JSON.stringify({
+                                model,
+                                messages,
+                                stream: false,
+                                tools: toolSchemas,
+                                ...tokenField,
+                            });
+                            const response = await fetchWithAuth(url, body, controller.signal);
+                            if (!response.ok) {
+                                let detail = '';
+                                try {
+                                    const errBody = await response.json();
+                                    detail = `: ${JSON.stringify(errBody.error ?? errBody)}`;
+                                }
+                                catch { /* ignore */ }
+                                yield { type: 'error', message: `OpenAI API error: ${response.status} ${response.statusText}${detail}` };
+                                yield { type: 'done' };
+                                return;
+                            }
+                            const json = await response.json();
+                            const choice = json.choices?.[0];
+                            const assistantMsg = choice?.message;
+                            if (!assistantMsg) {
+                                yield { type: 'error', message: 'No response from model' };
+                                yield { type: 'done' };
+                                return;
+                            }
+                            const toolCalls = assistantMsg.tool_calls;
+                            if (!toolCalls || toolCalls.length === 0) {
+                                // Model returned a final text response — emit and exit
+                                const content = assistantMsg.content ?? '';
+                                if (content)
+                                    yield { type: 'text_delta', text: content };
+                                yield { type: 'text_final', text: content };
+                                yield { type: 'done' };
+                                return;
+                            }
+                            // Append the assistant message (with tool_calls) to the conversation
+                            messages.push(assistantMsg);
+                            // Execute each tool call
+                            for (const tc of toolCalls) {
+                                const fnName = tc.function?.name ?? '';
+                                const tcId = tc.id;
+                                const discoName = OPENAI_TO_DISCO_NAME[fnName] ?? fnName;
+                                let args;
+                                try {
+                                    args = JSON.parse(tc.function?.arguments ?? '{}');
+                                }
+                                catch {
+                                    // Malformed JSON — feed error back to model instead of crashing
+                                    yield { type: 'tool_start', name: discoName, input: tc.function?.arguments };
+                                    yield { type: 'tool_end', name: discoName, output: 'Malformed JSON in tool call arguments', ok: false };
+                                    messages.push({
+                                        role: 'tool',
+                                        tool_call_id: tcId ?? 'unknown',
+                                        content: 'Malformed JSON in tool call arguments',
+                                    });
+                                    continue;
+                                }
+                                yield { type: 'tool_start', name: discoName, input: args };
+                                const result = await executeToolCall(fnName, args, allowedRoots);
+                                yield { type: 'tool_end', name: discoName, output: result.result, ok: result.ok };
+                                messages.push({
+                                    role: 'tool',
+                                    tool_call_id: tcId ?? 'unknown',
+                                    content: result.result,
+                                });
+                            }
+                        }
+                        // Safety cap reached
+                        yield { type: 'error', message: 'Tool loop safety cap reached (25 iterations)' };
                         yield { type: 'done' };
-                        return;
                     }
-                    const reader = response.body.getReader();
-                    const decoder = new TextDecoder();
-                    let buffer = '';
-                    // Process a single SSE line, returning 'done' if [DONE] sentinel was hit
-                    const processLine = function* (line) {
-                        const data = parseSSEData(line);
-                        if (data === undefined)
-                            return false;
-                        if (data === '[DONE]') {
-                            yield { type: 'text_final', text: accumulated };
+                    else {
+                        // ── Streaming text path (no tools) ─────────────────────────
+                        const streamMessages = [];
+                        if (sysContent)
+                            streamMessages.push({ role: 'system', content: sysContent });
+                        streamMessages.push({ role: 'user', content: userContent });
+                        const body = JSON.stringify({
+                            model,
+                            messages: streamMessages,
+                            stream: true,
+                            ...tokenField,
+                        });
+                        let accumulated = '';
+                        const response = await fetchWithAuth(url, body, controller.signal);
+                        if (!response.ok) {
+                            let detail = '';
+                            try {
+                                const errBody = await response.json();
+                                detail = `: ${JSON.stringify(errBody.error ?? errBody)}`;
+                            }
+                            catch { /* ignore */ }
+                            yield { type: 'error', message: `OpenAI API error: ${response.status} ${response.statusText}${detail}` };
                             yield { type: 'done' };
-                            return true;
+                            return;
                         }
-                        try {
-                            const parsed = JSON.parse(data);
-                            const content = parsed?.choices?.[0]?.delta?.content;
-                            if (content) {
-                                accumulated += content;
-                                yield { type: 'text_delta', text: content };
-                            }
+                        if (!response.body) {
+                            yield { type: 'error', message: 'OpenAI API returned no response body' };
+                            yield { type: 'done' };
+                            return;
                         }
-                        catch {
-                            // Skip unparseable lines
+                        const reader = response.body.getReader();
+                        const decoder = new TextDecoder();
+                        let buffer = '';
+                        // Process a single SSE line, returning 'done' if [DONE] sentinel was hit
+                        const processLine = function* (line) {
+                            const data = parseSSEData(line);
+                            if (data === undefined)
+                                return false;
+                            if (data === '[DONE]') {
+                                yield { type: 'text_final', text: accumulated };
+                                yield { type: 'done' };
+                                return true;
+                            }
+                            try {
+                                const parsed = JSON.parse(data);
+                                const content = parsed?.choices?.[0]?.delta?.content;
+                                if (content) {
+                                    accumulated += content;
+                                    yield { type: 'text_delta', text: content };
+                                }
+                            }
+                            catch {
+                                // Skip unparseable lines
+                            }
+                            return false;
+                        };
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            buffer += decoder.decode(value, { stream: true });
+                            // Process complete lines
+                            const lines = buffer.split('\n');
+                            // Keep the last (possibly incomplete) line in the buffer
+                            buffer = lines.pop() ?? '';
+                            for (const line of lines) {
+                                const result = processLine(line);
+                                let step = result.next();
+                                while (!step.done) {
+                                    yield step.value;
+                                    step = result.next();
+                                }
+                                if (step.value)
+                                    return; // [DONE] hit
+                            }
                         }
-                        return false;
-                    };
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        buffer += decoder.decode(value, { stream: true });
-                        // Process complete lines
-                        const lines = buffer.split('\n');
-                        // Keep the last (possibly incomplete) line in the buffer
-                        buffer = lines.pop() ?? '';
-                        for (const line of lines) {
-                            const result = processLine(line);
+                        // Process any remaining buffered content (stream ended without trailing newline)
+                        if (buffer.trim()) {
+                            const result = processLine(buffer);
                             let step = result.next();
                             while (!step.done) {
                                 yield step.value;
@@ -135,21 +280,10 @@ export function createOpenAICompatRuntime(opts) {
                             if (step.value)
                                 return; // [DONE] hit
                         }
+                        // Stream ended without [DONE] — emit what we have
+                        yield { type: 'text_final', text: accumulated };
+                        yield { type: 'done' };
                     }
-                    // Process any remaining buffered content (stream ended without trailing newline)
-                    if (buffer.trim()) {
-                        const result = processLine(buffer);
-                        let step = result.next();
-                        while (!step.done) {
-                            yield step.value;
-                            step = result.next();
-                        }
-                        if (step.value)
-                            return; // [DONE] hit
-                    }
-                    // Stream ended without [DONE] — emit what we have
-                    yield { type: 'text_final', text: accumulated };
-                    yield { type: 'done' };
                 }
                 catch (err) {
                     if (timer)