@stage-labs/metro 0.1.0-beta.310 → 0.1.0-beta.312

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

@@ -1,14 +1,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from '@metro-labs/http/api-error';
-import { apiFailure, apiSession, cors, requireAdmin, sendJson, type ApiSession } from '@metro-labs/http/api-http';
-import { agentsDir } from '../agents/files.js';
-import { removeClaudeLogin } from './claude-logins.js';
-import { readClaudeLogins, type ClaudeLogin } from './claude-store.js';
+import { apiFailure, apiSession, cors, sendJson } from '@metro-labs/http/api-http';
 import { effectiveSetup } from './effective.js';
 import { chainStatus } from './fallback.js';
 import { notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
 import { orgModels, type SyncStatus } from './org-models.js';
-import { claudeModels } from './provider-models.js';
 import { lastServed } from './served.js';
 import { refreshUsage, type UsageDeps } from './usage-refresh.js';
 import { usageSeen } from './usage.js';
@@ -16,19 +12,15 @@ import { usageSeen } from './usage.js';
 const PATH = '/api/model';
 const SNAPSHOT = '/api/model/snapshot';
 const SYNC = '/api/model/sync';
-const CLAUDE_MODELS = '/api/model/claude-models';
-const CLAUDE_LOGIN = '/api/model/claude/';
-const LOGIN_RE = /^[A-Za-z0-9_-]{11}$/;
 
 export interface ModelApiDeps extends UsageDeps {
-  dir?: () => string;
   setup?: () => ModelSetup;
   sync?: () => Promise<void>;
   syncStatus?: () => SyncStatus;
-  anthropicBase?: string;
 }
 
 const NO_SYNC: SyncStatus = { enrolled: false, at: null, error: null };
+const NO_MODEL = "No model is set up for this agent yet: choose one on the organization's Models page.";
 
 function publicConnection(c: Connection): Record<string, unknown> {
   return {
@@ -37,9 +29,9 @@ function publicConnection(c: Connection): Record<string, unknown> {
     label: c.label,
     model: c.model,
     hasKey: c.apiKey !== '',
+    subscription: c.claudeToken !== '',
     region: c.region,
     zdr: c.zdr,
-    signedIn: c.codex !== null || (c.claude !== null && !c.signedOut),
     signedOut: c.signedOut,
     account: c.account.email,
     plan: c.account.plan,
@@ -47,13 +39,12 @@ function publicConnection(c: Connection): Record<string, unknown> {
   };
 }
 
-const loginsOf = (deps: ModelApiDeps): ClaudeLogin[] => readClaudeLogins(deps.dir?.() ?? agentsDir());
-const setupOf = (deps: ModelApiDeps): ModelSetup => (deps.setup ?? (() => effectiveSetup(deps.dir?.())))();
+const setupOf = (deps: ModelApiDeps): ModelSetup => (deps.setup ?? (() => effectiveSetup()))();
 
 export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
   const setup = setupOf(deps);
   const primary = primaryRoute(setup);
-  const reason = primary === null ? null : notReady(primary);
+  const reason = primary === null ? NO_MODEL : notReady(primary);
   return {
     source: setup.source,
     sync: (deps.syncStatus ?? (() => orgModels()?.syncStatus() ?? NO_SYNC))(),
@@ -64,14 +55,13 @@ export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
     connections: setup.connections.map(publicConnection),
     fallbacks: setup.fallbacks,
     chain: chainStatus(setup),
-    claude: loginsOf(deps),
     lastServed: lastServed(),
     usage: usageSeen(),
   };
 }
 
 async function withUsage(deps: ModelApiDeps): Promise<Record<string, unknown>> {
-  await refreshUsage(setupOf(deps), loginsOf(deps), deps);
+  await refreshUsage(setupOf(deps), deps);
   return settingsBody(deps);
 }
 
@@ -80,23 +70,19 @@ async function synced(deps: ModelApiDeps): Promise<Record<string, unknown>> {
   return settingsBody(deps);
 }
 
-function dropLogin(session: ApiSession, login: string, deps: ModelApiDeps): Record<string, unknown> {
-  requireAdmin(session);
-  removeClaudeLogin(login, { ...deps.claudeLogins, dir: deps.dir?.() ?? deps.claudeLogins?.dir });
-  return settingsBody(deps);
-}
+type Run = () => Promise<unknown>;
 
-type Run = (session: ApiSession) => Promise<unknown>;
+const ROUTES: Record<string, [string, (deps: ModelApiDeps) => Promise<unknown>]> = {
+  [PATH]: ['GET', withUsage],
+  [SNAPSHOT]: ['GET', (deps) => Promise.resolve(settingsBody(deps))],
+  [SYNC]: ['POST', synced],
+};
 
 function routeFor(path: string, method: string | undefined, deps: ModelApiDeps): Run | number {
-  const only = (wanted: string, run: Run): Run | number => (method === wanted ? run : 405);
-  if (path === PATH) return only('GET', () => withUsage(deps));
-  if (path === SNAPSHOT) return only('GET', () => Promise.resolve(settingsBody(deps)));
-  if (path === SYNC) return only('POST', () => synced(deps));
-  if (path === CLAUDE_MODELS) return only('GET', () => Promise.resolve({ models: claudeModels(deps.anthropicBase) }));
-  const login = path.slice(CLAUDE_LOGIN.length);
-  if (!LOGIN_RE.test(login)) return 404;
-  return only('DELETE', (session) => Promise.resolve(dropLogin(session, login, deps)));
+  const known = ROUTES[path];
+  if (known === undefined) return 404;
+  const [wanted, run] = known;
+  return method === wanted ? () => run(deps) : 405;
 }
 
 const mine = (path: string): boolean => path === PATH || path.startsWith(`${PATH}/`);
@@ -108,7 +94,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  const route = path === PATH || path.startsWith(CLAUDE_LOGIN) || [SNAPSHOT, SYNC, CLAUDE_MODELS].includes(path) ? routeFor(path, req.method, deps) : 404;
+  const route = routeFor(path, req.method, deps);
   if (typeof route === 'number') {
     sendJson(req, res, route, { error: route === 404 ? 'not found' : 'method not allowed' });
     return true;
@@ -116,7 +102,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
   apiSession(req)
     .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);
-      sendJson(req, res, 200, await route(session));
+      sendJson(req, res, 200, await route());
     })
     .catch((err: unknown) => {
       apiFailure(req, res, err, 'model-api');

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

@@ -1,4 +1,4 @@
-export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex'] as const;
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'routeway'] as const;
 export type Provider = (typeof PROVIDERS)[number];
 export type CodexMethod = 'chatgpt' | 'code';
 export type RouteSource = 'agent' | 'organization';
@@ -26,7 +26,7 @@ export interface Connection {
   zdr: boolean;
   revision: number;
   codex: CodexAccess | null;
-  claude: string | null;
+  claudeToken: string;
   account: Account;
   signedOut: boolean;
 }
@@ -48,64 +48,28 @@ export interface Route {
   model: string;
 }
 
-export const LOCAL_PREFIX = 'local:';
-export const SESSION_LOGIN = `${LOCAL_PREFIX}session`;
 export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Models page.";
 
-const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
+const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex|routeway):(.+)$/;
 const SMALL_RE = /haiku/i;
