orquesta-cli 0.2.45 → 0.2.47

package/dist/core/llm/llm-client.js

@@ -108,6 +108,7 @@ export class LLMClient {
     modelName;
     currentAbortController = null;
     isInterrupted = false;
+    onStreamingContent = null;
     static DEFAULT_MAX_RETRIES = 3;
     constructor() {
         const endpoint = configManager.getCurrentEndpoint();
@@ -183,11 +184,11 @@ export class LLMClient {
             const modelId = options.model || this.model;
             const processedMessages = options.messages ?
                 this.preprocessMessages(options.messages, modelId) : [];
-            logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0.7 });
+            logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0 });
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: false,
                 ...(options.tools && {
@@ -210,13 +211,112 @@ export class LLMClient {
             }
             logger.startTimer('llm-api-call');
             this.currentAbortController = new AbortController();
-            const response = await this.axiosInstance.post(url, requestBody, {
-                signal: this.currentAbortController.signal,
-                headers: buildPerRequestHeaders(),
-            });
-            this.currentAbortController = null;
+            let response;
+            if (this.onStreamingContent) {
+                const streamRequestBody = { ...requestBody, stream: true };
+                const streamResp = await this.axiosInstance.post(url, streamRequestBody, {
+                    responseType: 'stream',
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                captureBatutaHeaders(streamResp.headers);
+                const stream = streamResp.data;
+                let buffer = '';
+                let contentAccum = '';
+                let reasoningAccum = '';
+                let role = 'assistant';
+                let finishReason = null;
+                const toolCallsMap = new Map();
+                let responseId = '';
+                let responseModel = '';
+                for await (const chunk of stream) {
+                    if (this.isInterrupted) {
+                        throw new Error('INTERRUPTED');
+                    }
+                    buffer += chunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === 'data: [DONE]')
+                            continue;
+                        if (!trimmed.startsWith('data: '))
+                            continue;
+                        try {
+                            const data = JSON.parse(trimmed.slice(6));
+                            if (data.id)
+                                responseId = data.id;
+                            if (data.model)
+                                responseModel = data.model;
+                            const choice = data.choices?.[0];
+                            if (!choice)
+                                continue;
+                            if (choice.finish_reason)
+                                finishReason = choice.finish_reason;
+                            const delta = choice.delta;
+                            if (!delta)
+                                continue;
+                            if (delta.role)
+                                role = delta.role;
+                            if (delta.content) {
+                                contentAccum += delta.content;
+                                this.onStreamingContent(delta.content);
+                            }
+                            if (delta.reasoning) {
+                                reasoningAccum += delta.reasoning;
+                            }
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    if (!toolCallsMap.has(idx)) {
+                                        toolCallsMap.set(idx, { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } });
+                                    }
+                                    const existing = toolCallsMap.get(idx);
+                                    if (tc.id)
+                                        existing.id = tc.id;
+                                    if (tc.function?.name)
+                                        existing.function.name += tc.function.name;
+                                    if (tc.function?.arguments)
+                                        existing.function.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                this.currentAbortController = null;
+                const toolCalls = Array.from(toolCallsMap.values())
+                    .filter(tc => tc.id && tc.function.name)
+                    .map(tc => ({ id: tc.id, type: 'function', function: { name: tc.function.name, arguments: tc.function.arguments } }));
+                const reassembledMessage = {
+                    role: role,
+                    content: contentAccum,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                    ...(reasoningAccum ? { reasoning: reasoningAccum } : {}),
+                };
+                response = {
+                    data: {
+                        id: responseId,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: responseModel || modelId,
+                        choices: [{ index: 0, message: reassembledMessage, finish_reason: finishReason }],
+                    },
+                    status: streamResp.status,
+                    statusText: streamResp.statusText,
+                    headers: streamResp.headers,
+                };
+            }
+            else {
+                const httpResp = await this.axiosInstance.post(url, requestBody, {
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                this.currentAbortController = null;
+                response = { data: httpResp.data, status: httpResp.status, statusText: httpResp.statusText, headers: httpResp.headers };
+                captureBatutaHeaders(response.headers);
+            }
             const elapsed = logger.endTimer('llm-api-call');
-            captureBatutaHeaders(response.headers);
             logger.flow('API response received');
             if (!response.data.choices || !Array.isArray(response.data.choices)) {
                 logger.error('Invalid response structure - missing choices array', response.data);
@@ -354,7 +454,7 @@ export class LLMClient {
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: true,
                 ...(options.tools && {
@@ -495,9 +595,7 @@ export class LLMClient {
         const toolCallHistory = [];
         let iterations = 0;
         let contextLengthRecoveryAttempted = false;
-        let noToolCallRetries = 0;
         let finalResponseFailures = 0;
-        const MAX_NO_TOOL_CALL_RETRIES = 3;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
         const recentToolSignatures = [];
         const recentNormalizedSignatures = [];
@@ -524,7 +622,7 @@ export class LLMClient {
                 response = await this.chatCompletion({
                     messages: workingMessages,
                     tools,
-                    tool_choice: 'required',
+                    tool_choice: 'auto',
                     ...(roleModel ? { model: roleModel } : {}),
                 });
             }
@@ -733,34 +831,14 @@ export class LLMClient {
                 continue;
             }
             else {
-                noToolCallRetries++;
-                logger.flow(`No tool call - enforcing tool usage (attempt ${noToolCallRetries}/${MAX_NO_TOOL_CALL_RETRIES})`);
-                if (noToolCallRetries > MAX_NO_TOOL_CALL_RETRIES) {
-                    logger.warn('Max no-tool-call retries exceeded - returning content as final response');
-                    const fallbackContent = assistantMessage.content || 'Task completed.';
-                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
-                    emitAssistantResponse(fallbackContent);
-                    return {
-                        message: { role: 'assistant', content: fallbackContent },
-                        toolCalls: toolCallHistory,
-                        allMessages: workingMessages,
-                    };
-                }
-                const hasMalformedToolCall = assistantMessage.content &&
-                    (/<tool_call>/i.test(assistantMessage.content) ||
-                        /<arg_key>/i.test(assistantMessage.content) ||
-                        /<arg_value>/i.test(assistantMessage.content) ||
-                        /<\/tool_call>/i.test(assistantMessage.content) ||
-                        /bash<arg_key>/i.test(assistantMessage.content));
-                const retryMessage = hasMalformedToolCall
-                    ? 'Your previous response contained a malformed tool call (XML tags in content). You MUST use the proper tool_calls API format. Use final_response tool to deliver your message to the user.'
-                    : 'You must use tools for all actions. Use final_response tool to deliver your final message to the user after completing all tasks.';
-                workingMessages.push({
-                    role: 'user',
-                    content: retryMessage,
-                });
-                logger.debug('Enforcing tool call - added retry message');
-                continue;
+                const finalContent = assistantMessage.content || 'Task completed.';
+                const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
+                emitAssistantResponse(finalContent);
+                return {
+                    message: { role: 'assistant', content: finalContent },
+                    toolCalls: toolCallHistory,
+                    allMessages: workingMessages,
+                };
             }
         }
     }

package/dist/core/onboarding.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldShowOnboarding(): boolean;
+export declare function runOnboarding(): Promise<boolean>;
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/core/onboarding.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { configManager } from './config/config-manager.js';
+import { scanProviders, toEndpointConfig } from './config/auto-detect.js';
+import { CONFIG_FILE_PATH } from '../constants.js';
+import * as fs from 'fs';
+export function shouldShowOnboarding() {
+    if (!fs.existsSync(CONFIG_FILE_PATH))
+        return true;
+    return !configManager.hasEndpoints();
+}
+export async function runOnboarding() {
+    console.log();
+    console.log(chalk.cyan('  ╔══════════════════════════════════════════╗'));
+    console.log(chalk.cyan('  ║') + chalk.bold('   Welcome to Orquesta CLI! 🎵            ') + chalk.cyan('║'));
+    console.log(chalk.cyan('  ╚══════════════════════════════════════════╝'));
+    console.log();
+    console.log(chalk.dim('  Scanning for LLM providers...'));
+    console.log();
+    const result = await scanProviders();
+    if (result.detected.length === 0) {
+        console.log(chalk.yellow('  No LLM providers detected.'));
+        console.log();
+        console.log(chalk.dim('  To get started, do one of the following:'));
+        console.log(chalk.dim('    • Set an env var: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.'));
+        console.log(chalk.dim('    • Start a local provider (Ollama on port 11434)'));
+        console.log(chalk.dim('    • Run: orquesta --add-provider <provider-id>'));
+        console.log();
+        return false;
+    }
+    let addedCount = 0;
+    for (const detected of result.detected) {
+        const endpoint = toEndpointConfig(detected);
+        await configManager.addEndpoint(endpoint);
+        addedCount++;
+        if (addedCount === 1 && endpoint.models.length > 0) {
+            await configManager.setCurrentEndpoint(endpoint.id);
+            await configManager.setCurrentModel(endpoint.models[0].id);
+        }
+    }
+    console.log(chalk.green(`  ✓ Auto-configured ${addedCount} provider(s):`));
+    for (const d of result.detected) {
+        const modelCount = d.discoveredModels.length;
+        console.log(chalk.white(`    • ${d.provider.name}`) + chalk.dim(` (${modelCount} model${modelCount !== 1 ? 's' : ''})`));
+    }
+    console.log();
+    return true;
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/core/slash-command-handler.js

@@ -1,3 +1,4 @@
+import { commandRegistry } from './commands/index.js';
 import { sessionManager } from './session/session-manager.js';
 import { usageTracker } from './usage-tracker.js';
 import { logger } from '../utils/logger.js';
@@ -6,72 +7,24 @@ import { readHookConfig, writeHookFiles, disableHooks } from '../orquesta/hook-i
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../utils/update-checker.js';
 import { createRequire } from 'module';
 import { configManager } from './config/config-manager.js';
-import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
+import { getForcedTier, setForcedTier } from './routing-state.js';
 import { auditLog } from '../orchestration/audit-log.js';
 import { remotePhone } from '../orquesta/remote-phone.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
+    const commandName = trimmedCommand.split(/\s/)[0];
+    const registryResult = await commandRegistry.execute(commandName, context, trimmedCommand);
+    if (registryResult) {
+        logger.exit('executeSlashCommand', { handled: true, command: commandName, source: 'registry' });
+        return registryResult;
+    }
     if (trimmedCommand === '/exit' || trimmedCommand === '/quit') {
         logger.flow('Exit command received');
         context.exit();
         logger.exit('executeSlashCommand', { handled: true, command: 'exit' });
         return { handled: true, shouldContinue: false };
     }
-    if (trimmedCommand === '/clear') {
-        logger.flow('Clear command - resetting messages and todos');
-        context.setMessages([]);
-        context.setTodos([]);
-        resetBatutaSession();
-        logger.exit('executeSlashCommand', { handled: true, command: 'clear' });
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: [],
-                todos: [],
-            },
-        };
-    }
-    if (trimmedCommand === '/compact') {
-        logger.flow('Compact command received');
-        if (context.onCompact) {
-            logger.flow('Executing compact callback');
-            const result = await context.onCompact();
-            logger.vars({ name: 'compactSuccess', value: result.success }, { name: 'originalCount', value: result.originalMessageCount }, { name: 'newCount', value: result.newMessageCount });
-            const compactMessage = result.success
-                ? `✅ Conversation compacted successfully. (${result.originalMessageCount} → ${result.newMessageCount} messages)`
-                : `❌ Compact failed: ${result.error}`;
-            const baseMessages = (result.success && result.compactedMessages)
-                ? result.compactedMessages
-                : context.messages;
-            const updatedMessages = [
-                ...baseMessages,
-                { role: 'assistant', content: compactMessage },
-            ];
-            context.setMessages(updatedMessages);
-            return {
-                handled: true,
-                shouldContinue: false,
-                updatedContext: {
-                    messages: updatedMessages,
-                },
-            };
-        }
-        const fallbackMessage = '/compact is only available in interactive mode.';
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: fallbackMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand === '/settings') {
         if (context.onShowSettings) {
             context.onShowSettings();
@@ -524,41 +477,6 @@ ${executorLines}
         context.setMessages(updatedMessages);
         return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
     }
-    if (trimmedCommand.startsWith('/memory')) {
-        const sub = trimmedCommand.slice(7).trim();
-        const { addMemory, removeMemory, clearMemory, listMemory } = await import('./memory.js');
-        const reply = (content) => {
-            const updatedMessages = [...context.messages, { role: 'assistant', content }];
-            context.setMessages(updatedMessages);
-            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
-        };
-        if (sub.startsWith('add ')) {
-            const note = sub.slice(4).trim();
-            if (!note)
-                return reply('Usage: /memory add <note>');
-            addMemory(note);
-            return reply(`✓ Saved to memory: "${note}"`);
-        }
-        if (sub === 'list' || sub === '') {
-            const entries = listMemory();
-            if (entries.length === 0)
-                return reply('Memory is empty. Use `/memory add <note>` to save preferences.');
-            const list = entries.map((e, i) => `  ${i + 1}. ${e}`).join('\n');
-            return reply(`📝 User memory (${entries.length} entries):\n${list}\n\nCommands: /memory add <note> | remove <n> | clear`);
-        }
-        if (sub.startsWith('remove ')) {
-            const idx = parseInt(sub.slice(7).trim(), 10);
-            if (isNaN(idx))
-                return reply('Usage: /memory remove <number>');
-            const ok = removeMemory(idx);
-            return reply(ok ? `✓ Removed entry #${idx}` : `Entry #${idx} not found`);
-        }
-        if (sub === 'clear') {
-            clearMemory();
-            return reply('✓ Memory cleared');
-        }
-        return reply('Usage: /memory add <note> | list | remove <n> | clear');
-    }
     if (trimmedCommand === '/update') {
         logger.flow('Update command received');
         const reply = (content) => {
@@ -661,51 +579,6 @@ ${executorLines}
             return reply(`❌ Could not open the remote phone channel: ${e.message}`);
         }
     }
-    if (trimmedCommand === '/help') {
-        const helpMessage = `
-Available commands:
-  /exit, /quit    - Exit the application
-  /clear          - Clear conversation and TODOs
-  /compact        - Compact conversation to free up context
-  /memory         - Persistent memory: /memory add <note> | list | remove <n> | clear
-  /settings       - Open settings menu
-  /model          - Switch between LLM models
-  /project        - Switch between Orquesta projects
-  /tool           - Enable/disable optional tools (Browser, Background)
-  /load           - Load a saved session
-  /usage          - Show token usage statistics
-  /cost           - Estimated USD spend this process (by model)
-  /route          - Pin Batuta Auto tier (fast/balanced/premium/auto)
-  /sync           - Bidirectional sync with Orquesta dashboard (pull & push LLM configs)
-  /login          - Sign in to Orquesta via browser (opens getorquesta.com)
-  /logout         - Sign out of Orquesta (clears token, keeps local LLM configs)
-  /whoami         - Show current Orquesta connection
-  /hook           - Claude Code hook here: /hook status | enable | disable
-  /remote-phone   - Drive this session from your phone: on | off | status
-  /update         - Update orquesta-cli to the latest version
-
-Keyboard shortcuts:
-  Ctrl+C          - Exit
-  Ctrl+T          - Toggle TODO details
-  ESC             - Interrupt current execution
-  @               - File browser
-  /               - Command autocomplete
-
-Note: All conversations are automatically saved.
-    `;
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: helpMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand.startsWith('/load')) {
         logger.flow('Load command received');
         const parts = trimmedCommand.split(' ');

package/dist/eval/eval-runner.d.ts

@@ -7,6 +7,7 @@ export declare class EvalRunner {
     private filesModified;
     private lastResponse;
     private todos;
+    private followUpFile;
     constructor();
     run(input: EvalInput): Promise<void>;
     private execute;

package/dist/eval/eval-runner.js

@@ -1,6 +1,8 @@
 import { createLLMClient } from '../core/llm/llm-client.js';
 import { configManager } from '../core/config/config-manager.js';
 import { PlanExecutor } from '../orchestration/plan-executor.js';
+import * as fs from 'fs';
+import * as path from 'path';
 function emitEvent(event) {
     console.log(JSON.stringify(event));
 }
@@ -15,8 +17,11 @@ export class EvalRunner {
     filesModified = new Set();
     lastResponse = '';
     todos = [];
+    followUpFile;
     constructor() {
         this.planExecutor = new PlanExecutor();
+        const tmpDir = process.env['ORQUESTA_IPC_DIR'] || path.join(process.env['HOME'] || '/tmp', '.orquesta-cli');
+        this.followUpFile = path.join(tmpDir, 'follow-up.msg');
     }
     async run(input) {
         this.startTime = Date.now();
@@ -126,6 +131,23 @@ export class EvalRunner {
             },
             setAskUserRequest: () => {
             },
+            getPendingMessage: () => {
+                try {
+                    if (fs.existsSync(this.followUpFile)) {
+                        const msg = fs.readFileSync(this.followUpFile, 'utf-8').trim();
+                        if (msg)
+                            return msg;
+                    }
+                }
+                catch { }
+                return null;
+            },
+            clearPendingMessage: () => {
+                try {
+                    fs.unlinkSync(this.followUpFile);
+                }
+                catch { }
+            },
         };
     }
     emitTodo(action, todo) {