@stage-labs/metro 0.1.0-beta.70 → 0.1.0-beta.72

package/runtime/node_modules/@metro-labs/mcp/src/gateway/forward.ts

@@ -0,0 +1,169 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+export class GatewayError extends Error {
+  constructor(
+    readonly status: number,
+    readonly kind: string,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+export const BODY_MAX = 64 * 1024 * 1024;
+const DRAIN_FACTOR = 2;
+const PING_MS = 25_000;
+const IDLE_MS = 300_000;
+const HOP_BY_HOP = new Set([
+  'host',
+  'connection',
+  'content-length',
+  'transfer-encoding',
+  'keep-alive',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'upgrade',
+  'accept-encoding',
+  'x-metro-key',
+]);
+const RESPONSE_DROP = new Set(['content-length', 'content-encoding', 'transfer-encoding', 'connection', 'keep-alive']);
+
+export function sendError(res: ServerResponse, status: number, kind: string, message: string): void {
+  res.writeHead(status, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ type: 'error', error: { type: kind, message } }));
+}
+
+export const errorFrame = (kind: string, message: string): string => `event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: kind, message } })}\n\n`;
+
+export const providerStatus = (status: number): number => (status === 401 ? 403 : status);
+
+export const idleMs = (): number => Number(process.env.METRO_GATEWAY_IDLE_MS) || IDLE_MS;
+
+export const idleMessage = (ms: number): string => `metro gateway: the provider sent nothing for ${String(Math.round(ms / 1000))}s; giving up on this request`;
+
+export interface Watch {
+  signal: AbortSignal;
+  ms: number;
+  touch: () => void;
+  idle: () => boolean;
+  stop: () => void;
+}
+
+export function watchUpstream(res: ServerResponse, ms = idleMs()): Watch {
+  const control = new AbortController();
+  let expired = false;
+  let timer: NodeJS.Timeout | null = null;
+  const stop = (): void => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+  };
+  const arm = (): void => {
+    stop();
+    timer = setTimeout(() => {
+      expired = true;
+      control.abort();
+    }, ms);
+    timer.unref();
+  };
+  res.on('close', () => {
+    stop();
+    if (!res.writableEnded) control.abort();
+  });
+  arm();
+  return { signal: control.signal, ms, touch: arm, idle: () => expired, stop };
+}
+
+export async function readBody(req: IncomingMessage): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  let over = false;
+  for await (const chunk of req) {
+    const buf = chunk as Buffer;
+    total += buf.length;
+    if (total > BODY_MAX) {
+      over = true;
+      if (total > BODY_MAX * DRAIN_FACTOR) break;
+      continue;
+    }
+    chunks.push(buf);
+  }
+  if (over) throw new GatewayError(413, 'invalid_request_error', 'request too large');
+  return Buffer.concat(chunks);
+}
+
+export function parseJson(raw: Buffer): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw.toString('utf8'));
+  } catch {
+    throw new GatewayError(400, 'invalid_request_error', 'body must be JSON');
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+    throw new GatewayError(400, 'invalid_request_error', 'body must be a JSON object');
+  return parsed as Record<string, unknown>;
+}
+
+export function forwardedHeaders(req: IncomingMessage): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (HOP_BY_HOP.has(name) || value === undefined) continue;
+    out[name] = Array.isArray(value) ? value.join(', ') : value;
+  }
+  return out;
+}
+
+export interface PipeOptions {
+  keepalive?: boolean;
+  ownCredential?: boolean;
+}
+
+function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions): boolean {
+  const headers: Record<string, string> = {};
+  upstream.headers.forEach((value, name) => {
+    if (!RESPONSE_DROP.has(name)) headers[name] = value;
+  });
+  res.writeHead(opts.ownCredential === true ? providerStatus(upstream.status) : upstream.status, headers);
+  return (upstream.headers.get('content-type') ?? '').startsWith('text/event-stream');
+}
+
+async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch): Promise<void> {
+  const reader = body.getReader();
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) return;
+    watch.touch();
+    res.write(value);
+  }
+}
+
+export async function pipeResponse(upstream: Response, res: ServerResponse, watch: Watch, opts: PipeOptions = {}): Promise<void> {
+  const streaming = openResponse(upstream, res, opts);
+  const body = upstream.body;
+  if (body === null) {
+    res.end();
+    return;
+  }
+  const ping = opts.keepalive === true && streaming ? setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS) : null;
+  try {
+    await pump(body, res, watch);
+  } catch (err) {
+    if (!watch.idle()) throw err;
+    if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));
+  } finally {
+    if (ping !== null) clearInterval(ping);
+    watch.stop();
+    res.end();
+  }
+}
+
+export function upstreamMessage(text: string, fallback: string): string {
+  if (text === '') return fallback;
+  try {
+    const parsed = JSON.parse(text) as { message?: unknown; Message?: unknown; error?: { message?: unknown } };
+    const message = parsed.message ?? parsed.Message ?? parsed.error?.message;
+    return typeof message === 'string' && message !== '' ? message : text;
+  } catch {
+    return text;
+  }
+}

