@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/channels/telegram.js

@@ -1,189 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { STATE_DIR } from '../paths.js';
-import { errMsg, log } from '../log.js';
-import { mdToTelegramHtml } from '../helpers/telegram-format.js';
-const API_BASE = 'https://api.telegram.org';
-function token() {
-    const t = process.env.TELEGRAM_BOT_TOKEN;
-    if (!t)
-        throw new Error('TELEGRAM_BOT_TOKEN is not set');
-    return t;
-}
-async function tg(method, body, opts = {}) {
-    const signals = [AbortSignal.timeout(opts.timeoutMs ?? 30_000)];
-    if (opts.signal)
-        signals.push(opts.signal);
-    const res = await fetch(`${API_BASE}/bot${token()}/${method}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-        signal: AbortSignal.any(signals),
-    });
-    const json = (await res.json());
-    if (!json.ok)
-        throw new Error(`telegram ${method}: ${json.description ?? 'unknown error'}`);
-    return json.result;
-}
-let botUsername = null;
-let botUserId = null;
-export async function getMe() {
-    const me = await tg('getMe', {});
-    botUsername = me.username;
-    botUserId = me.id;
-    return me;
-}
-let onInboundHandler = () => { };
-export const onInbound = (handler) => { onInboundHandler = handler; };
-const offsetFile = join(STATE_DIR, 'telegram-offset.json');
-let pollOffset = 0;
-let pollAbort = null;
-function loadOffset() {
-    try {
-        return existsSync(offsetFile) ? Number(readFileSync(offsetFile, 'utf8').trim()) || 0 : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function saveOffset(o) {
-    try {
-        writeFileSync(offsetFile, String(o));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err) }, 'telegram offset save failed');
-    }
-}
-export async function startPolling() {
-    await tg('deleteWebhook', { drop_pending_updates: false }).catch(() => { });
-    const persisted = loadOffset();
-    if (persisted > 0) {
-        pollOffset = persisted;
-        log.info({ offset: pollOffset }, 'telegram polling: resuming from persisted offset');
-    }
-    else {
-        /** First run: anchor on latest update id (-1 returns most recent without consuming). */
-        const initial = await tg('getUpdates', { offset: -1, timeout: 0 });
-        pollOffset = initial.length ? initial[0].update_id + 1 : 0;
-        saveOffset(pollOffset);
-        log.info({ offset: pollOffset }, 'telegram polling: starting fresh');
-    }
-    pollAbort = new AbortController();
-    void pollLoop();
-}
-async function pollLoop() {
-    const abortSignal = pollAbort?.signal;
-    while (pollAbort && !pollAbort.signal.aborted) {
-        try {
-            const updates = await tg('getUpdates', { offset: pollOffset, timeout: 25 }, { timeoutMs: 60_000, signal: abortSignal });
-            for (const u of updates) {
-                pollOffset = u.update_id + 1;
-                await dispatchUpdate(u);
-            }
-            if (updates.length)
-                saveOffset(pollOffset);
-        }
-        catch (err) {
-            if (pollAbort?.signal.aborted)
-                break;
-            log.warn({ err: errMsg(err) }, 'telegram poll error; backing off');
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    log.info('telegram polling stopped');
-}
-export async function shutdownPolling() { pollAbort?.abort(); pollAbort = null; }
-async function dispatchUpdate(u) {
-    const m = u.message;
-    if (!m?.chat?.id || typeof m.message_id !== 'number' || m.from?.is_bot)
-        return;
-    const text = messageToText(m);
-    if (!text)
-        return;
-    onInboundHandler({
-        chat_id: m.chat.id,
-        message_id: m.message_id,
-        message_thread_id: m.is_topic_message ? m.message_thread_id : undefined,
-        text,
-        is_private: m.chat.type === 'private',
-        is_forum_topic: !!m.is_topic_message,
-        in_forum: !!m.chat.is_forum,
-        mentions_bot: detectMentionsBot(m),
-    });
-}
-function detectMentionsBot(m) {
-    if (m.chat?.type === 'private')
-        return true;
-    const text = m.text ?? m.caption ?? '';
-    for (const e of m.entities ?? m.caption_entities ?? []) {
-        if (e.type === 'mention' && botUsername) {
-            if (text.substring(e.offset, e.offset + e.length).toLowerCase() === `@${botUsername.toLowerCase()}`)
-                return true;
-        }
-        else if (e.type === 'text_mention' && e.user?.id === botUserId)
-            return true;
-    }
-    return false;
-}
-function messageToText(m) {
-    if (m.text)
-        return m.text;
-    const caption = m.caption ?? '';
-    if (m.photo?.length || m.document?.mime_type?.startsWith('image/'))
-        return [caption, '[image]'].filter(Boolean).join(' ');
-    if (m.voice)
-        return [caption, '[voice]'].filter(Boolean).join(' ');
-    if (m.audio)
-        return [caption, '[audio]'].filter(Boolean).join(' ');
-    return caption || null;
-}
-/** Create a forum topic; requires `can_manage_topics` admin permission. */
-export async function createForumTopic(chatId, name) {
-    const r = await tg('createForumTopic', { chat_id: chatId, name: name.slice(0, 128) || 'metro' });
-    return r.message_thread_id;
-}
-/** Deep link `t.me/c/<id>/<topic>`; strips supergroup's `-100` prefix from chat id. */
-export function topicLink(chatId, topicId) {
-    const id = String(Math.abs(chatId)).replace(/^100/, '');
-    return `https://t.me/c/${id}/${topicId}`;
-}
-const isParseError = (err) => errMsg(err).includes("can't parse entities");
-const NO_PREVIEW = { link_preview_options: { is_disabled: true } };
-/** Send agent-style markdown as Telegram HTML, falling back to plain text on parse errors. */
-export async function sendMessage(chatId, threadId, text, replyToMessageId) {
-    const base = { chat_id: chatId, ...NO_PREVIEW };
-    if (threadId !== undefined)
-        base.message_thread_id = threadId;
-    if (replyToMessageId !== undefined)
-        base.reply_parameters = { message_id: replyToMessageId };
-    try {
-        return (await tg('sendMessage', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' })).message_id;
-    }
-    catch (err) {
-        if (!isParseError(err))
-            throw err;
-        log.warn({ err: errMsg(err) }, 'telegram: HTML rejected, sending plain');
-        return (await tg('sendMessage', { ...base, text })).message_id;
-    }
-}
-export async function editMessageText(chatId, messageId, text) {
-    const base = { chat_id: chatId, message_id: messageId, ...NO_PREVIEW };
-    const swallow = (err) => { if (!errMsg(err).includes('message is not modified'))
-        throw err; };
-    try {
-        await tg('editMessageText', { ...base, text: mdToTelegramHtml(text), parse_mode: 'HTML' });
-    }
-    catch (err) {
-        if (errMsg(err).includes('message is not modified'))
-            return;
-        if (!isParseError(err))
-            throw err;
-        log.warn({ err: errMsg(err) }, 'telegram: HTML edit rejected, retrying plain');
-        try {
-            await tg('editMessageText', { ...base, text });
-        }
-        catch (e) {
-            swallow(e);
-        }
-    }
-}

package/dist/cli.js

@@ -1,221 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import pkg from '../package.json' with { type: 'json' };
-import * as discord from './channels/discord.js';
-import * as telegram from './channels/telegram.js';
-import { errMsg } from './log.js';
-import { CONFIG_ENV_FILE, configuredPlatforms, loadMetroEnv, readDotenv, STATE_DIR, writeDotenv } from './paths.js';
-const USAGE = `metro — Telegram + Discord bridge for your Claude Code / Codex agent
-
-Usage:
-  metro                                       Run the orchestrator daemon.
-  metro setup [telegram|discord <token>]      Save token, or show status with no args.
-  metro setup clear [telegram|discord|all]    Remove tokens.
-  metro doctor                                Health check.
-  metro update                                Upgrade in place.
-  metro --version | --help
-
-Exit codes: 0 success · 1 usage · 2 config · 3 upstream
-`;
-const exitErr = (msg, code) => Object.assign(new Error(msg), { code });
-const isJson = (f) => f.json === true;
-const emit = (f, human, structured) => {
-    process.stdout.write(isJson(f) ? JSON.stringify(structured) + '\n' : human + '\n');
-};
-const maskToken = (t) => !t ? '' : t.length <= 8 ? '••••' : `${t.slice(0, 6)}…${t.slice(-2)}`;
-const TOKEN_KEYS = { telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN' };
-function parseArgs(argv) {
-    const positional = [];
-    const flags = {};
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (!a.startsWith('--')) {
-            positional.push(a);
-            continue;
-        }
-        const eq = a.indexOf('=');
-        if (eq !== -1) {
-            flags[a.slice(2, eq)] = a.slice(eq + 1);
-            continue;
-        }
-        const key = a.slice(2);
-        const next = argv[i + 1];
-        if (next !== undefined && !next.startsWith('--')) {
-            flags[key] = next;
-            i++;
-        }
-        else
-            flags[key] = true;
-    }
-    return { positional, flags };
-}
-async function cmdSetup(positional, flags) {
-    const [sub, value] = positional;
-    if (!sub)
-        return cmdSetupStatus(flags);
-    if (sub === 'telegram' || sub === 'discord') {
-        if (!value)
-            throw new Error(`metro setup ${sub} <token> — token is required`);
-        const trimmed = value.trim();
-        let identity;
-        if (!flags['no-validate']) {
-            process.env[TOKEN_KEYS[sub]] = trimmed;
-            try {
-                identity = sub === 'telegram' ? `@${(await telegram.getMe()).username}` : (await discord.getMe()).username;
-            }
-            catch (err) {
-                delete process.env[TOKEN_KEYS[sub]];
-                throw exitErr(`token rejected by ${sub}: ${errMsg(err)} (use --no-validate to save anyway)`, 3);
-            }
-        }
-        const env = readDotenv(CONFIG_ENV_FILE);
-        env[TOKEN_KEYS[sub]] = trimmed;
-        writeDotenv(CONFIG_ENV_FILE, env);
-        const human = `saved ${TOKEN_KEYS[sub]}${identity ? ` (verified as ${identity})` : ''} to ${CONFIG_ENV_FILE} (chmod 0600)`;
-        emit(flags, human, { ok: true, saved: TOKEN_KEYS[sub], verified_as: identity ?? null });
-        return;
-    }
-    if (sub === 'clear') {
-        const target = value ?? 'all';
-        const env = readDotenv(CONFIG_ENV_FILE);
-        if (target === 'all') {
-            delete env.TELEGRAM_BOT_TOKEN;
-            delete env.DISCORD_BOT_TOKEN;
-        }
-        else if (target === 'telegram' || target === 'discord')
-            delete env[TOKEN_KEYS[target]];
-        else
-            throw new Error(`metro setup clear <telegram|discord|all> — got '${target}'`);
-        writeDotenv(CONFIG_ENV_FILE, env);
-        emit(flags, `cleared ${target === 'all' ? 'all metro tokens' : TOKEN_KEYS[target]}`, { ok: true, cleared: target });
-        return;
-    }
-    throw new Error(`unknown setup subcommand '${sub}' (try: telegram, discord, clear)`);
-}
-async function cmdSetupStatus(flags) {
-    loadMetroEnv();
-    const tg = process.env.TELEGRAM_BOT_TOKEN ?? '';
-    const dc = process.env.DISCORD_BOT_TOKEN ?? '';
-    if (isJson(flags)) {
-        process.stdout.write(JSON.stringify({
-            version: pkg.version,
-            config_env_file: CONFIG_ENV_FILE,
-            tokens: { telegram: { set: !!tg, masked: maskToken(tg) }, discord: { set: !!dc, masked: maskToken(dc) } },
-        }) + '\n');
-        return;
-    }
-    const cfgState = existsSync(CONFIG_ENV_FILE) ? '' : ' (not yet written)';
-    process.stdout.write(`metro ${pkg.version}\n\nconfig:  ${CONFIG_ENV_FILE}${cfgState}\n\n` +
-        `  TELEGRAM_BOT_TOKEN  ${tg ? `set (${maskToken(tg)})` : 'not set'}\n` +
-        `  DISCORD_BOT_TOKEN   ${dc ? `set (${maskToken(dc)})` : 'not set'}\n\n`);
-    process.stdout.write(!tg && !dc
-        ? 'Get started:\n  1. metro setup telegram <token>   # https://t.me/BotFather\n     metro setup discord <token>     # https://discord.com/developers/applications\n  2. metro doctor\n  3. metro\n'
-        : 'Run `metro` to start the orchestrator, or `metro doctor` to verify.\n');
-}
-async function cmdDoctor(flags) {
-    loadMetroEnv();
-    const cfg = configuredPlatforms();
-    const checks = [{
-            name: 'tokens',
-            ok: cfg.telegram || cfg.discord,
-            detail: cfg.telegram || cfg.discord ? `loaded from ${existsSync(CONFIG_ENV_FILE) ? CONFIG_ENV_FILE : 'process env'}` : 'no platform configured — run `metro setup telegram|discord <token>`',
-        }];
-    for (const [p, getMe] of [['telegram', telegram.getMe], ['discord', discord.getMe]]) {
-        if (!cfg[p]) {
-            checks.push({ name: p, ok: null, detail: 'not configured' });
-            continue;
-        }
-        try {
-            const me = await getMe();
-            checks.push({ name: p, ok: true, detail: `getMe → ${p === 'telegram' ? '@' : ''}${me.username}` });
-        }
-        catch (err) {
-            checks.push({ name: p, ok: false, detail: errMsg(err) });
-        }
-    }
-    const lockFile = join(STATE_DIR, '.tail-lock');
-    if (!existsSync(lockFile))
-        checks.push({ name: 'orchestrator', ok: null, detail: 'not running' });
-    else
-        try {
-            const pid = Number(readFileSync(lockFile, 'utf8').trim());
-            if (!Number.isInteger(pid) || pid <= 0)
-                throw new Error('invalid pid');
-            process.kill(pid, 0);
-            checks.push({ name: 'orchestrator', ok: true, detail: `running (pid ${pid})` });
-        }
-        catch {
-            checks.push({ name: 'orchestrator', ok: null, detail: 'stale lockfile (will auto-reclaim on next start)' });
-        }
-    if (isJson(flags))
-        process.stdout.write(JSON.stringify({ checks }) + '\n');
-    else {
-        process.stdout.write('metro doctor\n\n');
-        for (const c of checks)
-            process.stdout.write(`  ${c.ok === true ? '✓' : c.ok === false ? '✗' : '–'} ${c.name.padEnd(15)} ${c.detail}\n`);
-        process.stdout.write('\n');
-    }
-    if (checks.some(c => c.ok === false))
-        throw exitErr('one or more checks failed', 3);
-}
-async function cmdUpdate(flags) {
-    const tag = pkg.version.includes('-') ? 'beta' : 'latest';
-    const res = await fetch('https://registry.npmjs.org/@stage-labs/metro', { signal: AbortSignal.timeout(15_000) });
-    if (!res.ok)
-        throw new Error(`npm registry: ${res.status}`);
-    const latest = (await res.json())['dist-tags']?.[tag];
-    if (!latest)
-        throw new Error(`no '${tag}' dist-tag for @stage-labs/metro`);
-    if (latest === pkg.version)
-        return emit(flags, `already on ${pkg.version} (latest ${tag})`, { ok: true, current: pkg.version, latest, upgraded: false });
-    const argv1 = process.argv[1] ?? '';
-    const spec = `@stage-labs/metro@${tag}`;
-    const argv = argv1.includes('/.bun/') || argv1.includes('\\bun\\') ? ['bun', 'add', '-g', spec]
-        : argv1.includes('/pnpm/') || argv1.includes('\\pnpm\\') ? ['pnpm', 'add', '-g', spec]
-            : ['npm', 'install', '-g', spec];
-    if (isJson(flags))
-        process.stdout.write(JSON.stringify({ ok: true, current: pkg.version, latest, command: argv.join(' ') }) + '\n');
-    else
-        process.stdout.write(`metro ${pkg.version} → ${latest}\n$ ${argv.join(' ')}\n`);
-    await new Promise((resolve, reject) => {
-        const child = spawn(argv[0], argv.slice(1), { stdio: isJson(flags) ? 'ignore' : 'inherit' });
-        child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${argv[0]} exited ${code}`)));
-        child.on('error', reject);
-    });
-}
-const COMMANDS = {
-    setup: cmdSetup,
-    doctor: (_, f) => cmdDoctor(f),
-    update: (_, f) => cmdUpdate(f),
-};
-async function main() {
-    const cmd = process.argv[2];
-    if (cmd === '--version' || cmd === '-v')
-        return void process.stdout.write(`${pkg.version}\n`);
-    if (cmd === '--help' || cmd === '-h')
-        return void process.stdout.write(USAGE);
-    if (!cmd) {
-        await import('./orchestrator.js');
-        return;
-    }
-    const handler = COMMANDS[cmd];
-    if (!handler) {
-        process.stderr.write(`unknown command '${cmd}'\n\n${USAGE}`);
-        process.exit(1);
-    }
-    const { positional, flags } = parseArgs(process.argv.slice(3));
-    try {
-        await handler(positional, flags);
-    }
-    catch (err) {
-        const code = err.code;
-        if (isJson(flags))
-            process.stdout.write(JSON.stringify({ ok: false, error: errMsg(err), code: code ?? 1 }) + '\n');
-        else
-            process.stderr.write(`error: ${errMsg(err)}\n`);
-        process.exit(typeof code === 'number' ? code : 1);
-    }
-}
-await main();

package/dist/helpers/scope-cache.js

@@ -1,65 +0,0 @@
-/** Per-machine scope→{thread ids,last-used} cache. Keys: `discord:<id>` / `telegram:<chat>:<topic>`. */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { errMsg, log } from '../log.js';
-import { STATE_DIR } from '../paths.js';
-const cacheFile = join(STATE_DIR, 'scopes.json');
-function read() {
-    if (!existsSync(cacheFile))
-        return {};
-    try {
-        return JSON.parse(readFileSync(cacheFile, 'utf8'));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache read failed; treating as empty');
-        return {};
-    }
-}
-function write(cache) {
-    try {
-        writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
-    }
-    catch (err) {
-        log.warn({ err: errMsg(err), path: cacheFile }, 'scope cache write failed');
-    }
-}
-function ensure(cache, scopeKey) {
-    if (!cache[scopeKey])
-        cache[scopeKey] = { createdAt: new Date().toISOString(), agents: {} };
-    if (!cache[scopeKey].agents)
-        cache[scopeKey].agents = {};
-    return cache[scopeKey];
-}
-export function getAgentThread(scopeKey, kind) {
-    return read()[scopeKey]?.agents?.[kind];
-}
-export function setAgentThread(scopeKey, kind, threadId) {
-    const cache = read();
-    const entry = ensure(cache, scopeKey);
-    entry.agents[kind] = threadId;
-    entry.lastAgent = kind;
-    write(cache);
-}
-export function getLastAgent(scopeKey) {
-    return read()[scopeKey]?.lastAgent;
-}
-export function setLastAgent(scopeKey, kind) {
-    const cache = read();
-    if (!cache[scopeKey])
-        return;
-    cache[scopeKey].lastAgent = kind;
-    write(cache);
-}
-export function setLastSeen(scopeKey, messageId) {
-    const cache = read();
-    if (!cache[scopeKey])
-        return;
-    cache[scopeKey].lastSeenMessageId = messageId;
-    write(cache);
-}
-export function listScopes() {
-    return Object.entries(read()).map(([scopeKey, entry]) => ({ scopeKey, entry }));
-}
-export const discordScopeKey = (threadChannelId) => `discord:${threadChannelId}`;
-export const discordChannelFromScopeKey = (scopeKey) => scopeKey.startsWith('discord:') ? scopeKey.slice('discord:'.length) : null;
-export const telegramScopeKey = (chatId, topicId) => `telegram:${chatId}:${topicId ?? 'main'}`;

package/dist/helpers/streaming.js

@@ -1,209 +0,0 @@
-/** Streams agent deltas + tool calls to chat via debounced edits; splits past MAX_BODY_LEN. */
-import { errMsg, log } from '../log.js';
-/** 1500ms keeps us under Discord's ~5/5s per-channel edit cap; leading-edge 500ms for first delta. */
-const DEFAULT_DEBOUNCE_MS = 1500;
-const LEADING_MS = 500;
-/** Discord cap is 2000; 1900 leaves headroom for status suffix. */
-const MAX_BODY_LEN = 1900;
-const STATUS_RESERVE = 80;
-/** Cap result so a 1000-line file dump doesn't blow the per-message char budget. */
-const MAX_RESULT_LINES = 50;
-const MAX_RESULT_CHARS = 1500;
-/** One per bot. Coalesces edits so concurrent threads don't compound rate limits. */
-export class StreamScheduler {
-    debounceMs;
-    leadingMs;
-    dirty = new Set();
-    timer = null;
-    lastFlushAt = 0;
-    constructor(debounceMs = DEFAULT_DEBOUNCE_MS, leadingMs = LEADING_MS) {
-        this.debounceMs = debounceMs;
-        this.leadingMs = leadingMs;
-    }
-    request(stream) {
-        this.dirty.add(stream);
-        if (this.timer)
-            return;
-        const sinceLast = Date.now() - this.lastFlushAt;
-        const delay = sinceLast >= this.debounceMs ? this.leadingMs : this.debounceMs - sinceLast;
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            this.lastFlushAt = Date.now();
-            const batch = [...this.dirty];
-            this.dirty.clear();
-            for (const s of batch)
-                void s._flushFromScheduler();
-        }, delay);
-    }
-    forget(stream) { this.dirty.delete(stream); }
-}
-/** Break embedded triple backticks so they can't close our fenced block early. */
-const escapeFence = (s) => s.replace(/```/g, '`​`​`');
-/** Cap output by lines + chars; return `body` to embed and a `_(N more …)_` overflow note (or ''). */
-function truncateResult(s) {
-    const lines = s.split('\n');
-    let body = lines.slice(0, MAX_RESULT_LINES).join('\n');
-    const droppedLines = Math.max(0, lines.length - MAX_RESULT_LINES);
-    if (body.length > MAX_RESULT_CHARS)
-        body = body.slice(0, MAX_RESULT_CHARS) + '…';
-    if (droppedLines === 0 && body === s)
-        return { body: s, overflow: '' };
-    const noun = droppedLines > 0 ? `${droppedLines} more line${droppedLines === 1 ? '' : 's'}` : 'output truncated';
-    return { body, overflow: `_(${noun})_` };
-}
-export class StreamingMessage {
-    adapter;
-    scheduler;
-    blocks = [];
-    segments = [{ id: null, text: '', dirty: false }];
-    statusLine = null;
-    flushing = false;
-    flushAgain = false;
-    finalized = false;
-    constructor(adapter, scheduler) {
-        this.adapter = adapter;
-        this.scheduler = scheduler;
-    }
-    appendDelta(delta) {
-        if (this.finalized || !delta)
-            return;
-        const last = this.blocks.at(-1);
-        if (last?.kind === 'text')
-            last.text += delta;
-        else
-            this.blocks.push({ kind: 'text', text: delta });
-        this.scheduler.request(this);
-    }
-    setStatus(status) {
-        if (this.finalized)
-            return;
-        this.statusLine = status;
-        this.scheduler.request(this);
-    }
-    /** Add a tool block keyed by `id`; rendered immediately as a header, output filled in via appendToolResult. */
-    appendToolCall(id, name, detail) {
-        if (this.finalized)
-            return;
-        this.blocks.push({ kind: 'tool', id, name, detail });
-        this.scheduler.request(this);
-    }
-    /** Set the matching tool block's result; renders truncated output under the header. */
-    appendToolResult(id, result) {
-        if (this.finalized || !result)
-            return;
-        const tool = this.blocks.find((b) => b.kind === 'tool' && b.id === id);
-        if (tool)
-            tool.result = result;
-        this.scheduler.request(this);
-    }
-    appendError(message) {
-        if (this.finalized)
-            return;
-        this.statusLine = null;
-        this.blocks.push({ kind: 'text', text: `⚠️ ${message}` });
-        this.scheduler.request(this);
-    }
-    async finalize() {
-        if (this.finalized)
-            return;
-        this.finalized = true;
-        this.scheduler.forget(this);
-        this.statusLine = null;
-        await this.flush();
-    }
-    async _flushFromScheduler() { await this.flush(); }
-    /** Render the block list into a single markdown body. */
-    renderBody() {
-        return this.blocks.map(b => b.kind === 'text' ? b.text : this.renderToolBlock(b)).join('\n\n').trim();
-    }
-    /** Plain header + fenced input block + fenced output block. Each fence is fully visible (no collapse). */
-    renderToolBlock(b) {
-        const parts = [`🛠 **${b.name}**`];
-        if (b.detail)
-            parts.push('```\n' + escapeFence(b.detail) + '\n```');
-        if (b.result) {
-            const { body, overflow } = truncateResult(b.result);
-            parts.push('```\n' + escapeFence(body) + '\n```');
-            if (overflow)
-                parts.push(overflow);
-        }
-        return parts.join('\n');
-    }
-    /** Redistribute the rendered body across segments, keeping existing segment ids stable. */
-    redistribute() {
-        const fullBody = this.renderBody();
-        const chunks = this.chunkify(fullBody, MAX_BODY_LEN - STATUS_RESERVE);
-        if (!chunks.length)
-            chunks.push('');
-        for (let i = 0; i < chunks.length; i++) {
-            if (i >= this.segments.length) {
-                this.segments.push({ id: null, text: chunks[i], dirty: true });
-            }
-            else if (this.segments[i].text !== chunks[i]) {
-                this.segments[i].text = chunks[i];
-                this.segments[i].dirty = true;
-            }
-        }
-    }
-    chunkify(s, cap) {
-        if (s.length <= cap)
-            return [s];
-        const out = [];
-        for (let r = s; r.length > 0;) {
-            const take = r.length > cap ? this.sliceAtBoundary(r, cap) : r;
-            out.push(take);
-            r = r.slice(take.length);
-        }
-        return out;
-    }
-    /** Split at the last paragraph/line/sentence/word break in range; hard slice otherwise. */
-    sliceAtBoundary(s, room) {
-        if (s.length <= room)
-            return s;
-        const candidate = s.slice(0, room);
-        for (const b of ['\n\n', '\n', '. ', ' ']) {
-            const i = candidate.lastIndexOf(b);
-            if (i > room * 0.5)
-                return candidate.slice(0, i + b.length);
-        }
-        return candidate;
-    }
-    async flush() {
-        if (this.flushing) {
-            this.flushAgain = true;
-            return;
-        }
-        this.flushing = true;
-        try {
-            do {
-                this.flushAgain = false;
-                this.redistribute();
-                for (let i = 0; i < this.segments.length; i++) {
-                    const s = this.segments[i];
-                    const body = this.render(s, i === this.segments.length - 1);
-                    if (!body)
-                        continue;
-                    try {
-                        if (s.id === null)
-                            s.id = await this.adapter.send(body);
-                        else if (s.dirty)
-                            await this.adapter.edit(s.id, body);
-                        s.dirty = false;
-                    }
-                    catch (err) {
-                        log.warn({ err: errMsg(err) }, 'streaming edit failed');
-                    }
-                }
-            } while (this.flushAgain);
-        }
-        finally {
-            this.flushing = false;
-        }
-    }
-    render(s, isLast) {
-        const showStatus = isLast && !!this.statusLine;
-        if (!s.text)
-            return showStatus ? this.statusLine : '';
-        return showStatus ? `${s.text}\n\n${this.statusLine}` : s.text;
-    }
-}