@stage-labs/metro 0.1.0-beta.119 → 0.1.0-beta.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.119",
+  "version": "0.1.0-beta.120",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.119",
+  "version": "0.1.0-beta.120",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, the standing rules loaded at each session start, and a refresh skill for when the daemon could not keep the server list current. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/daemon/src/gateway/bedrock.ts

@@ -3,6 +3,7 @@ import { log } from '@metro-labs/core/log';
 import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
 import { errorFrame, GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import type { BedrockSettings } from './model-config.js';
+import { UsageScanner } from './usage.js';
 
 const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
 const EXTRA_INPUT_RE = /^([A-Za-z0-9_]+)(?:\.[^:]*)?: Extra inputs are not permitted/;
@@ -154,11 +155,12 @@ function eventTypeOf(event: string): string {
   }
 }
 
-function writeEvent(res: ServerResponse, message: EventStreamMessage): void {
+function writeEvent(res: ServerResponse, message: EventStreamMessage, scanner: UsageScanner): void {
   if (message.headers[':message-type'] === 'event') {
     const parsed = JSON.parse(message.payload.toString('utf8')) as { bytes?: unknown };
     if (typeof parsed.bytes !== 'string') return;
     const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+    scanner.feed(`${event}\n`);
     res.write(`event: ${eventTypeOf(event)}\ndata: ${event}\n\n`);
     return;
   }
@@ -178,6 +180,7 @@ async function relayStream(upstream: Response, res: ServerResponse, watch: Watch
     return;
   }
   const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
+  const scanner = new UsageScanner('bedrock');
   try {
     const decoder = new EventStreamDecoder();
     const reader = body.getReader();
@@ -185,7 +188,7 @@ async function relayStream(upstream: Response, res: ServerResponse, watch: Watch
       const { done, value } = await reader.read();
       if (done) break;
       watch.touch();
-      for (const message of decoder.push(Buffer.from(value))) writeEvent(res, message);
+      for (const message of decoder.push(Buffer.from(value))) writeEvent(res, message, scanner);
     }
   } catch (err) {
     if (!watch.idle()) throw err;
@@ -194,6 +197,7 @@ async function relayStream(upstream: Response, res: ServerResponse, watch: Watch
     clearInterval(ping);
     watch.stop();
     res.end();
+    scanner.done();
   }
 }
 
@@ -220,6 +224,9 @@ export async function bedrockMessages(
     return;
   }
   const text = await upstream.text();
+  const scanner = new UsageScanner('bedrock');
+  scanner.feed(text);
+  scanner.done();
   res.writeHead(200, { 'content-type': 'application/json' });
   res.end(text);
 }

package/runtime/node_modules/@metro-labs/daemon/src/gateway/codex.ts

@@ -8,7 +8,7 @@ import { assembleMessage, CodexEventTranslator, parseEvent, SseParser } from './
 import { ToolNames, toResponsesRequest } from './codex-translate.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import type { ModelConfig } from './model-config.js';
-import { noteUsageHeaders } from './usage.js';
+import { noteUsageHeaders, UsageScanner } from './usage.js';
 
 export const CODEX_BASE = 'https://chatgpt.com/backend-api/codex';
 const CODEX_VERSION = '0.153.4';
@@ -136,6 +136,11 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
     return;
   }
   const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
+  const scanner = new UsageScanner('codex');
+  const emit = (frames: string): void => {
+    scanner.feed(frames);
+    res.write(frames);
+  };
   try {
     const parser = new SseParser();
     const decoder = new TextDecoder();
@@ -146,10 +151,10 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
       watch.touch();
       for (const raw of parser.push(decoder.decode(value, { stream: true }))) {
         const parsed = parseEvent(raw);
-        if (parsed !== null) res.write(translator.push(parsed.event, parsed.data));
+        if (parsed !== null) emit(translator.push(parsed.event, parsed.data));
       }
     }
-    res.write(translator.close());
+    emit(translator.close());
   } catch (err) {
     if (!watch.idle()) throw err;
     res.write(translator.finished ? '' : translator.close(idleMessage(watch.ms)));
@@ -157,6 +162,7 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
     clearInterval(ping);
     watch.stop();
     res.end();
+    scanner.done();
   }
 }
 
@@ -169,6 +175,9 @@ async function relayWhole(upstream: Response, res: ServerResponse, model: string
     if (parsed !== null) frames += translator.push(parsed.event, parsed.data);
   }
   frames += translator.close();
+  const scanner = new UsageScanner('codex');
+  scanner.feed(frames);
+  scanner.done();
   const message = assembleMessage(frames);
   const kind = isRecord(message.error) ? String(message.error.type) : '';
   res.writeHead(message.type === 'error' ? (STATUS_OF[kind] ?? 502) : 200, { 'content-type': 'application/json' });

