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

package/dist/claude.js

@@ -1,7 +1,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { markOnboardingDone, seedChannels } from './onboarding.js';
 import { writeMcpConfig } from './mcp-config.js';
-import { currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
+import { anthropicRoute, currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
 import { settingsConflicts, settingsFiles } from './claude-settings.js';
 import { localAgent } from './local.js';
 import { PROVIDER_FLAGS } from './provider-flags.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, anthropic) => !anthropic || 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, anthropicRoute());
+    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/dist/route.js

@@ -16,17 +16,27 @@ function routeIn(cfg) {
     const model = text(conn.model);
     return PROVIDERS.has(provider) && model !== '' ? `${provider}:${model}` : null;
 }
-export function currentRoute(dir = agentsDir()) {
+function modelConfig(dir) {
     const path = join(dir, 'model.json');
     if (!existsSync(path))
         return null;
     try {
-        return routeIn(JSON.parse(readFileSync(path, 'utf8')));
+        return JSON.parse(readFileSync(path, 'utf8'));
     }
     catch {
         return null;
     }
 }
+export const currentRoute = (dir = agentsDir()) => routeIn(modelConfig(dir));
+const isRecord = (value) => typeof value === 'object' && value !== null;
+export function anthropicRoute(dir = agentsDir()) {
+    const cfg = modelConfig(dir);
+    if (!isRecord(cfg) || !Array.isArray(cfg.connections))
+        return true;
+    const connections = cfg.connections.filter(isRecord);
+    const routed = connections.find((c) => c.id === cfg.route) ?? connections[0];
+    return routed === undefined || routed.provider === 'anthropic';
+}
 export function routeModelEnv(env, route) {
     if (route === null || (env.ANTHROPIC_MODEL ?? '').trim() !== '')
         return env;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.217",
+  "version": "0.1.0-beta.218",
   "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.218",
   "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';
@@ -208,8 +209,9 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
   const cfg = deps.config();
   const raw = await readBody(req);
   const sent = parseJson(raw);
-  const body = shapedFor(req, sent);
-  const route = resolveRoute(requestedModel(body), cfg) ?? passthrough(body);
+  const shaped = shapedFor(req, sent);
+  const route = resolveRoute(requestedModel(shaped), cfg) ?? passthrough(shaped);
+  const body = fitToolSearch(req, shaped, route);
   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() });

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

@@ -0,0 +1,62 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+import type { Route } from './model-config.js';
+
+type Body = Record<string, unknown>;
+
+const TOOL_SEARCH_BETA = /^(advanced-tool-use|tool-search-tool)-/;
+const BEFORE_TOOL_REFERENCE = /^claude-3|^claude-(opus|sonnet)-4(-[01])?(-\d{8})?$/;
+
+export const takesToolSearch = (route: Route): boolean =>
+  route.connection.provider === 'anthropic' && !BEFORE_TOOL_REFERENCE.test(route.model);
+
+const isReference = (block: unknown): boolean => isRecord(block) && block.type === 'tool_reference';
+
+const holdsReference = (block: unknown): boolean =>
+  isReference(block) || (isRecord(block) && block.type === 'tool_result' && Array.isArray(block.content) && block.content.some(isReference));
+
+const referencing = (message: unknown): boolean => isRecord(message) && Array.isArray(message.content) && message.content.some(holdsReference);
+
+const deferred = (tool: unknown): tool is Body => isRecord(tool) && tool.defer_loading !== undefined;
+
+function flatBlock(block: unknown): unknown {
+  if (!isRecord(block)) return block;
+  if (block.type === 'tool_reference') return { type: 'text', text: `Tool ${stringOf(block.tool_name)} is loaded: call it directly.` };
+  if (block.type === 'tool_result' && Array.isArray(block.content)) return { ...block, content: block.content.map(flatBlock) };
+  return block;
+}
+
+const flatMessage = (message: unknown): unknown =>
+  isRecord(message) && Array.isArray(message.content) ? { ...message, content: message.content.map(flatBlock) } : message;
+
+const loadedTool = (tool: unknown): unknown =>
+  deferred(tool) ? Object.fromEntries(Object.entries(tool).filter(([key]) => key !== 'defer_loading')) : tool;
+
+export function withoutToolSearch(body: Body): Body {
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  if (!tools.some(deferred) && !messages.some(referencing)) return body;
+  return {
+    ...body,
+    ...(Array.isArray(body.tools) ? { tools: tools.map(loadedTool) } : {}),
+    ...(Array.isArray(body.messages) ? { messages: messages.map(flatMessage) } : {}),
+  };
+}
+
+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, route: Route): Body {
+  if (takesToolSearch(route)) return body;
+  dropToolSearchBeta(req);
+  return withoutToolSearch(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.218"
 }