@stage-labs/metro 0.1.0-beta.170 → 0.1.0-beta.172

package/dist/cli.js

@@ -9,15 +9,15 @@ import { service, serviceStopHint } from './service.js';
 import { currentVersion } from './version.js';
 const USAGE = `metro — run your agent on this machine
 
-  metro serve [--port <n>] [--owner <address>]
+  metro serve [--port <n>] [--owner <organization id>]
                   run the daemon: the agent, its channels and its connectors live in
                   ~/.metro/agents here, and it is published through Tailscale Funnel at a
                   permanent https://<machine>.<tailnet>.ts.net (Tailscale installed and
                   signed in on this machine); the page at metro.box manages it through the
-                  link it prints; --owner names the one wallet that may sign in, needed on
-                  the first start only; Stop on the page parks the daemon and keeps the
+                  link it prints; --owner names the organization whose members may sign
+                  in, needed on the first start only; Stop on the page parks the daemon and keeps the
                   address, so Start works from the page too
-  metro service install [--port <n>] [--owner <address>]
+  metro service install [--port <n>] [--owner <organization id>]
                   run metro serve as a service (systemd on Linux, launchd on macOS): it
                   starts at boot and after a crash, so the page can stop, start and
                   restart it with no shell; metro service uninstall and status as well
@@ -26,18 +26,15 @@ const USAGE = `metro — run your agent on this machine
                   follow this machine's inbound events, one JSON line each
   metro whoami    print the agent this machine runs
   metro claude [args...]
-                  open Claude Code with the metro channel; every argument is passed through
-                  the same, with inference on Amazon Bedrock through a local proxy so the
-                  channel still works (needs AWS_BEARER_TOKEN_BEDROCK and AWS_REGION)
+                  open Claude Code with the metro channel and the metro MCP server, its
+                  inference routed through the daemon's model gateway (the Model page);
+                  every argument is passed through the same
   metro update    update to the newest published version (--check only reports)
   metro version   print this CLI's version
 
   METRO_WEBHOOK_PORT the daemon's port (default 8420)
   METRO_AGENTS_DIR   where the agents live (default ~/.metro/agents)
   METRO_AGENT_KEY    the key metro tail presents, instead of the agent file's
-  METRO_BEDROCK_MODEL
-                     send every request to this Bedrock model id (default: derive from the
-                     model Claude Code asks for, e.g. eu.anthropic.claude-sonnet-4-6)
   METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
 async function stopDaemon() {

package/dist/route.js

@@ -1,19 +1,27 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentsDir } from './local.js';
-const PROVIDERS = ['bedrock', 'openrouter', 'codex', 'gemini'];
+const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini']);
+const text = (value) => (typeof value === 'string' ? value : '');
+function routeIn(cfg) {
+    if (typeof cfg !== 'object' || cfg === null)
+        return null;
+    const { route, connections } = cfg;
+    if (!Array.isArray(connections))
+        return null;
+    const conn = connections.find((c) => typeof c === 'object' && c !== null && c.id === route);
+    if (typeof conn !== 'object' || conn === null)
+        return null;
+    const provider = text(conn.provider);
+    const model = text(conn.model);
+    return PROVIDERS.has(provider) && model !== '' ? `${provider}:${model}` : null;
+}
 export function currentRoute(dir = agentsDir()) {
     const path = join(dir, 'model.json');
     if (!existsSync(path))
         return null;
     try {
-        const cfg = JSON.parse(readFileSync(path, 'utf8'));
-        const provider = PROVIDERS.find((p) => p === cfg.provider);
-        if (provider === undefined)
-            return null;
-        const block = cfg[provider];
-        const model = typeof block === 'object' && block !== null ? block.model : undefined;
-        return typeof model === 'string' && model !== '' ? `${provider}:${model}` : null;
+        return routeIn(JSON.parse(readFileSync(path, 'utf8')));
     }
     catch {
         return null;

package/dist/serve.js

@@ -12,7 +12,7 @@ const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
 const PORT_FLAG = /^--port=(.*)$/;
 const OWNER_FLAG = /^--owner=(.*)$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
-const USAGE = 'usage: metro serve [--port <n>] [--owner <address>]';
+const USAGE = 'usage: metro serve [--port <n>] [--owner <organization id>]';
 const TUNNEL_FLAG = /^--(no-)?tunnel(=.*)?$/;
 const TAILSCALE_APP = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
 function portOf(raw) {

package/dist/service.js

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { serveLockedBy } from './control.js';
 import { findBun } from './runtime.js';
 import { findTailscale, parseServeArgs, requireOwner } from './serve.js';
-const USAGE = 'usage: metro service install [--port <n>] [--owner <address>] | uninstall | status';
+const USAGE = 'usage: metro service install [--port <n>] [--owner <organization id>] | uninstall | status';
 const SERVICE = 'metro';
 const LABEL = 'box.metro.serve';
 const CARRIED = /^(METRO_.*|XDG_CACHE_HOME|PATH|HOME)$/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.170",
+  "version": "0.1.0-beta.172",
   "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/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
     {
       "name": "metro",
       "source": "./plugin",
-      "description": "Sign in as one metro agent and use the connectors it holds as MCP servers through metro's relay, credentials injected server-side."
+      "description": "Every connector on this box as its own MCP server through metro's local relay, the orchestrator guard, and the standing rules loaded at session start."
     }
   ]
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.170",
+  "version": "0.1.0-beta.172",
   "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",
@@ -13,6 +13,5 @@
     "mcp",
     "connectors",
     "relay"
-  ],
-  "skills": "./skills/"
+  ]
 }