package/runtime/node_modules/@metro-labs/daemon/src/gateway/forward.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { UsageScanner } from './usage.js';
 
 export class GatewayError extends Error {
   constructor(
@@ -129,6 +130,7 @@ export function anthropicHeaders(req: IncomingMessage, apiKey: string): Record<s
 export interface PipeOptions {
   keepalive?: boolean;
   ownCredential?: boolean;
+  scanner?: UsageScanner;
 }
 
 function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions): boolean {
@@ -140,12 +142,14 @@ function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions
   return (upstream.headers.get('content-type') ?? '').startsWith('text/event-stream');
 }
 
-async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch): Promise<void> {
+async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, scanner?: UsageScanner): Promise<void> {
   const reader = body.getReader();
+  const decoder = scanner === undefined ? null : new TextDecoder();
   for (;;) {
     const { done, value } = await reader.read();
     if (done) return;
     watch.touch();
+    if (decoder !== null) scanner?.feed(decoder.decode(value, { stream: true }));
     res.write(value);
   }
 }
@@ -159,7 +163,7 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
   }
   const ping = opts.keepalive === true && streaming ? setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS) : null;
   try {
-    await pump(body, res, watch);
+    await pump(body, res, watch, opts.scanner);
   } catch (err) {
     if (!watch.idle()) throw err;
     if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));
@@ -167,6 +171,7 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
     if (ping !== null) clearInterval(ping);
     watch.stop();
     res.end();
+    opts.scanner?.done();
   }
 }
 

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gateway.ts

@@ -15,7 +15,7 @@ import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './co
 import { OPENROUTER_BASE } from './openrouter.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
-import { forgetUsage, noteUsageHeaders } from './usage.js';
+import { forgetUsage, noteUsageHeaders, UsageScanner } from './usage.js';
 import type { CodexTokens } from './codex-auth.js';
 
 export const GATEWAY_PREFIX = '/gateway';
@@ -105,7 +105,8 @@ async function toAnthropic(
     redirect: 'manual',
   });
   noteUsageHeaders('anthropic', upstream.headers);
-  await pipeResponse(upstream, res, watch, key === '' ? {} : { ownCredential: true });
+  const scanner = new UsageScanner('anthropic');
+  await pipeResponse(upstream, res, watch, key === '' ? { scanner } : { ownCredential: true, scanner });
 }
 
 async function toOpenRouter(
@@ -136,7 +137,7 @@ async function toOpenRouter(
     signal: watch.signal,
     redirect: 'manual',
   });
