orquesta-cli 0.1.25 → 0.1.26

package/dist/agents/planner/index.js

@@ -38,7 +38,7 @@ export class PlanningLLM {
             });
         }
         const planningTools = toolRegistry.getLLMPlanningToolDefinitions();
-        const MAX_RETRIES = 3;
+        const MAX_RETRIES = 2;
         const MAX_ASK_ITERATIONS = 5;
         let askIterations = 0;
         let lastError = null;

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

@@ -5,7 +5,7 @@ import { NetworkError, APIError, TimeoutError, ConnectionError, } from '../../er
 import { LLMError, TokenLimitError, RateLimitError, ContextLengthError, } from '../../errors/llm.js';
 import { logger, isLLMLogEnabled } from '../../utils/logger.js';
 import { usageTracker } from '../usage-tracker.js';
-import { getForcedTier, getBatutaSessionId } from '../routing-state.js';
+import { getForcedTier, getBatutaSessionId, setLastBatutaRoute } from '../routing-state.js';
 function buildPerRequestHeaders() {
     const headers = {
         'X-Batuta-Session-ID': getBatutaSessionId(),
@@ -15,6 +15,22 @@ function buildPerRequestHeaders() {
         headers['X-Batuta-Force-Tier'] = tier;
     return headers;
 }
+function captureBatutaHeaders(headers) {
+    const get = (k) => {
+        const lower = k.toLowerCase();
+        for (const key of Object.keys(headers)) {
+            if (key.toLowerCase() === lower)
+                return headers[key];
+        }
+        return undefined;
+    };
+    const routedFrom = get('X-Batuta-Routed-From');
+    const routedTo = get('X-Batuta-Routed-To');
+    const tier = get('X-Batuta-Tier');
+    if (routedFrom && routedTo && (tier === 'fast' || tier === 'balanced' || tier === 'premium')) {
+        setLastBatutaRoute({ tier, routedTo, routedFrom });
+    }
+}
 export class LLMClient {
     axiosInstance;
     baseUrl;
@@ -125,6 +141,7 @@ export class LLMClient {
             });
             this.currentAbortController = null;
             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);
@@ -283,6 +300,7 @@ export class LLMClient {
                 signal: this.currentAbortController.signal,
                 headers: buildPerRequestHeaders(),
             });
+            captureBatutaHeaders(response.headers);
             logger.debug('Streaming response started', { status: response.status });
             const stream = response.data;
             let buffer = '';

package/dist/core/pricing.d.ts

@@ -0,0 +1,8 @@
+export interface ModelPricing {
+    input: number;
+    output: number;
+}
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+export declare function estimateCost(modelId: string, inputTokens: number, outputTokens: number): number | null;
+export declare function formatCostUsd(usd: number): string;
+//# sourceMappingURL=pricing.d.ts.map

package/dist/core/pricing.js

@@ -0,0 +1,41 @@
+export const MODEL_PRICING = {
+    'claude-haiku-4-5-20251001': { input: 1, output: 5 },
+    'claude-sonnet-4-6': { input: 3, output: 15 },
+    'claude-sonnet-4-5-20250514': { input: 3, output: 15 },
+    'claude-opus-4-6': { input: 15, output: 75 },
+    'claude-opus-4-7': { input: 15, output: 75 },
+    'gpt-4o': { input: 2.50, output: 10 },
+    'gpt-4o-mini': { input: 0.15, output: 0.60 },
+    'gpt-4-turbo': { input: 10, output: 30 },
+    'o1': { input: 15, output: 60 },
+    'o1-mini': { input: 3, output: 12 },
+    'o3-mini': { input: 1.10, output: 4.40 },
+    'deepseek-chat': { input: 0.27, output: 1.10 },
+    'deepseek-reasoner': { input: 0.55, output: 2.19 },
+    'gemini-2.0-flash': { input: 0.10, output: 0.40 },
+    'gemini-2.0-pro': { input: 1.25, output: 5 },
+    'gemini-1.5-pro': { input: 1.25, output: 5 },
+    'gemini-1.5-flash': { input: 0.075, output: 0.30 },
+    'llama-3.3-70b-versatile': { input: 0.59, output: 0.79 },
+    'mistral-large-latest': { input: 2, output: 6 },
+    'codestral-latest': { input: 0.30, output: 0.90 },
+    'grok-4': { input: 5, output: 15 },
+    'grok-3': { input: 5, output: 15 },
+    'claude-cli': { input: 0, output: 0 },
+};
+export function estimateCost(modelId, inputTokens, outputTokens) {
+    const price = MODEL_PRICING[modelId];
+    if (!price)
+        return null;
+    return (inputTokens / 1_000_000) * price.input + (outputTokens / 1_000_000) * price.output;
+}
+export function formatCostUsd(usd) {
+    if (usd === 0)
+        return '$0.00';
+    if (usd < 0.01)
+        return `$${usd.toFixed(4)}`;
+    if (usd < 1)
+        return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}
+//# sourceMappingURL=pricing.js.map