-const NO_ACCOUNT: Account = { email: null, plan: null, method: null };
 
 export const isProvider = (value: unknown): value is Provider => typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
 
 export const emptySetup = (): ModelSetup => ({ primary: null, fallbacks: [], connections: [], source: null });
 
-export const loginRef = (login: string): string => `${LOCAL_PREFIX}${login}`;
-
-const localConnection = (id: string, label: string, claude: string | null, account: Account, missing: boolean): Connection => ({
-  id,
-  provider: 'anthropic',
-  label,
-  model: '',
-  apiKey: '',
-  region: '',
-  zdr: false,
-  revision: 0,
-  codex: null,
-  claude,
-  account,
-  signedOut: missing,
-});
-
-export const sessionConnection = (): Connection => localConnection(SESSION_LOGIN, 'Claude Code login', null, NO_ACCOUNT, false);
-
-export interface LocalLogin {
-  id: string;
-  email: string | null;
-  plan: string | null;
-}
-
-export function loginConnection(login: string, known: LocalLogin | undefined): Connection {
-  const account = known === undefined ? NO_ACCOUNT : { email: known.email, plan: known.plan, method: null };
-  return localConnection(loginRef(login), known?.email ?? 'Claude login', login, account, known === undefined);
-}
-
 export const connectionOf = (setup: ModelSetup, id: string): Connection | null => setup.connections.find((c) => c.id === id) ?? null;
 
 export function primaryRoute(setup: ModelSetup): Route | null {
-  const primary = setup.primary;
-  const conn = primary === null ? null : connectionOf(setup, primary.connection);
-  if (primary === null || conn === null) return null;
-  return { connection: conn, model: primary.model === '' ? conn.model : primary.model };
+  const steps = setup.primary === null ? [] : [setup.primary, ...setup.fallbacks];
+  for (const step of steps) {
+    const conn = connectionOf(setup, step.connection);
+    if (conn !== null) return { connection: conn, model: step.model === '' ? conn.model : step.model };
+  }
+  return null;
 }
 
