@stage-labs/metro 0.1.0-beta.163 → 0.1.0-beta.165

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.163",
+  "version": "0.1.0-beta.165",
   "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.163",
+  "version": "0.1.0-beta.165",
   "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, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

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

@@ -49,6 +49,7 @@ import { pipeline } from 'node:stream/promises';
 import {
   claudeDir,
   deleteClaudeSession,
+  deleteMemoryFile,
   listClaudeProjects,
   listClaudeSessions,
   listMemory,
@@ -259,6 +260,7 @@ function removed(rest: string[], query: URLSearchParams, dir: string): unknown {
   const [head = '', item = ''] = rest;
   if (rest.length !== 2) throw new ApiError('method not allowed', 405);
   if (head === 'skills') return { deleted: deleteClaudeSkill(decodeURIComponent(item), dir) };
+  if (head === 'memory') return { deleted: deleteMemoryFile(projectOf(query), decodeURIComponent(item), dir) };
   if (head !== 'sessions') throw new ApiError('method not allowed', 405);
   deleteClaudeSession(projectOf(query), item, dir);
   return { deleted: item };

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

@@ -351,6 +351,14 @@ export function writeMemoryFile(project: string, name: string, text: string, dir
   return { name: file, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
 }
 
+export function deleteMemoryFile(project: string, name: string, dir = claudeDir()): string {
+  const file = safeName(name, MEMORY_RE, 'memory file name');
+  const path = join(memoryDir(project, dir), file);
+  if (!existsSync(path)) throw new ApiError('no such memory file', 404);
+  rmSync(path);
+  return file;
+}
+
 export function readMemoryFile(project: string, name: string, dir = claudeDir()): string {
   const path = join(memoryDir(project, dir), safeName(name, MEMORY_RE, 'memory file name'));
   if (!existsSync(path)) throw new ApiError('no such memory file', 404);

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

@@ -7,7 +7,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { METRO_VERSION } from '@metro-labs/core/version';
 import { agentsDir, listAgentFiles } from '../agents/files.js';
-import { notReady, readModelConfig } from '../gateway/model-config.js';
+import { notReady, readModelConfig, routedConnection } from '../gateway/model-config.js';
 import { claudeDir, listClaudeProjects } from './files.js';
 import { claudeAccount, claudeInstalled } from './login.js';
 import { trustFolder } from './onboarding.js';
@@ -105,7 +105,8 @@ function credentialReady(deps: SessionDeps): string | null {
   if (signedIn()) return null;
   try {
     const cfg = readModelConfig(deps.agents ?? agentsDir());
-    if (cfg.provider !== 'anthropic' && notReady(cfg) === null) return null;
+    const conn = routedConnection(cfg);
+    if (conn !== null && conn.provider !== 'anthropic' && notReady(cfg) === null) return null;
   } catch (err) {
     return `the Model page is not readable (${errMsg(err)})`;
   }

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

@@ -7,7 +7,7 @@ import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { agentsDir } from '../agents/files.js';
 import { claudeDir } from './files.js';
 import { stagedMarketplaceDir } from './plugin-install.js';
-import { readModelConfig, type ModelConfig } from '../gateway/model-config.js';
+import { readModelConfig, routedConnection, type ModelConfig } from '../gateway/model-config.js';
 
 export const PRIVACY_ENV: Record<string, string> = {
   DISABLE_TELEMETRY: '1',
@@ -222,9 +222,9 @@ const MODELS_KEY = 'availableModels';
 const ENFORCE_KEY = 'enforceAvailableModels';
 
 export function routeOf(cfg: ModelConfig): string | null {
-  if (cfg.provider === 'anthropic') return null;
-  const model = cfg[cfg.provider].model;
-  return model === '' ? null : `${cfg.provider}:${model}`;
+  const conn = routedConnection(cfg);
+  if (conn === null || conn.provider === 'anthropic' || conn.model === '') return null;
+  return `${conn.provider}:${conn.model}`;
 }
 
 function withAvailableModels(settings: Record<string, unknown>, route: string | null, metroWrote: boolean): Record<string, unknown> {

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

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 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 type { Connection } from './model-config.js';
 import { UsageScanner } from './usage.js';
 
 const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
@@ -18,7 +18,7 @@ export interface Adaptations {
 export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false });
 
 export interface BedrockUpstream {
-  settings: BedrockSettings;
+  settings: Connection;
   base: string;
   learned: Adaptations;
   watch: Watch;
@@ -253,7 +253,7 @@ export async function bedrockCount(
   res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
 }
 
-export function assertBedrockReady(settings: BedrockSettings): void {
+export function assertBedrockReady(settings: Connection): void {
   if (settings.apiKey === '' || settings.region === '')
     throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key and a region: add them on the Model page.');
 }

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

@@ -7,7 +7,7 @@ import { refreshTokens, tokensStale, type CodexTokens } from './codex-auth.js';
 import { assembleMessage, CodexEventTranslator, parseEvent, SseParser } from './codex-stream.js';
 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 type { Connection } from './model-config.js';
 import { noteUsageHeaders, UsageScanner } from './usage.js';
 
 export const CODEX_BASE = 'https://chatgpt.com/backend-api/codex';
@@ -20,7 +20,7 @@ export interface CodexDeps {
   base?: string;
   issuer?: string;
   fetchImpl?: typeof fetch;
-  save: (tokens: CodexTokens) => void;
+  save: (id: string, tokens: CodexTokens) => void;
 }
 
 export interface CodexState {
@@ -57,13 +57,13 @@ function headersFor(tokens: CodexTokens, sessionId: string): Record<string, stri
 
 const newerThan = (a: CodexTokens, b: CodexTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
-function refreshed(tokens: CodexTokens, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
+function refreshed(id: string, tokens: CodexTokens, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
   const latest = state.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
   if (state.refreshing !== null) return state.refreshing;
   const run = refreshTokens(tokens, deps.issuer, deps.fetchImpl)
     .then((fresh) => {
-      deps.save(fresh);
+      deps.save(id, fresh);
       state.latest = fresh;
       return fresh;
     })
@@ -77,10 +77,10 @@ function refreshed(tokens: CodexTokens, deps: CodexDeps, state: CodexState): Pro
   return run;
 }
 
-export function currentTokens(cfg: ModelConfig, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
-  const tokens = cfg.codex.auth;
+export function currentTokens(conn: Connection, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
+  const tokens = conn.codex;
   if (tokens === null) throw new GatewayError(400, 'invalid_request_error', 'Codex is not connected: sign in on the Model page.');
-  return tokensStale(tokens) ? refreshed(tokens, deps, state) : Promise.resolve(tokens);
+  return tokensStale(tokens) ? refreshed(conn.id, tokens, deps, state) : Promise.resolve(tokens);
 }
 
 function errorKind(status: number): string {
@@ -116,18 +116,18 @@ function send(call: Call, tokens: CodexTokens): Promise<Response> {
   });
 }
 
-async function reach(call: Call, cfg: ModelConfig, state: CodexState): Promise<Response> {
-  let tokens = await currentTokens(cfg, call.deps, state);
+async function reach(call: Call, conn: Connection, state: CodexState): Promise<Response> {
+  let tokens = await currentTokens(conn, call.deps, state);
   let upstream = await send(call, tokens);
   if (upstream.status === 401) {
     await upstream.body?.cancel();
-    tokens = await refreshed(tokens, call.deps, state);
+    tokens = await refreshed(conn.id, tokens, call.deps, state);
     upstream = await send(call, tokens);
   }
   return upstream;
 }
 
-async function relayStream(upstream: Response, res: ServerResponse, model: string, names: ToolNames, watch: Watch): Promise<void> {
+async function relayStream(upstream: Response, res: ServerResponse, model: string, names: ToolNames, watch: Watch, key: string): Promise<void> {
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
   const translator = new CodexEventTranslator(model, (name) => names.restore(name));
   const body = upstream.body;
@@ -136,7 +136,7 @@ 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 scanner = new UsageScanner(key);
   const emit = (frames: string): void => {
     scanner.feed(frames);
     res.write(frames);
@@ -166,7 +166,7 @@ async function relayStream(upstream: Response, res: ServerResponse, model: strin
   }
 }
 
-async function relayWhole(upstream: Response, res: ServerResponse, model: string, names: ToolNames): Promise<void> {
+async function relayWhole(upstream: Response, res: ServerResponse, model: string, names: ToolNames, key: string): Promise<void> {
   const translator = new CodexEventTranslator(model, (name) => names.restore(name));
   let frames = '';
   const parser = new SseParser();
@@ -175,7 +175,7 @@ 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');
+  const scanner = new UsageScanner(key);
   scanner.feed(frames);
   scanner.done();
   const message = assembleMessage(frames);
@@ -189,21 +189,21 @@ export async function codexMessages(
   res: ServerResponse,
   body: Record<string, unknown>,
   model: string,
-  cfg: ModelConfig,
+  conn: Connection,
   deps: CodexDeps,
   state: CodexState,
   watch: Watch,
 ): 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);
+  const upstream = await reach(call, conn, state);
+  noteUsageHeaders('codex', conn.id, 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)}`));
     return;
   }
-  if (body.stream === true) await relayStream(upstream, res, model, call.names, watch);
-  else await relayWhole(upstream, res, model, call.names);
+  if (body.stream === true) await relayStream(upstream, res, model, call.names, watch, conn.id);
+  else await relayWhole(upstream, res, model, call.names, conn.id);
 }
 
 export function codexCount(res: ServerResponse, body: Record<string, unknown>): void {

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

@@ -10,7 +10,7 @@ import {
   type Adaptations,
 } from './bedrock.js';
 import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
-import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
+import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type Connection, type ModelConfig, type Route } from './model-config.js';
 import { codexCount, codexMessages, freshCodexState } from './codex.js';
 import { freshGeminiState, geminiCount, geminiMessages } from './gemini.js';
 import type { GeminiDeps } from './gemini.js';
@@ -52,12 +52,12 @@ export function resetGatewayState(): void {
   Object.assign(geminiState, freshGeminiState());
 }
 
-const saveCodexTokens = (tokens: CodexTokens): void => {
-  writeModelConfig(setCodexAuth(readModelConfig(), tokens));
+const saveCodexTokens = (id: string, tokens: CodexTokens): void => {
+  writeModelConfig(setCodexAuth(readModelConfig(), id, tokens));
 };
 
-const saveGeminiTokens = (tokens: GeminiTokens): void => {
-  writeModelConfig(setGeminiAuth(readModelConfig(), tokens));
+const saveGeminiTokens = (id: string, tokens: GeminiTokens): void => {
+  writeModelConfig(setGeminiAuth(readModelConfig(), id, tokens));
 };
 
 const keyOf = (req: IncomingMessage): string => {
@@ -68,18 +68,16 @@ const keyOf = (req: IncomingMessage): string => {
 const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
 
 function modelsBody(cfg: ModelConfig): Record<string, unknown> {
-  const data: Record<string, string>[] = [];
-  if (cfg.bedrock.model !== '')
-    data.push({ id: `bedrock:${cfg.bedrock.model}`, display_name: `Bedrock · ${cfg.bedrock.model}`, description: 'Through metro, billed to Amazon Bedrock' });
-  if (cfg.openrouter.model !== '')
-    data.push({ id: `openrouter:${cfg.openrouter.model}`, display_name: `OpenRouter · ${cfg.openrouter.model}`, description: 'Through metro, billed to OpenRouter' });
-  if (cfg.codex.model !== '')
-    data.push({ id: `codex:${cfg.codex.model}`, display_name: `Codex · ${cfg.codex.model}`, description: 'Through metro, on your ChatGPT subscription' });
-  if (cfg.gemini.model !== '')
-    data.push({ id: `gemini:${cfg.gemini.model}`, display_name: `Gemini · ${cfg.gemini.model}`, description: 'Through metro, on your Google account' });
+  const data = cfg.connections
+    .filter((c) => c.provider !== 'anthropic' && c.model !== '')
+    .map((c) => ({ id: `${c.provider}:${c.model}`, display_name: `${c.label} · ${c.model}`, description: 'Through metro' }));
   return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
 }
 
+const PASSTHROUGH: Connection = { id: 'passthrough', provider: 'anthropic', label: 'Claude Code login', model: '', apiKey: '', region: '', zdr: false, codex: null, gemini: null };
+
+const passthrough = (body: Record<string, unknown>): Route => ({ connection: PASSTHROUGH, model: requestedModel(body) });
+
 function requestedModel(body: Record<string, unknown>): string {
   const model = body.model;
   if (typeof model !== 'string' || model === '') throw new GatewayError(400, 'invalid_request_error', 'model is required');
@@ -99,10 +97,11 @@ async function toAnthropic(
   route: Route,
   deps: GatewayDeps,
 ): Promise<void> {
+  const conn = route.connection;
   const explicit = typeof body.model === 'string' && body.model !== route.model;
   const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
   const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
-  const key = deps.config().anthropic.apiKey;
+  const key = conn.apiKey;
   if (key === '' && standsInFor(req))
     throw new GatewayError(
       403,
@@ -117,9 +116,9 @@ async function toAnthropic(
     signal: watch.signal,
     redirect: 'manual',
   });
-  noteRefusal('anthropic', route.model, upstream);
-  noteUsageHeaders('anthropic', upstream.headers);
-  const scanner = new UsageScanner('anthropic');
+  noteRefusal(conn.label, route.model, upstream);
+  noteUsageHeaders('anthropic', conn.id, upstream.headers);
+  const scanner = new UsageScanner(conn.id);
   await pipeResponse(upstream, res, watch, key === '' ? { scanner } : { ownCredential: true, scanner });
 }
 
@@ -131,12 +130,13 @@ async function toOpenRouter(
   cfg: ModelConfig,
   deps: GatewayDeps,
 ): Promise<void> {
-  const reason = notReady(cfg, 'openrouter');
+  const conn = route.connection;
+  const reason = notReady(cfg, conn);
   if (reason !== null) throw new GatewayError(400, 'invalid_request_error', reason);
   const headers: Record<string, string> = {
     'content-type': 'application/json',
     accept: req.headers.accept ?? 'application/json',
-    authorization: `Bearer ${cfg.openrouter.apiKey}`,
+    authorization: `Bearer ${conn.apiKey}`,
     'anthropic-version': typeof req.headers['anthropic-version'] === 'string' ? req.headers['anthropic-version'] : '2023-06-01',
     'http-referer': 'https://metro.box',
     'x-title': 'metro',
@@ -147,12 +147,12 @@ async function toOpenRouter(
   const upstream = await fetch(`${deps.openrouterBase ?? OPENROUTER_BASE}${MESSAGES}`, {
     method: 'POST',
     headers,
-    body: JSON.stringify(openrouterBody(body, route.model, cfg.openrouter.zdr)),
+    body: JSON.stringify(openrouterBody(body, route.model, conn.zdr)),
     signal: watch.signal,
     redirect: 'manual',
   });
-  noteRefusal('openrouter', route.model, upstream);
-  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner('openrouter') });
+  noteRefusal(conn.label, route.model, upstream);
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
 }
 
 const thinkingOff = (body: Record<string, unknown>): boolean => isRecord(body.thinking) && body.thinking.type === 'disabled';
@@ -165,41 +165,43 @@ export function openrouterBody(body: Record<string, unknown>, model: string, zdr
   return { ...sent, provider: { ...provider, zdr: true } };
 }
 
-function noteRefusal(provider: string, model: string, upstream: Response): void {
-  if (!upstream.ok) log.warn({ provider, model, status: upstream.status }, 'gateway: the provider refused the request');
+function noteRefusal(connection: string, model: string, upstream: Response): void {
+  if (!upstream.ok) log.warn({ connection, model, status: upstream.status }, 'gateway: the provider refused the request');
 }
 
-async function toSubscription(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, cfg: ModelConfig, deps: GatewayDeps): Promise<void> {
-  if (route.provider === 'gemini') {
+async function toSubscription(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
+  const conn = route.connection;
+  if (conn.provider === 'gemini') {
     if (path === COUNT) geminiCount(res, body);
-    else await geminiMessages(req, res, body, route.model, cfg, { save: saveGeminiTokens, ...deps.gemini }, geminiState, watchUpstream(res));
+    else await geminiMessages(req, res, body, route.model, conn, { save: saveGeminiTokens, ...deps.gemini }, geminiState, watchUpstream(res));
     return;
   }
   if (path === COUNT) codexCount(res, body);
-  else await codexMessages(req, res, body, route.model, cfg, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
+  else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
 }
 
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
   const cfg = deps.config();
   const raw = await readBody(req);
   const body = parseJson(raw);
-  const route = resolveRoute(requestedModel(body), cfg);
-  log.info({ route: routeLabel(route), path }, 'gateway: routing');
-  if (path === MESSAGES) noteServed({ provider: route.provider, model: route.model, at: new Date().toISOString() });
-  if (route.provider === 'bedrock') {
-    assertBedrockReady(cfg.bedrock);
-    const up = { settings: cfg.bedrock, base: deps.bedrockBase ?? bedrockBase(cfg.bedrock.region), learned, watch: watchUpstream(res) };
+  const route = resolveRoute(requestedModel(body), cfg) ?? passthrough(body);
+  const conn = route.connection;
+  log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
+  if (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() });
+  if (conn.provider === 'bedrock') {
+    assertBedrockReady(conn);
+    const up = { settings: conn, base: deps.bedrockBase ?? bedrockBase(conn.region), learned, watch: watchUpstream(res) };
     if (path === COUNT) await bedrockCount(req, res, body, route.model, up);
     else await bedrockMessages(req, res, body, route.model, up);
     return;
   }
-  if (route.provider === 'openrouter') {
+  if (conn.provider === 'openrouter') {
     if (path === COUNT) throw new GatewayError(404, 'not_found_error', 'OpenRouter does not count tokens');
     await toOpenRouter(req, res, body, route, cfg, deps);
     return;
   }
-  if (route.provider === 'codex' || route.provider === 'gemini') {
-    await toSubscription(req, res, path, body, route, cfg, deps);
+  if (conn.provider === 'codex' || conn.provider === 'gemini') {
+    await toSubscription(req, res, path, body, route, deps);
     return;
   }
   await toAnthropic(req, res, raw, body, route, deps);

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

@@ -8,7 +8,7 @@ import { toGeminiRequest } from './gemini-translate.js';
 import { ToolNames } from './codex-translate.js';
 import { assembleMessage, SseParser } from './codex-stream.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
-import type { ModelConfig } from './model-config.js';
+import type { Connection } from './model-config.js';
 import { UsageScanner } from './usage.js';
 
 const PING_MS = 25_000;
@@ -18,7 +18,7 @@ export interface GeminiDeps {
   base?: Bases;
   tokenBase?: string;
   fetchImpl?: typeof fetch;
-  save: (tokens: GeminiTokens) => void;
+  save: (id: string, tokens: GeminiTokens) => void;
 }
 
 export interface GeminiState {
@@ -30,13 +30,13 @@ export const freshGeminiState = (): GeminiState => ({ refreshing: null, latest:
 
 const newerThan = (a: GeminiTokens, b: GeminiTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
-function refreshed(tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
+function refreshed(id: string, tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
   const latest = state.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
   if (state.refreshing !== null) return state.refreshing;
   const run = refreshTokens(tokens, deps.tokenBase, deps.fetchImpl)
     .then((fresh) => {
-      deps.save(fresh);
+      deps.save(id, fresh);
       state.latest = fresh;
       return fresh;
     })
@@ -50,10 +50,10 @@ function refreshed(tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState):
   return run;
 }
 
-export function currentGeminiTokens(cfg: ModelConfig, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
-  const tokens = cfg.gemini.auth;
+export function currentGeminiTokens(conn: Connection, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
+  const tokens = conn.gemini;
   if (tokens === null) throw new GatewayError(400, 'invalid_request_error', 'Gemini is not connected: sign in with Google on the Model page.');
-  return tokensStale(tokens) ? refreshed(tokens, deps, state) : Promise.resolve(tokens);
+  return tokensStale(tokens) ? refreshed(conn.id, tokens, deps, state) : Promise.resolve(tokens);
 }
 
 function errorKind(status: number): string {
@@ -76,6 +76,7 @@ interface Call {
   watch: Watch;
   deps: GeminiDeps;
   names: ToolNames;
+  conn: Connection;
 }
 
 const headersFor = (token: string, stream: boolean): Record<string, string> => ({
@@ -140,12 +141,12 @@ export function refusalMessage(text: string, status: number): string {
   return notes.length === 0 ? message : `${message} (${notes.join('; ')})`;
 }
 
-async function reach(call: Call, cfg: ModelConfig, state: GeminiState, stream: boolean): Promise<Response> {
-  let tokens = await currentGeminiTokens(cfg, call.deps, state);
+async function reach(call: Call, conn: Connection, state: GeminiState, stream: boolean): Promise<Response> {
+  let tokens = await currentGeminiTokens(conn, call.deps, state);
   let upstream = await send(call, tokens, stream);
   if (upstream.status === 401) {
     await upstream.body?.cancel();
-    tokens = await refreshed(tokens, call.deps, state);
+    tokens = await refreshed(conn.id, tokens, call.deps, state);
     upstream = await send(call, tokens, stream);
   }
   return upstream;
@@ -210,7 +211,7 @@ async function relayStream(upstream: Response, res: ServerResponse, call: Call):
     return;
   }
   const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
-  const scanner = new UsageScanner('gemini');
+  const scanner = new UsageScanner(call.conn.id);
   const emit = (frames: string): void => {
     if (frames === '') return;
     scanner.feed(frames);
@@ -245,7 +246,7 @@ async function relayWhole(upstream: Response, res: ServerResponse, call: Call):
   const translator = new GeminiStreamTranslator(call.model, (name) => call.names.restore(name));
   const data = parseData(await upstream.text());
   const frames = (data === null ? '' : translator.push(data)) + translator.close();
-  const scanner = new UsageScanner('gemini');
+  const scanner = new UsageScanner(call.conn.id);
   scanner.feed(frames);
   scanner.done();
   const message = assembleMessage(frames);
@@ -259,14 +260,14 @@ export async function geminiMessages(
   res: ServerResponse,
   body: Record<string, unknown>,
   model: string,
-  cfg: ModelConfig,
+  conn: Connection,
   deps: GeminiDeps,
   state: GeminiState,
   watch: Watch,
 ): Promise<void> {
   const stream = body.stream === true;
-  const call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames() };
-  const upstream = await reach(call, cfg, state, stream);
+  const call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames(), conn };
+  const upstream = await reach(call, conn, state, stream);
   if (!upstream.ok) {
     const text = await upstream.text();
     log.warn({ provider: 'gemini', model, status: upstream.status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');