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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.309",
+  "version": "0.1.0-beta.310",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

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

@@ -62,7 +62,8 @@ import { startCloudWatchPublisher } from '../server/cloudwatch.js';
 import { watchFallbackUsage } from '../gateway/usage-refresh.js';
 import { startOrgModels, stopOrgModels } from '../gateway/org-models.js';
 import { effectiveSetup, watchModelChanges } from '../gateway/effective.js';
-import { readClaudeLogins } from '../gateway/claude-store.js';
+import { readClaudeLogins, retireV2ModelFile } from '../gateway/claude-store.js';
+import { removeModelLeftovers } from '../gateway/model-leftovers.js';
 import { readAgentKey } from '../connectors/agent-key.js';
 import { METRO_API } from '../connectors/metro-api.js';
 import { isCallEvent, leaveCallsForShutdown, onCallEvent, sweepLeftoverCalls } from '../voice/calls.js';
@@ -144,6 +145,8 @@ function sessionApis(setLiveEvents: (on: boolean) => void): SessionApis {
 
 async function main(): Promise<void> {
   removeConnectorLeftovers();
+  removeModelLeftovers();
+  retireV2ModelFile();
   applyLocalOwner();
 installBearerSessions(agentsDir(), localOwner);
   watchPolicySnapshot();
@@ -154,7 +157,7 @@ installBearerSessions(agentsDir(), localOwner);
   syncGmailHost();
   supervisor.start();
   sweepLeftoverCalls();
-  const models = startOrgModels({ owner: localOwner, key: () => readAgentKey(), api: METRO_API, dir: agentsDir });
+  const models = startOrgModels({ owner: localOwner, key: () => readAgentKey(), api: METRO_API });
   const metroMcp = await createMetroMcp({ liveEvents: liveEvents() });
   watchModelChanges(models, metroMcp.switchModel);
   webhookServer = await startWebhookServer(

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

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
-import { ID_RE, newId } from '@metro-labs/core/ids';
+import { ID_RE } from '@metro-labs/core/ids';
 import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
 import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
 import { agentsDir } from '../agents/files.js';
 
@@ -16,22 +17,22 @@ const MODEL_FILE = 'model.json';
 const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
 const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
 
-export function claudeLoginOf(raw: unknown): ClaudeLogin | null {
+function claudeLoginOf(raw: unknown): ClaudeLogin | null {
   if (!isRecord(raw) || !ID_RE.test(text(raw.id))) return null;
   return { id: text(raw.id), email: maybe(raw.email), plan: maybe(raw.plan), savedAt: text(raw.savedAt) };
 }
 
-export const modelPath = (dir: string): string => join(dir, MODEL_FILE);
+const modelPath = (dir: string): string => join(dir, MODEL_FILE);
 
-export const readModelFile = (dir = agentsDir()): unknown =>
+const readModelFile = (dir: string): unknown =>
   readJson<unknown>(modelPath(dir), null, { warn: 'model.json is unreadable, so the Claude logins of this box are not seen until it is fixed' });
 
-export const isV2 = (raw: unknown): raw is Record<string, unknown> & { connections: unknown[] } =>
+const isV2 = (raw: unknown): raw is Record<string, unknown> & { connections: unknown[] } =>
   isRecord(raw) && raw.version !== 3 && Array.isArray(raw.connections);
 
 const unique = (logins: ClaudeLogin[]): ClaudeLogin[] => logins.filter((l, at) => logins.findIndex((o) => o.id === l.id) === at);
 
-export function claudeLoginsIn(raw: unknown): ClaudeLogin[] {
+function claudeLoginsIn(raw: unknown): ClaudeLogin[] {
   if (isV2(raw)) return unique(raw.connections.flatMap((c: unknown) => (isRecord(c) && c.provider === 'anthropic' ? (claudeLoginOf(c.claude) ?? []) : [])));
   if (!isRecord(raw) || !Array.isArray(raw.claude)) return [];
   return unique(raw.claude.flatMap((c: unknown) => claudeLoginOf(c) ?? []));
@@ -39,17 +40,20 @@ export function claudeLoginsIn(raw: unknown): ClaudeLogin[] {
 
 export const readClaudeLogins = (dir = agentsDir()): ClaudeLogin[] => claudeLoginsIn(readModelFile(dir));
 
-export const v3Text = (logins: ClaudeLogin[]): string => JSON.stringify({ version: 3, claude: logins }, null, 2);
-
-function v2With(raw: Record<string, unknown> & { connections: unknown[] }, logins: ClaudeLogin[]): Record<string, unknown> {
-  const holds = (c: unknown): c is Record<string, unknown> => isRecord(c) && c.provider === 'anthropic' && claudeLoginOf(c.claude) !== null;
-  const held = new Map(raw.connections.filter(holds).map((c) => [claudeLoginOf(c.claude)?.id ?? '', c]));
-  const others = raw.connections.filter((c) => !holds(c));
-  const logged = logins.map((login) => ({ ...(held.get(login.id) ?? { id: newId(), provider: 'anthropic', label: 'Anthropic', model: '' }), claude: login }));
-  return { ...raw, connections: [...others, ...logged] };
+export function writeClaudeLogins(logins: ClaudeLogin[], dir = agentsDir()): void {
+  writeSecure(modelPath(dir), JSON.stringify({ version: 3, claude: logins }, null, 2));
 }
 
-export function writeClaudeLogins(logins: ClaudeLogin[], dir = agentsDir()): void {
-  const raw = readModelFile(dir);
-  writeSecure(modelPath(dir), isV2(raw) ? JSON.stringify(v2With(raw, logins), null, 2) : v3Text(logins));
+export function retireV2ModelFile(dir = agentsDir()): boolean {
+  try {
+    const raw = readModelFile(dir);
+    if (!isV2(raw)) return false;
+    const logins = claudeLoginsIn(raw);
+    writeClaudeLogins(logins, dir);
+    log.warn({ claudeLogins: logins.length, connections: raw.connections.length }, 'org-models: model.json was still the old version 2; it keeps only its Claude logins now, and its connections are never served');
+    return true;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'org-models: the old version 2 model.json could not be rewritten; its connections are never served');
+    return false;
+  }
 }

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

@@ -27,7 +27,7 @@ function refOf(raw: unknown): Fallback | null {
 function routeOf(raw: unknown): DeliveredRoute | null {
   if (!isRecord(raw)) return null;
   const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
-  return { primary: refOf(raw.primary), fallbacks: fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS) };
+  return { primary: refOf(raw.primary), fallbacks: fallbacks.filter((f) => f.model !== '' || f.connection.startsWith(LOCAL_PREFIX)).slice(0, MAX_FALLBACKS) };
 }
 
 function accountOf(raw: unknown): Account {

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

@@ -1,9 +1,8 @@
 import { log } from '@metro-labs/core/log';
 import { agentsDir } from '../agents/files.js';
-import { claudeLoginsIn, isV2, readModelFile, type ClaudeLogin } from './claude-store.js';
+import { readClaudeLogins, type ClaudeLogin } from './claude-store.js';
 import type { Delivered } from './delivered.js';
 import { emptySetup, LOCAL_PREFIX, loginConnection, primaryRoute, runnerModel, SESSION_LOGIN, sessionConnection, type Connection, type ModelSetup } from './model-config.js';
-import { v2Setup } from './model-v2.js';
 import { deliveredSetup, type OrgModels } from './org-models.js';
 
 function localOf(id: string, logins: ClaudeLogin[]): Connection | null {
@@ -21,10 +20,7 @@ export function setupOf(delivered: Delivered | null, logins: ClaudeLogin[]): Mod
   return { primary: route.primary, fallbacks: route.fallbacks, connections: [...delivered.connections, ...locals], source: delivered.source };
 }
 
-export function effectiveSetup(dir = agentsDir(), delivered: Delivered | null = deliveredSetup()): ModelSetup {
-  const raw = readModelFile(dir);
-  return isV2(raw) ? v2Setup(raw) : setupOf(delivered, claudeLoginsIn(raw));
-}
+export const effectiveSetup = (dir = agentsDir(), delivered: Delivered | null = deliveredSetup()): ModelSetup => setupOf(delivered, readClaudeLogins(dir));
 
 export function modelViewText(setup: ModelSetup): string | null {
   const primary = primaryRoute(setup);

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

@@ -55,7 +55,7 @@ export function holdOf(route: Route, now = Date.now()): Hold | null {
 
 function fallbackModel(requested: string, conn: Connection, model: string): string {
   const bare = bareModel(requested);
-  return conn.provider === 'anthropic' && isSmallModel(bare) ? bare : model;
+  return model === '' || (conn.provider === 'anthropic' && isSmallModel(bare)) ? bare : model;
 }
 
 function fallbackRoute(setup: ModelSetup, fallback: Fallback, requested: string): Route | null {

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

@@ -0,0 +1,42 @@
+import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+
+const LEFTOVER_RE = /^chatgpt-host\.json(?:\.tmp-[0-9]+)?$/;
+
+const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
+
+function namesIn(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter((name) => LEFTOVER_RE.test(name));
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), dir }, 'org-models: could not list the old model files');
+    return [];
+  }
+}
+
+function removeOne(path: string): boolean {
+  try {
+    if (!lstatSync(path).isFile()) {
+      log.warn({ path }, 'org-models: left an old model file alone, it is not a regular file');
+      return false;
+    }
+    unlinkSync(path);
+    return true;
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), path }, 'org-models: could not remove an old model file');
+    return false;
+  }
+}
+
+export function removeModelLeftovers(dir = agentsDir()): number {
+  try {
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length;
+    log.info({ removed }, 'org-models: removed the files of the old model setup');
+    return removed;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'org-models: could not remove the files of the old model setup');
+    return 0;
+  }
+}

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

@@ -2,7 +2,6 @@ import { errMsg, log } from '@metro-labs/core/log';
 import type { AgentKey } from '../connectors/agent-key.js';
 import { agentCall, MetroApiRefusal, type MetroApi } from '../connectors/metro-api.js';
 import { deliveredOf, refreshedConnection, type Delivered } from './delivered.js';
-import { importModelFile, settleModelFile, type Moved } from './model-import.js';
 import type { Connection } from './model-config.js';
 
 const MODELS_PATH = '/api/agents/models';
@@ -15,7 +14,6 @@ export interface OrgModelsDeps {
   owner: () => string | null;
   key: () => AgentKey | null;
   api: MetroApi;
-  dir: () => string;
   pageSyncMs?: number;
 }
 
@@ -27,14 +25,6 @@ export interface SyncStatus {
 
 const identityRefused = (err: unknown): boolean => err instanceof MetroApiRefusal && err.upstreamStatus === 401 && err.code === AGENT_KEY_MISSING;
 
-const unrenewed = new Set<string>();
-
-function noteUnrenewed(conn: Connection): void {
-  if (unrenewed.has(conn.id)) return;
-  unrenewed.add(conn.id);
-  log.warn({ connection: conn.id }, 'org-models: a Codex sign-in still read from model.json is not renewed on this box; api.metro.box renews it once the box moved its model setup to the organization');
-}
-
 export class OrgModels {
   private kept: Delivered | null = null;
   private status: SyncStatus = { enrolled: false, at: null, error: null };
@@ -100,10 +90,6 @@ export class OrgModels {
   }
 
   refresh(conn: Connection): Promise<Connection | null> {
-    if (conn.revision < 1) {
-      noteUnrenewed(conn);
-      return Promise.resolve(null);
-    }
     const newer = this.kept?.connections.find((c) => c.id === conn.id && c.revision > conn.revision);
     if (newer !== undefined) return Promise.resolve(newer);
     const slot = `${conn.id}\n${String(conn.revision)}`;
@@ -167,10 +153,6 @@ export class OrgModels {
       return;
     }
     this.status = { ...this.status, enrolled: true };
-    const moved = await importModelFile(this.deps.api, key, this.deps.dir()).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'org-models: model.json could not be read for the move to the organization');
-      return null;
-    });
     try {
       const delivered = deliveredOf(await agentCall(this.deps.api, key, MODELS_PATH, {}));
       if (delivered === null) {
@@ -182,16 +164,6 @@ export class OrgModels {
       this.keep(delivered);
     } catch (err) {
       this.failed(errMsg(err), identityRefused(err));
-      return;
-    }
-    if (moved !== null) this.settle(moved);
-  }
-
-  private settle(moved: Moved): void {
-    try {
-      if (settleModelFile(this.deps.dir(), moved)) this.notify();
-    } catch (err) {
-      log.warn({ err: errMsg(err) }, 'org-models: model.json could not be rewritten after the move to the organization');
     }
   }
 

package/runtime/runtime.json

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

package/runtime/sdk-runner/runner.json

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

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

@@ -1,125 +0,0 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg, log } from '@metro-labs/core/log';
-import { writeSecure } from '@metro-labs/core/secure-fs';
-import type { AgentKey } from '../connectors/agent-key.js';
-import { agentCall, type MetroApi } from '../connectors/metro-api.js';
-import { claudeLoginOf, claudeLoginsIn, isV2, modelPath, readModelFile, v3Text } from './claude-store.js';
-import { isProvider, type Fallback } from './model-config.js';
-
-const IMPORT_PATH = '/api/agents/models/import';
-let lastRefusal = '';
-
-const CODEX_FIELDS = ['clientId', 'subject', 'accountId', 'plan', 'email', 'accessToken', 'refreshToken', 'expiresAt', 'savedAt'] as const;
-
-const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
-
-type Row = Record<string, unknown>;
-
-interface Plan {
-  connections: Row[];
-  sessionOnly: Set<string>;
-  credentialed: number;
-  gemini: number;
-}
-
-function codexOf(raw: unknown): Row | null {
-  if (!isRecord(raw) || text(raw.accessToken) === '' || text(raw.refreshToken) === '') return null;
-  const method = text(raw.accountId) !== '' ? 'code' : text(raw.clientId) !== '' ? 'chatgpt' : '';
-  if (method === '') return null;
-  return { method, ...Object.fromEntries(CODEX_FIELDS.flatMap((field) => (raw[field] === undefined ? [] : [[field, raw[field]]]))) };
-}
-
-function credentialOf(c: Row): Row | null {
-  if (c.provider === 'codex') {
-    const codex = codexOf(c.codex);
-    return codex === null ? null : { codex };
-  }
-  return text(c.apiKey) === '' ? null : { apiKey: text(c.apiKey) };
-}
-
-function addRow(plan: Plan, c: Row): void {
-  const base = { id: text(c.id), provider: c.provider, label: text(c.label), model: text(c.model), region: text(c.region), zdr: c.zdr === true };
-  const credential = credentialOf(c);
-  const login = c.provider === 'anthropic' && credential === null ? claudeLoginOf(c.claude) : null;
-  if (credential !== null) {
-    plan.connections.push({ ...base, ...credential });
-    plan.credentialed += 1;
-  } else if (login !== null) plan.connections.push({ ...base, claude: { id: login.id } });
-  else if (c.provider === 'anthropic') {
-    plan.connections.push(base);
-    plan.sessionOnly.add(base.id);
-  }
-}
-
-function planOf(rows: Row[]): Plan {
-  const plan: Plan = { connections: [], sessionOnly: new Set(), credentialed: 0, gemini: 0 };
-  for (const c of rows) {
-    if (c.provider === 'gemini') plan.gemini += 1;
-    else if (text(c.id) !== '' && isProvider(c.provider)) addRow(plan, c);
-  }
-  return plan;
-}
-
-function fallbacksOf(raw: unknown, sent: Set<string>): Fallback[] {
-  if (!Array.isArray(raw)) return [];
-  return raw.flatMap((f: unknown) => {
-    const fallback = isRecord(f) ? { connection: text(f.connection), model: text(f.model) } : null;
-    return fallback === null || !sent.has(fallback.connection) || fallback.model === '' ? [] : [fallback];
-  });
-}
-
-function routeOf(raw: Row, rows: Row[], plan: Plan, fallbacks: Fallback[]): Fallback | '' {
-  const id = text(raw.route);
-  const routed = rows.find((c) => text(c.id) === id);
-  if (routed === undefined || !plan.connections.some((c) => c.id === id)) return '';
-  const route = { connection: id, model: text(routed.model) };
-  return plan.sessionOnly.has(id) && route.model === '' && fallbacks.length === 0 ? '' : route;
-}
-
-function importBody(raw: Row & { connections: unknown[] }): { body: Row | null; sent: number; gemini: number } {
-  const rows = raw.connections.filter(isRecord);
-  const plan = planOf(rows);
-  const fallbacks = fallbacksOf(raw.fallbacks, new Set(plan.connections.map((c) => text(c.id))));
-  const route = routeOf(raw, rows, plan, fallbacks);
-  const empty = plan.credentialed === 0 && route === '' && fallbacks.length === 0;
-  return { body: empty ? null : { connections: plan.connections, route, fallbacks }, sent: plan.credentialed, gemini: plan.gemini };
-}
-
-export interface Moved {
-  sent: number;
-  gemini: number;
-}
-
-function noteSkipped(raw: unknown): void {
-  const skipped = Array.isArray(raw) ? raw.flatMap((s: unknown) => (isRecord(s) ? [{ id: text(s.id), reason: text(s.reason) }] : [])) : [];
-  if (skipped.length > 0) log.warn({ skipped }, 'org-models: api.metro.box could not import some connections of model.json, so they are not moved');
-}
-
-export async function importModelFile(api: MetroApi, key: AgentKey, dir: string): Promise<Moved | null> {
-  const raw = readModelFile(dir);
-  if (!isV2(raw)) return null;
-  const { body, sent, gemini } = importBody(raw);
-  try {
-    if (body !== null) {
-      const answer = await agentCall(api, key, IMPORT_PATH, body);
-      if (!isRecord(answer.ids)) throw new Error('api.metro.box answered the import without ids');
-      noteSkipped(answer.skipped);
-    }
-  } catch (err) {
-    if (errMsg(err) !== lastRefusal) log.warn({ err: errMsg(err) }, 'org-models: the model setup of this box could not move to its organization yet; it is tried again');
-    lastRefusal = errMsg(err);
-    return null;
-  }
-  lastRefusal = '';
-  return { sent, gemini };
-}
-
-export function settleModelFile(dir: string, moved: Moved): boolean {
-  const raw = readModelFile(dir);
-  if (!isV2(raw)) return false;
-  const logins = claudeLoginsIn(raw);
-  writeSecure(modelPath(dir), v3Text(logins));
-  if (moved.gemini > 0) log.info({ dropped: moved.gemini }, 'org-models: Gemini connections are no longer supported, so they were dropped');
-  log.info({ moved: moved.sent, claudeLogins: logins.length }, 'org-models: the model setup of this box moved to its organization; model.json keeps only its Claude logins');
-  return true;
-}

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

@@ -1,79 +0,0 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import { claudeLoginOf } from './claude-store.js';
-import { isProvider, LOCAL_PREFIX, loginConnection, sessionConnection, type Account, type CodexAccess, type Connection, type Fallback, type ModelSetup, type Provider } from './model-config.js';
-
-const MAX_CONNECTIONS = 20;
-const MAX_FALLBACKS = 8;
-const NEW_CLIENT = 'dynamic_agent_client';
-const NO_ACCOUNT: Account = { email: null, plan: null, method: null };
-
-type Row = Record<string, unknown>;
-
-const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
-const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
-
-const expiryOf = (value: unknown): number => (typeof value === 'number' && Number.isFinite(value) ? value : 0);
-
-function codexOf(raw: unknown): CodexAccess | null {
-  if (!isRecord(raw) || text(raw.accessToken) === '' || text(raw.refreshToken) === '') return null;
-  const accountId = maybe(text(raw.accountId));
-  const clientId = text(raw.clientId);
-  if (accountId === null && (clientId === '' || clientId === NEW_CLIENT)) return null;
-  return { method: accountId === null ? 'chatgpt' : 'code', accessToken: text(raw.accessToken), expiresAt: expiryOf(raw.expiresAt), accountId };
-}
-
-function accountOf(raw: unknown, codex: CodexAccess | null): Account {
-  if (codex === null || !isRecord(raw)) return NO_ACCOUNT;
-  return { email: maybe(raw.email), plan: codex.method === 'code' ? maybe(raw.plan) : null, method: codex.method };
-}
-
-function ownConnection(row: Row, id: string, provider: Provider): Connection {
-  const codex = provider === 'codex' ? codexOf(row.codex) : null;
-  const apiKey = provider === 'codex' ? '' : text(row.apiKey);
-  const label = text(row.label);
-  return {
-    id,
-    provider,
-    label: label === '' ? provider : label,
-    model: text(row.model),
-    apiKey,
-    region: text(row.region),
-    zdr: row.zdr === true,
-    revision: 0,
-    codex,
-    claude: null,
-    account: accountOf(row.codex, codex),
-    signedOut: codex === null && apiKey === '',
-  };
-}
-
-function connectionOf(row: Row): Connection | null {
-  const id = text(row.id);
-  if (id === '' || id.startsWith(LOCAL_PREFIX) || !isProvider(row.provider)) return null;
-  if (row.provider !== 'anthropic' || text(row.apiKey) !== '') return ownConnection(row, id, row.provider);
-  const login = claudeLoginOf(row.claude);
-  return login === null ? sessionConnection() : loginConnection(login.id, login);
-}
-
-function fallbacksOf(raw: unknown, linked: Map<string, Connection>): Fallback[] {
-  if (!Array.isArray(raw)) return [];
-  const known = raw.flatMap((f: unknown) => {
-    const conn = isRecord(f) ? linked.get(text(f.connection)) : undefined;
-    const model = isRecord(f) ? text(f.model) : '';
-    return conn === undefined || model === '' ? [] : [{ connection: conn.id, model }];
-  });
-  return known.filter((f, at) => known.findIndex((o) => o.connection === f.connection && o.model === f.model) === at).slice(0, MAX_FALLBACKS);
-}
-
-export function v2Setup(raw: Row & { connections: unknown[] }): ModelSetup {
-  const rows = raw.connections.filter((c): c is Row => isRecord(c) && (isProvider(c.provider) || c.provider === 'gemini')).slice(0, MAX_CONNECTIONS);
-  const linked = new Map(rows.flatMap((row) => {
-    const conn = connectionOf(row);
-    return conn === null ? [] : [[text(row.id), conn] as const];
-  }));
-  const routed = rows.find((row) => text(row.id) === text(raw.route)) ?? rows[0];
-  const head = routed === undefined ? undefined : linked.get(text(routed.id));
-  const primary = routed === undefined || head === undefined ? null : { connection: head.id, model: text(routed.model) };
-  const connections = [...linked.values()].filter((c, at, all) => all.findIndex((o) => o.id === c.id) === at);
-  return { primary, fallbacks: fallbacksOf(raw.fallbacks, linked), connections, source: null };
-}