@stage-labs/metro 0.1.0-beta.312 → 0.1.0-beta.313

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.312",
+  "version": "0.1.0-beta.313",
   "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/node_modules/@metro-labs/daemon/src/gateway/gateway.ts

@@ -43,7 +43,7 @@ import { notReady, resolveRoute, routeLabel, type Connection, type ModelSetup, t
 import { codexMessages, type CodexDeps } from './codex.js';
 import { countTokens } from './subscription.js';
 import { OPENROUTER_BASE } from './openrouter.js';
-import { refusedWithPage, ROUTEWAY_BASE, routewayHeaders } from './routeway.js';
+import { refusedWithPage, ROUTEWAY_BASE, routewayHeaders, routewayTools } from './routeway.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
 import { forgetUsage, noteUsageHeaders, UsageScanner } from './usage.js';
@@ -189,7 +189,9 @@ async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shape
   const conn = route.connection;
   const watch = watchUpstream(res);
   const send = sender(`${deps.routewayBase ?? ROUTEWAY_BASE}${upstreamPath(req)}`, watch);
-  const upstream = await shapedAttempt(send, routewayHeaders(req, conn.apiKey), { ...body, bind: false }, route);
+  const sent = routewayTools(body.sent);
+  const fitted: Shaped = { raw: sent === body.sent ? body.raw : Buffer.from(JSON.stringify(sent)), sent, shaped: routewayTools(body.shaped), bind: false };
+  const upstream = await shapedAttempt(send, routewayHeaders(req, conn.apiKey), fitted, route);
   noteRefusal(conn.label, route.model, upstream);
   await refusedWithPage(upstream, watch);
   await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });

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

@@ -1,4 +1,5 @@
 import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
 import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
 
 export const ROUTEWAY_BASE = 'https://api.routeway.ai';
@@ -17,3 +18,15 @@ export async function refusedWithPage(upstream: Response, watch: Watch): Promise
   watch.stop();
   throw new GatewayError(502, 'api_error', `metro gateway: Routeway answered with a web page instead of its API (${String(upstream.status)}); try again in a moment`);
 }
