@stage-labs/metro 0.1.0-beta.27 → 0.1.0-beta.29

package/dist/bedrock-eventstream.js

@@ -0,0 +1,120 @@
+const PRELUDE_BYTES = 12;
+const CRC_BYTES = 4;
+const HEADER_TRUE = 0;
+const HEADER_FALSE = 1;
+const HEADER_BYTE = 2;
+const HEADER_SHORT = 3;
+const HEADER_INT = 4;
+const HEADER_LONG = 5;
+const HEADER_BYTES = 6;
+const HEADER_STRING = 7;
+const HEADER_TIMESTAMP = 8;
+const HEADER_UUID = 9;
+const FIXED_WIDTH = {
+    [HEADER_TRUE]: 0,
+    [HEADER_FALSE]: 0,
+    [HEADER_BYTE]: 1,
+    [HEADER_SHORT]: 2,
+    [HEADER_INT]: 4,
+    [HEADER_LONG]: 8,
+    [HEADER_TIMESTAMP]: 8,
+    [HEADER_UUID]: 16,
+};
+function readHeaderValue(buf, at, type) {
+    if (type === HEADER_BYTES || type === HEADER_STRING) {
+        const len = buf.readUInt16BE(at);
+        const raw = buf.subarray(at + 2, at + 2 + len);
+        const value = type === HEADER_STRING ? raw.toString('utf8') : raw.toString('base64');
+        return { value, next: at + 2 + len };
+    }
+    const width = FIXED_WIDTH[type];
+    if (width === undefined)
+        throw new Error(`eventstream: unknown header type ${String(type)}`);
+    if (type === HEADER_TRUE)
+        return { value: 'true', next: at };
+    if (type === HEADER_FALSE)
+        return { value: 'false', next: at };
+    return { value: buf.subarray(at, at + width).toString('hex'), next: at + width };
+}
+function readHeaders(buf) {
+    const out = {};
+    let at = 0;
+    while (at < buf.length) {
+        const nameLen = buf.readUInt8(at);
+        const name = buf.subarray(at + 1, at + 1 + nameLen).toString('utf8');
+        const type = buf.readUInt8(at + 1 + nameLen);
+        const parsed = readHeaderValue(buf, at + 2 + nameLen, type);
+        out[name] = parsed.value;
+        at = parsed.next;
+    }
+    return out;
+}
+export function decodeFrame(buf, offset) {
+    if (buf.length - offset < PRELUDE_BYTES)
+        return null;
+    const total = buf.readUInt32BE(offset);
+    const headersLen = buf.readUInt32BE(offset + 4);
+    if (total < PRELUDE_BYTES + CRC_BYTES || headersLen > total)
+        throw new Error('eventstream: malformed frame prelude');
+    if (buf.length - offset < total)
+        return null;
+    const headersStart = offset + PRELUDE_BYTES;
+    const payloadStart = headersStart + headersLen;
+    const payloadEnd = offset + total - CRC_BYTES;
+    return {
+        message: {
+            headers: readHeaders(buf.subarray(headersStart, payloadStart)),
+            payload: Buffer.from(buf.subarray(payloadStart, payloadEnd)),
+        },
+        end: offset + total,
+    };
+}
+export class EventStreamDecoder {
+    pending = Buffer.alloc(0);
+    push(chunk) {
+        this.pending =
+            this.pending.length === 0 ? chunk : Buffer.concat([this.pending, chunk]);
+        const out = [];
+        let offset = 0;
+        for (;;) {
+            const frame = decodeFrame(this.pending, offset);
+            if (frame === null)
+                break;
+            out.push(frame.message);
+            offset = frame.end;
+        }
+        this.pending = this.pending.subarray(offset);
+        return out;
+    }
+    leftover() {
+        return this.pending.length;
+    }
+}
+function encodeHeader(name, value) {
+    const nameBuf = Buffer.from(name, 'utf8');
+    const valueBuf = Buffer.from(value, 'utf8');
+    const out = Buffer.alloc(1 + nameBuf.length + 1 + 2 + valueBuf.length);
+    let at = 0;
+    out.writeUInt8(nameBuf.length, at);
+    at += 1;
+    nameBuf.copy(out, at);
+    at += nameBuf.length;
+    out.writeUInt8(HEADER_STRING, at);
+    at += 1;
+    out.writeUInt16BE(valueBuf.length, at);
+    at += 2;
+    valueBuf.copy(out, at);
+    return out;
+}
+export function encodeFrame(headers, payload) {
+    const headerBuf = Buffer.concat(Object.entries(headers).map(([name, value]) => encodeHeader(name, value)));
+    const total = PRELUDE_BYTES + headerBuf.length + payload.length + CRC_BYTES;
+    const out = Buffer.alloc(total);
+    out.writeUInt32BE(total, 0);
+    out.writeUInt32BE(headerBuf.length, 4);
+    out.writeUInt32BE(0, 8);
+    headerBuf.copy(out, PRELUDE_BYTES);
+    payload.copy(out, PRELUDE_BYTES + headerBuf.length);
+    out.writeUInt32BE(0, total - CRC_BYTES);
+    return out;
+}

