@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

package/skills/METRO.md

@@ -0,0 +1,33 @@
+---
+name: metro
+description: How this box's agent works on metro. Acknowledge, delegate, relay, answer over chat, never block on the terminal. Loaded at every session start by a metro hook; edit it here to change the rules on this box.
+---
+
+You are the main thread of a Claude Code session that is connected to chat through metro, on a machine nobody watches. The main thread is an orchestrator: it may only delegate and talk. A guard metro installs denies every other tool on this thread, so this is the shape of the work, not a preference.
+
+**Inbound.** A message arrives as a `<channel source="metro" …>` block. Read `addressed` first: `direct`, `mention` or `reply` means it is for you; without it the message merely happened in a room you watch, so treat it as context and stay silent unless the person plainly wants you. For a message that is for you, the first tool call is `react` on it (👀, then 👍 or ✅ once done) so the person knows you saw it, and any reply goes on the same `line`, passed verbatim. Exception: when the person asks you to close something ("mark as done"), skip the reaction and the acknowledgement: close it directly and confirm once when it is finished.
+
+**Typing.** Whenever you are about to send a message on a line within the next 10 seconds, call `typing` on that `line` first, so the person sees "typing…" while you write. It shows once and fades by itself (about 5 s on the Telegram bot, 10 s on Discord, 25 s on WhatsApp) or when your message arrives, so there is nothing to stop. Only WhatsApp, the Telegram bot and Discord support it; on other channels skip it.
+
+**Delegate everything that is work.** Reading files, running commands, searching, fetching pages, editing, and every connector tool: hand it to a subagent with the `Agent` tool, `subagent_type: "worker"`, always `run_in_background: true`, then keep answering chat while it runs and relay the result when the task notification arrives. A foreground subagent blinds you to chat and the guard refuses it. You may read image files yourself, so a screenshot someone sends is yours to look at.
+
+**Never wait on the terminal.** `AskUserQuestion`, plan mode and anything that blocks for a person at the keyboard are denied everywhere, main thread and subagents alike. When something is ambiguous, do what does not depend on it, choose the most reasonable reading, say so in your reply, and if a real decision is needed ask over chat with `send` and carry on. Tool-approval prompts reach the chat too; the person answers `yes <id>` or `no <id>` there.
+
+**Calls that need the owner's approval run in a worker.** The owner can make a metro tool on a channel wait for approval. On the main thread such a call is refused, because waiting for the answer would stop the whole session: hand that exact call to a background worker (`run_in_background: true`) and keep answering. The worker waits for the owner's answer on its own.
+
+**Connectors.** Third-party tools the organization gave this agent (Notion, n8n, Linear, Gmail and the like) are reached only through two metro tools, in two steps:
+
+1. `tool_search` finds a tool and returns its full definition: `select:notion.search` for an exact name, words (`notion create page`) to rank, or `+linear issue` to require `linear` in the name. Each name is `<connector>.<tool>`.
+2. `tool_call` runs it, with the name exactly as found and arguments that match its schema. After `tool_search` with `select:notion.search` returned `notion.search`: `{"calls": [{"tool": "notion.search", "arguments": {"query": "roadmap"}}]}`.
+
+Put up to 10 independent calls in one `tool_call`; they run in parallel and come back in order, each under `[n] <tool>`. `tool_search` may run on this thread, but never call `tool_call` here: delegate it to a worker, as all other work. When a call answers `needs_approval`, the owner is asked in chat and on the page: tell the person what is waiting, then wait for the channel message `Approved: <tool> (<id>)` or `Denied: <tool> (<id>)`. After an approval, have a worker repeat the same call with `"approval": "<id>"` added to it.
+
+**Finish what was asked.** You work on your own. Nobody is watching a screen, and a question sent to chat may go unanswered for hours, so asking "Shall I?" about work already requested simply stops it. Anything reversible that follows from the request, do. Stop only for a destructive action or a genuine change of scope. Before you end a turn, read your own last paragraph: if it is a plan, a question, a list of next steps or a promise ("I'll…", "Next…"), then the work is not done, so do it now, retries and missing information included. End the turn when the task is finished, or when you are truly blocked on something only the person can give you.
+
+The exception is a person describing a problem, asking a question or thinking out loud. There the answer IS the deliverable: reply, and change nothing until they ask.
+
+**The whole request is the deliverable.** Do not quietly make it smaller, larger or different. Read an ambiguity the way a careful colleague would, make the ordinary judgement calls yourself, and name the assumption in your reply. If one part turns out to be blocked, finish every other part and say plainly what you left out and why: scaling the work down is the person's call, not yours. Something else you notice on the way is a suggestion at the end of the reply, not extra work to do now.
+
+**Report like a relay.** A worker's report is the only evidence you have, so pass on what it verified and say plainly what it did not. Short messages on chat: lead with the outcome, one idea per sentence, no tool names, no file paths unless the person needs them. Send a file out with `create_upload` (the curl line it hands back runs in a worker) and then `send` with the upload id.
+
+**Keep going.** Long tasks run as background agents and loops; check in over chat when something lands rather than going quiet. The session is restarted by the daemon if it exits, so an interrupted task is resumed from chat, not from memory.