package/runtime/node_modules/@metro-labs/mcp/src/gateway/gateway.ts

@@ -0,0 +1,193 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '../daemon/log.js';
+import { agentIdForKey } from '../db/key-map.js';
+import {
+  assertBedrockReady,
+  bedrockBase,
+  bedrockCount,
+  bedrockMessages,
+  freshAdaptations,
+  type Adaptations,
+} from './bedrock.js';
+import { forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
+import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './codex.js';
+import { OPENROUTER_BASE } from './openrouter.js';
+import type { CodexTokens } from './codex-auth.js';
+
+export const GATEWAY_PREFIX = '/gateway';
+export const ANTHROPIC_BASE = 'https://api.anthropic.com';
+const MESSAGES = '/v1/messages';
+const COUNT = '/v1/messages/count_tokens';
+const MODELS = '/v1/models';
+const HELLO = '/api/hello';
+
+export interface GatewayDeps {
+  config: () => ModelConfig;
+  identify?: (key: string) => boolean;
+  anthropicBase?: string;
+  bedrockBase?: string;
+  openrouterBase?: string;
+  codex?: Partial<CodexDeps>;
+}
+
+const learned: Adaptations = freshAdaptations();
+const codexState = freshCodexState();
+
+export function resetGatewayState(): void {
+  learned.fields.clear();
+  learned.dropBetas = false;
+  Object.assign(codexState, freshCodexState());
+}
+
+const saveCodexTokens = (tokens: CodexTokens): void => {
+  writeModelConfig(setCodexAuth(readModelConfig(), tokens));
+};
+
+const keyOf = (req: IncomingMessage): string => {
+  const raw = req.headers['x-metro-key'];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+};
+
+const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
+
+function modelsBody(cfg: ModelConfig): Record<string, unknown> {
+  const data: Record<string, string>[] = [];
+  if (cfg.bedrock.model !== '')
+    data.push({ id: `bedrock:${cfg.bedrock.model}`, display_name: `Bedrock · ${cfg.bedrock.model}`, description: 'Through metro, billed to Amazon Bedrock' });
+  if (cfg.openrouter.model !== '')
+    data.push({ id: `openrouter:${cfg.openrouter.model}`, display_name: `OpenRouter · ${cfg.openrouter.model}`, description: 'Through metro, billed to OpenRouter' });
+  if (cfg.codex.model !== '')
+    data.push({ id: `codex:${cfg.codex.model}`, display_name: `Codex · ${cfg.codex.model}`, description: 'Through metro, on your ChatGPT subscription' });
+  return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
+}
+
+function requestedModel(body: Record<string, unknown>): string {
+  const model = body.model;
+  if (typeof model !== 'string' || model === '') throw new GatewayError(400, 'invalid_request_error', 'model is required');
+  return model;
+}
+
+async function toAnthropic(
+  req: IncomingMessage,
+  res: ServerResponse,
+  raw: Buffer,
+  body: Record<string, unknown>,
+  route: Route,
+  deps: GatewayDeps,
+): Promise<void> {
+  const explicit = typeof body.model === 'string' && body.model !== route.model;
+  const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
+  const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
+  const watch = watchUpstream(res);
+  const upstream = await fetch(url, {
+    method: 'POST',
+    headers: forwardedHeaders(req),
+    body: new Uint8Array(payload),
+    signal: watch.signal,
+    redirect: 'manual',
+  });
+  await pipeResponse(upstream, res, watch);
+}
+
+async function toOpenRouter(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  route: Route,
+  cfg: ModelConfig,
+  deps: GatewayDeps,
+): Promise<void> {
+  const reason = notReady(cfg, 'openrouter');
+  if (reason !== null) throw new GatewayError(400, 'invalid_request_error', reason);
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+    accept: req.headers.accept ?? 'application/json',
+    authorization: `Bearer ${cfg.openrouter.apiKey}`,
+    'anthropic-version': typeof req.headers['anthropic-version'] === 'string' ? req.headers['anthropic-version'] : '2023-06-01',
+    'http-referer': 'https://metro.box',
+    'x-title': 'metro',
+  };
+  const beta = req.headers['anthropic-beta'];
+  if (typeof beta === 'string' && beta !== '') headers['anthropic-beta'] = beta;
+  const watch = watchUpstream(res);
+  const upstream = await fetch(`${deps.openrouterBase ?? OPENROUTER_BASE}${MESSAGES}`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ ...body, model: route.model }),
+    signal: watch.signal,
+    redirect: 'manual',
+  });
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true });
+}
+
+async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
+  const cfg = deps.config();
+  const raw = await readBody(req);
+  const body = parseJson(raw);
+  const route = resolveRoute(requestedModel(body), cfg);
+  log.info({ route: routeLabel(route), path }, 'gateway: routing');
+  if (route.provider === 'bedrock') {
+    assertBedrockReady(cfg.bedrock);
+    const up = { settings: cfg.bedrock, base: deps.bedrockBase ?? bedrockBase(cfg.bedrock.region), learned, watch: watchUpstream(res) };
+    if (path === COUNT) await bedrockCount(req, res, body, route.model, up);
+    else await bedrockMessages(req, res, body, route.model, up);
+    return;
+  }
+  if (route.provider === 'openrouter') {
+    if (path === COUNT) throw new GatewayError(404, 'not_found_error', 'OpenRouter does not count tokens');
+    await toOpenRouter(req, res, body, route, cfg, deps);
+    return;
+  }
+  if (route.provider === 'codex') {
+    if (path === COUNT) {
+      codexCount(res, body);
+      return;
+    }
+    const codexDeps: CodexDeps = { save: saveCodexTokens, ...deps.codex };
+    await codexMessages(req, res, body, route.model, cfg, codexDeps, codexState, watchUpstream(res));
+    return;
+  }
+  await toAnthropic(req, res, raw, body, route, deps);
+}
+
+function failed(res: ServerResponse, err: unknown): void {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  if (err instanceof GatewayError) {
+    sendError(res, err.status, err.kind, err.message);
+    return;
+  }
+  log.warn({ err: errMsg(err) }, 'gateway: request failed');
+  sendError(res, 502, 'api_error', `metro gateway: ${errMsg(err)}`);
+}
+
+function answer(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): void {
+  if (req.method === 'GET' && path === MODELS) {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(modelsBody(deps.config())));
+    return;
+  }
+  if (req.method === 'POST' && (path === MESSAGES || path === COUNT)) {
+    dispatch(req, res, path, deps).catch((err: unknown) => {
+      failed(res, err);
+    });
+    return;
+  }
+  sendError(res, 404, 'not_found_error', 'not found');
+}
+
+export function handleGatewayRequest(req: IncomingMessage, res: ServerResponse, deps: GatewayDeps): boolean {
+  const full = req.url ?? '';
+  if (full !== GATEWAY_PREFIX && !full.startsWith(`${GATEWAY_PREFIX}/`)) return false;
+  const path = (full.split('?')[0] ?? '').slice(GATEWAY_PREFIX.length);
+  if (req.method === 'HEAD' && path === HELLO) {
+    res.writeHead(200).end();
+    return true;
+  }
+  if ((deps.identify ?? defaultIdentify)(keyOf(req))) answer(req, res, path, deps);
+  else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start Claude Code with metro claude');
+  return true;
+}