package/dist/bedrock-proxy.js

@@ -0,0 +1,296 @@
+import { createServer, } from 'node:http';
+import { EventStreamDecoder } from './bedrock-eventstream.js';
+export class BedrockConfigError extends Error {
+}
+export class ProxyError extends Error {
+    status;
+    kind;
+    constructor(status, kind, message) {
+        super(message);
+        this.status = status;
+        this.kind = kind;
+    }
+}
+const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
+const BODY_MAX = 64 * 1024 * 1024;
+const MESSAGES_PATH = '/v1/messages';
+const COUNT_PATH = '/v1/messages/count_tokens';
+function firstEnv(env, names) {
+    for (const name of names) {
+        const value = env[name]?.trim() ?? '';
+        if (value !== '')
+            return value;
+    }
+    return '';
+}
+export function bedrockConfigFromEnv(env = process.env) {
+    const bearerToken = firstEnv(env, ['AWS_BEARER_TOKEN_BEDROCK']);
+    if (bearerToken === '')
+        throw new BedrockConfigError('AWS_BEARER_TOKEN_BEDROCK is not set. Create an Amazon Bedrock API key in the AWS console (Bedrock → API keys) and export it.');
+    const region = firstEnv(env, ['METRO_BEDROCK_REGION', 'AWS_REGION', 'AWS_DEFAULT_REGION']);
+    if (region === '')
+        throw new BedrockConfigError('no AWS region: set AWS_REGION (or METRO_BEDROCK_REGION) to the region your Bedrock API key belongs to');
+    const model = firstEnv(env, ['METRO_BEDROCK_MODEL']);
+    return { region, bearerToken, model: model === '' ? null : model };
+}
+const PREFIXES = [
+    [/^us-gov-/, 'us-gov'],
+    [/^us-/, 'us'],
+    [/^eu-/, 'eu'],
+    [/^ap-/, 'apac'],
+];
+export function regionPrefix(region) {
+    for (const [pattern, prefix] of PREFIXES)
+        if (pattern.test(region))
+            return prefix;
+    return 'global';
+}
+export function mapModel(requested, cfg) {
+    if (cfg.model !== null)
+        return cfg.model;
+    if (requested.includes('anthropic.'))
+        return requested;
+    return `${regionPrefix(cfg.region)}.anthropic.${requested}`;
+}
+export const upstreamBase = (cfg, override) => override ?? `https://bedrock-runtime.${cfg.region}.amazonaws.com`;
+function splitBetas(header) {
+    const raw = Array.isArray(header) ? header.join(',') : (header ?? '');
+    return raw
+        .split(',')
+        .map((b) => b.trim())
+        .filter((b) => b !== '');
+}
+export function rewriteBody(raw, betaHeader, cfg) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw new ProxyError(400, 'invalid_request_error', 'body must be a JSON object');
+    const { model, stream, ...rest } = raw;
+    if (typeof model !== 'string' || model === '')
+        throw new ProxyError(400, 'invalid_request_error', 'model is required');
+    const betas = splitBetas(betaHeader);
+    const body = { ...rest, anthropic_version: ANTHROPIC_VERSION };
+    if (betas.length > 0)
+        body.anthropic_beta = betas;
+    return { modelId: mapModel(model, cfg), stream: stream === true, body, betas };
+}
+export function errorKind(status, errorType) {
+    if (status === 429 || errorType === 'ThrottlingException')
+        return 'rate_limit_error';
+    if (status === 400)
+        return 'invalid_request_error';
+    if (status === 401)
+        return 'authentication_error';
+    if (status === 403)
+        return 'permission_error';
+    if (status === 404)
+        return 'not_found_error';
+    if (status === 503)
+        return 'overloaded_error';
+    return 'api_error';
+}
+function sendError(res, status, kind, message) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ type: 'error', error: { type: kind, message } }));
+}
+async function readBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = chunk;
+        total += buf.length;
+        if (total > BODY_MAX)
+            throw new ProxyError(413, 'invalid_request_error', 'request too large');
+        chunks.push(buf);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new ProxyError(400, 'invalid_request_error', 'body must be JSON');
+    }
+}
+function invokeUrl(up, modelId, action) {
+    return `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
+}
+function callBedrock(up, url, body, accept, signal) {
+    return fetch(url, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${up.cfg.bearerToken}`,
+            'content-type': 'application/json',
+            accept,
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+}
+async function invoke(up, req, signal) {
+    const action = req.stream ? 'invoke-with-response-stream' : 'invoke';
+    const accept = req.stream ? 'application/vnd.amazon.eventstream' : 'application/json';
+    const url = invokeUrl(up, req.modelId, action);
+    const first = await callBedrock(up, url, req.body, accept, signal);
+    if (first.status !== 400 || req.betas.length === 0)
+        return first;
+    await first.text();
+    process.stderr.write(`metro bedrock: retrying without anthropic_beta [${req.betas.join(', ')}]\n`);
+    const stripped = Object.fromEntries(Object.entries(req.body).filter(([key]) => key !== 'anthropic_beta'));
+    return callBedrock(up, url, stripped, accept, signal);
+}
+function upstreamMessage(text) {
+    try {
+        const parsed = JSON.parse(text);
+        const message = parsed.message ?? parsed.Message;
+        if (typeof message === 'string' && message !== '')
+            return message;
+    }
+    catch {
+        return text === '' ? 'Bedrock returned no body' : text;
+    }
+    return text === '' ? 'Bedrock returned no body' : text;
+}
+async function relayError(upstream, res) {
+    const text = await upstream.text();
+    const kind = errorKind(upstream.status, upstream.headers.get('x-amzn-errortype'));
+    sendError(res, upstream.status, kind, upstreamMessage(text));
+}
+function eventTypeOf(event) {
+    try {
+        const parsed = JSON.parse(event);
+        return typeof parsed.type === 'string' ? parsed.type : 'message';
+    }
+    catch {
+        return 'message';
+    }
+}
+function writeEvent(res, message) {
+    if (message.headers[':message-type'] === 'event') {
+        const parsed = JSON.parse(message.payload.toString('utf8'));
+        if (typeof parsed.bytes !== 'string')
+            return;
+        const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+        res.write(`event: ${eventTypeOf(event)}\ndata: ${event}\n\n`);
+        return;
+    }
+    const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+    const body = {
+        type: 'error',
+        error: {
+            type: errorKind(500, errorType),
+            message: upstreamMessage(message.payload.toString('utf8')),
+        },
+    };
+    res.write(`event: error\ndata: ${JSON.stringify(body)}\n\n`);
+}
+async function relayStream(upstream, res) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-store',
+        connection: 'keep-alive',
+    });
+    const body = upstream.body;
+    if (body === null) {
+        res.end();
+        return;
+    }
+    const decoder = new EventStreamDecoder();
+    const reader = body.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        for (const message of decoder.push(Buffer.from(value)))
+            writeEvent(res, message);
+    }
+    res.end();
+}
+async function relayJson(upstream, res) {
+    const text = await upstream.text();
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(text);
+}
+async function handleMessages(req, res, up) {
+    const rewritten = rewriteBody(await readBody(req), req.headers['anthropic-beta'], up.cfg);
+    const controller = new AbortController();
+    res.on('close', () => {
+        if (!res.writableEnded)
+            controller.abort();
+    });
+    const upstream = await invoke(up, rewritten, controller.signal);
+    if (!upstream.ok) {
+        await relayError(upstream, res);
+        return;
+    }
+    if (rewritten.stream)
+        await relayStream(upstream, res);
+    else
+        await relayJson(upstream, res);
+}
+function estimateTokens(body) {
+    return Math.ceil(JSON.stringify(body).length / 4);
+}
+async function handleCount(req, res, up) {
+    const rewritten = rewriteBody(await readBody(req), req.headers['anthropic-beta'], up.cfg);
+    const controller = new AbortController();
+    const upstream = await callBedrock(up, invokeUrl(up, rewritten.modelId, 'count-tokens'), { input: { invokeModel: { body: JSON.stringify(rewritten.body) } } }, 'application/json', controller.signal);
+    const text = await upstream.text();
+    let counted = null;
+    if (upstream.ok) {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.inputTokens === 'number')
+            counted = parsed.inputTokens;
+    }
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
+}
+function presentedToken(req) {
+    const auth = req.headers.authorization ?? '';
+    if (auth.toLowerCase().startsWith('bearer '))
+        return auth.slice(7).trim();
+    const key = req.headers['x-api-key'];
+    return Array.isArray(key) ? (key[0] ?? '') : (key ?? '');
+}
+async function route(req, res, cfg, opts) {
+    if (presentedToken(req) !== opts.token)
+        throw new ProxyError(401, 'authentication_error', 'unauthorized');
+    const path = (req.url ?? '').split('?')[0] ?? '';
+    const up = { cfg, base: upstreamBase(cfg, opts.upstream) };
+    if (req.method === 'POST' && path === MESSAGES_PATH)
+        return handleMessages(req, res, up);
+    if (req.method === 'POST' && path === COUNT_PATH)
+        return handleCount(req, res, up);
+    throw new ProxyError(404, 'not_found_error', 'not found');
+}
+function failed(res, err) {
+    if (res.headersSent) {
+        res.end();
+        return;
+    }
+    if (err instanceof ProxyError) {
+        sendError(res, err.status, err.kind, err.message);
+        return;
+    }
+    const message = err instanceof Error ? err.message : 'proxy failure';
+    sendError(res, 502, 'api_error', `metro bedrock proxy: ${message}`);
+}
+export function startBedrockProxy(cfg, opts) {
+    const server = createServer((req, res) => {
+        route(req, res, cfg, opts).catch((err) => {
+            failed(res, err);
+        });
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(opts.port ?? 0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            resolve({
+                port,
+                server,
+                close: () => new Promise((done) => {
+                    server.close(() => {
+                        done();
+                    });
+                }),
+            });
+        });
+    });
+}