package/dist/core/routing-state.d.ts

@@ -3,4 +3,11 @@ export declare function getForcedTier(): ForcedTier;
 export declare function setForcedTier(tier: ForcedTier): void;
 export declare function getBatutaSessionId(): string;
 export declare function resetBatutaSession(): void;
+export interface LastBatutaRoute {
+    tier: 'fast' | 'balanced' | 'premium';
+    routedTo: string;
+    routedFrom: string;
+}
+export declare function getLastBatutaRoute(): LastBatutaRoute | null;
+export declare function setLastBatutaRoute(route: LastBatutaRoute | null): void;
 //# sourceMappingURL=routing-state.d.ts.map

package/dist/core/routing-state.js

@@ -13,4 +13,11 @@ export function getBatutaSessionId() {
 export function resetBatutaSession() {
     sessionId = randomUUID();
 }
+let lastBatutaRoute = null;
+export function getLastBatutaRoute() {
+    return lastBatutaRoute;
+}
+export function setLastBatutaRoute(route) {
+    lastBatutaRoute = route;
+}
 //# sourceMappingURL=routing-state.js.map

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

@@ -169,6 +169,19 @@ export async function executeSlashCommand(command, context) {
             updatedContext: { messages: updatedMessages },
         };
     }
+    if (trimmedCommand === '/cost') {
+        const costMessage = usageTracker.formatCostDisplay();
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: costMessage },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
     if (trimmedCommand === '/usage') {
         const usageMessage = usageTracker.formatUsageDisplay();
         const updatedMessages = [
@@ -314,6 +327,7 @@ Available commands:
   /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)
 

package/dist/core/usage-tracker.d.ts

@@ -63,6 +63,7 @@ declare class UsageTrackerClass {
     resetSession(): void;
     formatSessionStatus(currentActivity?: string): string;
     formatUsageDisplay(): string;
+    formatCostDisplay(): string;
     clearData(): void;
 }
 export declare const usageTracker: UsageTrackerClass;

package/dist/core/usage-tracker.js

@@ -2,6 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { logger } from '../utils/logger.js';
 import { contextTracker } from './compact/context-tracker.js';
+import { estimateCost, formatCostUsd } from './pricing.js';
 const DATA_DIR = path.join(process.env['HOME'] || '.', '.local-cli');
 const USAGE_FILE = path.join(DATA_DIR, 'usage.json');
 class UsageTrackerClass {
@@ -232,6 +233,47 @@ class UsageTrackerClass {
         logger.exit('UsageTracker.formatUsageDisplay');
         return lines.join('\n');
     }
+    formatCostDisplay() {
+        const records = this.data.records;
+        if (records.length === 0) {
+            return '💸 Cost: no usage recorded yet this session.';
+        }
+        const byModel = new Map();
+        let totalCost = 0;
+        let hadUnknown = false;
+        for (const r of records) {
+            const cost = estimateCost(r.model, r.inputTokens, r.outputTokens);
+            const b = byModel.get(r.model) ?? { model: r.model, requests: 0, inputTokens: 0, outputTokens: 0, cost: 0 };
+            b.requests++;
+            b.inputTokens += r.inputTokens;
+            b.outputTokens += r.outputTokens;
+            if (cost === null) {
+                b.cost = null;
+                hadUnknown = true;
+            }
+            else if (b.cost !== null) {
+                b.cost += cost;
+                totalCost += cost;
+            }
+            byModel.set(r.model, b);
+        }
+        const lines = [];
+        lines.push('💸 Estimated Cost (this process)');
+        lines.push('');
+        lines.push(`   Total: ${formatCostUsd(totalCost)}${hadUnknown ? ' (some models unknown — excluded)' : ''}`);
+        lines.push(`   Requests: ${records.length}`);
+        lines.push('');
+        lines.push('   By model:');
+        const sorted = Array.from(byModel.values()).sort((a, b) => (b.cost ?? 0) - (a.cost ?? 0));
+        for (const b of sorted) {
+            const cost = b.cost === null ? '?' : formatCostUsd(b.cost);
+            const subsidy = b.model === 'claude-cli' ? ' (subscription)' : '';
+            lines.push(`     ${b.model.padEnd(32)} ${b.requests}×  in=${b.inputTokens.toLocaleString()}  out=${b.outputTokens.toLocaleString()}  ${cost}${subsidy}`);
+        }
+        lines.push('');
+        lines.push('Note: estimates use public list pricing. Batuta tier subscriptions absorb claude-cli routed costs (shown as $0.00).');
+        return lines.join('\n');
+    }
     clearData() {
         logger.flow('Clearing all usage data');
         this.data = {

package/dist/ui/components/StatusBar.js

@@ -1,6 +1,16 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text } from 'ink';
 import { logger } from '../../utils/logger.js';
+import { useBatutaRoute } from '../hooks/useBatutaRoute.js';
+const MODEL_SHORT_LABEL = {
+    'claude-cli-haiku': 'Haiku 4.5',
+    'claude-cli-sonnet': 'Sonnet 4.6',
+    'claude-cli-opus': 'Opus 4.7',
+    'claude-haiku-4-5-20251001': 'Haiku 4.5',
+    'claude-sonnet-4-6': 'Sonnet 4.6',
+    'claude-opus-4-7': 'Opus 4.7',
+    'claude-opus-4-6': 'Opus 4.6',
+};
 function formatTokens(count) {
     if (count < 1000)
         return count.toString();
@@ -63,6 +73,11 @@ function formatElapsedTime(seconds) {
     return `${mins}m ${secs}s`;
 }
 export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizationName: _organizationName, workingDirectory, status = 'idle', message: _message, messageCount = 0, sessionTokens = 0, contextUsage, contextRemainingPercent, todoCount, todoCompleted, healthStatus, currentActivity, sessionElapsedSeconds, batutaUsage, }) => {
+    const batutaRoute = useBatutaRoute();
+    const showBatutaSuffix = model === 'batuta-auto' && !!batutaRoute;
+    const batutaSuffix = showBatutaSuffix
+        ? ` → ${MODEL_SHORT_LABEL[batutaRoute.routedTo] || batutaRoute.routedTo}`
+        : '';
     void _endpoint;
     void _message;
     useEffect(() => {
@@ -109,7 +124,9 @@ export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizatio
                     formatTokens(sessionTokens),
                     " tokens")),
                 React.createElement(Text, { color: "gray" }, ")")),
-            React.createElement(Box, null, model && React.createElement(Text, { color: "cyan" }, model.slice(0, 15)))));
+            React.createElement(Box, null, model && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "cyan" }, model.slice(0, 15)),
+                batutaSuffix && React.createElement(Text, { color: "magenta" }, batutaSuffix))))));
     }
     const getContextColor = (percent) => {
         if (percent > 50)
@@ -131,7 +148,8 @@ export const StatusBar = ({ model, endpoint: _endpoint, projectName, organizatio
             getStatusIndicator(),
             model && (React.createElement(React.Fragment, null,
                 React.createElement(Text, { color: "gray" }, " | "),
-                React.createElement(Text, { color: "cyan" }, model.slice(0, 15)))),
+                React.createElement(Text, { color: "cyan" }, model.slice(0, 15)),
+                batutaSuffix && React.createElement(Text, { color: "magenta" }, batutaSuffix))),
             projectName && (React.createElement(React.Fragment, null,
                 React.createElement(Text, { color: "gray" }, " | "),
                 React.createElement(Text, { color: "magenta" },

package/dist/ui/hooks/useBatutaRoute.d.ts

@@ -0,0 +1,3 @@
+import { type LastBatutaRoute } from '../../core/routing-state.js';
+export declare function useBatutaRoute(): LastBatutaRoute | null;
+//# sourceMappingURL=useBatutaRoute.d.ts.map

package/dist/ui/hooks/useBatutaRoute.js

@@ -0,0 +1,22 @@
+import { useEffect, useState } from 'react';
+import { getLastBatutaRoute } from '../../core/routing-state.js';
+export function useBatutaRoute() {
+    const [route, setRoute] = useState(getLastBatutaRoute());
+    useEffect(() => {
+        const interval = setInterval(() => {
+            const next = getLastBatutaRoute();
+            setRoute(prev => {
+                if (prev === next)
+                    return prev;
+                if (!prev || !next)
+                    return next;
+                if (prev.tier === next.tier && prev.routedTo === next.routedTo)
+                    return prev;
+                return next;
+            });
+        }, 500);
+        return () => clearInterval(interval);
+    }, []);
+    return route;
+}
+//# sourceMappingURL=useBatutaRoute.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",