package/runtime/node_modules/@metro-labs/mcp/src/gateway/model-config.ts

@@ -0,0 +1,180 @@
+import { join } from 'node:path';
+import { readJson, writeSecure } from '../daemon/secure-fs.js';
+import { agentsDir } from '../db/file-source.js';
+import { isRecord } from '../daemon/is-record.js';
+import type { CodexTokens } from './codex-auth.js';
+
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex'] as const;
+export type Provider = (typeof PROVIDERS)[number];
+
+export interface BedrockSettings {
+  region: string;
+  apiKey: string;
+  model: string;
+}
+
+export interface OpenRouterSettings {
+  apiKey: string;
+  model: string;
+}
+
+export interface CodexSettings {
+  model: string;
+  auth: CodexTokens | null;
+}
+
+export interface ModelConfig {
+  version: 1;
+  provider: Provider;
+  bedrock: BedrockSettings;
+  openrouter: OpenRouterSettings;
+  codex: CodexSettings;
+}
+
+export interface Route {
+  provider: Provider;
+  model: string;
+}
+
+export class ModelConfigError extends Error {}
+
+export const MODEL_FILE = 'model.json';
+const MAX_FIELD = 512;
+const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
+
+const empty = (): ModelConfig => ({
+  version: 1,
+  provider: 'anthropic',
+  bedrock: { region: '', apiKey: '', model: '' },
+  openrouter: { apiKey: '', model: '' },
+  codex: { model: '', auth: null },
+});
+
+const isProvider = (value: unknown): value is Provider =>
+  typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
+
+const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
+const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+function tokensFromDisk(raw: unknown): CodexTokens | null {
+  if (!isRecord(raw)) return null;
+  const accessToken = text(raw.accessToken);
+  const refreshToken = text(raw.refreshToken);
+  const accountId = text(raw.accountId);
+  if (accessToken === '' || refreshToken === '' || accountId === '') return null;
+  return {
+    accessToken,
+    refreshToken,
+    idToken: text(raw.idToken),
+    accountId,
+    email: maybe(raw.email),
+    plan: maybe(raw.plan),
+    savedAt: text(raw.savedAt) === '' ? new Date(0).toISOString() : text(raw.savedAt),
+  };
+}
+
+function fromDisk(raw: unknown): ModelConfig {
+  const base = empty();
+  if (!isRecord(raw)) return base;
+  const bedrock = isRecord(raw.bedrock) ? raw.bedrock : {};
+  const openrouter = isRecord(raw.openrouter) ? raw.openrouter : {};
+  const codex = isRecord(raw.codex) ? raw.codex : {};
+  return {
+    version: 1,
+    provider: isProvider(raw.provider) ? raw.provider : 'anthropic',
+    bedrock: { region: text(bedrock.region), apiKey: text(bedrock.apiKey), model: text(bedrock.model) },
+    openrouter: { apiKey: text(openrouter.apiKey), model: text(openrouter.model) },
+    codex: { model: text(codex.model), auth: tokensFromDisk(codex.auth) },
+  };
+}
+
+export function readModelConfig(dir = agentsDir()): ModelConfig {
+  return fromDisk(readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' }));
+}
+
+export function writeModelConfig(cfg: ModelConfig, dir = agentsDir()): void {
+  writeSecure(join(dir, MODEL_FILE), JSON.stringify(cfg, null, 2));
+}
+
+function field(patch: Record<string, unknown>, key: string, current: string, what: string): string {
+  if (!(key in patch)) return current;
+  const value = patch[key];
+  if (typeof value !== 'string') throw new ModelConfigError(`${what} must be a string`);
+  if (value.length > MAX_FIELD) throw new ModelConfigError(`${what} is too long`);
+  return value.trim();
+}
+
+export function applyModelUpdate(cfg: ModelConfig, patch: unknown): ModelConfig {
+  if (!isRecord(patch)) throw new ModelConfigError('body must be a JSON object');
+  const provider = 'provider' in patch ? patch.provider : cfg.provider;
+  if (!isProvider(provider)) throw new ModelConfigError(`provider must be one of ${PROVIDERS.join(', ')}`);
+  const bedrock = isRecord(patch.bedrock) ? patch.bedrock : {};
+  const openrouter = isRecord(patch.openrouter) ? patch.openrouter : {};
+  const codex = isRecord(patch.codex) ? patch.codex : {};
+  return {
+    version: 1,
+    provider,
+    bedrock: {
+      region: field(bedrock, 'region', cfg.bedrock.region, 'Bedrock region'),
+      apiKey: field(bedrock, 'apiKey', cfg.bedrock.apiKey, 'Bedrock API key'),
+      model: field(bedrock, 'model', cfg.bedrock.model, 'Bedrock model'),
+    },
+    openrouter: {
+      apiKey: field(openrouter, 'apiKey', cfg.openrouter.apiKey, 'OpenRouter API key'),
+      model: field(openrouter, 'model', cfg.openrouter.model, 'OpenRouter model'),
+    },
+    codex: { model: field(codex, 'model', cfg.codex.model, 'Codex model'), auth: cfg.codex.auth },
+  };
+}
+
+export const setCodexAuth = (cfg: ModelConfig, auth: CodexTokens | null): ModelConfig => ({ ...cfg, codex: { ...cfg.codex, auth } });
+
+const CHECKS: Record<Provider, [(cfg: ModelConfig) => boolean, string][]> = {
+  anthropic: [],
+  bedrock: [
+    [(cfg) => cfg.bedrock.apiKey === '', 'Bedrock needs an API key: add it on the Model page.'],
+    [(cfg) => cfg.bedrock.region === '', 'Bedrock needs a region: add it on the Model page.'],
+  ],
+  openrouter: [
+    [(cfg) => cfg.openrouter.apiKey === '', 'OpenRouter needs an API key: add it on the Model page.'],
+    [(cfg) => cfg.openrouter.model === '', 'OpenRouter needs a model id: choose one on the Model page.'],
+  ],
+  codex: [
+    [(cfg) => cfg.codex.auth === null, 'Codex is not connected: sign in with ChatGPT on the Model page.'],
+    [(cfg) => cfg.codex.model === '', 'Codex needs a model id: choose one on the Model page.'],
+  ],
+};
+
+export function notReady(cfg: ModelConfig, provider: Provider = cfg.provider): string | null {
+  return CHECKS[provider].find(([missing]) => missing(cfg))?.[1] ?? null;
+}
+
+export function publicModelConfig(cfg: ModelConfig): Record<string, unknown> {
+  const auth = cfg.codex.auth;
+  return {
+    provider: cfg.provider,
+    ready: notReady(cfg) === null,
+    reason: notReady(cfg),
+    bedrock: { region: cfg.bedrock.region, model: cfg.bedrock.model, hasKey: cfg.bedrock.apiKey !== '' },
+    openrouter: { model: cfg.openrouter.model, hasKey: cfg.openrouter.apiKey !== '' },
+    codex: { model: cfg.codex.model, signedIn: auth !== null, account: auth?.email ?? null, plan: auth?.plan ?? null },
+  };
+}
+
+function defaultModelFor(provider: Provider, requested: string, cfg: ModelConfig): string {
+  if (provider === 'openrouter') return requested.includes('/') ? requested : cfg.openrouter.model;
+  if (provider === 'bedrock') return cfg.bedrock.model === '' ? requested : cfg.bedrock.model;
+  if (provider === 'codex') return requested.startsWith('gpt-') ? requested : cfg.codex.model;
+  return requested;
+}
+
+export function resolveRoute(requested: string, cfg: ModelConfig): Route {
+  const explicit = PREFIX_RE.exec(requested);
+  if (explicit !== null && isProvider(explicit[1]))
+    return { provider: explicit[1], model: (explicit[2] ?? '').trim() };
+  return { provider: cfg.provider, model: defaultModelFor(cfg.provider, requested, cfg) };
+}
+
+export function routeLabel(route: Route): string {
+  return route.provider === 'anthropic' ? route.model : `${route.provider}:${route.model}`;
+}

package/runtime/node_modules/@metro-labs/mcp/src/gateway/openrouter.ts

@@ -0,0 +1,31 @@
+import { GatewayError } from './forward.js';
+
+export const OPENROUTER_BASE = 'https://openrouter.ai/api';
+const MODELS_MAX = 2000;
+
+export interface OpenRouterModel {
+  id: string;
+  name: string;
+}
+
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+function modelOf(entry: unknown): OpenRouterModel | null {
+  if (typeof entry !== 'object' || entry === null) return null;
+  const row = entry as { id?: unknown; name?: unknown };
+  const id = str(row.id);
+  return id === '' ? null : { id, name: str(row.name) || id };
+}
+
+export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> {
+  const res = await fetchImpl(`${base}/v1/models`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its models (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no model list');
+  return data
+    .map(modelOf)
+    .filter((model): model is OpenRouterModel => model !== null)
+    .slice(0, MODELS_MAX)
+    .sort((a, b) => a.id.localeCompare(b.id));
+}

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.70"
+  "version": "0.1.0-beta.72"
 }