cray-code 1.0.0

package/dist/queryStream.js

@@ -0,0 +1,704 @@
+/**
+ * queryStream.ts — Streaming query engine (async generator pattern).
+ *
+ * Mirrors Claude Code's React pattern: uses `async function*` to yield
+ * QueryEvents that the React/Ink REPL consumes via for-await.
+ *
+ * Also accepts StreamCallbacks for real-time text/thinking streaming
+ * that the UI renders character-by-character.
+ */
+import { findTool } from './Tool.js';
+import { buildToolPool } from './tools.js';
+import { hasPermissionsToUseTool } from './services/permissions.js';
+/**
+ * Streaming query async generator — yields events while also
+ * providing real-time text/thinking through callbacks.
+ *
+ * Usage:
+ *   for await (const event of queryStream(input, callbacks)) {
+ *     // update React state per event type
+ *   }
+ */
+export async function* queryStream(input, cb) {
+    const { prompt, context, systemPrompt, allowedTools, isSubAgent = false, maxTurns = 25 } = input;
+    const messages = [];
+    const { modelConfig } = context;
+    const provider = modelConfig.provider;
+    const model = input.model ?? modelConfig.model;
+    const apiKey = modelConfig.apiKey;
+    if (!apiKey && provider !== 'ollama') {
+        yield { type: 'error', message: 'No API key configured. Run `cray --setup` first.' };
+        yield { type: 'done', messages: [], totalTurns: 0 };
+        return;
+    }
+    const fullSystemPrompt = buildSP(context, systemPrompt, isSubAgent);
+    let toolPool = isSubAgent && allowedTools
+        ? buildToolPool(context.permissionContext).filter((t) => allowedTools.includes(t.name))
+        : buildToolPool(context.permissionContext);
+    let providerTools = convTools(toolPool);
+    // Build conversation from full message history (context persistence)
+    const conversation = historyToConversation(context.messages || [], prompt);
+    let totalIn = 0, totalOut = 0, tc = 0, allowAll = false;
+    while (tc < maxTurns) {
+        tc++;
+        if (context.abortSignal.aborted) {
+            yield { type: 'cancelled', message: 'Cancelled by user.' };
+            break;
+        }
+        context.logDebug(`[Turn ${tc}] ${provider}/${model}`);
+        yield { type: 'request_start', turn: tc, model };
+        let resp;
+        try {
+            resp = await callLLMStreaming({
+                provider,
+                model,
+                apiKey,
+                baseUrl: modelConfig.baseUrl,
+                systemPrompt: fullSystemPrompt,
+                messages: conversation,
+                tools: providerTools,
+                maxTokens: modelConfig.maxTokens,
+                abortSignal: context.abortSignal,
+                cb,
+                turnNumber: tc,
+            });
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                yield { type: 'cancelled', message: 'Cancelled by user.' };
+            }
+            else {
+                yield { type: 'error', message: `LLM call failed: ${err.message}` };
+            }
+            yield { type: 'done', messages, totalTurns: tc };
+            return;
+        }
+        totalIn += resp.usage.inputTokens;
+        totalOut += resp.usage.outputTokens;
+        // Emit thinking done event if we had thinking
+        if (resp.thinking) {
+            yield {
+                type: 'thinking_done',
+                fullText: resp.thinking,
+                elapsed: 0,
+                turn: tc,
+            };
+        }
+        // No tool calls → final response
+        if (!resp.toolCalls || resp.toolCalls.length === 0) {
+            const cont = [];
+            if (resp.thinking)
+                cont.push({ type: 'thinking', thinking: resp.thinking, signature: '' });
+            if (resp.text)
+                cont.push({ type: 'text', text: resp.text });
+            messages.push({
+                role: 'assistant',
+                id: `msg-${Date.now()}-${tc}`,
+                timestamp: Date.now(),
+                model,
+                stopReason: resp.stopReason,
+                usage: { inputTokens: totalIn, outputTokens: totalOut },
+                content: cont,
+            });
+            yield {
+                type: 'turn_end',
+                turn: tc,
+                usage: { inputTokens: totalIn, outputTokens: totalOut },
+                totalInputTokens: totalIn,
+                totalOutputTokens: totalOut,
+            };
+            yield { type: 'done', messages, totalTurns: tc };
+            return;
+        }
+        // Build assistant message with tool calls
+        const aCont = [];
+        if (resp.thinking)
+            aCont.push({ type: 'thinking', thinking: resp.thinking, signature: '' });
+        if (resp.text)
+            aCont.push({ type: 'text', text: resp.text });
+        aCont.push(...resp.toolCalls);
+        messages.push({
+            role: 'assistant',
+            id: `msg-${Date.now()}-${tc}`,
+            timestamp: Date.now(),
+            model,
+            stopReason: 'tool_use',
+            usage: { inputTokens: totalIn, outputTokens: totalOut },
+            content: aCont,
+        });
+        conversation.push({
+            role: 'assistant',
+            content: [
+                ...(resp.text ? [{ type: 'text', text: resp.text }] : []),
+                ...resp.toolCalls.map((t) => ({
+                    type: 'tool_use',
+                    id: t.id,
+                    name: t.name,
+                    input: t.input,
+                })),
+            ],
+        });
+        // Execute tools — yield events
+        const results = [];
+        for (const tu of resp.toolCalls) {
+            if (context.abortSignal.aborted) {
+                yield {
+                    type: 'tool_end',
+                    toolId: tu.id,
+                    toolName: tu.name,
+                    result: 'Cancelled.',
+                    isError: true,
+                    turn: tc,
+                };
+                results.push({ toolUseId: tu.id, content: 'Cancelled.', isError: true });
+                continue;
+            }
+            yield {
+                type: 'tool_start',
+                toolId: tu.id,
+                toolName: tu.name,
+                input: tu.input,
+                turn: tc,
+            };
+            const tool = findTool(toolPool, tu.name);
+            if (!tool) {
+                const m = `Tool "${tu.name}" not found.`;
+                yield {
+                    type: 'tool_end',
+                    toolId: tu.id,
+                    toolName: tu.name,
+                    result: m,
+                    isError: true,
+                    turn: tc,
+                };
+                results.push({ toolUseId: tu.id, content: m, isError: true });
+                continue;
+            }
+            // Permission check
+            const pr = await hasPermissionsToUseTool(tool, tu.input, context.permissionContext);
+            if (pr.behavior === 'deny') {
+                const m = pr.message || 'Denied.';
+                yield {
+                    type: 'tool_end',
+                    toolId: tu.id,
+                    toolName: tu.name,
+                    result: m,
+                    isError: true,
+                    turn: tc,
+                };
+                results.push({ toolUseId: tu.id, content: m, isError: true });
+                continue;
+            }
+            if (pr.behavior === 'ask') {
+                if (allowAll) { /* pass */ }
+                else {
+                    const ans = await resolvePermission(tu.name, pr.message || `Allow ${tu.name}?`);
+                    if (ans === 'deny') {
+                        const m = 'User denied.';
+                        yield { type: 'tool_end', toolId: tu.id, toolName: tu.name, result: m, isError: true, turn: tc };
+                        results.push({ toolUseId: tu.id, content: m, isError: true });
+                        continue;
+                    }
+                    if (ans === 'allowAll')
+                        allowAll = true;
+                }
+            }
+            // Execute tool
+            try {
+                const tCtx = {
+                    ...context,
+                    abortSignal: context.abortSignal,
+                    writeProgress(d) {
+                        // Tool progress can be tracked via optional cb
+                    },
+                };
+                const r = await tool.call(tu.input, tCtx);
+                const c = r.content ?? JSON.stringify(r.data);
+                yield {
+                    type: 'tool_end',
+                    toolId: tu.id,
+                    toolName: tu.name,
+                    result: c,
+                    isError: r.isError ?? false,
+                    newMessages: r.newMessages,
+                    contextModifier: r.contextModifier,
+                    turn: tc,
+                };
+                results.push({ toolUseId: tu.id, content: c, isError: r.isError ?? false });
+                // Process newMessages
+                if (r.newMessages && r.newMessages.length > 0) {
+                    for (const msg of r.newMessages) {
+                        if (msg.role === 'user') {
+                            conversation.push({
+                                role: 'user',
+                                content: typeof msg.content === 'string'
+                                    ? msg.content
+                                    : msg.content.map((bl) => {
+                                        if (bl.type === 'text')
+                                            return { type: 'text', text: bl.text };
+                                        return { type: 'text', text: JSON.stringify(bl) };
+                                    }),
+                            });
+                        }
+                    }
+                }
+                // Apply contextModifier
+                if (r.contextModifier) {
+                    const modified = r.contextModifier(context);
+                    if (modified.permissionContext !== context.permissionContext) {
+                        Object.assign(context.permissionContext, modified.permissionContext);
+                        toolPool = buildToolPool(modified.permissionContext);
+                        providerTools = convTools(toolPool);
+                    }
+                    if (modified.modelConfig !== context.modelConfig) {
+                        Object.assign(context.modelConfig, modified.modelConfig);
+                    }
+                }
+            }
+            catch (err) {
+                yield {
+                    type: 'tool_end',
+                    toolId: tu.id,
+                    toolName: tu.name,
+                    result: `Error: ${err.message}`,
+                    isError: true,
+                    turn: tc,
+                };
+                results.push({ toolUseId: tu.id, content: `Error: ${err.message}`, isError: true });
+            }
+        }
+        conversation.push({
+            role: 'user',
+            content: results.map((r) => ({
+                type: 'tool_result',
+                tool_use_id: r.toolUseId,
+                content: r.content,
+                is_error: r.isError,
+            })),
+        });
+        // Also add tool results as user messages to the local messages array
+        // so they appear in the 'done' event and participate in context persistence.
+        // The API requires tool_result messages to follow assistant messages with tool_use blocks.
+        messages.push({
+            role: 'user',
+            id: `tr-${Date.now()}-${tc}`,
+            timestamp: Date.now(),
+            content: results.map((r) => ({
+                type: 'tool_result',
+                tool_use_id: r.toolUseId,
+                content: r.content,
+                is_error: r.isError,
+            })),
+        });
+        yield {
+            type: 'turn_end',
+            turn: tc,
+            usage: { inputTokens: totalIn, outputTokens: totalOut },
+            totalInputTokens: totalIn,
+            totalOutputTokens: totalOut,
+        };
+    }
+    yield { type: 'done', messages, totalTurns: tc };
+}
+// ─── Permission resolution — bridged from the REPL's askState ─────────
+let permissionResolver = null;
+export function setPermissionResolver(fn) {
+    permissionResolver = fn;
+}
+async function resolvePermission(toolName, message) {
+    if (permissionResolver) {
+        return permissionResolver(toolName, message);
+    }
+    return 'allow'; // Default: allow if no resolver is set (headless mode)
+}
+async function callLLMStreaming(i) {
+    switch (i.provider) {
+        case 'anthropic': return callA(i);
+        case 'ollama': return callO({ ...i, baseUrl: i.baseUrl || 'http://localhost:11434/v1' });
+        case 'openai': return callO({ ...i, baseUrl: i.baseUrl || 'https://api.openai.com/v1' });
+        case 'openrouter': return callO({ ...i, baseUrl: i.baseUrl || 'https://openrouter.ai/api/v1' });
+        case 'deepseek': return callO({ ...i, baseUrl: i.baseUrl || 'https://api.deepseek.com/v1' });
+        default: return callO(i);
+    }
+}
+// ─── Anthropic streaming ────────────────────────────────────────────────
+async function callA(i) {
+    const { model, apiKey, systemPrompt, messages, tools, maxTokens, abortSignal, cb, turnNumber } = i;
+    const body = {
+        model,
+        max_tokens: maxTokens || 8192,
+        stream: true,
+        system: systemPrompt,
+        messages: convAnt(messages),
+        thinking: { type: 'enabled', budget_tokens: 4000 },
+    };
+    if (tools.length) {
+        body.tools = tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema,
+        }));
+    }
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify(body),
+        signal: abortSignal,
+    });
+    if (!res.ok)
+        throw new Error(`API ${res.status}: ${(await res.text()).slice(0, 300)}`);
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error('No stream');
+    const d = new TextDecoder();
+    const tp = [], hp = [], tcs = [];
+    const tbuf = new Map();
+    let it = 0, ot = 0, sr = 'end_turn', b = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        b += d.decode(value, { stream: true });
+        const ls = b.split('\n');
+        b = ls.pop() || '';
+        for (const l of ls) {
+            if (!l.startsWith('data: '))
+                continue;
+            const js = l.slice(6).trim();
+            if (!js || js === '[DONE]')
+                continue;
+            let e;
+            try {
+                e = JSON.parse(js);
+            }
+            catch {
+                continue;
+            }
+            switch (e.type) {
+                case 'message_start':
+                    it = e.message?.usage?.input_tokens ?? 0;
+                    break;
+                case 'content_block_start':
+                    if (e.content_block?.type === 'tool_use') {
+                        tbuf.set(e.content_block.id, { name: e.content_block.name, input: '' });
+                    }
+                    break;
+                case 'content_block_delta':
+                    if (e.delta?.type === 'text_delta') {
+                        tp.push(e.delta.text);
+                        cb.onText(e.delta.text, turnNumber);
+                    }
+                    else if (e.delta?.type === 'thinking_delta') {
+                        hp.push(e.delta.thinking);
+                        cb.onThinking(e.delta.thinking, turnNumber);
+                    }
+                    else if (e.delta?.type === 'input_json_delta') {
+                        const bb = tbuf.get(e.index);
+                        if (bb)
+                            bb.input += e.delta.partial_json;
+                    }
+                    break;
+                case 'content_block_stop': {
+                    const bb = tbuf.get(e.index);
+                    if (bb) {
+                        try {
+                            tcs.push({ type: 'tool_use', id: e.index, name: bb.name, input: JSON.parse(bb.input) });
+                        }
+                        catch {
+                            tcs.push({ type: 'tool_use', id: e.index, name: bb.name, input: { raw: bb.input } });
+                        }
+                        tbuf.delete(e.index);
+                    }
+                    break;
+                }
+                case 'message_delta':
+                    ot = e.usage?.output_tokens ?? ot;
+                    sr = e.delta?.stop_reason ?? sr;
+                    break;
+            }
+        }
+    }
+    return {
+        text: tp.join('') || null,
+        thinking: hp.join('') || null,
+        toolCalls: tcs.length > 0 ? tcs : null,
+        usage: { inputTokens: it, outputTokens: ot },
+        stopReason: sr,
+    };
+}
+// ─── OpenAI-compatible streaming ────────────────────────────────────────
+async function callO(i) {
+    const { model, apiKey, baseUrl, systemPrompt, messages, tools, maxTokens, abortSignal, cb, turnNumber } = i;
+    const oMsgs = [{ role: 'system', content: systemPrompt }, ...convOAI(messages)];
+    const body = {
+        model,
+        messages: oMsgs,
+        max_tokens: maxTokens || 4096,
+        temperature: 0.7,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+    if (tools.length) {
+        body.tools = tools.map((t) => ({
+            type: 'function',
+            function: { name: t.name, description: t.description, parameters: t.input_schema },
+        }));
+        body.tool_choice = 'auto';
+    }
+    const h = { 'Content-Type': 'application/json' };
+    if (baseUrl.includes('openrouter.ai')) {
+        h['Authorization'] = `Bearer ${apiKey}`;
+        h['HTTP-Referer'] = 'https://github.com/cray-code';
+        h['X-Title'] = 'Cray Code';
+    }
+    else if (apiKey) {
+        h['Authorization'] = `Bearer ${apiKey}`;
+    }
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}/chat/completions`, {
+        method: 'POST', headers: h, body: JSON.stringify(body), signal: abortSignal,
+    });
+    if (!res.ok)
+        throw new Error(`API ${res.status}: ${(await res.text()).slice(0, 300)}`);
+    const reader = res.body?.getReader();
+    if (!reader)
+        throw new Error('No stream');
+    const d = new TextDecoder();
+    const tp = [], hp = [], fcs = [];
+    const deltas = new Map();
+    let it = 0, ot = 0, sr = 'stop', b = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        b += d.decode(value, { stream: true });
+        const ls = b.split('\n');
+        b = ls.pop() || '';
+        for (const l of ls) {
+            const dl = l.trim();
+            if (!dl.startsWith('data: '))
+                continue;
+            const js = dl.slice(6);
+            if (!js || js === '[DONE]')
+                continue;
+            let e;
+            try {
+                e = JSON.parse(js);
+            }
+            catch {
+                continue;
+            }
+            const dt = e.choices?.[0]?.delta;
+            if (!dt) {
+                if (e.usage) {
+                    it = e.usage.prompt_tokens ?? 0;
+                    ot = e.usage.completion_tokens ?? 0;
+                }
+                continue;
+            }
+            if (dt.reasoning_content) {
+                hp.push(dt.reasoning_content);
+                cb.onThinking(dt.reasoning_content, turnNumber);
+            }
+            else if (dt.reasoning) {
+                hp.push(dt.reasoning);
+                cb.onThinking(dt.reasoning, turnNumber);
+            }
+            if (dt.content) {
+                tp.push(dt.content);
+                cb.onText(dt.content, turnNumber);
+            }
+            if (dt.tool_calls) {
+                for (const tc of dt.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    const ex = deltas.get(idx) || { id: '', name: '', args: '' };
+                    if (tc.id)
+                        ex.id = tc.id;
+                    if (tc.function?.name)
+                        ex.name = tc.function.name;
+                    if (tc.function?.arguments)
+                        ex.args += tc.function.arguments;
+                    deltas.set(idx, ex);
+                }
+            }
+            if (e.choices?.[0]?.finish_reason)
+                sr = e.choices[0].finish_reason === 'tool_calls' ? 'tool_use' : e.choices[0].finish_reason;
+            if (e.usage) {
+                it = e.usage.prompt_tokens ?? 0;
+                ot = e.usage.completion_tokens ?? 0;
+            }
+        }
+    }
+    for (const [, tc] of deltas) {
+        if (tc.name) {
+            let inp = {};
+            try {
+                inp = JSON.parse(tc.args || '{}');
+            }
+            catch {
+                inp = { raw: tc.args };
+            }
+            fcs.push({ type: 'tool_use', id: tc.id || `call-${Date.now()}`, name: tc.name, input: inp });
+        }
+    }
+    return {
+        text: tp.join('') || null,
+        thinking: hp.join('') || null,
+        toolCalls: fcs.length > 0 ? fcs : null,
+        usage: { inputTokens: it, outputTokens: ot },
+        stopReason: sr,
+    };
+}
+// ─── History → Conversation Builder (context continuity) ─────────────
+/**
+ * Convert the full message history (from context.messages) into the
+ * API conversation format, then append the new user prompt.
+ *
+ * This is the key difference from starting fresh every turn:
+ * the LLM sees all previous user/assistant exchanges, so it maintains
+ * context across turns.
+ */
+function historyToConversation(history, newPrompt) {
+    const conversation = [];
+    for (const msg of history) {
+        if (msg.role === 'user') {
+            // User messages: content is string, or array of text/image/tool_result blocks.
+            // If array, keep only text + tool_result blocks for API format.
+            if (typeof msg.content === 'string') {
+                conversation.push({ role: 'user', content: msg.content });
+            }
+            else if (Array.isArray(msg.content)) {
+                const blocks = msg.content.filter((b) => b.type === 'text' || b.type === 'tool_result' || b.type === 'image');
+                if (blocks.length > 0) {
+                    conversation.push({ role: 'user', content: blocks });
+                }
+            }
+        }
+        else if (msg.role === 'assistant') {
+            // Assistant messages: content is ContentBlock[] with text/thinking/tool_use.
+            // For API format, keep only text + tool_use (skip thinking).
+            const blocks = Array.isArray(msg.content) ? msg.content : [{ type: 'text', text: String(msg.content) }];
+            const apiBlocks = [];
+            for (const block of blocks) {
+                if (block.type === 'text') {
+                    apiBlocks.push({ type: 'text', text: block.text });
+                }
+                else if (block.type === 'tool_use') {
+                    apiBlocks.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+                // Skip thinking and tool_result blocks in assistant messages
+            }
+            if (apiBlocks.length > 0) {
+                conversation.push({ role: 'assistant', content: apiBlocks });
+            }
+        }
+        // Skip system messages
+    }
+    // Append the new user prompt as the latest user message
+    conversation.push({ role: 'user', content: newPrompt });
+    return conversation;
+}
+// ─── Helpers ────────────────────────────────────────────────────────────
+function buildSP(ctx, cp, sub) {
+    const p = [];
+    if (sub) {
+        p.push('You are a Cray Code sub-agent.');
+    }
+    else {
+        p.push('You are Cray Code, an AI coding assistant. Help users with software engineering tasks.');
+        p.push(`Working directory: ${ctx.cwd}`);
+        p.push(`Date: ${new Date().toISOString().split('T')[0]}`);
+        p.push(`Permission mode: ${ctx.permissionContext.mode}`);
+    }
+    if (cp)
+        p.push(cp);
+    p.push("Use tools when needed. Be concise. Respond in the user's language.");
+    return p.join('\n');
+}
+function convTools(tp) {
+    return tp.map((t) => ({
+        name: t.name,
+        description: t.searchHint ?? t.name,
+        input_schema: (t.inputJSONSchema ?? {
+            type: 'object',
+            properties: {},
+            additionalProperties: true,
+        }),
+    }));
+}
+function convAnt(msgs) {
+    return msgs.map((m) => {
+        const role = m.role === 'assistant' ? 'assistant' : 'user';
+        if (typeof m.content === 'string')
+            return { role, content: m.content };
+        if (Array.isArray(m.content)) {
+            return {
+                role,
+                content: m.content.map((c) => {
+                    switch (c.type) {
+                        case 'text': return { type: 'text', text: String(c.text ?? '') };
+                        case 'tool_use': return { type: 'tool_use', id: String(c.id ?? ''), name: String(c.name ?? ''), input: { ...c.input } };
+                        case 'tool_result': return { type: 'tool_result', tool_use_id: String(c.tool_use_id ?? ''), content: String(c.content ?? '') };
+                        default: return { type: 'text', text: JSON.stringify(c) };
+                    }
+                }),
+            };
+        }
+        return { role, content: String(m.content) };
+    });
+}
+function convOAI(msgs) {
+    const out = [];
+    for (const m of msgs) {
+        if (m.role === 'user') {
+            if (typeof m.content === 'string') {
+                out.push({ role: 'user', content: m.content });
+                continue;
+            }
+            if (Array.isArray(m.content)) {
+                const tls = [], blks = [];
+                for (const c of m.content) {
+                    if (c.type === 'tool_result')
+                        tls.push({ role: 'tool', tool_call_id: String(c.tool_use_id ?? ''), content: String(c.content ?? '') });
+                    else if (c.type === 'text')
+                        blks.push({ type: 'text', text: String(c.text ?? '') });
+                }
+                if (tls.length)
+                    out.push(...tls);
+                if (blks.length)
+                    out.push({ role: 'user', content: blks });
+            }
+        }
+        else if (m.role === 'assistant') {
+            if (typeof m.content === 'string') {
+                out.push({ role: 'assistant', content: m.content });
+                continue;
+            }
+            if (Array.isArray(m.content)) {
+                const txt = [], tcs = [];
+                for (const c of m.content) {
+                    if (c.type === 'text')
+                        txt.push(String(c.text ?? ''));
+                    else if (c.type === 'tool_use')
+                        tcs.push({ id: String(c.id ?? ''), type: 'function', function: { name: String(c.name ?? ''), arguments: JSON.stringify(c.input ?? {}) } });
+                }
+                const msg = { role: 'assistant' };
+                if (txt.length)
+                    msg.content = txt.join('');
+                if (tcs.length)
+                    msg.tool_calls = tcs;
+                out.push(msg);
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=queryStream.js.map