@stage-labs/metro 0.1.0-beta.217 → 0.1.0-beta.219

package/dist/claude.js

@@ -40,6 +40,7 @@ export function gatewayEnv(base, agentKey, port) {
     };
 }
 export const channelEnv = (env) => set(env, 'MCP_PROTOCOL_NEGOTIATION') ? env : { ...env, MCP_PROTOCOL_NEGOTIATION: 'legacy' };
+export const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };
 const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
 export function credentialEnv(env, agentKey, signedIn) {
     if (signedIn || OWN_CREDENTIALS.some((name) => set(env, name)))
@@ -123,7 +124,10 @@ function mcpConfigFor(key, port) {
 }
 function gatewayLaunchEnv(key, port) {
     process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
-    const routed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
+    const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
+    const routed = toolSearchEnv(pointed);
+    if (routed !== pointed)
+        process.stderr.write('metro claude: MCP tool search is on, so connector tools load when Claude needs them instead of all at start\n');
     const env = credentialEnv(routed, key, claudeSignedIn());
     if (env !== routed)
         process.stderr.write("metro claude: Claude Code has no login of its own here, so metro's key stands in as its credential; the Model page must route to Bedrock, OpenRouter or Codex\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.217",
+  "version": "0.1.0-beta.219",
   "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.217",
+  "version": "0.1.0-beta.219",
   "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/gateway.ts

@@ -22,6 +22,7 @@ import { OPENROUTER_BASE } from './openrouter.js';
 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 type { CodexTokens } from './codex-auth.js';
 
 const GATEWAY_PREFIX = '/gateway';
@@ -204,12 +205,15 @@ function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<
   return effort === null ? sent : withEffort(sent, effort);
 }
 
+const bytesOf = (raw: Buffer, parsed: Record<string, unknown>, sent: Record<string, unknown>): Buffer => (sent === parsed ? raw : Buffer.from(JSON.stringify(sent)));
+
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
   const cfg = deps.config();
   const raw = await readBody(req);
-  const sent = parseJson(raw);
+  const parsed = parseJson(raw);
+  const sent = fitToolSearch(req, parsed);
+  const route = resolveRoute(requestedModel(sent), cfg) ?? passthrough(sent);
   const body = shapedFor(req, sent);
-  const route = resolveRoute(requestedModel(body), cfg) ?? passthrough(body);
   const conn = route.connection;
   log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
   if (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() });
@@ -229,7 +233,7 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
     await toSubscription(req, res, path, body, route, deps);
     return;
   }
-  await toAnthropic(req, res, raw, sent, body, route, deps);
+  await toAnthropic(req, res, bytesOf(raw, parsed, sent), sent, body, route, deps);
 }
 
 function failed(res: ServerResponse, err: unknown): void {

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);
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp/tool-catalog.ts

@@ -37,8 +37,12 @@ export interface PublishedTool {
   description: string;
   inputSchema: Record<string, unknown>;
   annotations: ToolAnnotations;
+  _meta?: Record<string, boolean>;
 }
 
+const ALWAYS_LOADED = new Set(['react', 'typing', 'send', 'reply']);
+const ALWAYS_LOAD = { 'anthropic/alwaysLoad': true };
+
 const annotationsOf = (def: ToolDef): ToolAnnotations =>
   toolGroupOf(def.name) === 'read'
     ? { readOnlyHint: true }
@@ -50,6 +54,7 @@ export const listedTools = (): PublishedTool[] =>
     description: def.description,
     inputSchema: def.inputSchema,
     annotations: annotationsOf(def),
+    ...(ALWAYS_LOADED.has(def.name) ? { _meta: ALWAYS_LOAD } : {}),
   }));
 
 const STATION_OF_TOOL = new Map(STATIONS.flatMap((s) => s.tools.map((t) => [t.name, s.name] as const)));

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.217"
+  "version": "0.1.0-beta.219"
 }