+
+function withProperties(tool: unknown): unknown {
+  if (!isRecord(tool) || !isRecord(tool.input_schema) || Object.hasOwn(tool.input_schema, 'properties')) return tool;
+  return { ...tool, input_schema: { ...tool.input_schema, properties: {} } };
+}
+
+export function routewayTools(body: Record<string, unknown>): Record<string, unknown> {
+  const listed: unknown = body.tools;
+  if (!Array.isArray(listed)) return body;
+  const tools: unknown[] = listed.map(withProperties);
+  return tools.some((tool, at) => tool !== listed[at]) ? { ...body, tools } : body;
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp-server/connector-tools.ts

@@ -10,7 +10,7 @@ export const CALL_TIMEOUT_MS = 120_000;
 const LIST_TIMEOUT_MS = 15_000;
 const REFRESH_MS = 5 * 60_000;
 
-export const NOT_SET_UP = 'Connectors are not set up on this agent: enroll it in its organization on the Server page of metro.box, then try again.';
+export const NOT_SET_UP = 'Connectors are not set up on this agent yet: it links to its organization once an admin of the organization opens its page on metro.box. Try again after that.';
 export const UNAVAILABLE = 'mcp.metro.box is unavailable, try again.';
 
 export interface ConnectorResult {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.312"
+  "version": "0.1.0-beta.313"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.312",
+  "version": "0.1.0-beta.313",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

package/runtime/sdk-runner/src/activity.ts

@@ -7,7 +7,7 @@ import { runnerFailureSummary, type RunnerActivity, type RunnerDiagnostic, type
 import { writeAtomic } from '@metro-labs/core/secure-fs';
 import { ActivityTasks, activityName } from './activity-tasks.js';
 import type { ApprovalAsk } from './approvals.js';
-import type { SavedTask } from './task-state.js';
+import { sdkTask, type SavedTask } from './task-state.js';
 import { sessionFailure } from './errors.js';
 export { failureSummary } from './errors.js';
 
@@ -94,10 +94,11 @@ export class Activity {
   }
 
   recover(tasks: SavedTask[]): void {
-    this.tasks.restore(tasks.map((task) => ({
-      id: task.id, kind: null, agent: null, status: task.state === 'interrupted' ? 'unknown' : task.state,
+    const workers = tasks.filter(sdkTask);
+    this.tasks.restore(workers.map((task) => ({
+      id: task.id, kind: null, agent: null, status: task.state === 'interrupted' ? 'unknown' : task.state, ...(task.description === undefined ? {} : { description: task.description }),
       background: true, startedAt: 0, updatedAt: task.updatedAt, endedAt: null, lastTool: null, toolUses: 0, durationMs: 0,
-    })), tasks.flatMap((task) => task.toolUseId === null ? [] : [[task.toolUseId, task.id]]));
+    })), workers.flatMap((task) => task.toolUseId === null ? [] : [[task.toolUseId, task.id]]));
     for (const task of tasks) {
       if (task.notice === null) continue;
       const code = task.notice.reason === 'worker_restart' ? 'interrupted' : task.notice.reason;

package/runtime/sdk-runner/src/task-ledger.ts

@@ -1,4 +1,5 @@
 import { isRecord } from '@metro-labs/core/is-record';
+import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Unanswered } from './inbox.js';
 import { pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
@@ -67,9 +68,11 @@ export class TaskLedger {
   changed(handled?: ReadonlySet<string>): void { this.save(this.snapshot(), handled); }
 
   private taskEvent(id: string, m: Record<string, unknown>, event: string | null, now: number): void {
-    if (m.subtype === 'task_started') this.start(id, m.tool_use_id, event, now);
+    const known = this.rows.get(id);
+    if (m.subtype === 'task_started') this.start(id, m.tool_use_id, event, now, m.description);
     else if (m.subtype === 'task_notification') this.end(id, m, event, now);
-    else if (m.subtype === 'task_updated' && isRecord(m.patch) && this.rows.has(id)) {
+    else if (m.subtype === 'task_updated' && isRecord(m.patch) && known !== undefined) {
+      if (this.describe(known, m.patch.description)) this.save(this.snapshot());
       this.end(id, { status: m.patch.status === 'killed' ? 'stopped' : m.patch.status, summary: m.patch.error }, event, now);
     } else if (m.subtype === 'task_progress') this.progress(id, m.tool_use_id, now);
   }
@@ -114,10 +117,11 @@ export class TaskLedger {
     return task;
   }
 
-  private start(id: string, rawTool: unknown, event: string | null, now: number): void {
+  private start(id: string, rawTool: unknown, event: string | null, now: number, description?: unknown): void {
     const task = this.get(id, now);
     if (task.state !== 'running') task.attempt += 1;
     task.state = 'running';
+    this.describe(task, description);
     if (event !== null) task.events = [...task.events, event].slice(-16);
     task.updatedAt = now;
     task.toolUseId = activityName(rawTool) ?? task.toolUseId;
@@ -165,13 +169,24 @@ export class TaskLedger {
 
   private background(m: Record<string, unknown>, now: number): void {
     if (!Array.isArray(m.tasks)) return;
+    let described = false;
     for (const row of m.tasks) {
       if (!isRecord(row)) continue;
       const id = activityName(row.task_id);
       if (id === null) continue;
+      const known = this.rows.get(id);
       if (row.ambient === true) this.hide(id);
-      else if (!this.rows.has(id)) this.start(id, undefined, activityName(m.uuid), now);
+      else if (known === undefined) this.start(id, undefined, activityName(m.uuid), now, row.description);
+      else described = this.describe(known, row.description) || described;
     }
+    if (described) this.save(this.snapshot());
+  }
+
+  private describe(task: SavedTask, raw: unknown): boolean {
+    const description = runnerTaskDescription(raw);
+    if (description === null || description === task.description) return false;
+    task.description = description;
+    return true;
   }
 
   private content(m: Record<string, unknown>, now: number): void {

package/runtime/sdk-runner/src/task-state.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
+import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Uuid } from './inbox.js';
 
@@ -26,6 +27,7 @@ export interface SavedTask {
   attempt: number;
   handledAttempt?: number;
   state: (typeof STATES)[number];
+  description?: string;
   events: string[];
   updatedAt: number;
   notice: TaskNotice | null;
@@ -35,6 +37,7 @@ const integer = (raw: unknown): raw is number => typeof raw === 'number' && Numb
 const name = (raw: unknown): raw is string | null => raw === null || activityName(raw) !== null;
 const reason = (raw: unknown): raw is TaskReason => REASONS.some((value) => value === raw);
 const optionalInteger = (raw: unknown): boolean => raw === undefined || integer(raw);
+const description = (raw: unknown): boolean => raw === undefined || (typeof raw === 'string' && runnerTaskDescription(raw) === raw);
 const optionalUuid = (raw: unknown): boolean => raw === undefined || (typeof raw === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(raw));
 
 function notice(raw: unknown): raw is TaskNotice | null {
@@ -45,14 +48,17 @@ function notice(raw: unknown): raw is TaskNotice | null {
 }
 
 const events = (raw: unknown): boolean => Array.isArray(raw) && raw.length <= 16 && raw.every((event) => activityName(event) !== null);
+const optionalFields = (raw: Record<string, unknown>): boolean => optionalInteger(raw.handledAttempt) && description(raw.description);
 
 function task(raw: unknown): raw is SavedTask {
   if (!isRecord(raw) || activityName(raw.id) === null) return false;
   if (![raw.toolUseId, raw.owner, raw.parentToolUseId ?? null].every(name)) return false;
-  if (!events(raw.events) || !optionalInteger(raw.handledAttempt)) return false;
+  if (!events(raw.events) || !optionalFields(raw)) return false;
   return integer(raw.attempt) && integer(raw.updatedAt) && STATES.some((state) => state === raw.state) && notice(raw.notice);
 }
 
+export const sdkTask = (task: SavedTask): boolean => !/^(?:input|turn):/.test(task.id);
+
 export function savedTasks(raw: unknown): SavedTask[] {
   if (raw === undefined) return [];
   if (!Array.isArray(raw) || raw.length > TASK_LIMIT || !raw.every(task) || new Set(raw.map((row) => row.id)).size !== raw.length)