@stage-labs/metro 0.1.0-beta.324 → 0.1.0-beta.326

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

@@ -1,4 +1,5 @@
 import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
 import { StreamErrors, type FailureSite } from './failures.js';
 import { UsageScanner } from './usage.js';
 
@@ -108,9 +109,8 @@ export function parseJson(raw: Buffer): Record<string, unknown> {
   } 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>;
+  if (!isRecord(parsed)) throw new GatewayError(400, 'invalid_request_error', 'body must be a JSON object');
+  return parsed;
 }
 
 export function forwardedHeaders(req: IncomingMessage): Record<string, string> {
@@ -153,7 +153,7 @@ export function addBeta(headers: Record<string, string>, beta: string): Record<s
   return { ...headers, 'anthropic-beta': [...listed, beta].join(',') };
 }
 
-export interface PipeOptions {
+interface PipeOptions {
   keepalive?: boolean;
   ownCredential?: boolean;
   scanner?: UsageScanner;
@@ -215,7 +215,7 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
   }
 }
 
-export interface Relayed {
+interface Relayed {
   push: (chunk: Uint8Array, emit: (frames: string) => void) => void;
   close: () => string;
   idle: (message: string) => string;

package/runtime/node_modules/@metro-labs/inference/src/measure.ts

@@ -2,7 +2,7 @@ import type { ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
 import { Attempt, inAttempt, tracked, type AttemptCall, type OnCall } from './attempts.js';
 import type { RequestKind } from './effort.js';
-import { GatewayError, SubscriptionRefused } from './forward.js';
+import { GatewayError } from './forward.js';
 import type { Route } from './model-config.js';
 
 const MESSAGES = '/v1/messages';
@@ -15,8 +15,7 @@ export interface Asked {
 
 function statusOf(failure: unknown, res: ServerResponse): number {
   if (failure === null) return res.statusCode;
-  if (failure instanceof GatewayError) return failure.status;
-  return failure instanceof SubscriptionRefused ? 401 : 502;
+  return failure instanceof GatewayError ? failure.status : 502;
 }
 
 function report(onCall: OnCall, call: AttemptCall): void {

package/runtime/node_modules/@metro-labs/inference/src/named.ts

@@ -10,8 +10,8 @@ export interface Chosen {
 
 const NO_ROUTE = "metro gateway: no model is set up for this agent yet: choose one on the organization's Gateway page";
 
-const noRoute = (message: string): never => {
-  throw new GatewayError(503, 'api_error', message);
+const noRoute = (): never => {
+  throw new GatewayError(503, 'api_error', NO_ROUTE);
 };
 
 const MAIN = 'metro';
@@ -32,5 +32,5 @@ export function namedChoice(requested: string, setup: ModelSetup): Chosen {
   if (requested !== MAIN && requested !== WORKERS) throw new GatewayError(400, 'invalid_request_error', NAMES);
   const helpers = requested === WORKERS ? helperSetup(setup) : null;
   const chain = helpers ?? setup;
-  return { lane: helpers === null ? 'main' : 'helpers', setup: chain, primary: primaryRoute(chain) ?? noRoute(NO_ROUTE) };
+  return { lane: helpers === null ? 'main' : 'helpers', setup: chain, primary: primaryRoute(chain) ?? noRoute() };
 }

package/runtime/node_modules/@metro-labs/inference/src/probes.ts

@@ -0,0 +1,98 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { userAgent } from './codex.js';
+import { OAUTH_BETA } from './forward.js';
+import type { Connection } from './model-config.js';
+import { openrouterKey } from './openrouter.js';
+import { anthropicUsage, clamp, creditsLeft, mergeUsage, openrouterUsage, PER_MINUTE, whenFrom, windowLabel, type Reported, type UsageWindow } from './usage.js';
+
+export const PROBE_EVERY_MS = 5 * 60_000;
+const PROBE_TIMEOUT_MS = 10_000;
+const SECONDS_PER_MINUTE = 60;
+const CHATGPT_BACKEND = 'https://chatgpt.com/backend-api';
+const ANTHROPIC_API = 'https://api.anthropic.com';
+const COUNT_MODEL = 'claude-haiku-4-5';
+
+export interface ProbeDeps {
+  fetchImpl?: typeof fetch;
+  openrouterBase?: string;
+  chatgptBase?: string;
+  anthropicBase?: string;
+}
+
+const numberOf = (value: unknown): number | null => {
+  const parsed = typeof value === 'number' ? value : typeof value === 'string' && value.trim() !== '' ? Number(value) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const textOf = (value: unknown): string | null => (typeof value === 'string' || typeof value === 'number' ? String(value) : null);
+
+function chatgptWindow(raw: unknown, now: Date): UsageWindow | null {
+  if (!isRecord(raw)) return null;
+  const percent = numberOf(raw.used_percent);
+  if (percent === null) return null;
+  const seconds = numberOf(raw.limit_window_seconds);
+  const minutes = seconds === null || seconds <= 0 ? null : Math.ceil(seconds / SECONDS_PER_MINUTE);
+  const resetAt = whenFrom(textOf(raw.reset_at), now) ?? whenFrom(textOf(raw.reset_after_seconds), now, true);
+  return { label: windowLabel(minutes), used: clamp(percent / 100), resetAt, detail: null };
+}
+
+function chatgptWall(limit: Record<string, unknown>, reached: unknown): string | null {
+  if (limit.limit_reached !== true && limit.allowed !== false) return null;
+  const kind = isRecord(reached) && typeof reached.type === 'string' ? reached.type : '';
+  return kind === '' ? 'limit reached' : kind.replaceAll('_', ' ');
+}
+
+export function chatgptUsage(body: unknown, now = new Date()): Reported | null {
+  if (!isRecord(body)) return null;
+  const limit = isRecord(body.rate_limit) ? body.rate_limit : {};
+  const credits = isRecord(body.credits) ? body.credits : {};
+  const windows = [chatgptWindow(limit.primary_window, now), chatgptWindow(limit.secondary_window, now), creditsLeft(credits.has_credits === true, textOf(credits.balance))].filter(
+    (w): w is UsageWindow => w !== null,
+  );
+  return windows.length === 0 ? null : { windows, note: chatgptWall(limit, body.rate_limit_reached_type), at: now.toISOString() };
+}
+
+async function answer(res: Response, provider: string): Promise<Response> {
+  if (res.ok) return res;
+  await res.body?.cancel();
+  throw new Error(`${provider} would not report its usage (${String(res.status)})`);
+}
+
+async function chatgptProbe(conn: Connection, deps: ProbeDeps, now: Date): Promise<Reported | null> {
+  const access = conn.codex;
+  if (access?.method !== 'code') return null;
+  const headers = { accept: 'application/json', authorization: `Bearer ${access.accessToken}`, 'chatgpt-account-id': access.accountId ?? '', originator: 'codex_cli_rs', 'user-agent': userAgent() };
+  const res = await (deps.fetchImpl ?? fetch)(`${deps.chatgptBase ?? CHATGPT_BACKEND}/wham/usage`, { headers, redirect: 'manual', signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+  return chatgptUsage(await (await answer(res, 'ChatGPT')).json(), now);
+}
+
+async function claudeProbe(conn: Connection, deps: ProbeDeps, now: Date): Promise<Reported | null> {
+  if (conn.claudeToken === '') return null;
+  const res = await (deps.fetchImpl ?? fetch)(`${deps.anthropicBase ?? ANTHROPIC_API}/v1/messages/count_tokens`, {
+    method: 'POST',
+    headers: { authorization: `Bearer ${conn.claudeToken}`, 'anthropic-version': '2023-06-01', 'anthropic-beta': OAUTH_BETA, 'content-type': 'application/json' },
+    body: JSON.stringify({ model: COUNT_MODEL, messages: [{ role: 'user', content: 'usage' }] }),
+    redirect: 'manual',
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+  });
+  await (await answer(res, 'Anthropic')).body?.cancel();
+  const usage = anthropicUsage(res.headers, now);
+  return usage === null || usage.windows.every((w) => w.label === PER_MINUTE) ? null : usage;
+}
+
+async function reported(conn: Connection, deps: ProbeDeps, now: Date): Promise<Reported | null> {
+  if (conn.provider === 'openrouter') return conn.apiKey === '' ? null : openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), now);
+  if (conn.provider === 'codex') return chatgptProbe(conn, deps, now);
+  if (conn.provider === 'anthropic') return claudeProbe(conn, deps, now);
+  return null;
+}
+
+export const probes = (conn: Connection): boolean =>
+  (conn.provider === 'openrouter' && conn.apiKey !== '') || (conn.provider === 'codex' && conn.codex?.method === 'code') || (conn.provider === 'anthropic' && conn.claudeToken !== '');
+
+export async function probeUsage(conn: Connection, deps: ProbeDeps = {}, now = new Date()): Promise<boolean> {
+  const usage = await reported(conn, deps, now);
+  if (usage === null) return false;
+  mergeUsage(conn.id, usage);
+  return true;
+}

package/runtime/node_modules/@metro-labs/inference/src/usage.ts

@@ -35,7 +35,7 @@ export const noteUsage = (key: Key, usage: Reported): void => {
   stamps.set(key, new Map(usage.windows.map((w) => [w.label, Date.parse(usage.at)])));
 };
 
-function mergeUsage(key: Key, usage: Reported): void {
+export function mergeUsage(key: Key, usage: Reported): void {
   const seen = latest.get(key);
   const marks = stamps.get(key);
   if (seen === undefined || marks === undefined) {
@@ -76,7 +76,7 @@ export function mayProbe(key: Key, now: number, every: number): boolean {
   return true;
 }
 
-export interface Counted {
+interface Counted {
   input: number;
   output: number;
   cached: number;
@@ -158,7 +158,7 @@ export class UsageScanner {
   }
 }
 
-const clamp = (value: number): number => Math.min(1, Math.max(0, value));
+export const clamp = (value: number): number => Math.min(1, Math.max(0, value));
 
 function fraction(raw: string | null): number | null {
   if (raw === null) return null;
@@ -168,7 +168,7 @@ function fraction(raw: string | null): number | null {
 
 const MS_THRESHOLD = 1e12;
 
-function whenFrom(raw: string | null, now: Date, relative = false): string | null {
+export function whenFrom(raw: string | null, now: Date, relative = false): string | null {
   if (raw === null || raw.trim() === '') return null;
   const numeric = Number(raw);
   if (Number.isFinite(numeric)) {
@@ -247,7 +247,7 @@ function codexWindow(headers: Headers, kind: 'primary' | 'secondary', now: Date)
   return { label: windowLabel(Number.isFinite(minutes) ? minutes : null), used, resetAt, detail: null };
 }
 
-function creditsLeft(hasCredits: boolean, raw: string | null): UsageWindow | null {
+export function creditsLeft(hasCredits: boolean, raw: string | null): UsageWindow | null {
   if (!hasCredits) return null;
   const balance = Number(raw ?? 'none');
   if (!Number.isFinite(balance)) return null;

package/runtime/node_modules/@metro-labs/outlook/src/accounts.ts

@@ -1,3 +1,4 @@
+import { errMsg } from '@metro-labs/core/log';
 import { makeAccountStore, resolveAccountId, type Die } from '@metro-labs/core/stations/account-store';
 import { threadOfLine } from '@metro-labs/core/stations/mail';
 import { TokenKeeper, type FetchLike } from '@metro-labs/core/stations/oauth';
@@ -27,7 +28,7 @@ export const { loadAccounts } = makeAccountStore<AccountConfig>({
 });
 
 const signedOut = (err: unknown): never => {
-  throw new TrainError('outlook_signed_out', err instanceof Error ? err.message : String(err), { retryable: false });
+  throw new TrainError('outlook_signed_out', errMsg(err), { retryable: false });
 };
 
 export class Account {
@@ -65,14 +66,11 @@ export class Account {
 
 export const accounts = new Map<string, Account>();
 
-function accountFor(id: string): Account {
-  const acct = accounts.get(id);
-  if (!acct) throw new Error(`unknown account '${id}' (have: ${[...accounts.keys()].join(', ')})`);
-  return acct;
-}
-
 export function accountOf(args: { account?: unknown; line?: unknown }): Account {
   const line = typeof args.line === 'string' && args.line !== '' ? args.line : undefined;
   const account = typeof args.account === 'string' && args.account !== '' ? args.account : undefined;
-  return accountFor(resolveAccountId(accounts, { account, line }, (l) => threadOfLine('outlook', l)?.accountId));
+  const id = resolveAccountId(accounts, { account, line }, (l) => threadOfLine('outlook', l)?.accountId);
+  const acct = accounts.get(id);
+  if (!acct) throw new Error(`unknown account '${id}'`);
+  return acct;
 }

package/runtime/node_modules/@metro-labs/outlook/src/auth.ts

@@ -1,3 +1,4 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { postForm, seconds, SignInError, tokensOf, type FetchLike, type OAuthBody, type Tokens } from '@metro-labs/core/stations/oauth';
 import { clientId, loginBase, NOT_SET_UP, SCOPES } from './config.js';
 
@@ -64,7 +65,7 @@ function decodeClaims(jwt: string): Body | null {
   if (part === undefined) return null;
   try {
     const raw: unknown = JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
-    return typeof raw === 'object' && raw !== null ? (raw as Body) : null;
+    return isRecord(raw) ? raw : null;
   } catch {
     return null;
   }

package/runtime/node_modules/@metro-labs/outlook/src/inbound.ts

@@ -1,4 +1,4 @@
-import { log } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { mailEnvelope, noteSeen, pollForever } from '@metro-labs/core/stations/mail';
 import type { Screened } from '@metro-labs/core/stations/mail-trust';
 import { emitInbound, reportAttachment } from '@metro-labs/core/stations/train-events';
@@ -26,11 +26,9 @@ function fresh(acct: Account, m: GraphMessage, since: string): boolean {
   return Date.parse(m.receivedDateTime ?? '') >= Date.parse(since);
 }
 
-const reasonOf = (err: unknown): string => (err instanceof Error ? err.message : String(err));
-
 async function screened(acct: Account, m: GraphMessage): Promise<Screened> {
   return screen(acct, m).catch((err: unknown) => {
-    process.stderr.write(`outlook[${acct.id}] could not read the headers of a message, so it counts as unverified: ${reasonOf(err)}\n`);
+    process.stderr.write(`outlook[${acct.id}] could not read the headers of a message, so it counts as unverified: ${errMsg(err)}\n`);
     return { verified: false };
   });
 }
@@ -44,7 +42,7 @@ async function deliver(acct: Account, m: GraphMessage): Promise<boolean> {
   const files: MailFile[] =
     m.hasAttachments === true
       ? await listFiles(acct, m.id).catch((err: unknown) => {
-          process.stderr.write(`outlook[${acct.id}] could not list the files of a message: ${reasonOf(err)}\n`);
+          process.stderr.write(`outlook[${acct.id}] could not list the files of a message: ${errMsg(err)}\n`);
           return [];
         })
       : [];

package/runtime/node_modules/@metro-labs/outlook/src/me.ts

@@ -1,3 +1,5 @@
+import { errMsg } from '@metro-labs/core/log';
+import { str } from '@metro-labs/core/stations/mail';
 import { SignInError, type FetchLike } from '@metro-labs/core/stations/oauth';
 import { graphBase } from './config.js';
 
@@ -6,8 +8,6 @@ export interface Mailbox {
   name: string;
 }
 
-const text = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
-
 const wrongMailbox = (actual: string, wanted: string): string =>
   `You signed in as ${actual}, not ${wanted}. Nothing was connected. Start again and pick ${wanted} on Microsoft's page, or use "Use another account".`;
 
@@ -18,14 +18,14 @@ export async function verifyMailbox(accessToken: string, fetchImpl: FetchLike, w
       headers: { authorization: `Bearer ${accessToken}`, accept: 'application/json' },
     });
   } catch (err) {
-    throw new SignInError(`Metro could not reach Microsoft Graph: ${err instanceof Error ? err.message : String(err)}`);
+    throw new SignInError(`Metro could not reach Microsoft Graph: ${errMsg(err)}`);
   }
   if (!res.ok) throw new SignInError(`Microsoft Graph refused the new sign-in (${String(res.status)}), so nothing was connected.`);
   const body = (await res.json().catch(() => ({}))) as Record<string, unknown>;
-  const mail = text(body.mail).toLowerCase();
-  const principal = text(body.userPrincipalName).toLowerCase();
+  const mail = str(body.mail).toLowerCase();
+  const principal = str(body.userPrincipalName).toLowerCase();
   const email = mail || principal;
   if (email === '') throw new SignInError('Microsoft Graph did not say which mailbox this is, so nothing was connected.');
   if (wanted !== null && wanted !== mail && wanted !== principal) throw new SignInError(wrongMailbox(email, wanted));
-  return { email, name: text(body.displayName) };
+  return { email, name: str(body.displayName) };
 }

package/runtime/node_modules/@metro-labs/outlook/src/outbound.ts

@@ -1,5 +1,6 @@
 import { checkAddress, filesOf, isAddress, mailLine, str, subjectOf, threadOfLine, type OutgoingFile } from '@metro-labs/core/stations/mail';
 import { escapeHtml } from '@metro-labs/core/stations/mail-text';
+import { errMsg } from '@metro-labs/core/log';
 import { respond } from '@metro-labs/core/stations/station-runtime';
 import { TrainError } from '@metro-labs/core/train-error';
 import { accountOf, type Account } from './accounts.js';
@@ -22,14 +23,11 @@ export async function latestInConversation(acct: Account, conversationId: string
 
 async function discard(acct: Account, draftId: string): Promise<void> {
   await graph(acct, messagePath(draftId), { method: 'DELETE' }).catch((err: unknown) => {
-    process.stderr.write(`outlook[${acct.id}] could not remove an unsent draft: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.stderr.write(`outlook[${acct.id}] could not remove an unsent draft: ${errMsg(err)}\n`);
   });
 }
 
-async function withFiles(acct: Account, target: string, verb: 'reply' | 'replyAll', comment: string, files: OutgoingFile[]): Promise<string[]> {
-  const draft = await graphJson<{ id?: string }>(acct, `${messagePath(target)}/${verb === 'reply' ? 'createReply' : 'createReplyAll'}`, jsonInit('POST', { comment }));
-  const draftId = draft.id;
-  if (draftId === undefined) throw new TrainError('outlook_graph_error', 'Outlook did not open a reply draft', { retryable: true });
+async function sendDraft(acct: Account, draftId: string, files: OutgoingFile[]): Promise<string[]> {
   const labels: string[] = [];
   try {
     for (const file of files) labels.push(await attachFile(acct, draftId, file));
@@ -41,6 +39,12 @@ async function withFiles(acct: Account, target: string, verb: 'reply' | 'replyAl
   return labels;
 }
 
+async function withFiles(acct: Account, target: string, verb: 'reply' | 'replyAll', comment: string, files: OutgoingFile[]): Promise<string[]> {
+  const draft = await graphJson<{ id?: string }>(acct, `${messagePath(target)}/${verb === 'reply' ? 'createReply' : 'createReplyAll'}`, jsonInit('POST', { comment }));
+  if (draft.id === undefined) throw new TrainError('outlook_graph_error', 'Outlook did not open a reply draft', { retryable: true });
+  return sendDraft(acct, draft.id, files);
+}
+
 async function compose(id: string, acct: Account, to: string, args: Args, text: string, files: OutgoingFile[]): Promise<void> {
   checkAddress('outlook', to);
   const draft = await graphJson<{ id?: string; conversationId?: string }>(acct, '/me/messages', jsonInit('POST', {
@@ -49,14 +53,7 @@ async function compose(id: string, acct: Account, to: string, args: Args, text:
     toRecipients: [{ emailAddress: { address: to } }],
   }));
   if (draft.id === undefined) throw new TrainError('outlook_graph_error', 'Outlook did not open a draft', { retryable: true });
-  const labels: string[] = [];
-  try {
-    for (const file of files) labels.push(await attachFile(acct, draft.id, file));
-    await graph(acct, `${messagePath(draft.id)}/send`, { method: 'POST' });
-  } catch (err) {
-    await discard(acct, draft.id);
-    throw err;
-  }
+  const labels = await sendDraft(acct, draft.id, files);
   const line = draft.conversationId === undefined ? undefined : mailLine('outlook', acct.id, draft.conversationId);
   respond(id, { result: { account: acct.id, messageId: draft.id, ...(line === undefined ? {} : { line }), ...(labels.length > 0 ? { attachments: labels } : {}) } });
 }

package/runtime/node_modules/@metro-labs/telegram/src/actions.ts

@@ -1,4 +1,5 @@
 import { TrainError } from '@metro-labs/core/train-error';
+import type { GroupResult } from '@metro-labs/core/stations/types';
 import { errMsg } from '@metro-labs/core/log';
 import {
   makeStation,
@@ -204,33 +205,13 @@ function makeGroupCreate(clientFor: ClientFor): StationHandler {
   };
 }
 
-function makeGroupAdd(clientFor: ClientFor): StationHandler {
-  return async (id, args) => {
-    const { client, chatId } = resolve(args, clientFor);
-    const line = lineOfArgs(args);
-    respond(id, {
-      result: await guard(() => groupAddMembers(client, chatId, line, args)),
-    });
-  };
-}
+type GroupOp = (client: UserClient, chatId: number, line: string, args: Args) => Promise<GroupResult>;
 
-function makeGroupRemove(clientFor: ClientFor): StationHandler {
+function makeGroupOp(clientFor: ClientFor, op: GroupOp): StationHandler {
   return async (id, args) => {
     const { client, chatId } = resolve(args, clientFor);
     const line = lineOfArgs(args);
-    respond(id, {
-      result: await guard(() => groupRemoveMembers(client, chatId, line, args)),
-    });
-  };
-}
-
-function makeGroupInvite(clientFor: ClientFor): StationHandler {
-  return async (id, args) => {
-    const { client, chatId } = resolve(args, clientFor);
-    const line = lineOfArgs(args);
-    respond(id, {
-      result: await guard(() => groupInviteLink(client, chatId, line)),
-    });
+    respond(id, { result: await guard(() => op(client, chatId, line, args)) });
   };
 }
 
@@ -264,9 +245,9 @@ export function makeHandleCall(
       listChannels: makeListChannels(clientFor),
       listMembers: makeListMembers(clientFor),
       groupCreate: makeGroupCreate(clientFor),
-      groupAddMembers: makeGroupAdd(clientFor),
-      groupRemoveMembers: makeGroupRemove(clientFor),
-      groupInviteLink: makeGroupInvite(clientFor),
+      groupAddMembers: makeGroupOp(clientFor, groupAddMembers),
+      groupRemoveMembers: makeGroupOp(clientFor, groupRemoveMembers),
+      groupInviteLink: makeGroupOp(clientFor, groupInviteLink),
       set_profile: makeSetProfile(clientFor),
       profile: makeReadProfile(clientFor),
     },

package/runtime/node_modules/@metro-labs/telegram/src/attachments.ts

@@ -19,7 +19,7 @@ interface MediaMeta {
 }
 
 function fallbackMime(media: DownloadableMedia): string | undefined {
-  const type = (media as { type?: unknown }).type;
+  const type = mediaType(media);
   if (type === 'photo') return 'image/jpeg';
   if (type === 'sticker') return 'image/webp';
   return undefined;

package/runtime/node_modules/@metro-labs/telegram/src/login.ts

@@ -1,4 +1,5 @@
 import { TelegramClient } from '@mtcute/bun';
+import { isRecord } from '@metro-labs/core/is-record';
 
 export class TelegramLoginError extends Error {}
 
@@ -19,9 +20,7 @@ const PHONE_RE = /^[0-9]{6,15}$/;
 const API_HASH_RE = /^[a-f0-9]{32}$/i;
 
 export function rpcErrorText(err: unknown): string {
-  if (typeof err !== 'object' || err === null) return '';
-  const text = (err as { text?: unknown }).text;
-  return typeof text === 'string' ? text : '';
+  return isRecord(err) && typeof err.text === 'string' ? err.text : '';
 }
 
 export function needsPassword(err: unknown): boolean {
@@ -75,9 +74,7 @@ interface SentCodeLike {
 }
 
 const isSentCode = (v: unknown): v is SentCodeLike =>
-  typeof v === 'object' &&
-  v !== null &&
-  typeof (v as { phoneCodeHash?: unknown }).phoneCodeHash === 'string';
+  isRecord(v) && typeof v.phoneCodeHash === 'string';
 
 interface UserLike {
   id: number;

package/runtime/node_modules/@metro-labs/telegram/src/profile.ts

@@ -1,4 +1,5 @@
 import type { TelegramClient } from '@mtcute/bun';
+import { errMsg } from '@metro-labs/core/log';
 import {
   assertImage,
   fieldsOf,
@@ -54,7 +55,7 @@ function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
         ...(nonEmpty(full.bio) === undefined ? {} : { about: nonEmpty(full.bio) }),
       };
     },
-    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${err instanceof Error ? err.message : String(err)}\n`) },
+    { onError: (user, err) => process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${user}: ${errMsg(err)}\n`) },
   );
   senders.set(client.account.id, made);
   return made;
@@ -63,7 +64,7 @@ function sendersOf(client: UserClient): ProfileCache<SenderProfile> {
 export function makeReadProfile(clientFor: (accountId: string) => UserClient): StationHandler {
   return async (id, args) => {
     const accountId = accountFor({ account: str(args.account) });
-    const user = str(args.user) ?? '';
+    const user = str(args.user);
     if (!/^\d+$/.test(user)) throw new TrainError('telegram_user_required', 'profile needs the numeric Telegram id of the person', { retryable: false });
     respond(id, { result: (await sendersOf(clientFor(accountId)).get(user)) ?? { id: user } });
   };

package/runtime/node_modules/@metro-labs/telegram-bot/src/actions.ts

@@ -6,19 +6,12 @@ import {
   inaccessibleMemberList,
   type TgChatMember,
 } from './members.js';
-import { makeStation, respond, type CallMsg, type StationHandler } from '@metro-labs/core/stations/station-runtime';
+import { makeStation, respond, type StationHandler } from '@metro-labs/core/stations/station-runtime';
 import { mediaKindOf } from './attachments.js';
-import {
-  emitOutbound,
-  finishSend,
-  MEDIA_METHOD_FIELD,
-  sendMedia,
-} from './media-actions.js';
+import { emitOutbound, MEDIA_METHOD_FIELD, sendMedia } from './media-actions.js';
 import { readProfile, setProfile } from './profile.js';
 import { listChannels } from './channels.js';
 
-export type { CallMsg };
-
 const meCache = new Map<string, { id: number; username: string | null }>();
 async function getMe(
   accountId: string,
@@ -70,7 +63,6 @@ interface SendArgs {
   }[];
 }
 
-
 type WireAttachment = NonNullable<SendArgs['attachments']>[number];
 
 const attachmentKind = (att: WireAttachment): string =>
@@ -139,7 +131,8 @@ async function send(id: string, args: Record<string, unknown>): Promise<void> {
   if (topicId !== undefined) body.message_thread_id = topicId;
   if (replyTo) body.reply_parameters = { message_id: Number(replyTo) };
   const sent = await tg<{ message_id: number }>(accountId, 'sendMessage', body);
-  finishSend(id, accountId, line, String(sent.message_id), text, replyTo);
+  emitOutbound(accountId, line, String(sent.message_id), text, replyTo);
+  respond(id, { result: { messageId: String(sent.message_id), account: accountId } });
 }
 
 async function react(id: string, args: Record<string, unknown>): Promise<void> {
@@ -212,19 +205,12 @@ async function listMembers(
     respond(id, { result: inaccessibleMemberList(errMsg(e)) });
     return;
   }
-  let total: number | null = null;
-  try {
-    total = await tg<number>(accountId, 'getChatMemberCount', {
-      chat_id: chatId,
-    });
-  } catch {
-    total = null;
-  }
+  const total = await tg<number>(accountId, 'getChatMemberCount', { chat_id: chatId }).catch(() => null);
   respond(id, { result: adminMemberList(admins, total) });
 }
 
 const HANDLERS: Record<string, StationHandler> = {
-  accounts: (id) => listAccounts(id),
+  accounts: listAccounts,
   send,
   react,
   typing,

package/runtime/node_modules/@metro-labs/telegram-bot/src/attachments.ts

@@ -1,13 +1,7 @@
-import {
-  saveBufferToCache,
-  assertContentLength,
-} from '@metro-labs/core/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { assertContentLength, saveBufferToCache, type SavedAttachment } from '@metro-labs/core/stations/attachments';
 import { tg, accounts } from './accounts.js';
 import type { TgMsg } from './types.js';
 
-export type { SavedAttachment };
-
 function isOggRef(mime: string | undefined, ref: string | undefined): boolean {
   const ext = ref?.split('?')[0]?.split('.').pop()?.toLowerCase();
   return mime === 'audio/ogg' || ext === 'ogg' || ext === 'oga';

package/runtime/node_modules/@metro-labs/telegram-bot/src/format.ts

@@ -4,8 +4,6 @@ import { mintId } from '@metro-labs/core/stations/station-runtime';
 import { mediaRefOf, saveTelegramMedia } from './attachments.js';
 import type { TgMsg, TgReaction, TgReactionCount, TgUser } from './types.js';
 
-export type { TgMsg, TgReaction, TgReactionCount };
-
 function lineForMsg(
   accountId: string,
   m: TgMsg,

package/runtime/node_modules/@metro-labs/telegram-bot/src/media-actions.ts

@@ -1,6 +1,6 @@
 import { tg, targetOf } from './accounts.js';
 import { selfUri } from '@metro-labs/core/stations/train-events';
-import { emit, mintId, respond } from '@metro-labs/core/stations/station-runtime';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
 import { appendFile } from '@metro-labs/core/stations/attachments';
 
 export function emitOutbound(
@@ -25,21 +25,6 @@ export function emitOutbound(
   });
 }
 
-export function finishSend(
-  id: string,
-  accountId: string,
-  line: string,
-  messageId: string,
-  label: string,
-  replyTo?: string,
-  extra?: Record<string, unknown>,
-): void {
-  emitOutbound(accountId, line, messageId, label, replyTo);
-  respond(id, {
-    result: { messageId, account: accountId, ...extra },
-  });
-}
-
 interface MediaArgs {
   line: string;
   path: string;

package/runtime/node_modules/@metro-labs/telegram-bot/src/members.ts

@@ -1,12 +1,5 @@
 import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
-
-export interface TgUser {
-  id: number;
-  username?: string;
-  first_name?: string;
-  last_name?: string;
-  is_bot?: boolean;
-}
+import type { TgUser } from './types.js';
 
 export interface TgChatMember {
   user: TgUser;

package/runtime/node_modules/@metro-labs/telegram-bot/src/profile.ts

@@ -1,3 +1,4 @@
+import { errMsg } from '@metro-labs/core/log';
 import { appendFile } from '@metro-labs/core/stations/attachments';
 import {
   assertImage,
@@ -74,7 +75,7 @@ const senders = makeProfileCache<SenderProfile>(
       ...(avatar === undefined ? {} : { avatar }),
     };
   },
-  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${errMsg(err)}\n`) },
 );
 
 export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {