@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.260

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

@@ -0,0 +1,104 @@
+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';
+import type { KeySpend } from './usage.js';
+
+export const OPENROUTER_BASE = 'https://openrouter.ai/api';
+const MODELS_MAX = 2000;
+const KEY_TIMEOUT_MS = 10_000;
+
+export interface OpenRouterModel {
+  id: string;
+  name: string;
+  prompt: number | null;
+  completion: number | null;
+  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;
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+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) || !chatCapable(entry)) return null;
+  const id = stringOf(entry.id);
+  if (id === '') return null;
+  const pricing = isRecord(entry.pricing) ? entry.pricing : {};
+  return {
+    id,
+    name: stringOf(entry.name) || id,
+    prompt: price(pricing.prompt),
+    completion: price(pricing.completion),
+    created: released(entry.created),
+  };
+}
+
+function newestFirst(a: OpenRouterModel, b: OpenRouterModel): number {
+  const when = (b.created ?? 0) - (a.created ?? 0);
+  return when !== 0 ? when : a.id.localeCompare(b.id);
+}
+
+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();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no model list');
+  return data
+    .map(modelOf)
+    .filter((model): model is OpenRouterModel => model !== null)
+    .sort(newestFirst)
+    .slice(0, MODELS_MAX);
+}
+
+export const openrouterModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> =>
+  modelLists.get(base, () => listModels(base, fetchImpl));
+
+const nullableAmount = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
+
+export async function openrouterKey(apiKey: string, base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<KeySpend> {
+  const res = await fetchImpl(`${base}/v1/key`, {
+    headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+    redirect: 'manual',
+    signal: AbortSignal.timeout(KEY_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    await res.body?.cancel();
+    throw new GatewayError(res.status, 'api_error', `OpenRouter would not describe the stored key (${String(res.status)})`);
+  }
+  const body: unknown = await res.json();
+  const data = isRecord(body) && isRecord(body.data) ? body.data : {};
+  const spent = nullableAmount(data.usage);
+  if (spent === null) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no spend for the key');
+  return { limit: nullableAmount(data.limit), remaining: nullableAmount(data.limit_remaining), spent };
+}
+
+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();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no endpoint list');
+  const ids = new Set<string>();
+  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/pkce.ts

@@ -0,0 +1,36 @@
+import { createHash, randomBytes } from 'node:crypto';
+
+const PENDING_TTL_MS = 10 * 60_000;
+
+const b64url = (buf: Buffer): string => buf.toString('base64url');
+
+export function newPkce(): { verifier: string; challenge: string } {
+  const verifier = b64url(randomBytes(32));
+  return { verifier, challenge: b64url(createHash('sha256').update(verifier).digest()) };
+}
+
+export class PendingLogins {
+  private readonly pending = new Map<string, { verifier: string; at: number }>();
+
+  constructor(private readonly stateBytes: number) {}
+
+  private sweep(now: number): void {
+    for (const [state, entry] of this.pending) if (now - entry.at > PENDING_TTL_MS) this.pending.delete(state);
+  }
+
+  begin(now: number): { state: string; challenge: string } {
+    this.sweep(now);
+    const { verifier, challenge } = newPkce();
+    const state = b64url(randomBytes(this.stateBytes));
+    this.pending.set(state, { verifier, at: now });
+    return { state, challenge };
+  }
+
+  take(state: string, now: number): string | null {
+    this.sweep(now);
+    const entry = this.pending.get(state);
+    if (entry === undefined) return null;
+    this.pending.delete(state);
+    return entry.verifier;
+  }
+}

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

@@ -0,0 +1,117 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError, OAUTH_BETA } 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';
+
+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 BEARER = 'Bearer ';
+
+export interface ProviderModel {
+  id: string;
+  name: string;
+}
+
+interface Dated extends ProviderModel {
+  created: string;
+}
+
+const KNOWN_CLAUDE: ProviderModel[] = [
+  { 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');
+
+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: { ...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 ${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 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`;
+
+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(
+      res.status,
+      'api_error',
+      `Bedrock would not list its inference profiles (${String(res.status)}); the stored key may cover the runtime only, so type the model id instead`,
+    );
+  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 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/node_modules/@metro-labs/daemon/src/gateway/served.ts

@@ -0,0 +1,18 @@
+export interface Served {
+  connection: string;
+  provider: string;
+  model: string;
+  at: string;
+}
+
+let last: Served | null = null;
+
+export const noteServed = (served: Served): void => {
+  last = served;
+};
+
+export const lastServed = (): Served | null => last;
+
+export const forgetServed = (): void => {
+  last = null;
+};

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

@@ -0,0 +1,120 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import { assembleMessage, SseParser, type SseEvent } from './frames.js';
+import { GatewayError, relayFrames, type Watch } from './forward.js';
+import { UsageScanner } from './usage.js';
+
+const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
+
+interface Slot<T> {
+  refreshing: Promise<T> | null;
+  latest: T | null;
+}
+
+export type TokenState<T> = Map<string, Slot<T>>;
+
+export interface TokenSource<T extends { savedAt: string }> {
+  label: string;
+  stale: (tokens: T) => boolean;
+  refresh: (tokens: T) => Promise<T>;
+  save: (id: string, tokens: T) => void;
+}
+
+function slotFor<T>(state: TokenState<T>, id: string): Slot<T> {
+  const found = state.get(id);
+  if (found !== undefined) return found;
+  const made: Slot<T> = { refreshing: null, latest: null };
+  state.set(id, made);
+  return made;
+}
+
+const newerThan = (a: { savedAt: string }, b: { savedAt: string }): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
+
+export function refreshed<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T, source: TokenSource<T>): Promise<T> {
+  const slot = slotFor(state, id);
+  const latest = slot.latest;
+  if (latest !== null && newerThan(latest, tokens) && !source.stale(latest)) return Promise.resolve(latest);
+  if (slot.refreshing !== null) return slot.refreshing;
+  const run = source
+    .refresh(tokens)
+    .then((fresh) => {
+      source.save(id, fresh);
+      slot.latest = fresh;
+      return fresh;
+    })
+    .catch((err: unknown) => {
+      throw new GatewayError(403, 'permission_error', `${source.label} sign-in expired (${errMsg(err)}): connect again on the Model page`);
+    })
+    .finally(() => {
+      slot.refreshing = null;
+    });
+  slot.refreshing = run;
+  return run;
+}
+
+export function currentOf<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T | null, source: TokenSource<T>, missing: string): Promise<T> {
+  if (tokens === null) throw new GatewayError(400, 'invalid_request_error', missing);
+  return source.stale(tokens) ? refreshed(state, id, tokens, source) : Promise.resolve(tokens);
+}
+
+export async function reach<T>(current: () => Promise<T>, again: (tokens: T) => Promise<T>, send: (tokens: T) => Promise<Response>): Promise<Response> {
+  const tokens = await current();
+  const upstream = await send(tokens);
+  if (upstream.status !== 401) return upstream;
+  await upstream.body?.cancel();
+  return send(await again(tokens));
+}
+
+export function errorKind(status: number, invalid: readonly number[] = [400, 404]): string {
+  if (status === 401 || status === 403) return 'permission_error';
+  if (status === 429) return 'rate_limit_error';
+  if (invalid.includes(status)) return 'invalid_request_error';
+  return 'api_error';
+}
+
+export function sessionHeader(req: IncomingMessage): string {
+  const raw = req.headers['x-claude-code-session-id'];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+}
+
+interface Translator {
+  readonly finished: boolean;
+  close: (message?: string) => string;
+}
+
+export function relayTranslated(
+  upstream: Response,
+  res: ServerResponse,
+  watch: Watch,
+  key: string,
+  translator: Translator,
+  onEvent: (raw: SseEvent) => string,
+): Promise<void> {
+  const parser = new SseParser();
+  const decoder = new TextDecoder();
+  return relayFrames(upstream, res, watch, key, {
+    push: (chunk, emit) => {
+      for (const raw of parser.push(decoder.decode(chunk, { stream: true }))) emit(onEvent(raw));
+    },
+    close: () => translator.close(),
+    idle: (message) => (translator.finished ? '' : translator.close(message)),
+  });
+}
+
+export function answerWhole(res: ServerResponse, frames: string, key: string): void {
+  const scanner = new UsageScanner(key);
+  scanner.feed(frames);
+  scanner.done();
+  const message = assembleMessage(frames);
+  const kind = isRecord(message.error) ? String(message.error.type) : '';
+  res.writeHead(message.type === 'error' ? (STATUS_OF[kind] ?? 502) : 200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(message));
+}
+
+export const estimateTokens = (body: Record<string, unknown>): number => Math.ceil(JSON.stringify(body).length / 4);
+
+export function countTokens(res: ServerResponse, body: Record<string, unknown>): void {
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ input_tokens: estimateTokens(body) }));
+}

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

@@ -0,0 +1,35 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+export const TOOL_ERROR = '[tool error]';
+
+export const nonEmpty = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+export interface InlineImage {
+  mediaType: string;
+  data: string;
+}
+
+type Part = Record<string, unknown>;
+type Accepts = (mediaType: string) => boolean;
+const anyImage: Accepts = () => true;
+
+export function inlineImage(block: Part, accepts = anyImage): InlineImage | null {
+  if (block.type !== 'image' || !isRecord(block.source) || block.source.type !== 'base64') return null;
+  const image = { mediaType: stringOf(block.source.media_type), data: stringOf(block.source.data) };
+  return image.mediaType !== '' && image.data !== '' && accepts(image.mediaType) ? image : null;
+}
+
+export const resultParts = (block: Part): Part[] => (Array.isArray(block.content) ? block.content.filter(isRecord) : []);
+
+export const partText = (part: Part, accepts = anyImage): string =>
+  part.type === 'text' ? stringOf(part.text) : part.type === 'image' && inlineImage(part, accepts) === null ? IMAGE_NOTE : '';
+
+export function resultText(block: Part, accepts = anyImage): string {
+  const content = block.content;
+  const text = typeof content === 'string' ? content : resultParts(block).map((part) => partText(part, accepts)).filter((t) => t !== '').join('\n');
+  return block.is_error === true ? `${TOOL_ERROR} ${text}` : text;
+}
+
+export const resultImages = (block: Part, accepts = anyImage): InlineImage[] => resultParts(block).flatMap((part) => inlineImage(part, accepts) ?? []);

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

@@ -0,0 +1,126 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Body = Record<string, unknown>;
+
+const TOOL_SEARCH_BETA = /^(advanced-tool-use|tool-search-tool|mid-conversation-tool-changes)-/;
+const PLACEHOLDER = 'DeferredToolPlaceholder';
+const NOTHING_FOUND = 'No matching deferred tools found';
+
+const blocksOf = (message: unknown): unknown[] => (isRecord(message) && Array.isArray(message.content) ? message.content : []);
+
+const isResult = (block: unknown): block is Body & { content: unknown[] } => isRecord(block) && block.type === 'tool_result' && Array.isArray(block.content);
+
+const inlineDefinition = (block: unknown): Body | null =>
+  isRecord(block) && block.type === 'tool_addition' && isRecord(block.tool) && block.tool.type === 'tool_definition' && isRecord(block.tool.definition) ? block.tool.definition : null;
+
+function loadedName(block: unknown): string | null {
+  if (!isRecord(block)) return null;
+  if (block.type === 'tool_reference') return stringOf(block.tool_name);
+  if (block.type !== 'tool_addition' || !isRecord(block.tool)) return null;
+  return stringOf(inlineDefinition(block)?.name ?? block.tool.name);
+}
+
+const removedName = (block: unknown): string | null => (isRecord(block) && block.type === 'tool_removal' && isRecord(block.tool) ? stringOf(block.tool.name) : null);
+
+const changes = (block: unknown): boolean => loadedName(block) !== null || removedName(block) !== null;
+
+const changing = (message: unknown): boolean => blocksOf(message).some((block) => changes(block) || (isResult(block) && block.content.some(changes)));
+
+const functionLine = (tool: Body): string =>
+  `<function>${JSON.stringify({ description: stringOf(tool.description), name: tool.name, parameters: isRecord(tool.input_schema) ? tool.input_schema : {} })}</function>`;
+
+function functionsText(blocks: unknown[], catalog: Map<string, Body>): string {
+  const lines = blocks.flatMap((block) => {
+    const tool = catalog.get(loadedName(block) ?? '');
+    return tool === undefined ? [] : [functionLine(tool)];
+  });
+  return lines.length === 0 ? NOTHING_FOUND : ['<functions>', ...lines, '</functions>'].join('\n');
+}
+
+const cacheOf = (blocks: unknown[]): Body => {
+  const marked = blocks.find((block) => isRecord(block) && block.cache_control !== undefined);
+  return isRecord(marked) ? { cache_control: marked.cache_control } : {};
+};
+
+function expanded(blocks: unknown[], catalog: Map<string, Body>): unknown[] {
+  const found = blocks.filter((block) => loadedName(block) !== null);
+  return blocks.flatMap((block) => {
+    if (block === found[0]) return [{ type: 'text', text: functionsText(found, catalog), ...cacheOf(found) }];
+    if (loadedName(block) !== null) return [];
+    const removed = removedName(block);
+    return removed === null ? [block] : [{ type: 'text', text: `Tool ${removed} is no longer available.`, ...cacheOf([block]) }];
+  });
+}
+
+const expandedBlock = (block: unknown, catalog: Map<string, Body>): unknown =>
+  isResult(block) && block.content.some(changes) ? { ...block, content: expanded(block.content, catalog) } : block;
+
+function expandedMessage(message: unknown, catalog: Map<string, Body>): unknown {
+  if (!changing(message) || !isRecord(message)) return message;
+  return { ...message, content: expanded(blocksOf(message).map((block) => expandedBlock(block, catalog)), catalog) };
+}
+
+interface Found {
+  names: Set<string>;
+  inline: Map<string, Body>;
+}
+
+function foundIn(messages: unknown[]): Found {
+  const found: Found = { names: new Set(), inline: new Map() };
+  const blocks = messages.flatMap(blocksOf).flatMap((block) => (isResult(block) ? block.content : [block]));
+  for (const block of blocks) {
+    const name = loadedName(block);
+    const definition = inlineDefinition(block);
+    if (name !== null) found.names.add(name);
+    if (definition !== null) found.inline.set(stringOf(definition.name), definition);
+    const removed = removedName(block);
+    if (removed === null) continue;
+    found.names.delete(removed);
+    found.inline.delete(removed);
+  }
+  return found;
+}
+
+const deferred = (tool: unknown): boolean => isRecord(tool) && tool.defer_loading === true;
+
+const loaded = (tool: unknown): unknown =>
+  isRecord(tool) && 'defer_loading' in tool ? Object.fromEntries(Object.entries(tool).filter(([key]) => key !== 'defer_loading')) : tool;
+
+const deferring = (tools: unknown): boolean => Array.isArray(tools) && tools.some((tool) => isRecord(tool) && 'defer_loading' in tool);
+
+const nameOf = (tool: unknown): string => (isRecord(tool) ? stringOf(tool.name) : '');
+
+export function resolveToolSearch(body: Body): Body {
+  const messages: unknown[] = Array.isArray(body.messages) ? body.messages : [];
+  if (!deferring(body.tools) && !messages.some(changing)) return body;
+  const declared: unknown[] = Array.isArray(body.tools) ? body.tools : [];
+  const found = foundIn(messages);
+  const shown = declared.filter((tool) => nameOf(tool) !== PLACEHOLDER && (!deferred(tool) || found.names.has(nameOf(tool)))).map(loaded);
+  const known = new Set(shown.map(nameOf));
+  const inline = [...found.inline.values()].filter((tool) => !known.has(nameOf(tool))).map(loaded);
+  const tools = [...shown, ...inline];
+  const catalog = new Map([...declared, ...inline].filter(isRecord).map((tool) => [nameOf(tool), tool]));
+  return {
+    ...body,
+    ...(Array.isArray(body.tools) || inline.length > 0 ? { tools } : {}),
+    ...(Array.isArray(body.messages) ? { messages: messages.map((message) => expandedMessage(message, catalog)) } : {}),
+  };
+}
+
+function dropToolSearchBeta(req: IncomingMessage): void {
+  const raw = req.headers['anthropic-beta'];
+  if (typeof raw !== 'string') return;
+  const kept = raw
+    .split(',')
+    .map((beta) => beta.trim())
+    .filter((beta) => beta !== '' && !TOOL_SEARCH_BETA.test(beta));
+  if (kept.length > 0) req.headers['anthropic-beta'] = kept.join(',');
+  else delete req.headers['anthropic-beta'];
+}
+
+export function fitToolSearch(req: IncomingMessage, body: Body): Body {
+  dropToolSearchBeta(req);
+  return resolveToolSearch(body);
+}