-const MISSING_LOGIN = 'This Claude login is not on this box: sign in again on the Model page.';
-
 const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
-  anthropic: [
-    [(r) => r.connection.claude !== null && r.connection.signedOut, MISSING_LOGIN],
-    [(r) => !r.connection.id.startsWith(LOCAL_PREFIX) && r.connection.apiKey === '', "Anthropic has no API key: add it on the organization's Models page."],
-  ],
+  anthropic: [[(r) => r.connection.apiKey === '' && r.connection.claudeToken === '', "Anthropic has no API key or Claude subscription: add one on the organization's Models page."]],
   bedrock: [
     [(r) => r.connection.apiKey === '', "Bedrock has no API key: add it on the organization's Models page."],
     [(r) => r.connection.region === '', "Bedrock needs a region: add it on the organization's Models page."],
@@ -118,6 +82,10 @@ const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
     [(r) => r.connection.codex === null, CODEX_SIGN_IN],
     [(r) => r.model === '', "Codex needs a model id: choose one on the organization's Models page."],
   ],
+  routeway: [
+    [(r) => r.connection.apiKey === '', "Routeway has no API key: add it on the organization's Models page."],
+    [(r) => r.model === '', "Routeway needs a model id: choose one on the organization's Models page."],
+  ],
 };
 
 export const notReady = (route: Route): string | null => CHECKS[route.connection.provider].find(([missing]) => missing(route))?.[1] ?? null;
@@ -128,6 +96,7 @@ const DEFAULTS: Record<Provider, (requested: string, model: string) => string> =
   openrouter: (requested, model) => (requested.includes('/') ? requested : model),
   bedrock: (requested, model) => (model === '' ? requested : model),
   codex: (requested, model) => (requested.startsWith('gpt-') ? requested : model),
+  routeway: (_requested, model) => model,
   anthropic: (requested, model) => (model === '' || isSmallModel(requested) ? requested : model),
 };
 

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

@@ -1,9 +1,13 @@
 import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { errMsg, log } from '@metro-labs/core/log';
 import { agentsDir } from '../agents/files.js';
+import { existsSync } from '../agent-user/agent-fs.js';
+import { removeHome } from '../agent-user/home-fs.js';
+import { agentUser, agentUserExpected } from '../agent-user/user.js';
 
-const LEFTOVER_RE = /^chatgpt-host\.json(?:\.tmp-[0-9]+)?$/;
+const LEFTOVER_RE = /^(?:chatgpt-host|model)\.json(?:\.tmp-[0-9]+)?$/;
 
 const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
 
@@ -30,9 +34,26 @@ function removeOne(path: string): boolean {
   }
 }
 
