@stage-labs/metro 0.1.0-beta.164 → 0.1.0-beta.166

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

@@ -0,0 +1,70 @@
+import type { IncomingMessage } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { CodexAuthError } from './codex-auth.js';
+import { GeminiAuthError } from './gemini-auth.js';
+import { GatewayError } from './forward.js';
+import { lastServed } from './served.js';
+import { usageSeen } from './usage.js';
+import { ModelConfigError, connectionOf, publicModelConfig, routedConnection, type Connection, type ModelConfig, type Provider } from './model-config.js';
+import type { SetupDeps } from '../claude/setup.js';
+
+export interface ModelApiDeps {
+  authorize: (subject: string) => void;
+  read?: () => ModelConfig;
+  write?: (cfg: ModelConfig) => void;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  codexHome?: string;
+  codexBase?: string;
+  geminiAuthBase?: string;
+  geminiTokenBase?: string;
+  geminiUserBase?: string;
+  geminiBase?: string;
+  openrouterBase?: string;
+  anthropicBase?: string;
+  bedrockControlBase?: string;
+  setup?: SetupDeps;
+}
+
+export interface Store {
+  read: () => ModelConfig;
+  write: (cfg: ModelConfig) => void;
+}
+
+export type Handler = (req: IncomingMessage, deps: ModelApiDeps, store: Store) => Promise<unknown>;
+
+export interface Route {
+  method: 'GET' | 'POST';
+  run: Handler;
+}
+
+export const BODY_MAX = 16 * 1024;
+export const CREDITS_TTL_MS = 5 * 60_000;
+
+export const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({
+  ...publicModelConfig(cfg),
+  lastServed: lastServed(),
+  usage: usageSeen(),
+});
+
+export function asApiError(err: unknown): never {
+  if (err instanceof ModelConfigError || err instanceof CodexAuthError || err instanceof GeminiAuthError) throw new ApiError(err.message, 400);
+  if (err instanceof GatewayError) throw new ApiError(err.message, err.status >= 400 && err.status < 500 ? 400 : 502);
+  throw err;
+}
+
+export const askedConnection = (req: IncomingMessage): string => new URL(req.url ?? '', 'http://metro').searchParams.get('connection') ?? '';
+
+export function connectionFor(cfg: ModelConfig, req: IncomingMessage, provider: Provider): Connection {
+  const asked = askedConnection(req);
+  if (asked !== '') {
+    const found = connectionOf(cfg, asked);
+    if (found?.provider !== provider) throw new ApiError('no such connection', 404);
+    return found;
+  }
+  const routed = routedConnection(cfg);
+  if (routed?.provider === provider) return routed;
+  const first = cfg.connections.find((c) => c.provider === provider);
+  if (first === undefined) throw new ApiError(`no ${provider} connection yet`, 400);
+  return first;
+}

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

@@ -1,6 +1,6 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { GatewayError } from './forward.js';
-import type { AnthropicSettings, BedrockSettings } from './model-config.js';
+import type { Connection } from './model-config.js';
 
 export const ANTHROPIC_API = 'https://api.anthropic.com';
 const ANTHROPIC_VERSION = '2023-06-01';
@@ -20,7 +20,7 @@ export const KNOWN_CLAUDE: ProviderModel[] = [
 
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
-export async function anthropicModels(settings: AnthropicSettings, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+export async function anthropicModels(settings: Connection, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
   if (settings.apiKey === '') return KNOWN_CLAUDE;
   const res = await fetchImpl(`${base}/v1/models?limit=${String(LIST_MAX)}`, {
     headers: { 'x-api-key': settings.apiKey, 'anthropic-version': ANTHROPIC_VERSION, accept: 'application/json' },
@@ -37,7 +37,7 @@ export async function anthropicModels(settings: AnthropicSettings, base = ANTHRO
 
 export const bedrockControlBase = (region: string): string => `https://bedrock.${region}.amazonaws.com`;
 
-export async function bedrockModels(settings: BedrockSettings, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+export async function bedrockModels(settings: Connection, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
   if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
   if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
   const res = await fetchImpl(`${base ?? bedrockControlBase(settings.region)}/inference-profiles?maxResults=${String(LIST_MAX)}`, {

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

@@ -1,4 +1,5 @@
 export interface Served {
+  connection: string;
   provider: string;
   model: string;
   at: string;

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

@@ -1,4 +1,4 @@
-export type UsageProvider = 'anthropic' | 'codex' | 'openrouter' | 'bedrock' | 'gemini';
+type Key = string;
 
 export interface UsageWindow {
   label: string;
@@ -24,27 +24,29 @@ export interface ProviderUsage {
 
 type Reported = Omit<ProviderUsage, 'tally'>;
 
-const latest = new Map<UsageProvider, Reported>();
-const tallies = new Map<UsageProvider, Tally>();
+const latest = new Map<Key, Reported>();
+const tallies = new Map<Key, Tally>();
 
-export const noteUsage = (provider: UsageProvider, usage: Reported): void => {
-  latest.set(provider, usage);
+export const noteUsage = (key: Key, usage: Reported): void => {
+  latest.set(key, usage);
 };
 
-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 };
+export function usageSeen(): Record<Key, ProviderUsage> {
+  const out: Record<Key, ProviderUsage> = {};
+  for (const key of new Set<Key>([...latest.keys(), ...tallies.keys()])) {
+    const reported = latest.get(key);
+    const tally = tallies.get(key) ?? null;
+    out[key] = reported === undefined ? { windows: [], note: null, at: tally?.since ?? new Date().toISOString(), tally } : { ...reported, tally };
   }
   return out;
 }
 
-export const usageOf = (provider: UsageProvider): Reported | undefined => latest.get(provider);
+export const usageOf = (key: Key): Reported | undefined => latest.get(key);
+
+export const forgetOne = (key: Key): void => {
+  latest.delete(key);
+  tallies.delete(key);
+};
 
 export const forgetUsage = (): void => {
   latest.clear();
@@ -57,9 +59,9 @@ export interface Counted {
   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, {
+export function tallyTokens(key: Key, counted: Counted, now = new Date()): void {
+  const so = tallies.get(key) ?? { requests: 0, input: 0, output: 0, cached: 0, since: now.toISOString() };
+  tallies.set(key, {
     requests: so.requests + 1,
     input: so.input + counted.input,
     output: so.output + counted.output,
@@ -75,7 +77,7 @@ export class UsageScanner {
   private readonly max = { input: 0, output: 0, read: 0, creation: 0 };
   private touched = false;
 
-  constructor(private readonly provider: UsageProvider) {}
+  constructor(private readonly key: Key) {}
 
   private scan(text: string): void {
     for (const hit of text.matchAll(TOKEN_FIELD)) {
@@ -104,7 +106,7 @@ export class UsageScanner {
     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);
+    tallyTokens(this.key, { input: this.max.input, output: this.max.output, cached: this.max.read + this.max.creation }, now);
     this.touched = false;
   }
 }
@@ -212,9 +214,9 @@ export function codexUsage(headers: Headers, now = new Date()): Reported | null
   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);
+export function noteUsageHeaders(kind: 'anthropic' | 'codex', key: Key, headers: Headers, now = new Date()): void {
+  const usage = kind === 'anthropic' ? anthropicUsage(headers, now) : codexUsage(headers, now);
+  if (usage !== null) noteUsage(key, usage);
 }
 
 const dollars = (value: number): string => `$${value.toFixed(2)}`;

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.164"
+  "version": "0.1.0-beta.166"
 }