@outputai/cli 0.7.1-next.5a29fff.0 → 0.7.1-next.bd6bd49.0

package/dist/utils/cost_formatter.js

@@ -29,76 +29,96 @@ export function parseCostData(report) {
     const byModel = {};
     for (const r of report.llmCalls) {
         if (!byModel[r.model]) {
-            byModel[r.model] = { count: 0, cost: 0 };
+            byModel[r.model] = { count: 0, originalCost: 0, adjustedCost: 0 };
         }
         byModel[r.model].count++;
-        byModel[r.model].cost += r.cost;
+        byModel[r.model].originalCost += r.originalCost;
+        byModel[r.model].adjustedCost += r.adjustedCost;
     }
     const llmModels = Object.entries(byModel)
-        .sort((a, b) => b[1].cost - a[1].cost)
-        .map(([model, stats]) => ({ model, count: stats.count, cost: stats.cost }));
-    const services = [...report.services]
-        .sort((a, b) => b.totalCost - a.totalCost)
-        .map(s => ({ serviceName: s.serviceName, callCount: s.calls.length, cost: s.totalCost }));
-    const serviceTotalCalls = services.reduce((sum, s) => sum + s.callCount, 0);
+        .sort((a, b) => b[1].adjustedCost - a[1].adjustedCost)
+        .map(([model, s]) => ({ model, ...s }));
+    const hosts = [...report.httpCosts]
+        .sort((a, b) => b.adjustedTotalCost - a.adjustedTotalCost)
+        .map(h => ({
+        host: h.host,
+        callCount: h.calls.length,
+        originalCost: h.originalTotalCost,
+        adjustedCost: h.adjustedTotalCost
+    }));
+    const httpTotalCalls = hosts.reduce((sum, h) => sum + h.callCount, 0);
     return {
         traceFile: report.traceFile,
         workflowName: report.workflowName,
         duration: report.durationMs ? `${(report.durationMs / 1000).toFixed(1)}s` : 'N/A',
         llmModels,
         llmTotalCalls: report.llmCalls.length,
-        llmTotalCost: report.llmTotalCost,
-        services,
-        serviceTotalCalls,
-        serviceTotalCost: report.serviceTotalCost,
+        llmOriginalCost: report.llmOriginalCost,
+        llmAdjustedCost: report.llmAdjustedCost,
+        hosts,
+        httpTotalCalls,
+        httpOriginalCost: report.httpOriginalCost,
+        httpAdjustedCost: report.httpAdjustedCost,
         verbose: {
             hasReasoning: report.totalReasoningTokens > 0,
             hasCached: report.totalCachedTokens > 0
         },
         llmCalls: report.llmCalls,
-        serviceDetails: report.services,
+        httpDetails: report.httpCosts,
         totalInputTokens: report.totalInputTokens,
         totalOutputTokens: report.totalOutputTokens,
         totalCachedTokens: report.totalCachedTokens,
         totalReasoningTokens: report.totalReasoningTokens,
+        originalTotalCost: report.originalTotalCost,
         totalCost: report.totalCost,
-        unknownModels: report.unknownModels,
-        isEmpty: report.llmCalls.length === 0 && report.services.length === 0
+        isEmpty: report.llmCalls.length === 0 && report.httpCosts.length === 0
     };
 }
 function formatSummary(data) {
     const lines = [];
     if (data.llmModels.length > 0) {
         const table = new Table({
-            head: ['Model', 'Calls', 'Cost'],
+            head: ['Model', 'Calls', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'right', 'right']
+            colAligns: ['left', 'right', 'right', 'right']
         });
         for (const m of data.llmModels) {
-            table.push([m.model, pluralize(m.count, 'call'), formatCurrency(m.cost)]);
+            table.push([
+                m.model,
+                pluralize(m.count, 'call'),
+                formatCurrency(m.originalCost),
+                formatCurrency(m.adjustedCost)
+            ]);
         }
         table.push([
             'Subtotal',
             pluralize(data.llmTotalCalls, 'call'),
-            formatCurrency(data.llmTotalCost)
+            formatCurrency(data.llmOriginalCost),
+            formatCurrency(data.llmAdjustedCost)
         ]);
         lines.push('LLM Costs:');
         lines.push(table.toString());
         lines.push('');
     }
-    if (data.services.length > 0) {
+    if (data.hosts.length > 0) {
         const table = new Table({
-            head: ['Service', 'Calls', 'Cost'],
+            head: ['Host', 'Calls', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'right', 'right']
+            colAligns: ['left', 'right', 'right', 'right']
         });
-        for (const s of data.services) {
-            table.push([s.serviceName, pluralize(s.callCount, 'call'), formatCurrency(s.cost)]);
+        for (const h of data.hosts) {
+            table.push([
+                h.host,
+                pluralize(h.callCount, 'call'),
+                formatCurrency(h.originalCost),
+                formatCurrency(h.adjustedCost)
+            ]);
         }
         table.push([
             'Subtotal',
-            pluralize(data.serviceTotalCalls, 'call'),
-            formatCurrency(data.serviceTotalCost)
+            pluralize(data.httpTotalCalls, 'call'),
+            formatCurrency(data.httpOriginalCost),
+            formatCurrency(data.httpAdjustedCost)
         ]);
         lines.push('API Costs:');
         lines.push(table.toString());
@@ -119,8 +139,8 @@ function formatVerbose(data) {
             head.push('Reasoning');
             colAligns.push('right');
         }
-        head.push('Cost');
-        colAligns.push('right');
+        head.push('Original', 'Adjusted');
+        colAligns.push('right', 'right');
         const table = new Table({
             head,
             style: { head: ['cyan'] },
@@ -139,7 +159,7 @@ function formatVerbose(data) {
             if (data.verbose.hasReasoning) {
                 row.push(formatNumber(r.reasoning));
             }
-            row.push(formatCurrency(r.cost) + (r.warning ? ` (${r.warning})` : ''));
+            row.push(formatCurrency(r.originalCost), formatCurrency(r.adjustedCost));
             table.push(row);
         }
         const totalRow = [
@@ -154,29 +174,34 @@ function formatVerbose(data) {
         if (data.verbose.hasReasoning) {
             totalRow.push(formatNumber(data.totalReasoningTokens));
         }
-        totalRow.push(formatCurrency(data.llmTotalCost));
+        totalRow.push(formatCurrency(data.llmOriginalCost), formatCurrency(data.llmAdjustedCost));
         table.push(totalRow);
         lines.push('LLM Calls:');
         lines.push(table.toString());
         lines.push('');
     }
-    if (data.serviceDetails.length > 0) {
+    if (data.httpDetails.length > 0) {
         const table = new Table({
-            head: ['Service', 'Step', 'Usage', 'Cost'],
+            head: ['Host', 'Step', 'Usage', 'Original', 'Adjusted'],
             style: { head: ['cyan'] },
-            colAligns: ['left', 'left', 'right', 'right']
+            colAligns: ['left', 'left', 'right', 'right', 'right']
         });
-        for (const service of data.serviceDetails) {
-            for (const call of service.calls) {
+        for (const host of data.httpDetails) {
+            for (const call of host.calls) {
                 table.push([
-                    service.serviceName,
+                    host.host,
                     call.step,
                     call.usage,
-                    formatCurrency(call.cost)
+                    formatCurrency(call.originalCost),
+                    formatCurrency(call.adjustedCost)
                 ]);
             }
         }
-        table.push(['Subtotal', '', '', formatCurrency(data.serviceTotalCost)]);
+        table.push([
+            'Subtotal', '', '',
+            formatCurrency(data.httpOriginalCost),
+            formatCurrency(data.httpAdjustedCost)
+        ]);
         lines.push('API Calls:');
         lines.push(table.toString());
         lines.push('');
@@ -203,13 +228,10 @@ export function formatCostReport(report, options = {}) {
             colAligns: ['left', 'right'],
             colWidths: [36, 12]
         });
-        totalTable.push(['TOTAL ESTIMATED COST', formatCurrency(data.totalCost)]);
+        totalTable.push(['TOTAL ESTIMATED COST (adjusted)', formatCurrency(data.totalCost)]);
+        totalTable.push(['As-charged (from trace)', formatCurrency(data.originalTotalCost)]);
         lines.push(totalTable.toString());
     }
-    if (data.unknownModels.length > 0) {
-        lines.push('');
-        lines.push(`Warning: Unknown models (add to config/costs.yml): ${data.unknownModels.join(', ')}`);
-    }
     if (data.isEmpty) {
         lines.push('No billable calls found in trace.');
     }

package/dist/utils/proxy.d.ts

@@ -4,6 +4,7 @@
  * `http_proxy`). No-op when none are set. Invalid URLs are logged and
  * skipped so the CLI keeps running.
  *
- * Call once at CLI startup, before any network activity.
+ * Call once at CLI startup, before any network activity. `undici` is
+ * imported lazily so invocations without a proxy skip loading it.
  */
-export declare const bootstrapProxy: () => void;
+export declare const bootstrapProxy: () => Promise<void>;

package/dist/utils/proxy.js

@@ -1,13 +1,13 @@
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
 /**
  * Routes all `fetch()` calls through an HTTP/HTTPS proxy when standard
  * proxy env vars are set (`HTTPS_PROXY`, `https_proxy`, `HTTP_PROXY`,
  * `http_proxy`). No-op when none are set. Invalid URLs are logged and
  * skipped so the CLI keeps running.
  *
- * Call once at CLI startup, before any network activity.
+ * Call once at CLI startup, before any network activity. `undici` is
+ * imported lazily so invocations without a proxy skip loading it.
  */
-export const bootstrapProxy = () => {
+export const bootstrapProxy = async () => {
     const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
         process.env.HTTP_PROXY || process.env.http_proxy;
     if (!proxyUrl) {
@@ -20,5 +20,6 @@ export const bootstrapProxy = () => {
         console.warn(`[proxy] Ignoring invalid proxy URL: ${proxyUrl}`);
         return;
     }
+    const { EnvHttpProxyAgent, setGlobalDispatcher } = await import('undici');
     setGlobalDispatcher(new EnvHttpProxyAgent());
 };

package/dist/utils/proxy.spec.js

@@ -19,20 +19,20 @@ describe('proxy bootstrap', () => {
     });
     it('does nothing when no proxy env vars are set', async () => {
         const { bootstrapProxy } = await import('./proxy.js');
-        bootstrapProxy();
+        await bootstrapProxy();
         expect(mockSetGlobalDispatcher).not.toHaveBeenCalled();
     });
     it('sets global dispatcher when HTTPS_PROXY is set', async () => {
         process.env.HTTPS_PROXY = 'http://proxy:8080';
         const { bootstrapProxy } = await import('./proxy.js');
-        bootstrapProxy();
+        await bootstrapProxy();
         expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
         expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
     });
     it('sets global dispatcher when HTTP_PROXY is set', async () => {
         process.env.HTTP_PROXY = 'http://proxy:8080';
         const { bootstrapProxy } = await import('./proxy.js');
-        bootstrapProxy();
+        await bootstrapProxy();
         expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
         expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
     });
@@ -40,7 +40,7 @@ describe('proxy bootstrap', () => {
         process.env.HTTPS_PROXY = 'not a url';
         const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
         const { bootstrapProxy } = await import('./proxy.js');
-        bootstrapProxy();
+        await bootstrapProxy();
         expect(mockSetGlobalDispatcher).not.toHaveBeenCalled();
         expect(warnSpy).toHaveBeenCalled();
         warnSpy.mockRestore();