-export function removeModelLeftovers(dir = agentsDir()): number {
+export function claudeLoginsDir(): string | null {
+  const user = agentUser();
+  if (user === null && agentUserExpected()) return null;
+  return join(user?.home ?? homedir(), '.metro', 'claude-logins');
+}
+
+function removeClaudeLogins(dir: string | null): number {
+  if (dir === null || !existsSync(dir)) return 0;
+  try {
+    removeHome(dir, true);
+    return 1;
+  } catch (err) {
+    log.warn({ err: errMsg(err), dir }, 'org-models: could not remove the folder of the old Claude logins');
+    return 0;
+  }
+}
+
+export function removeModelLeftovers(dir = agentsDir(), logins: string | null = claudeLoginsDir()): number {
   try {
-    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length;
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length + removeClaudeLogins(logins);
     log.info({ removed }, 'org-models: removed the files of the old model setup');
     return removed;
   } catch (err) {

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

@@ -0,0 +1,19 @@
+import type { IncomingMessage } from 'node:http';
+import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
+
+export const ROUTEWAY_BASE = 'https://api.routeway.ai';
+const USER_AGENT = 'metro (+https://metro.box)';
+const HANDED_OVER = new Set([402, 429]);
+
+export function routewayHeaders(req: IncomingMessage, apiKey: string): Record<string, string> {
+  const headers = anthropicHeaders(req, apiKey);
+  headers['user-agent'] ??= USER_AGENT;
+  return headers;
+}
+
+export async function refusedWithPage(upstream: Response, watch: Watch): Promise<void> {
+  if (upstream.ok || HANDED_OVER.has(upstream.status) || !(upstream.headers.get('content-type') ?? '').includes('text/html')) return;
+  await upstream.body?.cancel();
+  watch.stop();
+  throw new GatewayError(502, 'api_error', `metro gateway: Routeway answered with a web page instead of its API (${String(upstream.status)}); try again in a moment`);
+}

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

@@ -1,71 +1,11 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg } from '@metro-labs/core/log';
 import { assembleMessage, SseParser, type SseEvent } from './frames.js';
-import { GatewayError, relayFrames, type Watch } from './forward.js';
+import { relayFrames, type Watch } from './forward.js';
 import { UsageScanner } from './usage.js';
 
 const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
 
-interface Slot<T> {
-  refreshing: Promise<T> | null;
-  latest: T | null;
-}
-
-export type TokenState<T> = Map<string, Slot<T>>;
-
-export interface TokenSource<T extends { savedAt: string }> {
-  label: string;
-  stale: (tokens: T) => boolean;
-  refresh: (tokens: T) => Promise<T>;
-  save: (id: string, tokens: T) => void;
-}
-
-function slotFor<T>(state: TokenState<T>, id: string): Slot<T> {
-  const found = state.get(id);
-  if (found !== undefined) return found;
-  const made: Slot<T> = { refreshing: null, latest: null };
-  state.set(id, made);
-  return made;
-}
-
-const newerThan = (a: { savedAt: string }, b: { savedAt: string }): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
-
-export function refreshed<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T, source: TokenSource<T>): Promise<T> {
-  const slot = slotFor(state, id);
-  const latest = slot.latest;
-  if (latest !== null && newerThan(latest, tokens) && !source.stale(latest)) return Promise.resolve(latest);
-  if (slot.refreshing !== null) return slot.refreshing;
-  const run = source
-    .refresh(tokens)
-    .then((fresh) => {
-      source.save(id, fresh);
-      slot.latest = fresh;
-      return fresh;
-    })
-    .catch((err: unknown) => {
-      throw new GatewayError(403, 'permission_error', `${source.label} sign-in expired (${errMsg(err)}): connect again on the Model page`);
-    })
-    .finally(() => {
-      slot.refreshing = null;
-    });
-  slot.refreshing = run;
-  return run;
-}
-
-export function currentOf<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T | null, source: TokenSource<T>, missing: string): Promise<T> {
-  if (tokens === null) throw new GatewayError(400, 'invalid_request_error', missing);
-  return source.stale(tokens) ? refreshed(state, id, tokens, source) : Promise.resolve(tokens);
-}
-
-export async function reach<T>(current: () => Promise<T>, again: (tokens: T) => Promise<T>, send: (tokens: T) => Promise<Response>): Promise<Response> {
-  const tokens = await current();
-  const upstream = await send(tokens);
-  if (upstream.status !== 401) return upstream;
-  await upstream.body?.cancel();
-  return send(await again(tokens));
-}
-
 export function errorKind(status: number, invalid: readonly number[] = [400, 404]): string {
   if (status === 401 || status === 403) return 'permission_error';
   if (status === 429) return 'rate_limit_error';

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

@@ -1,20 +1,14 @@
 import { errMsg, log } from '@metro-labs/core/log';
-import { readClaudeUsage } from '../claude/usage-probe.js';
 import { openrouterKey } from './openrouter.js';
-import { claudeLoginUsage, keepProbeAnswer, mayProbe, mergeUsage, noteUsage, openrouterUsage, probeAnswer, usageOf } from './usage.js';
-import { loginRef, primaryRoute, SESSION_LOGIN, type Connection, type ModelSetup } from './model-config.js';
-import { probeClaudeLogin, type ClaudeLoginDeps } from './claude-logins.js';
-import type { ClaudeLogin } from './claude-store.js';
+import { mayProbe, noteUsage, openrouterUsage, usageOf } from './usage.js';
+import type { Connection, ModelSetup } from './model-config.js';
 
 export const CREDITS_TTL_MS = 5 * 60_000;
 const WAIT_MS = 4_000;
-const LOGIN_PROBE = 'claude-login';
 
 export interface UsageDeps {
   fetchImpl?: typeof fetch;
   openrouterBase?: string;
-  claudeUsage?: (env?: Record<string, string>) => Promise<unknown>;
-  claudeLogins?: ClaudeLoginDeps;
   usageWaitMs?: number;
 }
 
@@ -23,47 +17,15 @@ const fresh = (id: string, now: number): boolean => {
   return seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS;
 };
 
-const due = (id: string, now: number): boolean => !fresh(id, now) && mayProbe(id, now, CREDITS_TTL_MS);
-
-async function probe(what: string, run: () => Promise<void>): Promise<void> {
+async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
+  if (conn.provider !== 'openrouter' || conn.apiKey === '' || fresh(conn.id, now) || !mayProbe(conn.id, now, CREDITS_TTL_MS)) return;
   try {
-    await run();
+    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
   } catch (err) {
-    log.warn({ err: errMsg(err) }, `model-api: could not read the ${what}`);
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter key spend');
   }
 }
 
-async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
-  if (conn.provider !== 'openrouter' || conn.apiKey === '' || !due(conn.id, now)) return;
-  await probe('OpenRouter key spend', async () => {
-    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
-  });
-}
-
-const hasFallbacks = (setup: ModelSetup): boolean => setup.fallbacks.length > 0;
-
-async function refreshOwnLogin(login: string, setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
-  const key = loginRef(login);
-  if ((fresh(key, now) && !hasFallbacks(setup)) || !mayProbe(key, now, CREDITS_TTL_MS)) return;
-  await probe('usage of a Claude login', async () => {
-    const usage = claudeLoginUsage(await probeClaudeLogin(login, deps.claudeLogins), new Date(now));
-    if (usage !== null) mergeUsage(key, usage);
-  });
-}
-
-const ridesSession = (setup: ModelSetup): boolean => primaryRoute(setup) === null || setup.connections.some((c) => c.id === SESSION_LOGIN);
-
-async function refreshSession(setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
-  if (!ridesSession(setup) || (fresh(SESSION_LOGIN, now) && !hasFallbacks(setup))) return;
-  if (mayProbe(LOGIN_PROBE, now, CREDITS_TTL_MS))
-    await probe('usage of the Claude Code login', async () => {
-      const usage = claudeLoginUsage(await (deps.claudeUsage ?? (() => readClaudeUsage()))(), new Date(now));
-      if (usage !== null) keepProbeAnswer(LOGIN_PROBE, usage);
-    });
-  const usage = probeAnswer(LOGIN_PROBE);
-  if (usage !== undefined && now - Date.parse(usage.at) < CREDITS_TTL_MS) mergeUsage(SESSION_LOGIN, usage);
-}
-
 async function within(ms: number, work: Promise<unknown>): Promise<void> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   const waited = new Promise<void>((resolve) => {
@@ -73,21 +35,15 @@ async function within(ms: number, work: Promise<unknown>): Promise<void> {
   clearTimeout(timer);
 }
 
-export async function refreshUsage(setup: ModelSetup, logins: ClaudeLogin[], deps: UsageDeps = {}, now = Date.now()): Promise<void> {
-  const own = new Set([...logins.map((l) => l.id), ...setup.connections.flatMap((c) => (c.claude === null || c.signedOut ? [] : [c.claude]))]);
-  const work = Promise.all([
-    ...setup.connections.map((conn) => refreshKey(conn, deps, now)),
-    ...[...own].map((login) => refreshOwnLogin(login, setup, deps, now)),
-    refreshSession(setup, deps, now),
-  ]);
-  await within(deps.usageWaitMs ?? WAIT_MS, work);
+export async function refreshUsage(setup: ModelSetup, deps: UsageDeps = {}, now = Date.now()): Promise<void> {
+  await within(deps.usageWaitMs ?? WAIT_MS, Promise.all(setup.connections.map((conn) => refreshKey(conn, deps, now))));
 }
 
-export function watchFallbackUsage(setup: () => ModelSetup, logins: () => ClaudeLogin[], deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
+export function watchFallbackUsage(setup: () => ModelSetup, deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
   const run = (): void => {
     const current = setup();
-    if (!hasFallbacks(current)) return;
-    refreshUsage(current, logins(), deps).catch((err: unknown) => {
+    if (current.fallbacks.length === 0) return;
+    refreshUsage(current, deps).catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
     });
   };

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

@@ -1,6 +1,3 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { stringOf } from '@metro-labs/http/api-http';
-
 type Key = string;
 
 export interface UsageWindow {
@@ -31,14 +28,13 @@ const latest = new Map<Key, Reported>();
 const stamps = new Map<Key, Map<string, number>>();
 const tallies = new Map<Key, Tally>();
 const probed = new Map<Key, number>();
-const answers = new Map<Key, Reported>();
 
 export const noteUsage = (key: Key, usage: Reported): void => {
   latest.set(key, usage);
   stamps.set(key, new Map(usage.windows.map((w) => [w.label, Date.parse(usage.at)])));
 };
 
-export function mergeUsage(key: Key, usage: Reported): void {
+function mergeUsage(key: Key, usage: Reported): void {
   const seen = latest.get(key);
   const marks = stamps.get(key);
   if (seen === undefined || marks === undefined) {
@@ -66,25 +62,11 @@ export function usageSeen(): Record<Key, ProviderUsage> {
 
 export const usageOf = (key: Key): Reported | undefined => latest.get(key);
 
-export const forgetOne = (key: Key): void => {
-  latest.delete(key);
-  stamps.delete(key);
-  tallies.delete(key);
-  probed.delete(key);
-};
-
-export const forgetReported = (key: Key): void => {
-  latest.delete(key);
-  stamps.delete(key);
-  probed.delete(key);
-};
-
 export const forgetUsage = (): void => {
   latest.clear();
   stamps.clear();
   tallies.clear();
   probed.clear();
-  answers.clear();
 };
 
 export function mayProbe(key: Key, now: number, every: number): boolean {
@@ -93,12 +75,6 @@ export function mayProbe(key: Key, now: number, every: number): boolean {
   return true;
 }
 
-export const probeAnswer = (key: Key): Reported | undefined => answers.get(key);
-
-export const keepProbeAnswer = (key: Key, usage: Reported): void => {
-  answers.set(key, usage);
-};
-
 export interface Counted {
   input: number;
   output: number;
@@ -265,47 +241,6 @@ export function codexUsage(headers: Headers, now = new Date()): Reported | null
   return { windows, note: reached === null || reached === '' ? null : reached.replaceAll('_', ' '), at: now.toISOString() };
 }
 
-const present = (w: UsageWindow | null): w is UsageWindow => w !== null;
-
-const textOf = (raw: unknown): string | null => (typeof raw === 'number' || typeof raw === 'string' ? String(raw) : null);
-
-const numberOf = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
-
-const CLAUDE_WINDOWS: [string, string][] = [
-  ['five_hour', '5-hour window'],
-  ['seven_day', 'Weekly, all models'],
-  ['seven_day_sonnet', 'Weekly, Sonnet'],
-  ['seven_day_opus', 'Weekly, Opus'],
-];
-
-function percentWindow(label: string, raw: unknown, now: Date): UsageWindow | null {
-  if (!isRecord(raw)) return null;
-  const percent = numberOf(raw.utilization) ?? numberOf(raw.percent);
-  if (percent === null) return null;
-  return { label, used: clamp(percent / 100), resetAt: whenFrom(textOf(raw.resets_at), now), detail: null };
-}
-
-function scopedName(entry: Record<string, unknown>): string {
-  if (stringOf(entry.display_name) !== '') return stringOf(entry.display_name);
-  if (entry.kind !== 'weekly_scoped' || !isRecord(entry.scope) || !isRecord(entry.scope.model)) return '';
-  return stringOf(entry.scope.model.display_name);
-}
-
-function scopedWindows(limits: Record<string, unknown>, now: Date): (UsageWindow | null)[] {
-  const listed = [limits.model_scoped, limits.limits].flatMap((list): unknown[] => (Array.isArray(list) ? (list as unknown[]) : []));
-  return listed.map((entry) => {
-    const name = isRecord(entry) ? scopedName(entry) : '';
-    return name === '' ? null : percentWindow(`Weekly, ${name}`, entry, now);
-  });
-}
-
-export function claudeLoginUsage(limits: unknown, now = new Date()): Reported | null {
-  if (!isRecord(limits)) return null;
-  const all = [...CLAUDE_WINDOWS.map(([key, label]) => percentWindow(label, limits[key], now)), ...scopedWindows(limits, now)].filter(present);
-  const windows = all.filter((w, index) => all.findIndex((other) => other.label === w.label) === index);
-  return windows.length === 0 ? null : { windows, note: null, at: now.toISOString() };
-}
-
 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) return;

package/runtime/node_modules/@metro-labs/http/src/api-http.ts

@@ -33,7 +33,7 @@ export function requireAdmin(session: ApiSession): void {
 export function cors(req: IncomingMessage): Record<string, string> {
   return {
     'access-control-allow-origin': req.headers.origin ?? '*',
-    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
     'access-control-allow-headers': 'Authorization, Content-Type',
     'access-control-allow-private-network': 'true',
     'access-control-max-age': '86400',

package/runtime/node_modules/@metro-labs/http/src/connector-tools.ts

@@ -9,6 +9,8 @@ export interface RemoteTool {
   title: string;
   description: string;
   readOnly: boolean;
+  destructive?: boolean;
+  openWorld?: boolean;
   inputSchema?: Record<string, unknown>;
 }
 
@@ -36,11 +38,15 @@ async function rpc(url: URL, auth: ConnectorAuth, session: Map<string, string>,
   return resultOf(text, res.headers.get('content-type') ?? '');
 }
 
+function hintsOf(annotations: Record<string, unknown>): Pick<RemoteTool, 'destructive' | 'openWorld'> {
+  return { ...(annotations.destructiveHint === true ? { destructive: true } : {}), ...(annotations.openWorldHint === true ? { openWorld: true } : {}) };
+}
+
 function toTool(raw: unknown): RemoteTool | null {
   if (!isRecord(raw) || typeof raw.name !== 'string') return null;
   const annotations = isRecord(raw.annotations) ? raw.annotations : {};
   const title = typeof raw.title === 'string' && raw.title !== '' ? raw.title : raw.name;
-  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true, ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}) };
+  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true, ...hintsOf(annotations), ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}) };
 }
 
 async function endSession(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<void> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.310"
+  "version": "0.1.0-beta.312"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -18,6 +18,7 @@
     "./train-error": "./src/train-error.ts",
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
+    "./claude-token": "./src/claude-token.ts",
     "./tickets": "./src/tickets.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/claude-token.ts

@@ -0,0 +1,3 @@
+const TOKEN_RE = /^sk-ant-oat01-[A-Za-z0-9_-]{32,512}$/;
+
+export const isClaudeToken = (value: string): boolean => TOKEN_RE.test(value);

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.310",
+  "version": "0.1.0-beta.312",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",