package/dist/bedrock.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { claudeArgs } from './claude.js';
+import { bedrockConfigFromEnv, startBedrockProxy } from './bedrock-proxy.js';
+export const PROVIDER_FLAGS = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_MANTLE',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+    'CLAUDE_CODE_USE_GATEWAY',
+];
+const CONFLICTING = [
+    ...PROVIDER_FLAGS,
+    'ANTHROPIC_BASE_URL',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+];
+const SCRUBBED = [...PROVIDER_FLAGS, 'ANTHROPIC_API_KEY', 'AWS_BEARER_TOKEN_BEDROCK'];
+export function settingsFiles(cwd = process.cwd(), env = process.env) {
+    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
+    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
+    return [
+        join(configDir, 'settings.json'),
+        join(cwd, '.claude', 'settings.json'),
+        join(cwd, '.claude', 'settings.local.json'),
+    ];
+}
+function envBlock(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        const block = parsed.env;
+        return typeof block === 'object' && block !== null
+            ? block
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function settingsConflicts(files) {
+    const out = [];
+    for (const file of files) {
+        const block = envBlock(file);
+        for (const key of CONFLICTING) {
+            const value = block[key];
+            if (typeof value === 'string' && value.trim() !== '')
+                out.push(`${file}: ${key}`);
+        }
+    }
+    return out;
+}
+export function claudeEnv(base, port, token) {
+    const kept = Object.entries(base).filter(([key]) => !SCRUBBED.includes(key));
+    return {
+        ...Object.fromEntries(kept),
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}`,
+        ANTHROPIC_AUTH_TOKEN: token,
+    };
+}
+function runClaude(args, env) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn('claude', args, { stdio: 'inherit', env });
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT'
+                ? 'the `claude` command is not on PATH — install Claude Code first'
+                : err.message));
+        });
+        child.on('exit', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+export async function bedrock(argv) {
+    const cfg = bedrockConfigFromEnv();
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        throw new Error('metro bedrock: these settings would put Claude Code back on a third-party provider, or override the proxy. Remove them, or point CLAUDE_CONFIG_DIR at a separate profile:\n  ' +
+            conflicts.join('\n  '));
+    const token = `mb_${randomBytes(18).toString('base64url')}`;
+    const proxy = await startBedrockProxy(cfg, { token });
+    const pinned = cfg.model === null ? '' : ` (${cfg.model})`;
+    process.stderr.write(`metro bedrock: Claude Code → http://127.0.0.1:${String(proxy.port)} → Bedrock ${cfg.region}${pinned}\n`);
+    try {
+        return await runClaude(claudeArgs(argv), claudeEnv(process.env, proxy.port, token));
+    }
+    finally {
+        await proxy.close();
+    }
+}

package/dist/claude.js

@@ -0,0 +1,15 @@
+import { spawnSync } from 'node:child_process';
+const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
+export const claudeArgs = (extra) => [
+    ...CHANNEL_FLAGS,
+    ...extra,
+];
+export function launchClaude(extra) {
+    const leaveToChild = () => undefined;
+    process.on('SIGINT', leaveToChild);
+    process.on('SIGTERM', leaveToChild);
+    const res = spawnSync('claude', claudeArgs(extra), { stdio: 'inherit' });
+    if (res.error !== undefined)
+        throw new Error('the `claude` command is not on PATH — install Claude Code first');
+    return Promise.resolve(res.status ?? 1);
+}

package/dist/cli.js

@@ -6,6 +6,8 @@ import { clearToken, credentialsPath, metroUrl, metroWebUrl, writeToken, } from
 import { detach, lockedBy, probe, runningPid, stopAll, tail } from './control.js';
 import { tailEvents } from './tail.js';
 import { assertAgentId, daemonPlan, localUrl, readRunToken, runDaemon, runtimeDir, writeRunToken, } from './runtime.js';
+import { launchClaude } from './claude.js';
+import { bedrock } from './bedrock.js';
 import { installPlugin, syncPluginServers } from './plugin.js';
 import { update } from './update.js';
 import { currentVersion } from './version.js';
@@ -26,6 +28,11 @@ const USAGE = `metro — the command line for your MCP connectors
   metro whoami    print the account and collection this machine may read
   metro mcp       print the mcpServers block for the authorized collection
   metro plugin    set up the Claude Code plugin (connector servers + /metro:login)
+  metro claude [args...]
+                  open Claude Code with the metro channel; every argument is passed through
+  metro bedrock [args...]
+                  the same, with inference on Amazon Bedrock through a local proxy so the
+                  channel still works (needs AWS_BEARER_TOKEN_BEDROCK and AWS_REGION)
   metro update    update to the newest published version
   metro version   print this CLI's version
 
@@ -37,6 +44,9 @@ Start Claude Code with all of them, without writing them to disk:
   METRO_UI_URL       where the web UI lives (default https://metro.box)
   METRO_TOKEN        use this connector sign-in instead of the stored one
   METRO_RUN_TOKEN    use this runtime authorization instead of the stored one
+  METRO_BEDROCK_MODEL
+                     send every request to this Bedrock model id (default: derive from the
+                     model Claude Code asks for, e.g. eu.anthropic.claude-sonnet-4-6)
   METRO_RUNTIME_DIR  run the daemon from this directory instead of the bundled one
 `;
 function hostLabel() {
@@ -137,6 +147,8 @@ const COMMANDS = {
         return 0;
     },
     plugin: installPlugin,
+    claude: () => launchClaude(process.argv.slice(3)),
+    bedrock: () => bedrock(process.argv.slice(3)),
     update,
     version: async () => {
         process.stdout.write(`${currentVersion()}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.27",
+  "version": "0.1.0-beta.29",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/mcp/src/daemon/agent-api.ts

@@ -91,8 +91,10 @@ export function mcpEndpoint(): string {
   return `${publicBaseOrDefault()}/mcp`;
 }
 
+const LOCAL_MCP_ENDPOINT = 'http://127.0.0.1:8420/mcp';
+
 export function mcpAddCommand(key: string): string {
-  const url = `${mcpEndpoint()}?token=${key}`;
+  const url = `${LOCAL_MCP_ENDPOINT}?token=${key}`;
   return `claude mcp add --transport http ${SERVER_NAME} "${url}"`;
 }
 
@@ -102,23 +104,18 @@ interface KeyPayload {
   command: string | null;
 }
 
-const LOCAL_MCP_ENDPOINT = 'http://127.0.0.1:8420/mcp';
-
-function credentials(key: string, heldLocally: boolean): KeyPayload {
-  const url = heldLocally
-    ? `${LOCAL_MCP_ENDPOINT}?token=${key}`
-    : `${mcpEndpoint()}?token=${key}`;
+function credentials(key: string): KeyPayload {
   return {
     key,
-    endpoint: url,
-    command: `claude mcp add --transport http ${SERVER_NAME} "${url}"`,
+    endpoint: `${LOCAL_MCP_ENDPOINT}?token=${key}`,
+    command: mcpAddCommand(key),
   };
 }
 
-function keyPayload(agent: AgentSummary, heldLocally: boolean): KeyPayload {
+function keyPayload(agent: AgentSummary): KeyPayload {
   const value = agent.owned ? agent.key : null;
   if (value === null) return { key: null, endpoint: null, command: null };
-  return credentials(value, heldLocally);
+  return credentials(value);
 }
 
 function livenessPayload(
@@ -144,7 +141,7 @@ function agentPayload(
     owned: agent.owned,
     runtime: agent.owned ? (runtimes.get(agent.id) ?? null) : null,
     ...livenessPayload(agent, live),
-    ...keyPayload(agent, agent.owned && runtimes.has(agent.id)),
+    ...keyPayload(agent),
   };
 }
 
@@ -224,7 +221,7 @@ async function handleCreate(
   sendJson(req, res, 201, {
     id: created.id,
     name: created.name,
-    ...credentials(created.key, false),
+    ...credentials(created.key),
   });
 }
 
@@ -236,7 +233,6 @@ async function handleResetKey(
   id: string,
 ): Promise<void> {
   const reset = await deps.resetKey(session.email, id);
-  const held = (await deps.runtimes([id])).has(id);
   log.info(
     { agent: reset.name, id: reset.id, owner: session.email },
     'agent-api: reset agent key',
@@ -245,7 +241,7 @@ async function handleResetKey(
     id: reset.id,
     name: reset.name,
     reset: true,
-    ...credentials(reset.key, held),
+    ...credentials(reset.key),
   });
 }
 

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.27"
+  "version": "0.1.0-beta.29"
 }