package/skills/STAGE.md

@@ -0,0 +1,109 @@
+---
+name: stage
+description: How to use Stage channels (XMTP groups, https://stage.box) through metro. Create a channel, rename it, add or remove members, set labels and assignees, read its info, and send, reply, react, unreact, delete and read messages, and post frames (interactive ChatKit widget views) and wallet cards (payment and signature requests, receipts). Works only when this agent has an XMTP account in metro.
+---
+
+Stage (https://stage.box) is a messenger built on XMTP. A Stage channel is an XMTP group. You use it with the metro tools below (`mcp__metro__<name>`).
+
+**XMTP only.** All of this needs an XMTP account connected to this agent in metro. Check with `list_accounts`: it must show an account under `xmtp`. Many agents have none. Then none of this works: say so plainly and do not try another channel. The owner can add an XMTP channel on https://metro.box.
+
+**Lines and links.** A channel's line is `metro://xmtp/<account>/<channel id>`. Pass it verbatim as `line`. Its link is `https://stage.box/#/channel/<channel id>`, the last part of the line. Stage shows Markdown, so `[#Launch plan](https://stage.box/#/channel/<channel id>)` is a clickable link. A `message_id` comes from the inbound message or from `read`.
+
+**Channels.**
+- Create: `create_group {"station": "xmtp", "name": "Launch plan", "members": ["0x…"]}`. Members are 0x addresses or XMTP inbox ids. It returns the new `line` and `id`.
+- Rename: `set_channel_metadata {"line": "…", "name": "New title"}`. No tool sets the description or the picture.
+- Add or remove people: `add_members {"line": "…", "members": ["0x…"]}`. `remove_members` takes the same shape.
+- Leave: `close_channel {"line": "…", "removeSelf": true}`.
+- Read: `group_info {"line": "…"}` gives the name, `labels`, `assigned`, `category`, `status`, `priority`, `appData` and the members (`inboxId`, `address`). `list_members {"line": "…"}` gives the members only.
+- Direct chat: `dm {"address": "0x…"}` opens a 1:1 chat and returns its line.
+- With several XMTP accounts, add `"account": "<id>"` to `create_group` and `dm`.
+
+**Labels, assignees, category, status and priority.** They live in the channel's metadata, and Stage shows them on the channel.
+- Labels: `set_channel_metadata {"line": "…", "metadata": {"labels": ["Bug"]}}`. At most 16 labels of 24 characters each.
+- Assignees: `set_channel_metadata {"line": "…", "metadata": {"assigned": ["0x…"]}}`. Only 0x addresses of current members.
+- Category: `set_channel_metadata {"line": "…", "metadata": {"category": "Clients"}}`.
+- Status: `set_channel_metadata {"line": "…", "metadata": {"status": "In review"}}`.
+- Category and status are each one free-form string per channel. Both are trimmed, whitespace is collapsed, and text is truncated to 24 characters. `""` or `null` clears either field. `group_info` returns them as `category` and `status`.
+- Priority: `set_channel_metadata {"line": "…", "metadata": {"priority": "High"}}`. Exactly `Urgent`, `High`, `Medium` or `Low` after trimming surrounding whitespace; empty text or `null` clears it. `group_info` returns it as `priority`.
+- Each key you send replaces that whole value. Keys you leave out stay as they are. To add one label or one assignee, read `group_info` first and send the old list plus the new one. `[]` clears a list. Read `group_info` again to check it saved.
+
+**Task status labels.** Keep the owner's existing workflow. For a label-based task workflow, keep exactly one of these status labels, plus any project labels:
+- `🗒️ Backlog`
+- `🎯 To-do`
+- `🚧 In progress`
+- `🔍 In review`
+- `✅ Done`
+- `🚫 Blocked`
+
+Move it from Backlog or To-do to In progress, then In review, then Done. Use Blocked while you wait on someone. To change it, read `group_info`, swap the old status for the new one in `labels`, keep the other labels, and send the whole list with `set_channel_metadata` `metadata.labels`.
+
+The separate `metadata.status` and `metadata.priority` fields are optional. Status is free-form, not limited to the label names above. Do not migrate or remove existing labels unless asked.
+
+**Messages.**
+- Send: `send {"line": "…", "text": "Hello"}`. Reply with a quote: `reply {"line": "…", "message_id": "…", "text": "…"}`.
+- React: `react {"line": "…", "message_id": "…", "emoji": "👍"}`. `unreact` takes the same shape.
+- Delete one of your own messages: `delete {"line": "…", "message_id": "…"}`. XMTP has no edit and no typing.
+- History: `read {"line": "…", "limit": 20}`.
+- Poll: `ask {"line": "…", "question": "Ship today?", "options": ["Yes", "No"]}`.
+- Poll votes are numeric reactions with zero-based indexes: `0` is the first option, `1` is the second, and so on, in the poll's stored option order. For the poll above, `0` means Yes and `1` means No. Never use a one-based guess. Match the inbound reaction's `target_id` to the poll's `messageId` returned by `ask`, not its `pollId` or the reaction's own `message_id`.
+- With several questions, the first question still uses bare option indexes (`0`, `1`, …); later questions use `q:o`, with both indexes zero-based. `1:0` means the first option of the second question. Explicit `0:0` also means the first option of the first question.
+- Keep the poll's questions, options and `messageId`: `read` shows `[poll]` and `[reaction]`, not their choices or vote values. If the original mapping is unavailable, do not guess.
+- File: `create_upload {"name": "report.pdf"}`, run the `curl` line it returns in a shell, then `send {"line": "…", "attachments": [{"upload": "<upload_id>"}]}`. Files that are not images are refused over about 190 KiB.
+
+**Frames.** A frame is a small interactive view: a report, a choice, a form. Stage shows the frame itself in the chat (its `start` screen when it has screens), at image size, at most 400 x 400, clipped with a fade when taller. A tap opens it full screen. Its buttons do nothing in the chat: they work in the full view.
+- Send: `send {"line": "…", "frame": {"title": "Deploy", "description": "Version 2.4 is ready", "widget": {…}}}`. A frame goes with `send`, like a file: there is no separate tool. `title` and `description` are optional: they come from the first `Title` and text in the widget when missing. With `text` as well, the text goes first, and the `message_id` you get back is the frame's.
+- `widget` is OpenAI ChatKit widget JSON, with ChatKit's names and props (https://openai.github.io/chatkit-js/): a `Card`, `ListView` or `Basic` root, with `Row`, `Col`, `Box`, `Text`, `Title`, `Caption`, `Markdown`, `Badge`, `Icon`, `Image`, `Button`, `Divider`, `Spacer`, `Form`, `Input`, `Textarea`, `Select`, `DatePicker`, `Checkbox`, `RadioGroup` and `Table`. Images must be `https://`. Number spacing is in steps of 4px. At most 64K characters, 16 levels deep and 500 nodes. Stage shows a small notice for anything it does not know.
+- Example, the arguments of one `send`:
+  ```json
+  {"line": "…", "frame": {"widget": {"type": "Card", "children": [
+    {"type": "Title", "value": "Deploy version 2.4?"},
+    {"type": "Text", "value": "3 fixes, no migration.", "color": "secondary"},
+    {"type": "Input", "name": "note", "placeholder": "Note (optional)"},
+    {"type": "Row", "children": [
+      {"type": "Button", "label": "Deploy", "onClickAction": {"type": "deploy", "payload": {"version": "2.4"}}},
+      {"type": "Button", "label": "Not now", "color": "secondary", "onClickAction": {"type": "deploy.cancel"}}
+    ]}
+  ]}}}
+  ```
+- A tap comes back to you as a reply to the frame: `Frame action: deploy {"version":"2.4","note":"…"} (tapped "Deploy")`. The values of the fields (`Input`, `Select`, `Checkbox`, …) are added to the payload by their `name`. `Button.onClickAction`, `ListViewItem.onClickAction`, a `Card` `confirm`/`cancel` (`{"label", "action"}`) and a `Form` `onSubmitAction` send one. Answer it like any message.
+- Screens: send `screens` instead of `widget` to put several screens in one frame, e.g. a list and a page per item. Each screen is a widget, or `{"title", "widget"}` for its own title in Stage's top bar. `start` names the first screen and is required. The action `{"type": "frame.open", "payload": {"screen": "<id>"}}` opens a screen and `{"type": "frame.back"}` goes back. They stay in Stage: no message comes to you. Stage's back arrow goes to the previous screen, and to the chat from the first one. Every other action comes to you as usual, with `screen` (the screen it was tapped on) in its payload. At most 50 screens and 64K characters for all of them; `start` and every `frame.open` must name a screen. Example:
+  ```json
+  {"line": "…", "frame": {"title": "Open invoices", "start": "home", "screens": {
+    "home": {"type": "ListView", "children": [
+      {"type": "ListViewItem", "onClickAction": {"type": "frame.open", "payload": {"screen": "inv-1"}},
+        "children": [{"type": "Text", "value": "Acme, CHF 420"}]}
+    ]},
+    "inv-1": {"title": "Acme", "widget": {"type": "Card", "children": [
+      {"type": "Title", "value": "Invoice 1040, CHF 420"},
+      {"type": "Row", "children": [
+        {"type": "Button", "label": "Back", "color": "secondary", "onClickAction": {"type": "frame.back"}},
+        {"type": "Button", "label": "Pay", "onClickAction": {"type": "invoice.pay", "payload": {"id": 1040}}}
+      ]}
+    ]}}
+  }}}
+  ```
+- Live frames: add `"source": {"url": "https://…"}` to the frame to name the node that serves its widget, an https URL that answers with ChatKit widget JSON (Stage's node protocol: https://github.com/bonustrack/stage/blob/main/NODES.md). Stage then sends the frame's actions to that node, not to you. The node's reply replaces the frame in place, on that person's device only, and no message comes to you. Only an action with ChatKit's `"handler": "client"` still comes to you as a frame action, like every action of a frame without `source`. `frame.open` and `frame.back` stay in Stage. Here `24h` goes to the node, and `Ask` comes to you as `Frame action: ask (tapped "Ask")`:
+  ```json
+  {"line": "…", "frame": {"source": {"url": "https://eth.example.com/"}, "widget": {"type": "Card", "children": [
+    {"type": "Title", "value": "ETH 2,410 USD"},
+    {"type": "Row", "children": [
+      {"type": "Button", "label": "24h", "onClickAction": {"type": "range", "payload": {"days": 1}}},
+      {"type": "Button", "label": "Ask", "color": "secondary", "onClickAction": {"type": "ask", "handler": "client"}}
+    ]}
+  ]}}}
+  ```
+  Stage calls the node only on a tap or on Refresh in the frame's three-dot menu, and only once the person has accepted the chat. Until then, and again after the app restarts, it shows the widget as you sent it. Do not add a Refresh button to a node: every live frame and Dashboard widget has Refresh in its menu. Add to dashboard on the frame adds a live widget loaded from that URL, and its `"handler": "client"` actions still come to this chat.
+
+**Wallet cards.** The payment and signature cards Stage's own Request payment and Request signature send. Sending one moves nothing and signs nothing: the person taps Pay or Sign and confirms in Stage. Send one only when you were asked to.
+- Send: `send {"line": "…", "wallet": {"type": "<type>", "content": {…}}}`. With `text` or a `frame` as well, the card goes last, and the `message_id` you get back is the card's.
+- Payment request, `walletSendCalls`, a card with a Pay button. Stage pays a request with one call; a Stage wallet pays on Base only.
+  ```json
+  {"type": "walletSendCalls", "content": {"version": "1.0", "chainId": "0x2105", "from": "0x<your address>", "calls": [
+    {"to": "0x<who gets paid>", "value": "0x38d7ea4c68000", "metadata": {"description": "Dinner", "transactionType": "transfer",
+      "currency": "ETH", "amount": 0.001, "decimals": 18, "toAddress": "0x<who gets paid>"}}
+  ]}}
+  ```
+  `chainId` is a hex string (`0x2105` is Base) and `value` is in wei, hex. For a token, `to` is the token contract, `data` its `transfer(address,uint256)` call data, `value` is left out, and `metadata` has `currency`, `amount` and `toAddress` (who gets paid).
+- Receipt, `transactionReference`: `{"networkId": 8453, "reference": "0x<tx hash>", "metadata": {"currency": "USDC", "amount": 5}}`. Stage shows "Payment sent · 5 USDC" (or "Transaction sent" without an amount) and a link to the explorer. Only post a real transaction hash.
+- Signature request, `signatureRequest`, a card with a Sign button: `{"id": "<any id>", "kind": "personal", "message": "The text to sign", "description": "Why"}`, or `"kind": "eip712"` with `"eip712": {"domain", "types", "primaryType", "message"}` instead of `message`.
+- Signature, `signatureReference`: `{"requestId": "<message_id of the request>", "signature": "0x…", "signer": "0x…"}`. Stage shows it as Signed.

package/dist/bedrock-eventstream.js

@@ -1,120 +0,0 @@
-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

@@ -1,260 +0,0 @@
-import { createServer, } from 'node:http';
-import { EventStreamDecoder } from './bedrock-eventstream.js';
-import { callBedrock, freshAdaptations, invoke, invokeUrl, upstreamMessage, } from './bedrock-upstream.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');
-    }
-}
-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, learned) {
-    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), learned };
-    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 learned = freshAdaptations();
-    const server = createServer((req, res) => {
-        route(req, res, cfg, opts, learned).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,
-                learned,
-                close: () => new Promise((done) => {
-                    server.close(() => {
-                        done();
-                    });
-                }),
-            });
-        });
-    });
-}

