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

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 { anthropicRoute, currentRoute, permissionMode, routeModelEnv, systemPrompt } from './route.js';
+import { 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,7 +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' };
+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)))
@@ -125,7 +125,7 @@ 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 pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
-    const routed = toolSearchEnv(pointed, anthropicRoute());
+    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());

package/dist/route.js

@@ -16,27 +16,17 @@ function routeIn(cfg) {
     const model = text(conn.model);
     return PROVIDERS.has(provider) && model !== '' ? `${provider}:${model}` : null;
 }
-function modelConfig(dir) {
+export function currentRoute(dir = agentsDir()) {
     const path = join(dir, 'model.json');
     if (!existsSync(path))
         return null;
     try {
-        return JSON.parse(readFileSync(path, 'utf8'));
+        return routeIn(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.218",
+  "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.218",
+  "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

@@ -205,13 +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 shaped = shapedFor(req, sent);
-  const route = resolveRoute(requestedModel(shaped), cfg) ?? passthrough(shaped);
-  const body = fitToolSearch(req, shaped, route);
+  const parsed = parseJson(raw);
+  const sent = fitToolSearch(req, parsed);
+  const route = resolveRoute(requestedModel(sent), cfg) ?? passthrough(sent);
+  const body = shapedFor(req, sent);
   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() });
@@ -231,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

@@ -1,46 +1,111 @@
 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})?$/;
+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';
 
-export const takesToolSearch = (route: Route): boolean =>
-  route.connection.provider === 'anthropic' && !BEFORE_TOOL_REFERENCE.test(route.model);
+const blocksOf = (message: unknown): unknown[] => (isRecord(message) && Array.isArray(message.content) ? message.content : []);
 
-const isReference = (block: unknown): boolean => isRecord(block) && block.type === 'tool_reference';
+const isResult = (block: unknown): block is Body & { content: unknown[] } => isRecord(block) && block.type === 'tool_result' && Array.isArray(block.content);
 
-const holdsReference = (block: unknown): boolean =>
-  isReference(block) || (isRecord(block) && block.type === 'tool_result' && Array.isArray(block.content) && block.content.some(isReference));
+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;
 
-const referencing = (message: unknown): boolean => isRecord(message) && Array.isArray(message.content) && message.content.some(holdsReference);
+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 } : {};
+};
 
-const deferred = (tool: unknown): tool is Body => isRecord(tool) && tool.defer_loading !== undefined;
+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) };
+}
 
-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;
+interface Found {
+  names: Set<string>;
+  inline: Map<string, Body>;
 }
 
-const flatMessage = (message: unknown): unknown =>
-  isRecord(message) && Array.isArray(message.content) ? { ...message, content: message.content.map(flatBlock) } : message;
+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 loadedTool = (tool: unknown): unknown =>
-  deferred(tool) ? Object.fromEntries(Object.entries(tool).filter(([key]) => key !== 'defer_loading')) : tool;
+const nameOf = (tool: unknown): string => (isRecord(tool) ? stringOf(tool.name) : '');
 
-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;
+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) ? { tools: tools.map(loadedTool) } : {}),
-    ...(Array.isArray(body.messages) ? { messages: messages.map(flatMessage) } : {}),
+    ...(Array.isArray(body.tools) || inline.length > 0 ? { tools } : {}),
+    ...(Array.isArray(body.messages) ? { messages: messages.map((message) => expandedMessage(message, catalog)) } : {}),
   };
 }
 
@@ -55,8 +120,7 @@ function dropToolSearchBeta(req: IncomingMessage): void {
   else delete req.headers['anthropic-beta'];
 }
 
-export function fitToolSearch(req: IncomingMessage, body: Body, route: Route): Body {
-  if (takesToolSearch(route)) return body;
+export function fitToolSearch(req: IncomingMessage, body: Body): Body {
   dropToolSearchBeta(req);
-  return withoutToolSearch(body);
+  return resolveToolSearch(body);
 }

package/runtime/runtime.json

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