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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.118",
+  "version": "0.1.0-beta.119",
   "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.118",
+  "version": "0.1.0-beta.119",
   "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/codex.ts

@@ -8,6 +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';
 
 export const CODEX_BASE = 'https://chatgpt.com/backend-api/codex';
 const CODEX_VERSION = '0.153.4';
@@ -186,6 +187,7 @@ export async function codexMessages(
 ): Promise<void> {
   const call: Call = { body, model, sessionId: sessionIdOf(req), watch, deps, names: new ToolNames() };
   const upstream = await reach(call, cfg, state);
+  noteUsageHeaders('codex', upstream.headers);
   if (!upstream.ok) {
     const text = await upstream.text();
     sendError(res, providerStatus(upstream.status), errorKind(upstream.status), upstreamMessage(text, `Codex answered ${String(upstream.status)}`));

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

@@ -15,6 +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 type { CodexTokens } from './codex-auth.js';
 
 export const GATEWAY_PREFIX = '/gateway';
@@ -38,6 +39,7 @@ const codexState = freshCodexState();
 
 export function resetGatewayState(): void {
   forgetServed();
+  forgetUsage();
   learned.fields.clear();
   learned.dropBetas = false;
   Object.assign(codexState, freshCodexState());
@@ -102,6 +104,7 @@ async function toAnthropic(
     signal: watch.signal,
     redirect: 'manual',
   });
+  noteUsageHeaders('anthropic', upstream.headers);
   await pipeResponse(upstream, res, watch, key === '' ? {} : { ownCredential: true });
 }
 

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

@@ -2,14 +2,15 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from '@metro-labs/http/api-error';
 import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-labs/http/api-http';
 import { isRecord } from '@metro-labs/core/is-record';
-import { log } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './codex-auth.js';
 import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from './codex.js';
-import { openrouterModels, openrouterZdrModels } from './openrouter.js';
+import { openrouterCredits, openrouterModels, openrouterZdrModels } from './openrouter.js';
 import { anthropicModels, bedrockModels } from './provider-models.js';
 import { syncAvailableModelsQuietly, type SetupDeps } from '../claude/setup.js';
 import { lastServed } from './served.js';
+import { noteUsage, openrouterUsage, usageOf, usageSeen } from './usage.js';
 import type { CodexTokens } from './codex-auth.js';
 import { GatewayError } from './forward.js';
 import {
@@ -57,7 +58,31 @@ interface Route {
   run: Handler;
 }
 
-const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({ ...publicModelConfig(cfg), lastServed: lastServed() });
+const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({
+  ...publicModelConfig(cfg),
+  lastServed: lastServed(),
+  usage: usageSeen(),
+});
+
+const CREDITS_TTL_MS = 5 * 60_000;
+
+async function refreshCredits(cfg: ModelConfig, deps: ModelApiDeps, now = Date.now()): Promise<void> {
+  const key = cfg.openrouter.apiKey;
+  if (key === '') return;
+  const seen = usageOf('openrouter');
+  if (seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS) return;
+  try {
+    const credits = await openrouterCredits(key, deps.openrouterBase, deps.fetchImpl);
+    noteUsage('openrouter', openrouterUsage(credits.total, credits.spent, new Date(now)));
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter credits');
+  }
+}
+
+async function settingsWithUsage(cfg: ModelConfig, deps: ModelApiDeps): Promise<Record<string, unknown>> {
+  await refreshCredits(cfg, deps);
+  return settingsBody(cfg);
+}
 
 function asApiError(err: unknown): never {
   if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
@@ -175,7 +200,7 @@ const named = (table: Record<string, Route>, name: string, method: string | unde
 };
 
 function settingsRoute(method: string | undefined): Route | number {
-  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(settingsBody(store.read())) };
+  if (method === 'GET') return { method: 'GET', run: (_req, deps, store) => settingsWithUsage(store.read(), deps) };
   if (method === 'PUT') return { method: 'POST', run: (req, deps, store) => update(req, store, deps) };
   return 405;
 }

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

@@ -55,6 +55,29 @@ export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof
     .slice(0, MODELS_MAX);
 }
 
+export interface OpenRouterCredits {
+  total: number;
+  spent: number;
+}
+
+export async function openrouterCredits(
+  apiKey: string,
+  base = OPENROUTER_BASE,
+  fetchImpl: typeof fetch = fetch,
+): Promise<OpenRouterCredits> {
+  const res = await fetchImpl(`${base}/v1/credits`, {
+    headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+    redirect: 'manual',
+  });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not report the credits (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = isRecord(body) && isRecord(body.data) ? body.data : {};
+  const total = Number(data.total_credits);
+  const spent = Number(data.total_usage);
+  if (!Number.isFinite(total) || !Number.isFinite(spent)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no credit figures');
+  return { total, spent };
+}
+
 export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> {
   const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
   if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${String(res.status)})`);

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

@@ -0,0 +1,140 @@
+export type UsageProvider = 'anthropic' | 'codex' | 'openrouter';
+
+export interface UsageWindow {
+  label: string;
+  used: number | null;
+  resetAt: string | null;
+  detail: string | null;
+}
+
+export interface ProviderUsage {
+  windows: UsageWindow[];
+  note: string | null;
+  at: string;
+}
+
+const latest = new Map<UsageProvider, ProviderUsage>();
+
+export const noteUsage = (provider: UsageProvider, usage: ProviderUsage): void => {
+  latest.set(provider, usage);
+};
+
+export const usageSeen = (): Partial<Record<UsageProvider, ProviderUsage>> => Object.fromEntries(latest);
+
+export const usageOf = (provider: UsageProvider): ProviderUsage | undefined => latest.get(provider);
+
+export const forgetUsage = (): void => {
+  latest.clear();
+};
+
+const clamp = (value: number): number => Math.min(1, Math.max(0, value));
+
+function fraction(raw: string | null): number | null {
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? clamp(value) : null;
+}
+
+const MS_THRESHOLD = 1e12;
+
+function whenFrom(raw: string | null, now: Date, relative = false): string | null {
+  if (raw === null || raw.trim() === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric)) {
+    const absolute = numeric > MS_THRESHOLD ? numeric : numeric * 1000;
+    const ms = relative ? now.getTime() + numeric * 1000 : absolute;
+    return new Date(ms).toISOString();
+  }
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+
+const ANTHROPIC_WINDOWS: [string, string][] = [
+  ['5h', '5-hour window'],
+  ['7d', 'Weekly'],
+  ['7d_sonnet', 'Weekly, Sonnet'],
+];
+
+function anthropicUnified(headers: Headers, now: Date): { windows: UsageWindow[]; note: string | null } {
+  const windows: UsageWindow[] = [];
+  let note: string | null = null;
+  for (const [key, label] of ANTHROPIC_WINDOWS) {
+    const used = fraction(headers.get(`anthropic-ratelimit-unified-${key}-utilization`));
+    if (used === null) continue;
+    const status = headers.get(`anthropic-ratelimit-unified-${key}-status`);
+    const blocked = status !== null && status !== 'allowed' ? status.replaceAll('_', ' ') : null;
+    if (blocked !== null && note === null) note = `${label}: ${blocked}`;
+    windows.push({ label, used, resetAt: whenFrom(headers.get(`anthropic-ratelimit-unified-${key}-reset`), now), detail: blocked });
+  }
+  return { windows, note };
+}
+
+function anthropicKeyed(headers: Headers, now: Date): UsageWindow[] {
+  const limit = Number(headers.get('anthropic-ratelimit-tokens-limit'));
+  const remaining = Number(headers.get('anthropic-ratelimit-tokens-remaining'));
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining) || limit <= 0) return [];
+  return [
+    {
+      label: 'Tokens per minute',
+      used: clamp(1 - remaining / limit),
+      resetAt: whenFrom(headers.get('anthropic-ratelimit-tokens-reset'), now),
+      detail: `${remaining.toLocaleString('en-US')} of ${limit.toLocaleString('en-US')} left`,
+    },
+  ];
+}
+
+export function anthropicUsage(headers: Headers, now = new Date()): ProviderUsage | null {
+  const unified = anthropicUnified(headers, now);
+  if (unified.windows.length > 0) return { ...unified, at: now.toISOString() };
+  const keyed = anthropicKeyed(headers, now);
+  return keyed.length === 0 ? null : { windows: keyed, note: null, at: now.toISOString() };
+}
+
+const MINUTES_PER_HOUR = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_WEEK = 7 * MINUTES_PER_DAY;
+
+export function windowLabel(minutes: number | null): string {
+  if (minutes === null || !Number.isFinite(minutes) || minutes <= 0) return 'Usage window';
+  if (minutes === MINUTES_PER_WEEK) return 'Weekly';
+  if (minutes % MINUTES_PER_DAY === 0) return `${String(minutes / MINUTES_PER_DAY)}-day window`;
+  if (minutes % MINUTES_PER_HOUR === 0) return `${String(minutes / MINUTES_PER_HOUR)}-hour window`;
+  return `${String(minutes)}-minute window`;
+}
+
+function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date): UsageWindow | null {
+  const raw = headers.get(`x-codex-${kind}-used-percent`);
+  if (raw === null) return null;
+  const percent = Number(raw);
+  if (!Number.isFinite(percent)) return null;
+  const used = clamp(percent / 100);
+  const minutes = Number(headers.get(`x-codex-${kind}-window-minutes`) ?? 'none');
+  const absolute = whenFrom(headers.get(`x-codex-${kind}-reset-at`), now);
+  const resetAt = absolute ?? whenFrom(headers.get(`x-codex-${kind}-reset-after-seconds`), now, true);
+  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(
+    (w): w is UsageWindow => w !== null,
+  );
+  if (windows.length === 0) return null;
+  const reached = headers.get('x-codex-rate-limit-reached-type');
+  return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
+}
+
+export function noteUsageHeaders(provider: 'anthropic' | 'codex', headers: Headers, now = new Date()): void {
+  const usage = provider === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
+  if (usage !== null) noteUsage(provider, usage);
+}
+
+const dollars = (value: number): string => `$${value.toFixed(2)}`;
+
+export function openrouterUsage(total: number, spent: number, now = new Date()): ProviderUsage {
+  const used = total > 0 ? clamp(spent / total) : null;
+  return {
+    windows: [{ label: 'Credits', used, resetAt: null, detail: `${dollars(spent)} of ${dollars(total)} used` }],
+    note: null,
+    at: now.toISOString(),
+  };
+}

package/runtime/runtime.json

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