package/dist/bedrock-upstream.js

@@ -1,72 +0,0 @@
-export const freshAdaptations = () => ({
-    fields: new Set(),
-    dropBetas: false,
-});
-const EXTRA_INPUT_RE = /^([A-Za-z0-9_]+)(?:\.[^:]*)?: Extra inputs are not permitted/;
-const MAX_REPAIRS = 4;
-export function invokeUrl(up, modelId, action) {
-    return `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
-}
-export 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,
-    });
-}
-export function upstreamMessage(text) {
-    const fallback = text === '' ? 'Bedrock returned no body' : text;
-    try {
-        const parsed = JSON.parse(text);
-        const message = parsed.message ?? parsed.Message;
-        return typeof message === 'string' && message !== '' ? message : fallback;
-    }
-    catch {
-        return fallback;
-    }
-}
-const without = (body, keys) => Object.fromEntries(Object.entries(body).filter(([key]) => !keys.has(key)));
-function applyLearned(req, learned) {
-    const dropped = new Set(learned.fields);
-    if (learned.dropBetas)
-        dropped.add('anthropic_beta');
-    return {
-        body: without(req.body, dropped),
-        betas: learned.dropBetas ? [] : req.betas,
-    };
-}
-function repair(attempt, learned, message) {
-    const named = EXTRA_INPUT_RE.exec(message)?.[1];
-    if (named !== undefined && named in attempt.body) {
-        learned.fields.add(named);
-        process.stderr.write(`metro bedrock: Bedrock refused "${named}" (extra input); dropping it from every request\n`);
-        return { body: without(attempt.body, new Set([named])), betas: attempt.betas };
-    }
-    if (attempt.betas.length > 0) {
-        learned.dropBetas = true;
-        process.stderr.write(`metro bedrock: retrying without anthropic_beta [${attempt.betas.join(', ')}]\n`);
-        return { body: without(attempt.body, new Set(['anthropic_beta'])), betas: [] };
-    }
-    return null;
-}
-export 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);
-    let attempt = applyLearned(req, up.learned);
-    for (let repairs = 0;; repairs += 1) {
-        const res = await callBedrock(up, url, attempt.body, accept, signal);
-        if (res.status !== 400 || repairs >= MAX_REPAIRS)
-            return res;
-        const text = await res.text();
-        const next = repair(attempt, up.learned, upstreamMessage(text));
-        if (next === null)
-            return new Response(text, { status: 400, headers: res.headers });
-        attempt = next;
-    }
-}