package/runtime/node_modules/@metro-labs/core/src/stations/account-store.ts

@@ -26,7 +26,7 @@ export function makeAccountStore<T extends { id: string }>(
   function loadAccounts(): T[] {
     if (!existsSync(opts.file))
       return die(
-        `no accounts file ${opts.file} — the daemon writes it from the database at boot; set DATABASE_URL and populate the accounts table`,
+        `no accounts file ${opts.file} — the daemon writes it from ~/.metro/agents/agent.json at boot; attach an account to this station from the page first`,
       );
     chmodIfExists(opts.file);
     let raw: T[];

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

@@ -44,7 +44,7 @@ export class InboundRelay {
   private readonly pendingAttachments = new Map<string, PendingMsg>();
   private readonly seenEvents = new Map<string, number>();
   private readonly allowedLines = new Set<string>();
-  private readonly pendingPermissions = new Set<string>();
+  private readonly pendingPermissions = new Map<string, string>();
   private readonly sentIds = new Set<string>();
   private lastLine: string | undefined;
 
@@ -56,9 +56,13 @@ export class InboundRelay {
     return this.lastLine;
   }
 
-  registerPermission(requestId: string): void {
-    this.pendingPermissions.add(requestId);
-    capSet(this.pendingPermissions, PENDING_PERMISSIONS_MAX);
+  registerPermission(requestId: string, line: string): void {
+    this.pendingPermissions.set(requestId, line);
+    while (this.pendingPermissions.size > PENDING_PERMISSIONS_MAX) {
+      const oldest = this.pendingPermissions.keys().next();
+      if (oldest.done) break;
+      this.pendingPermissions.delete(oldest.value);
+    }
   }
 
   noteSent(messageId: string): void {
@@ -104,6 +108,7 @@ export class InboundRelay {
         from: ctx.from,
         station: ctx.station,
         ...senderMeta(ctx),
+        ...ctx.reply,
         kind: note.kind,
         mime: p.mime ?? '',
         name: note.name,
@@ -149,6 +154,7 @@ export class InboundRelay {
         line_name: e.lineName,
         from_name: e.fromName,
         ...displayNameMeta(e.fromDisplayName),
+        ...e.reply,
       },
     });
   }
@@ -206,6 +212,7 @@ export class InboundRelay {
       lineName: str(ev.lineName),
       fromName: str(ev.fromName),
       fromDisplayName: str(ev.fromDisplayName),
+      reply: replyMeta(ev, this.sentIds),
       attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
       saved: new Set<number>(),
       timer: setTimeout(() => {
@@ -253,12 +260,12 @@ export class InboundRelay {
     });
   }
 
-  private async handlePermissionReply(text: string): Promise<boolean> {
+  private async handlePermissionReply(text: string, line: string): Promise<boolean> {
     const m = PERMISSION_REPLY_RE.exec(text);
     if (m?.[1] === undefined || m[2] === undefined || !this.pendingPermissions.size)
       return false;
     const id = m[2].toLowerCase();
-    if (!this.pendingPermissions.has(id)) return false;
+    if (this.pendingPermissions.get(id) !== line) return false;
     this.pendingPermissions.delete(id);
     await this.notify('notifications/claude/channel/permission', {
       request_id: id,
@@ -315,7 +322,7 @@ export class InboundRelay {
       this.deps.log('drop: empty message', base.station, base.line, str(ev.messageId));
       return;
     }
-    if (base.evType === 'msg' && (await this.handlePermissionReply(base.text)))
+    if (base.evType === 'msg' && (await this.handlePermissionReply(base.text, base.line)))
       return;
     await this.notify('notifications/claude/channel', {
       content:

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

@@ -15,6 +15,7 @@ export interface PendingMsg {
   lineName: string;
   fromName: string;
   fromDisplayName: string;
+  reply: Record<string, string>;
   attachments: PendingAtt[];
   saved: Set<number>;
   timer: ReturnType<typeof setTimeout>;
@@ -30,6 +31,7 @@ export interface MediaCtx {
   lineName?: string;
   fromName?: string;
   fromDisplayName?: string;
+  reply?: Record<string, string>;
 }
 
 export function capSet(set: Set<string>, max: number): void {
@@ -69,6 +71,7 @@ export function takeMediaCtx(buf: PendingMsg): MediaCtx {
     lineName: buf.lineName,
     fromName: buf.fromName,
     fromDisplayName: buf.fromDisplayName,
+    reply: buf.reply,
   };
   buf.text = '';
   return ctx;

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

@@ -70,12 +70,49 @@ function sweep(now: number): void {
   }
 }
 
+const CHECK_MS = 30_000;
+
+interface Checked<T> {
+  at: number;
+  value: T;
+}
+
+const checks: { installed?: Checked<boolean>; account?: Checked<ClaudeAccount> } = {};
+
+function remembered<T>(slot: Checked<T> | undefined, read: () => T, keep: (c: Checked<T>) => void): T {
+  const now = Date.now();
+  if (slot !== undefined && now - slot.at < CHECK_MS) return slot.value;
+  const value = read();
+  keep({ at: now, value });
+  return value;
+}
+
+function forgetClaudeChecks(): void {
+  delete checks.installed;
+  delete checks.account;
+}
+
 export function claudeInstalled(): boolean {
-  const run = spawnSync('claude', ['--version'], { stdio: 'ignore' });
-  return run.error === undefined && run.status === 0;
+  return remembered(checks.installed, () => {
+    const run = spawnSync('claude', ['--version'], { stdio: 'ignore' });
+    return run.error === undefined && run.status === 0;
+  }, (c) => {
+    checks.installed = c;
+  });
+}
+
+interface ClaudeAccount {
+  signedIn: boolean;
+  account: string | null;
+}
+
+export function claudeAccount(): ClaudeAccount {
+  return remembered(checks.account, readAccount, (c) => {
+    checks.account = c;
+  });
 }
 
-export function claudeAccount(): { signedIn: boolean; account: string | null } {
+function readAccount(): ClaudeAccount {
   const run = spawnSync('claude', STATUS_COMMAND, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
   if (run.error !== undefined || typeof run.stdout !== 'string') return { signedIn: false, account: null };
   try {
@@ -126,6 +163,7 @@ export function startClaudeLogin(deps: LoginDeps = {}, now = Date.now()): LoginV
       session.state = code === 0 ? 'done' : 'failed';
       if (code !== 0) session.error = `the login ended with status ${String(code)}`;
       terminal.close();
+      forgetClaudeChecks();
       const onboarding = code === 0 ? markOnboardingDone() : 'skipped';
       log.info({ state: session.state, onboarding }, 'claude-login: the official login finished');
     })

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

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { ApiError } from '@metro-labs/http/api-error';
 import { claudeDir, listClaudeProjects } from './files.js';
@@ -68,8 +68,17 @@ function projectEntries(dir: string): ClaudeSettingsFile[] {
   return out;
 }
 
+const sameFile = (a: string, b: string): boolean => {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return a === b;
+  }
+};
+
 export function listClaudeSettings(dir = claudeDir()): ClaudeSettingsFile[] {
-  return [entryOf(USER_ID, 'user', 'This machine', join(dir, 'settings.json')), ...projectEntries(dir)];
+  const user = entryOf(USER_ID, 'user', 'This machine', join(dir, 'settings.json'));
+  return [user, ...projectEntries(dir).filter((p) => !sameFile(p.path, user.path))];
 }
 
 function assertSettingsJson(text: string): void {

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

@@ -146,6 +146,18 @@ function startKeepalive(res: ServerResponse): Keepalive {
   };
 }
 
+function drainedOrClosed(res: ServerResponse): Promise<void> {
+  return new Promise((resolve) => {
+    const done = (): void => {
+      res.off('drain', done);
+      res.off('close', done);
+      resolve();
+    };
+    res.once('drain', done);
+    res.once('close', done);
+  });
+}
+
 async function pumpBody(
   res: ServerResponse,
   body: ReadableStream<Uint8Array>,
@@ -156,11 +168,7 @@ async function pumpBody(
     const { done, value } = await reader.read();
     if (done) return;
     touch();
-    const ok = res.write(value);
-    if (!ok)
-      await new Promise((resolve) => {
-        res.once('drain', resolve);
-      });
+    if (!res.write(value)) await drainedOrClosed(res);
   }
 }
 
@@ -229,13 +237,29 @@ async function relayExchange(
   res.once('finish', () => {
     res.socket?.removeListener('close', bail);
   });
+  try {
+    await relayOnce(req, res, connectorId, deps, control.signal);
+  } catch (err) {
+    if (!control.signal.aborted) throw err;
+    log.debug({ connector: connectorId }, 'relay: the client left before the answer ended');
+    if (!res.writableEnded) res.end();
+  }
+}
+
+async function relayOnce(
+  req: IncomingMessage,
+  res: ServerResponse,
+  connectorId: string,
+  deps: RelayApiDeps,
+  signal: AbortSignal,
+): Promise<void> {
   const body = req.method === 'POST' ? await readCapped(req) : null;
   const out = await exchange(
     req,
     connectorId,
     deps,
     body,
-    control.signal,
+    signal,
   );
   if (out.kind === 'missing') {
     answer(res, 404, { error: 'no such connector' });

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

@@ -216,19 +216,25 @@ export function localMarkSignedOut(id: string, dir = agentsDir()): void {
   replace(dir, signedOut(row));
 }
 
-async function freshAuth(auth: ConnectorAuth, resource: string): Promise<ConnectorAuth> {
+async function freshAuth(row: LocalConnectorRow, dir: string): Promise<ConnectorAuth> {
+  const auth = row.config.auth;
   if (auth.kind !== 'oauth' || !oauthExpired(auth)) return auth;
-  return refreshOAuth(auth, resource);
+  return refreshOnce(row, auth, dir);
+}
+
+function updateRow(dir: string, id: string, config: Partial<LocalConnectorRow['config']>): void {
+  const now = readLocalConnectors(dir).find((r) => r.id === id);
+  if (now !== undefined) replace(dir, { ...now, config: { ...now.config, ...config } });
 }
 
 export async function localVerifyConnector(subject: string, id: string, dir = agentsDir()): Promise<ConnectorCheck> {
   const row = rowOrThrow(subject, id, dir);
   try {
     const url = parseConnectorUrl(row.url);
-    const auth = await freshAuth(row.config.auth, url.toString());
+    const auth = await freshAuth(row, dir);
     const verified = stamp(await verifyRemoteMcp(url, auth));
     const oauth = row.config.oauth || (await oauthCapable(url, auth));
-    replace(dir, { ...row, config: { ...row.config, auth, verified, oauth } });
+    updateRow(dir, row.id, { auth, verified, oauth });
     return { id: row.id, name: row.name, ok: true, verified };
   } catch (err) {
     if (!(err instanceof ConnectorVerifyError)) throw err;
@@ -239,9 +245,7 @@ export async function localVerifyConnector(subject: string, id: string, dir = ag
 export async function localConnectorTools(subject: string, id: string, dir = agentsDir()): Promise<RemoteTool[]> {
   const row = rowOrThrow(subject, id, dir);
   const url = parseConnectorUrl(row.url);
-  const auth = await freshAuth(row.config.auth, url.toString());
-  if (auth !== row.config.auth) replace(dir, { ...row, config: { ...row.config, auth } });
-  return listRemoteTools(url, auth);
+  return listRemoteTools(url, await freshAuth(row, dir));
 }
 
 export async function localRenameConnector(subject: string, id: string, raw: string, dir = agentsDir()): Promise<Connector> {
@@ -264,7 +268,7 @@ function refreshOnce(row: LocalConnectorRow, auth: OAuthAuth, dir: string): Prom
   if (running !== undefined) return running;
   const job = refreshOAuth(auth, parseConnectorUrl(row.url).toString())
     .then((fresh) => {
-      replace(dir, { ...row, config: { ...row.config, auth: fresh } });
+      updateRow(dir, row.id, { auth: fresh });
       return fresh;
     })
     .finally(() => {

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

@@ -172,7 +172,7 @@ function writeEvent(res: ServerResponse, message: EventStreamMessage, scanner: U
   res.write(`event: error\ndata: ${JSON.stringify(body)}\n\n`);
 }
 
-async function relayStream(upstream: Response, res: ServerResponse, watch: Watch): Promise<void> {
+async function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string): Promise<void> {
   res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
   const body = upstream.body;
   if (body === null) {
@@ -180,7 +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');
+  const scanner = new UsageScanner(key);
   try {
     const decoder = new EventStreamDecoder();
     const reader = body.getReader();
@@ -220,11 +220,11 @@ export async function bedrockMessages(
     return;
   }
   if (rewritten.stream) {
-    await relayStream(upstream, res, up.watch);
+    await relayStream(upstream, res, up.watch, up.settings.id);
     return;
   }
   const text = await upstream.text();
-  const scanner = new UsageScanner('bedrock');
+  const scanner = new UsageScanner(up.settings.id);
   scanner.feed(text);
   scanner.done();
   res.writeHead(200, { 'content-type': 'application/json' });

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

@@ -23,12 +23,22 @@ export interface CodexDeps {
   save: (id: string, tokens: CodexTokens) => void;
 }
 
-export interface CodexState {
+interface Slot {
   refreshing: Promise<CodexTokens> | null;
   latest: CodexTokens | null;
 }
 
-export const freshCodexState = (): CodexState => ({ refreshing: null, latest: null });
+export type CodexState = Map<string, Slot>;
+
+export const sharedCodexState: CodexState = new Map();
+
+function slotFor(state: CodexState, id: string): Slot {
+  const found = state.get(id);
+  if (found !== undefined) return found;
+  const made: Slot = { refreshing: null, latest: null };
+  state.set(id, made);
+  return made;
+}
 
 const OS_NAMES: Record<string, string> = { darwin: 'Mac OS', linux: 'Linux', win32: 'Windows' };
 
@@ -58,22 +68,23 @@ 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(id: string, tokens: CodexTokens, deps: CodexDeps, state: CodexState): Promise<CodexTokens> {
-  const latest = state.latest;
+  const slot = slotFor(state, id);
+  const latest = slot.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
-  if (state.refreshing !== null) return state.refreshing;
+  if (slot.refreshing !== null) return slot.refreshing;
   const run = refreshTokens(tokens, deps.issuer, deps.fetchImpl)
     .then((fresh) => {
       deps.save(id, fresh);
-      state.latest = fresh;
+      slot.latest = fresh;
       return fresh;
     })
     .catch((err: unknown) => {
       throw new GatewayError(403, 'permission_error', `Codex sign-in expired (${errMsg(err)}): connect again on the Model page`);
     })
     .finally(() => {
-      state.refreshing = null;
+      slot.refreshing = null;
     });
-  state.refreshing = run;
+  slot.refreshing = run;
   return run;
 }
 

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

@@ -12,8 +12,8 @@ import {
 import { addBeta, anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
 import { BINDING_BETA, cappedEffort, effortToApply, plannedEffort, withBlockBinding, withEffort, withThinkingFor } from './effort.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 { codexCount, codexMessages, sharedCodexState } from './codex.js';
+import { geminiCount, geminiMessages, sharedGeminiState } from './gemini.js';
 import type { GeminiDeps } from './gemini.js';
 import type { CodexDeps } from './codex.js';
 import type { GeminiTokens } from './gemini-auth.js';
@@ -41,16 +41,14 @@ export interface GatewayDeps {
 }
 
 const learned: Adaptations = freshAdaptations();
-const codexState = freshCodexState();
-const geminiState = freshGeminiState();
 
 export function resetGatewayState(): void {
   forgetServed();
   forgetUsage();
   learned.fields.clear();
   learned.dropBetas = false;
-  Object.assign(codexState, freshCodexState());
-  Object.assign(geminiState, freshGeminiState());
+  sharedCodexState.clear();
+  sharedGeminiState.clear();
 }
 
 const saveCodexTokens = (id: string, tokens: CodexTokens): void => {
@@ -197,11 +195,11 @@ async function toSubscription(req: IncomingMessage, res: ServerResponse, path: s
   const conn = route.connection;
   if (conn.provider === 'gemini') {
     if (path === COUNT) geminiCount(res, body);
-    else await geminiMessages(req, res, body, route.model, conn, { save: saveGeminiTokens, ...deps.gemini }, geminiState, watchUpstream(res));
+    else await geminiMessages(req, res, body, route.model, conn, { save: saveGeminiTokens, ...deps.gemini }, sharedGeminiState, watchUpstream(res));
     return;
   }
   if (path === COUNT) codexCount(res, body);
-  else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
+  else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, sharedCodexState, watchUpstream(res));
 }
 
 function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<string, unknown> {

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

@@ -39,6 +39,7 @@ export class GeminiStreamTranslator {
   private toolCalls = 0;
   private usage: Usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
   private stop = 'end_turn';
+  private finishedBy: string | null = null;
   private refusal: string | null = null;
   private readonly model: string;
   private readonly restore: (name: string) => string;
@@ -115,6 +116,7 @@ export class GeminiStreamTranslator {
     const parts = Array.isArray(content.parts) ? content.parts.filter(isRecord) : [];
     const out = parts.map((part) => this.part(part)).join('');
     const finish = str(candidate.finishReason);
+    if (finish !== '') this.finishedBy = finish;
     const stop = STOP_OF[finish];
     if (stop !== undefined) this.stop = stop;
     else if (REFUSALS.has(finish)) this.refusal = `Gemini stopped the answer (${finish})`;
@@ -137,8 +139,9 @@ export class GeminiStreamTranslator {
     if (this.done) return '';
     this.done = true;
     let out = this.start() + this.closeOpen();
-    const failure = error ?? this.refusal;
-    if (failure !== null && failure !== undefined && this.toolCalls === 0 && this.next === 0)
+    const unfinished = this.finishedBy === null && this.refusal === null ? 'Gemini ended the stream before completing the response' : null;
+    const failure = error ?? this.refusal ?? unfinished;
+    if (failure !== null)
       return out + frame('error', { type: 'error', error: { type: 'api_error', message: failure } });
     const stop = this.toolCalls > 0 ? 'tool_use' : this.stop;
     out += frame('message_delta', { type: 'message_delta', delta: { stop_reason: stop, stop_sequence: null }, usage: this.usage });

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

@@ -22,32 +22,43 @@ export interface GeminiDeps {
   save: (id: string, tokens: GeminiTokens) => void;
 }
 
-export interface GeminiState {
+interface Slot {
   refreshing: Promise<GeminiTokens> | null;
   latest: GeminiTokens | null;
 }
 
-export const freshGeminiState = (): GeminiState => ({ refreshing: null, latest: null });
+export type GeminiState = Map<string, Slot>;
+
+export const sharedGeminiState: GeminiState = new Map();
+
+function slotFor(state: GeminiState, id: string): Slot {
+  const found = state.get(id);
+  if (found !== undefined) return found;
+  const made: Slot = { refreshing: null, latest: null };
+  state.set(id, made);
+  return made;
+}
 
 const newerThan = (a: GeminiTokens, b: GeminiTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
 function refreshed(id: string, tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
-  const latest = state.latest;
+  const slot = slotFor(state, id);
+  const latest = slot.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
-  if (state.refreshing !== null) return state.refreshing;
+  if (slot.refreshing !== null) return slot.refreshing;
   const run = refreshTokens(tokens, deps.tokenBase, deps.fetchImpl)
     .then((fresh) => {
       deps.save(id, fresh);
-      state.latest = fresh;
+      slot.latest = fresh;
       return fresh;
     })
     .catch((err: unknown) => {
       throw new GatewayError(403, 'permission_error', `Google sign-in expired (${errMsg(err)}): connect again on the Model page`);
     })
     .finally(() => {
-      state.refreshing = null;
+      slot.refreshing = null;
     });
-  state.refreshing = run;
+  slot.refreshing = run;
   return run;
 }