-  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true });
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner('openrouter') });
 }
 
 export function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {

package/runtime/node_modules/@metro-labs/daemon/src/gateway/usage.ts

@@ -1,4 +1,4 @@
-export type UsageProvider = 'anthropic' | 'codex' | 'openrouter';
+export type UsageProvider = 'anthropic' | 'codex' | 'openrouter' | 'bedrock';
 
 export interface UsageWindow {
   label: string;
@@ -7,26 +7,108 @@ export interface UsageWindow {
   detail: string | null;
 }
 
+export interface Tally {
+  requests: number;
+  input: number;
+  output: number;
+  cached: number;
+  since: string;
+}
+
 export interface ProviderUsage {
   windows: UsageWindow[];
   note: string | null;
   at: string;
+  tally: Tally | null;
 }
 
-const latest = new Map<UsageProvider, ProviderUsage>();
+type Reported = Omit<ProviderUsage, 'tally'>;
+
+const latest = new Map<UsageProvider, Reported>();
+const tallies = new Map<UsageProvider, Tally>();
 
-export const noteUsage = (provider: UsageProvider, usage: ProviderUsage): void => {
+export const noteUsage = (provider: UsageProvider, usage: Reported): void => {
   latest.set(provider, usage);
 };
 
-export const usageSeen = (): Partial<Record<UsageProvider, ProviderUsage>> => Object.fromEntries(latest);
+export function usageSeen(): Partial<Record<UsageProvider, ProviderUsage>> {
+  const out: Partial<Record<UsageProvider, ProviderUsage>> = {};
+  const providers = new Set<UsageProvider>([...latest.keys(), ...tallies.keys()]);
+  for (const provider of providers) {
+    const reported = latest.get(provider);
+    const tally = tallies.get(provider) ?? null;
+    out[provider] = reported === undefined
+      ? { windows: [], note: null, at: tally?.since ?? new Date().toISOString(), tally }
+      : { ...reported, tally };
+  }
+  return out;
+}
 
-export const usageOf = (provider: UsageProvider): ProviderUsage | undefined => latest.get(provider);
+export const usageOf = (provider: UsageProvider): Reported | undefined => latest.get(provider);
 
 export const forgetUsage = (): void => {
   latest.clear();
+  tallies.clear();
 };
 
+export interface Counted {
+  input: number;
+  output: number;
+  cached: number;
+}
+
+export function tallyTokens(provider: UsageProvider, counted: Counted, now = new Date()): void {
+  const so = tallies.get(provider) ?? { requests: 0, input: 0, output: 0, cached: 0, since: now.toISOString() };
+  tallies.set(provider, {
+    requests: so.requests + 1,
+    input: so.input + counted.input,
+    output: so.output + counted.output,
+    cached: so.cached + counted.cached,
+    since: so.since,
+  });
+}
+
+const TOKEN_FIELD = /"(input_tokens|output_tokens|cache_read_input_tokens|cache_creation_input_tokens)"\s*:\s*(\d+)/g;
+
+export class UsageScanner {
+  private carry = '';
+  private readonly max = { input: 0, output: 0, read: 0, creation: 0 };
+  private touched = false;
+
+  constructor(private readonly provider: UsageProvider) {}
+
+  private scan(text: string): void {
+    for (const hit of text.matchAll(TOKEN_FIELD)) {
+      const value = Number(hit[2]);
+      if (!Number.isFinite(value)) continue;
+      this.touched = true;
+      if (hit[1] === 'input_tokens') this.max.input = Math.max(this.max.input, value);
+      else if (hit[1] === 'output_tokens') this.max.output = Math.max(this.max.output, value);
+      else if (hit[1] === 'cache_read_input_tokens') this.max.read = Math.max(this.max.read, value);
+      else this.max.creation = Math.max(this.max.creation, value);
+    }
+  }
+
+  feed(text: string): void {
+    const joined = this.carry + text;
+    const cut = joined.lastIndexOf('\n');
+    if (cut === -1) {
+      this.carry = joined;
+      return;
+    }
+    this.scan(joined.slice(0, cut));
+    this.carry = joined.slice(cut + 1);
+  }
+
+  done(now = new Date()): void {
+    if (this.carry !== '') this.scan(this.carry);
+    this.carry = '';
+    if (!this.touched) return;
+    tallyTokens(this.provider, { input: this.max.input, output: this.max.output, cached: this.max.read + this.max.creation }, now);
+    this.touched = false;
+  }
+}
+
 const clamp = (value: number): number => Math.min(1, Math.max(0, value));
 
 function fraction(raw: string | null): number | null {
@@ -83,7 +165,7 @@ function anthropicKeyed(headers: Headers, now: Date): UsageWindow[] {
   ];
 }
 
-export function anthropicUsage(headers: Headers, now = new Date()): ProviderUsage | null {
+export function anthropicUsage(headers: Headers, now = new Date()): Reported | null {
   const unified = anthropicUnified(headers, now);
   if (unified.windows.length > 0) return { ...unified, at: now.toISOString() };
   const keyed = anthropicKeyed(headers, now);
@@ -114,8 +196,15 @@ function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date)
   return { label: windowLabel(Number.isFinite(minutes) ? minutes : null), used, resetAt, detail: null };
 }
 
-export function codexUsage(headers: Headers, now = new Date()): ProviderUsage | null {
-  const windows = [codexWindow(headers, 'primary', now), codexWindow(headers, 'secondary', now)].filter(
+function codexCredits(headers: Headers): UsageWindow | null {
+  if (headers.get('x-codex-credits-has-credits') !== 'true') return null;
+  const balance = Number(headers.get('x-codex-credits-balance') ?? 'none');
+  if (!Number.isFinite(balance)) return null;
+  return { label: 'Credits', used: null, resetAt: null, detail: `${balance.toLocaleString('en-US')} left` };
+}
+
+export function codexUsage(headers: Headers, now = new Date()): Reported | null {
+  const windows = [codexWindow(headers, 'primary', now), codexWindow(headers, 'secondary', now), codexCredits(headers)].filter(
     (w): w is UsageWindow => w !== null,
   );
   if (windows.length === 0) return null;
@@ -130,7 +219,7 @@ export function noteUsageHeaders(provider: 'anthropic' | 'codex', headers: Heade
 
 const dollars = (value: number): string => `$${value.toFixed(2)}`;
 
-export function openrouterUsage(total: number, spent: number, now = new Date()): ProviderUsage {
+export function openrouterUsage(total: number, spent: number, now = new Date()): Reported {
   const used = total > 0 ? clamp(spent / total) : null;
   return {
     windows: [{ label: 'Credits', used, resetAt: null, detail: `${dollars(spent)} of ${dollars(total)} used` }],

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.119"
+  "version": "0.1.0-beta.120"
 }