@stage-labs/metro 0.1.0-beta.220 → 0.1.0-beta.221

package/package.json

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

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.220",
+  "version": "0.1.0-beta.221",
   "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/gateway/codex.ts

@@ -8,6 +8,7 @@ import { ToolNames, toResponsesRequest } from './codex-translate.js';
 import { GatewayError, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import { parseEvent, SseParser, type SseEvent } from './frames.js';
 import type { Connection } from './model-config.js';
+import { listCache } from './model-lists.js';
 import { answerWhole, currentOf, errorKind, reach, refreshed, relayTranslated, sessionHeader, type TokenSource, type TokenState } from './subscription.js';
 import { noteUsageHeaders } from './usage.js';
 
@@ -25,6 +26,8 @@ export type CodexState = TokenState<CodexTokens>;
 
 export const sharedCodexState: CodexState = new Map();
 
+const codexLists = listCache<string>('codex');
+
 const sourceOf = (deps: CodexDeps): TokenSource<CodexTokens> => ({
   label: 'Codex',
   stale: (tokens) => tokensStale(tokens),
@@ -109,7 +112,12 @@ export async function codexMessages(
 
 export async function codexModels(tokens: CodexTokens, deps: Omit<CodexDeps, 'save'>): Promise<string[]> {
   const version = await learnCodexVersion();
-  const res = await (deps.fetchImpl ?? fetch)(`${deps.base ?? CODEX_BASE}/models?client_version=${version}`, {
+  const base = deps.base ?? CODEX_BASE;
+  return codexLists.get(`${base}:${tokens.accountId}:${version}`, () => listCodex(tokens, version, base, deps.fetchImpl ?? fetch));
+}
+
+async function listCodex(tokens: CodexTokens, version: string, base: string, fetchImpl: typeof fetch): Promise<string[]> {
+  const res = await fetchImpl(`${base}/models?client_version=${version}`, {
     headers: { ...headersFor(tokens, randomUUID()), accept: 'application/json' },
     redirect: 'manual',
   });

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

@@ -64,12 +64,28 @@ export function effortToApply(body: Body): string | null {
 export const cappedEffort = (effort: string): string => (ABOVE_HIGH.has(effort) ? 'high' : effort);
 
 const THINKING_ALWAYS_ON = /claude-(fable|mythos)-5|claude-opus-5-5/;
+const REFUSES_THINKING_OFF = '"thinking.type.disabled" is not supported';
+const thinkingAlwaysOn = new Set<string>();
+
+export const thinkingOff = (body: Body): boolean => record(body.thinking).type === 'disabled';
+
+const alwaysThinks = (model: string): boolean => THINKING_ALWAYS_ON.test(model) || thinkingAlwaysOn.has(model);
 
 export function withThinkingFor(body: Body, model: string): Body {
-  if (!THINKING_ALWAYS_ON.test(model) || record(body.thinking).type !== 'disabled') return body;
+  if (!alwaysThinks(model) || !thinkingOff(body)) return body;
   return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'thinking'));
 }
 
+export function learnAlwaysThinks(model: string, refusal: string): boolean {
+  if (!refusal.includes(REFUSES_THINKING_OFF)) return false;
+  thinkingAlwaysOn.add(model);
+  return true;
+}
+
+export function forgetLearnedThinking(): void {
+  thinkingAlwaysOn.clear();
+}
+
 export function withBlockBinding(body: Body): Body {
   const thinking = body.thinking;
   if (!isRecord(thinking) || thinking.block_binding !== undefined) return body;

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

@@ -9,8 +9,19 @@ import {
   freshAdaptations,
   type Adaptations,
 } from './bedrock.js';
-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 { addBeta, anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, upstreamMessage, watchUpstream } from './forward.js';
+import {
+  BINDING_BETA,
+  cappedEffort,
+  effortToApply,
+  forgetLearnedThinking,
+  learnAlwaysThinks,
+  plannedEffort,
+  thinkingOff,
+  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 { codexMessages, sharedCodexState } from './codex.js';
 import { geminiMessages, sharedGeminiState } from './gemini.js';
@@ -23,10 +34,10 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
 import { forgetUsage, noteUsageHeaders, UsageScanner } from './usage.js';
 import { fitToolSearch } from './tool-search.js';
+import { ANTHROPIC_API, refreshLoginModels } from './provider-models.js';
 import type { CodexTokens } from './codex-auth.js';
 
 const GATEWAY_PREFIX = '/gateway';
-const ANTHROPIC_BASE = 'https://api.anthropic.com';
 const MESSAGES = '/v1/messages';
 const COUNT = '/v1/messages/count_tokens';
 const MODELS = '/v1/models';
@@ -49,6 +60,7 @@ export function resetGatewayState(): void {
   forgetUsage();
   learned.fields.clear();
   learned.dropBetas = false;
+  forgetLearnedThinking();
   sharedCodexState.clear();
   sharedGeminiState.clear();
 }
@@ -97,8 +109,9 @@ interface Payloads {
 }
 
 function anthropicPayloads(raw: Buffer, sent: Record<string, unknown>, shaped: Record<string, unknown>, model: string): Payloads {
-  const rewrite = typeof sent.model === 'string' && sent.model !== model;
-  const asSent = rewrite ? Buffer.from(JSON.stringify({ ...sent, model })) : raw;
+  const runnable = withThinkingFor(sent, model);
+  const rewrite = runnable !== sent || (typeof sent.model === 'string' && sent.model !== model);
+  const asSent = rewrite ? Buffer.from(JSON.stringify({ ...runnable, model })) : raw;
   const bound = withBlockBinding(withThinkingFor(shaped, model));
   if (bound === sent) return { metro: asSent, asSent: null, bound: false };
   return { metro: Buffer.from(JSON.stringify(rewrite ? { ...bound, model } : bound)), asSent, bound: bound !== shaped };
@@ -115,6 +128,20 @@ async function asAnthropicWants(send: Send, base: Record<string, string>, payloa
   return send(asSent, base);
 }
 
+async function refusedThinkingOff(upstream: Response, shaped: Record<string, unknown>, model: string): Promise<boolean> {
+  if (upstream.status !== 400 || !thinkingOff(shaped)) return false;
+  if (!learnAlwaysThinks(model, upstreamMessage(await upstream.clone().text(), ''))) return false;
+  await upstream.body?.cancel();
+  log.info({ model }, 'gateway: this model cannot run with thinking off, so metro leaves that setting out for it from now on');
+  return true;
+}
+
+function listLoginModels(req: IncomingMessage, anthropicBase: string): void {
+  refreshLoginModels(req.headers, anthropicBase).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'gateway: could not list the models of the Claude Code login');
+  });
+}
+
 async function toAnthropic(
   req: IncomingMessage,
   res: ServerResponse,
@@ -125,7 +152,8 @@ async function toAnthropic(
   deps: GatewayDeps,
 ): Promise<void> {
   const conn = route.connection;
-  const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
+  const anthropicBase = deps.anthropicBase ?? ANTHROPIC_API;
+  const url = `${anthropicBase}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
   const key = conn.apiKey;
   if (key === '' && standsInFor(req))
     throw new GatewayError(
@@ -134,10 +162,13 @@ async function toAnthropic(
       'Claude Code on this machine has no Anthropic login of its own; choose Bedrock, OpenRouter, Codex or Gemini on the Model page, or sign in on the Claude tab',
     );
   const watch = watchUpstream(res);
+  if (key === '') listLoginModels(req, anthropicBase);
   const base = key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key);
   const send = (payload: Buffer, headers: Record<string, string>): Promise<Response> =>
     fetch(url, { method: 'POST', headers, body: new Uint8Array(payload), signal: watch.signal, redirect: 'manual' });
-  const upstream = await asAnthropicWants(send, base, anthropicPayloads(raw, sent, shaped, route.model), conn.label, route.model);
+  const attempt = (): Promise<Response> => asAnthropicWants(send, base, anthropicPayloads(raw, sent, shaped, route.model), conn.label, route.model);
+  const first = await attempt();
+  const upstream = (await refusedThinkingOff(first, shaped, route.model)) ? await attempt() : first;
   noteRefusal(conn.label, route.model, upstream);
   noteUsageHeaders('anthropic', conn.id, upstream.headers);
   const scanner = new UsageScanner(conn.id);
@@ -177,8 +208,6 @@ async function toOpenRouter(
   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';
-
 function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {
   const sent: Record<string, unknown> = { ...body, model };
   if (thinkingOff(body)) delete sent.thinking;

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

@@ -0,0 +1,57 @@
+import { createHash } from 'node:crypto';
+import { errMsg, log } from '@metro-labs/core/log';
+
+export const LIST_TTL_MS = 60 * 60_000;
+export const RETRY_MS = 5 * 60_000;
+
+export interface ListCache<T> {
+  get: (key: string, load: () => Promise<T[]>) => Promise<T[]>;
+  peek: (key: string) => T[] | null;
+  refresh: (key: string, load: () => Promise<T[]>) => Promise<void>;
+}
+
+const clears = new Set<() => void>();
+
+export function listCache<T>(name: string, now: () => number = Date.now): ListCache<T> {
+  const kept = new Map<string, { at: number; list: T[] }>();
+  const tried = new Map<string, number>();
+  clears.add(() => {
+    kept.clear();
+    tried.clear();
+  });
+  const fresh = (key: string): boolean => {
+    const hit = kept.get(key);
+    return hit !== undefined && now() - hit.at < LIST_TTL_MS;
+  };
+  return {
+    async get(key, load) {
+      const hit = kept.get(key);
+      if (hit !== undefined && fresh(key)) return hit.list;
+      try {
+        const list = await load();
+        kept.set(key, { at: now(), list });
+        return list;
+      } catch (err) {
+        if (hit === undefined) throw err;
+        log.warn({ list: name, err: errMsg(err) }, 'model-lists: the provider would not list its models, so the last list it gave stands');
+        return hit.list;
+      }
+    },
+    peek: (key) => kept.get(key)?.list ?? null,
+    async refresh(key, load) {
+      if (fresh(key) || now() - (tried.get(key) ?? Number.NEGATIVE_INFINITY) < RETRY_MS) return;
+      tried.set(key, now());
+      try {
+        kept.set(key, { at: now(), list: await load() });
+      } catch (err) {
+        log.warn({ list: name, err: errMsg(err) }, 'model-lists: the provider would not list its models, so the last list it gave stands');
+      }
+    },
+  };
+}
+
+export function forgetModelLists(): void {
+  for (const clear of clears) clear();
+}
+
+export const fingerprint = (...parts: string[]): string => createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 16);

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

@@ -11,6 +11,7 @@ import { onboard, parseGeminiProject } from './gemini-setup.js';
 import { currentGeminiTokens, listGeminiModels, sharedGeminiState, type GeminiDeps } from './gemini.js';
 import { openrouterCredits } from './openrouter.js';
 import { lastServed } from './served.js';
+import { listCache } from './model-lists.js';
 import { geminiUsage, noteUsage, openrouterUsage, usageOf } from './usage.js';
 import {
   addConnection,
@@ -140,12 +141,20 @@ async function connectGemini(req: IncomingMessage, deps: ModelApiDeps, store: St
   return saved(store, setGeminiAuth(cfg, id, full), 'model-api: Gemini connected', { connection: id, tier: onboarded.tier });
 }
 
+const geminiLists = listCache<string>('gemini');
+
+async function geminiIds(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<string[]> {
+  const conn = connectionFor(store.read(), req, 'gemini');
+  const key = `${deps.geminiBase ?? ''}:${conn.id}:${conn.gemini?.email ?? ''}:${conn.gemini?.project ?? ''}`;
+  return geminiLists.get(key, async () => (await geminiModelsOf(conn, deps, store)).map((m) => m.id));
+}
+
 export const GEMINI_ROUTES: Record<string, Route> = {
   login: { method: 'POST', run: (_req, deps) => Promise.resolve(beginGeminiLogin(deps.geminiAuthBase)) },
   code: { method: 'POST', run: connectGemini },
   models: {
     method: 'GET',
-    run: async (req, deps, store) => ({ models: (await geminiModelsOf(connectionFor(store.read(), req, 'gemini'), deps, store).catch(asApiError)).map((m) => m.id) }),
+    run: async (req, deps, store) => ({ models: await geminiIds(req, deps, store).catch(asApiError) }),
   },
 };
 

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

@@ -1,5 +1,6 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { GatewayError } from './forward.js';
+import { listCache } from './model-lists.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 export const OPENROUTER_BASE = 'https://openrouter.ai/api';
@@ -13,6 +14,8 @@ export interface OpenRouterModel {
   created: number | null;
 }
 
+const modelLists = listCache<OpenRouterModel>('openrouter');
+const zdrLists = listCache<string>('openrouter-zdr');
 
 function price(raw: unknown): number | null {
   const value = typeof raw === 'string' ? Number(raw) : typeof raw === 'number' ? raw : Number.NaN;
@@ -23,8 +26,16 @@ function released(raw: unknown): number | null {
   return typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : null;
 }
 
+const strings = (value: unknown): string[] | null => (Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string') : null);
+
+function chatCapable(entry: Record<string, unknown>): boolean {
+  const output = strings(isRecord(entry.architecture) ? entry.architecture.output_modalities : undefined);
+  const params = strings(entry.supported_parameters);
+  return (output === null || output.includes('text')) && (params === null || params.includes('tools'));
+}
+
 function modelOf(entry: unknown): OpenRouterModel | null {
-  if (!isRecord(entry)) return null;
+  if (!isRecord(entry) || !chatCapable(entry)) return null;
   const id = stringOf(entry.id);
   if (id === '') return null;
   const pricing = isRecord(entry.pricing) ? entry.pricing : {};
@@ -42,7 +53,7 @@ function newestFirst(a: OpenRouterModel, b: OpenRouterModel): number {
   return when !== 0 ? when : a.id.localeCompare(b.id);
 }
 
-export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> {
+async function listModels(base: string, fetchImpl: typeof fetch): Promise<OpenRouterModel[]> {
   const res = await fetchImpl(`${base}/v1/models`, { headers: { accept: 'application/json' }, redirect: 'manual' });
   if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its models (${String(res.status)})`);
   const body: unknown = await res.json();
@@ -55,6 +66,9 @@ export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof
     .slice(0, MODELS_MAX);
 }
 
+export const openrouterModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> =>
+  modelLists.get(base, () => listModels(base, fetchImpl));
+
 export interface OpenRouterCredits {
   total: number;
   spent: number;
@@ -78,7 +92,7 @@ export async function openrouterCredits(
   return { total, spent };
 }
 
-export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> {
+async function listZdr(base: string, fetchImpl: typeof fetch): Promise<string[]> {
   const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
   if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${String(res.status)})`);
   const body: unknown = await res.json();
@@ -88,3 +102,5 @@ export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typ
   for (const entry of data) if (isRecord(entry) && stringOf(entry.model_id) !== '') ids.add(stringOf(entry.model_id));
   return [...ids].sort();
 }
+
+export const openrouterZdrModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> => zdrLists.get(base, () => listZdr(base, fetchImpl));

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

@@ -1,49 +1,102 @@
+import type { IncomingHttpHeaders } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
 import { GatewayError } from './forward.js';
 import type { Connection } from './model-config.js';
+import { fingerprint, listCache } from './model-lists.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
-const ANTHROPIC_API = 'https://api.anthropic.com';
+export const ANTHROPIC_API = 'https://api.anthropic.com';
 const ANTHROPIC_VERSION = '2023-06-01';
 const LIST_MAX = 1000;
+const LIST_TIMEOUT_MS = 10_000;
+const OAUTH_BETA = 'oauth-2025-04-20';
+const BEARER = 'Bearer ';
 
 export interface ProviderModel {
   id: string;
   name: string;
 }
 
+interface Dated extends ProviderModel {
+  created: string;
+}
+
 const KNOWN_CLAUDE: ProviderModel[] = [
-  { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },
+  { id: 'claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },
   { id: 'claude-opus-5-5', name: 'Claude Opus 5.5' },
+  { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },
   { id: 'claude-opus-5', name: 'Claude Opus 5' },
   { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },
   { id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5' },
 ];
 
+const claudeLists = listCache<ProviderModel>('anthropic');
+const bedrockLists = listCache<ProviderModel>('bedrock');
 
-export async function anthropicModels(settings: Connection, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
-  if (settings.apiKey === '') return KNOWN_CLAUDE;
+const newestFirst = (list: Dated[]): ProviderModel[] =>
+  list.sort((a, b) => b.created.localeCompare(a.created) || a.id.localeCompare(b.id)).map(({ id, name }) => ({ id, name }));
+
+function claudeEntry(entry: unknown): Dated[] {
+  if (!isRecord(entry) || stringOf(entry.id) === '') return [];
+  const type = stringOf(entry.type);
+  if (type !== '' && type !== 'model') return [];
+  const id = stringOf(entry.id);
+  return [{ id, name: stringOf(entry.display_name) || id, created: stringOf(entry.created_at) }];
+}
+
+async function listClaude(auth: Record<string, string>, what: string, base: string, fetchImpl: typeof fetch): Promise<ProviderModel[]> {
   const res = await fetchImpl(`${base}/v1/models?limit=${String(LIST_MAX)}`, {
-    headers: { 'x-api-key': settings.apiKey, 'anthropic-version': ANTHROPIC_VERSION, accept: 'application/json' },
+    headers: { ...auth, 'anthropic-version': ANTHROPIC_VERSION, accept: 'application/json' },
     redirect: 'manual',
+    signal: AbortSignal.timeout(LIST_TIMEOUT_MS),
   });
-  if (!res.ok) throw new GatewayError(res.status, 'api_error', `Anthropic would not list its models with the stored key (${String(res.status)})`);
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `Anthropic would not list its models with ${what} (${String(res.status)})`);
   const body: unknown = await res.json();
   const data = isRecord(body) && Array.isArray(body.data) ? body.data : null;
   if (data === null) throw new GatewayError(502, 'api_error', 'Anthropic answered with no model list');
-  return data
-    .flatMap((entry) => (isRecord(entry) && stringOf(entry.id) !== '' ? [{ id: stringOf(entry.id), name: stringOf(entry.display_name) || stringOf(entry.id) }] : []))
-    .sort((a, b) => a.id.localeCompare(b.id));
+  return newestFirst(data.flatMap(claudeEntry));
+}
+
+const loginKey = (base: string): string => `login:${base}`;
+
+const first = (value: string | string[] | undefined): string => (Array.isArray(value) ? value[0] : value)?.trim() ?? '';
+
+function loginAuth(headers: IncomingHttpHeaders): Record<string, string> | null {
+  const bearer = first(headers.authorization);
+  if (bearer.startsWith(BEARER) && bearer.length > BEARER.length) return { authorization: bearer, 'anthropic-beta': OAUTH_BETA };
+  const key = first(headers['x-api-key']);
+  return key === '' ? null : { 'x-api-key': key };
+}
+
+export function refreshLoginModels(headers: IncomingHttpHeaders, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<void> {
+  const auth = loginAuth(headers);
+  if (auth === null) return Promise.resolve();
+  return claudeLists.refresh(loginKey(base), () => listClaude(auth, 'the Claude Code login', base, fetchImpl));
+}
+
+export async function anthropicModels(settings: Connection, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.apiKey === '') {
+    const live = claudeLists.peek(loginKey(base)) ?? [];
+    return live.length > 0 ? live : KNOWN_CLAUDE;
+  }
+  return claudeLists.get(`key:${base}:${fingerprint(settings.apiKey)}`, () => listClaude({ 'x-api-key': settings.apiKey }, 'the stored key', base, fetchImpl));
 }
 
 export const bedrockControlBase = (region: string): string => `https://bedrock.${region}.amazonaws.com`;
 
-export async function bedrockModels(settings: Connection, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
-  if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
-  if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
-  const res = await fetchImpl(`${base ?? bedrockControlBase(settings.region)}/inference-profiles?maxResults=${String(LIST_MAX)}`, {
+function bedrockEntry(entry: unknown): Dated[] {
+  if (!isRecord(entry)) return [];
+  const id = stringOf(entry.inferenceProfileId);
+  const status = stringOf(entry.status);
+  if (id === '' || !id.includes('anthropic') || (status !== '' && status !== 'ACTIVE')) return [];
+  return [{ id, name: stringOf(entry.inferenceProfileName) || id, created: stringOf(entry.createdAt) }];
+}
+
+async function listBedrock(settings: Connection, base: string, fetchImpl: typeof fetch): Promise<ProviderModel[]> {
+  const res = await fetchImpl(`${base}/inference-profiles?maxResults=${String(LIST_MAX)}`, {
     headers: { authorization: `Bearer ${settings.apiKey}`, accept: 'application/json' },
     redirect: 'manual',
+    signal: AbortSignal.timeout(LIST_TIMEOUT_MS),
   });
   if (!res.ok)
     throw new GatewayError(
@@ -54,13 +107,12 @@ export async function bedrockModels(settings: Connection, base?: string, fetchIm
   const body: unknown = await res.json();
   const list = isRecord(body) && Array.isArray(body.inferenceProfileSummaries) ? body.inferenceProfileSummaries : null;
   if (list === null) throw new GatewayError(502, 'api_error', 'Bedrock answered with no inference profile list');
-  return list
-    .flatMap((entry) => {
-      if (!isRecord(entry)) return [];
-      const id = stringOf(entry.inferenceProfileId);
-      const status = stringOf(entry.status);
-      if (id === '' || !id.includes('anthropic') || (status !== '' && status !== 'ACTIVE')) return [];
-      return [{ id, name: stringOf(entry.inferenceProfileName) || id }];
-    })
-    .sort((a, b) => a.id.localeCompare(b.id));
+  return newestFirst(list.flatMap(bedrockEntry));
+}
+
+export async function bedrockModels(settings: Connection, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
+  if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
+  const from = base ?? bedrockControlBase(settings.region);
+  return bedrockLists.get(`${from}:${fingerprint(settings.apiKey)}`, () => listBedrock(settings, from, fetchImpl));
 }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.220"
+  "version": "0.1.0-beta.221"
 }