@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/controller/turn_rendering.js

@@ -0,0 +1,288 @@
+import { TELEGRAM_RICH_MESSAGE_TEXT_LIMIT } from '../telegram/rich.js';
+import { escapeTelegramHtml, telegramBold, telegramDetails, telegramExpandableBlockquote } from '../telegram/html.js';
+import { renderTelegramMarkdownRichHtml } from '../telegram/rich_markdown.js';
+import { TOOL_ARCHIVE_MAX_LINES, TOOL_ARCHIVE_LINE_LIMIT, } from './state_types.js';
+export function ensureTurnSegment(active, itemId, phase, outputKind, isPlan) {
+    let segment = active.segments.find((entry) => entry.itemId === itemId);
+    if (segment) {
+        if (phase !== undefined) {
+            segment.phase = phase;
+        }
+        if (outputKind !== undefined) {
+            segment.outputKind = outputKind;
+        }
+        if (isPlan !== undefined) {
+            segment.isPlan = segment.isPlan || isPlan;
+        }
+        return segment;
+    }
+    segment = {
+        itemId,
+        phase: phase ?? null,
+        outputKind: outputKind ?? 'commentary',
+        isPlan: Boolean(isPlan),
+        text: '',
+        completed: false,
+        startedAtMs: Date.now(),
+        completedAtMs: null,
+        messages: [],
+        voiceSnippetId: null,
+    };
+    active.segments.push(segment);
+    return segment;
+}
+export function renderCollapsedCommentary(locale, segments) {
+    const firstAt = segments[0]?.startedAtMs ?? Date.now();
+    const lastSegment = segments[segments.length - 1];
+    const lastAt = lastSegment?.completedAtMs ?? lastSegment?.startedAtMs ?? firstAt;
+    const range = firstAt === lastAt
+        ? formatClockTimestamp(firstAt)
+        : `${formatClockTimestamp(firstAt)} - ${formatClockTimestamp(lastAt)}`;
+    const summary = locale === 'zh'
+        ? `过程汇报 · ${segments.length} 条 · ${range}`
+        : `Progress · ${segments.length} updates · ${range}`;
+    const maxBodyLength = TELEGRAM_RICH_MESSAGE_TEXT_LIMIT - summary.length - 1024;
+    const blocks = [];
+    let bodyLength = 0;
+    let omitted = 0;
+    for (const segment of segments) {
+        const endAt = segment.completedAtMs ?? segment.startedAtMs;
+        const timestamp = endAt === segment.startedAtMs
+            ? formatClockTimestamp(segment.startedAtMs)
+            : `${formatClockTimestamp(segment.startedAtMs)} - ${formatClockTimestamp(endAt)}`;
+        const block = `<h4>${escapeTelegramHtml(timestamp)}</h4>\n${renderTelegramMarkdownRichHtml(segment.text)}`;
+        if (bodyLength + block.length > maxBodyLength) {
+            omitted += 1;
+            continue;
+        }
+        blocks.push(block);
+        bodyLength += block.length;
+    }
+    if (omitted > 0) {
+        blocks.push(`<p>${escapeTelegramHtml(locale === 'zh' ? `另有 ${omitted} 条过长内容未收入归档` : `${omitted} oversized updates omitted`)}</p>`);
+    }
+    return telegramDetails(summary, blocks.join('\n'));
+}
+export function formatClockTimestamp(timestampMs) {
+    const date = new Date(timestampMs);
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+export function createToolBatchState() {
+    return {
+        openCallIds: new Set(),
+        actionKeys: new Set(),
+        actionLines: [],
+        counts: { files: 0, searches: 0, edits: 0, commands: 0 },
+        finalizeTimer: null,
+    };
+}
+export function incrementToolBatchCount(counts, kind) {
+    counts[kind] += 1;
+}
+export function formatToolBatchStatus(locale, counts, actionLines, inProgress) {
+    const heading = formatToolBatchHeading(locale, counts, inProgress);
+    const detailLines = actionLines.slice(0, 6);
+    if (detailLines.length === 0) {
+        return heading;
+    }
+    return [heading, ...detailLines].join('\n');
+}
+export function renderArchivedToolBatchStatus(locale, counts, actionLines) {
+    const text = formatToolBatchStatus(locale, counts, actionLines, false);
+    if (actionLines.length === 0) {
+        return { text, html: null };
+    }
+    const heading = formatToolBatchHeading(locale, counts, false);
+    const detailLines = actionLines
+        .slice(0, TOOL_ARCHIVE_MAX_LINES)
+        .map(line => truncateInline(line, TOOL_ARCHIVE_LINE_LIMIT));
+    const html = [
+        telegramBold(heading),
+        telegramExpandableBlockquote(detailLines.join('\n')),
+    ].join('\n');
+    return { text, html };
+}
+export function formatToolBatchHeading(locale, counts, inProgress) {
+    const parts = formatToolBatchCountParts(locale, counts);
+    const hasBrowse = counts.files > 0 || counts.searches > 0;
+    const hasEdit = counts.edits > 0;
+    const hasCommand = counts.commands > 0;
+    let verb;
+    if (hasEdit && !hasBrowse && !hasCommand) {
+        verb = locale === 'zh' ? (inProgress ? '正在编辑' : '已编辑') : (inProgress ? 'Editing' : 'Edited');
+    }
+    else if (hasBrowse && !hasEdit && !hasCommand) {
+        verb = locale === 'zh' ? (inProgress ? '正在浏览' : '已浏览') : (inProgress ? 'Browsing' : 'Browsed');
+    }
+    else if (hasCommand && !hasBrowse && !hasEdit) {
+        verb = locale === 'zh' ? (inProgress ? '正在运行' : '已运行') : (inProgress ? 'Running' : 'Ran');
+    }
+    else {
+        verb = locale === 'zh' ? (inProgress ? '正在处理' : '已处理') : (inProgress ? 'Processing' : 'Processed');
+    }
+    if (parts.length === 0) {
+        return locale === 'zh'
+            ? `${verb}操作...`
+            : `${verb} operations...`;
+    }
+    return locale === 'zh'
+        ? `${verb} ${parts.join('，')}`
+        : `${verb} ${parts.join(', ')}`;
+}
+export function formatToolBatchCountParts(locale, counts) {
+    const parts = [];
+    if (counts.files > 0) {
+        parts.push(locale === 'zh' ? `${counts.files} 个文件` : pluralize(counts.files, 'file'));
+    }
+    if (counts.searches > 0) {
+        parts.push(locale === 'zh' ? `${counts.searches} 个搜索` : pluralize(counts.searches, 'search'));
+    }
+    if (counts.edits > 0) {
+        parts.push(locale === 'zh' ? `${counts.edits} 个编辑` : pluralize(counts.edits, 'edit'));
+    }
+    if (counts.commands > 0) {
+        parts.push(locale === 'zh' ? `${counts.commands} 个命令` : pluralize(counts.commands, 'command'));
+    }
+    return parts;
+}
+export function pluralize(count, noun) {
+    if (count === 1) {
+        return `1 ${noun}`;
+    }
+    const plural = noun === 'search'
+        ? 'searches'
+        : noun === 'file'
+            ? 'files'
+            : `${noun}s`;
+    return `${count} ${plural}`;
+}
+export function describeExecCommand(event) {
+    const descriptors = (event.parsedCmd ?? [])
+        .map((entry) => describeParsedCommand(entry))
+        .filter((entry) => entry !== null);
+    if (descriptors.length > 0) {
+        return descriptors;
+    }
+    const commandText = renderShellCommand(event.command);
+    return [{
+            kind: 'commands',
+            key: `command:${commandText}`,
+            line: `$ ${commandText}`,
+        }];
+}
+export function describeParsedCommand(entry) {
+    const type = typeof entry?.type === 'string' ? entry.type : '';
+    const path = compactPath(entry?.path ?? entry?.name ?? null);
+    const query = typeof entry?.query === 'string' ? entry.query : null;
+    switch (type) {
+        case 'search':
+            return {
+                kind: 'searches',
+                key: `search:${path ?? '.'}:${query ?? ''}`,
+                line: path ? `Searched for ${truncateInline(query || '', 80)} in ${path}` : `Searched for ${truncateInline(query || '', 80)}`,
+            };
+        case 'read':
+            return {
+                kind: 'files',
+                key: `read:${path ?? 'unknown'}`,
+                line: `Read ${path ?? 'file'}`,
+            };
+        case 'list_files':
+            return {
+                kind: 'files',
+                key: `list:${path ?? 'workspace'}`,
+                line: path ? `Listed ${path}` : 'Listed files',
+            };
+        case 'write':
+        case 'edit':
+        case 'apply_patch':
+            return {
+                kind: 'edits',
+                key: `${type}:${path ?? 'workspace'}`,
+                line: `Edited ${path ?? 'files'}`,
+            };
+        case 'move':
+            return {
+                kind: 'edits',
+                key: `${type}:${path ?? 'workspace'}`,
+                line: `Moved ${path ?? 'files'}`,
+            };
+        case 'copy':
+            return {
+                kind: 'edits',
+                key: `${type}:${path ?? 'workspace'}`,
+                line: `Copied ${path ?? 'files'}`,
+            };
+        case 'delete':
+            return {
+                kind: 'edits',
+                key: `${type}:${path ?? 'workspace'}`,
+                line: `Deleted ${path ?? 'files'}`,
+            };
+        case 'mkdir':
+            return {
+                kind: 'edits',
+                key: `${type}:${path ?? 'workspace'}`,
+                line: `Created ${path ?? 'files'}`,
+            };
+        default:
+            return null;
+    }
+}
+export function compactPath(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return null;
+    }
+    return value.replace(/^\.\//, '');
+}
+export function renderShellCommand(command) {
+    if (command.length >= 3 && (command[0] === '/bin/zsh' || command[0] === 'zsh') && command[1] === '-lc') {
+        return command[2] ?? command.join(' ');
+    }
+    return command.join(' ');
+}
+export function truncateInline(value, limit) {
+    if (value.length <= limit) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, limit - 1))}…`;
+}
+export function extractLatestPlanMarkdown(active) {
+    const segmentPlan = extractLatestPlanSegmentMarkdown(active);
+    if (segmentPlan) {
+        return segmentPlan;
+    }
+    return extractLatestProposedPlanMarkdown(active);
+}
+export function extractLatestPlanSegmentMarkdown(active) {
+    for (let index = active.segments.length - 1; index >= 0; index -= 1) {
+        const segment = active.segments[index];
+        if (!segment.isPlan) {
+            continue;
+        }
+        const text = segment.text.trim();
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+export function extractLatestProposedPlanMarkdown(active) {
+    return extractLatestProposedPlanBlock([
+        active.finalText,
+        active.buffer,
+        ...active.segments.map(segment => segment.text),
+    ].filter((text) => typeof text === 'string' && text.length > 0).join('\n'));
+}
+export function extractLatestProposedPlanBlock(text) {
+    const pattern = /<proposed_plan\b[^>]*>([\s\S]*?)<\/proposed_plan>/gi;
+    let latest = null;
+    for (let match = pattern.exec(text); match !== null; match = pattern.exec(text)) {
+        const plan = match[1]?.trim();
+        if (plan) {
+            latest = plan;
+        }
+    }
+    return latest;
+}

package/dist/core/access.d.ts

@@ -0,0 +1,11 @@
+import type { AppConfig } from '../config.js';
+import type { AccessPresetValue, ApprovalPolicyValue, ChatSessionSettings, SandboxModeValue } from '../types.js';
+export interface ResolvedAccessMode {
+    preset: AccessPresetValue;
+    approvalPolicy: ApprovalPolicyValue;
+    sandboxMode: SandboxModeValue;
+}
+export declare const ACCESS_PRESETS: AccessPresetValue[];
+export declare function normalizeAccessPreset(value: string | null | undefined): AccessPresetValue | null;
+export declare function resolveConfiguredAccessPreset(settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): AccessPresetValue;
+export declare function resolveAccessMode(config: Pick<AppConfig, 'defaultApprovalPolicy' | 'defaultSandboxMode'>, settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): ResolvedAccessMode;

package/dist/core/access.js

@@ -0,0 +1,33 @@
+export const ACCESS_PRESETS = ['read-only', 'default', 'full-access'];
+export function normalizeAccessPreset(value) {
+    if (value === 'read-only' || value === 'default' || value === 'full-access') {
+        return value;
+    }
+    return null;
+}
+export function resolveConfiguredAccessPreset(settings) {
+    return settings?.accessPreset ?? 'default';
+}
+export function resolveAccessMode(config, settings) {
+    const preset = resolveConfiguredAccessPreset(settings);
+    switch (preset) {
+        case 'read-only':
+            return {
+                preset,
+                approvalPolicy: 'on-request',
+                sandboxMode: 'read-only',
+            };
+        case 'full-access':
+            return {
+                preset,
+                approvalPolicy: 'never',
+                sandboxMode: 'danger-full-access',
+            };
+        default:
+            return {
+                preset: 'default',
+                approvalPolicy: config.defaultApprovalPolicy,
+                sandboxMode: config.defaultSandboxMode,
+            };
+    }
+}

package/dist/core/attachment_files.d.ts

@@ -0,0 +1,13 @@
+export declare const ATTACHMENT_INBOX_DIR = ".telegram-inbox";
+export declare const DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES: number;
+import type { InboundAttachment, StagedAttachment } from './attachment_types.js';
+interface PlannedAttachmentPath {
+    fileName: string;
+    localPath: string;
+    relativePath: string;
+}
+export declare function isNativeImageAttachment(attachment: InboundAttachment): boolean;
+export declare function planAttachmentStoragePath(cwd: string, threadId: string, attachment: InboundAttachment, remoteFilePath?: string | null, now?: Date): PlannedAttachmentPath;
+export declare function buildAttachmentPrompt(userText: string, attachments: readonly StagedAttachment[]): string;
+export declare function summarizeInput(text: string, attachments: readonly InboundAttachment[]): string;
+export {};

package/dist/core/attachment_files.js

@@ -0,0 +1,180 @@
+import path from 'node:path';
+export const ATTACHMENT_INBOX_DIR = '.telegram-inbox';
+export const DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES = 20 * 1024 * 1024;
+const FALLBACK_EXTENSION_BY_KIND = {
+    photo: '.jpg',
+    document: '',
+    audio: '.mp3',
+    voice: '.ogg',
+    video: '.mp4',
+    animation: '.mp4',
+    sticker: '.webp',
+    videoNote: '.mp4',
+};
+const MIME_EXTENSION_MAP = {
+    'application/gzip': '.gz',
+    'application/json': '.json',
+    'application/pdf': '.pdf',
+    'application/zip': '.zip',
+    'audio/mpeg': '.mp3',
+    'audio/mp4': '.m4a',
+    'audio/ogg': '.ogg',
+    'audio/wav': '.wav',
+    'image/gif': '.gif',
+    'image/jpeg': '.jpg',
+    'image/png': '.png',
+    'image/webp': '.webp',
+    'text/csv': '.csv',
+    'text/html': '.html',
+    'text/markdown': '.md',
+    'text/plain': '.txt',
+    'video/mp4': '.mp4',
+    'video/quicktime': '.mov',
+};
+export function isNativeImageAttachment(attachment) {
+    if (attachment.kind === 'photo') {
+        return true;
+    }
+    if (attachment.kind === 'sticker') {
+        return !attachment.isAnimated && !attachment.isVideo;
+    }
+    if (attachment.kind !== 'document') {
+        return false;
+    }
+    const lowerMime = attachment.mimeType?.toLowerCase() ?? '';
+    if (lowerMime === 'image/jpeg' || lowerMime === 'image/png' || lowerMime === 'image/webp' || lowerMime === 'image/gif') {
+        return true;
+    }
+    const extension = extensionFromName(attachment.fileName);
+    return extension === '.jpg' || extension === '.jpeg' || extension === '.png' || extension === '.webp' || extension === '.gif';
+}
+export function planAttachmentStoragePath(cwd, threadId, attachment, remoteFilePath, now = new Date()) {
+    const dateSegment = now.toISOString().slice(0, 10);
+    const threadSegment = sanitizePathSegment(threadId);
+    const timestamp = now.toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
+    const resolvedFileName = resolveAttachmentFileName(attachment, remoteFilePath);
+    const uniquePrefix = `${timestamp}-${sanitizePathSegment(attachment.fileUniqueId).slice(0, 16)}`;
+    const joinedName = truncateFileName(`${uniquePrefix}-${resolvedFileName}`, 160);
+    const relativePath = path.join(ATTACHMENT_INBOX_DIR, dateSegment, threadSegment, joinedName);
+    return {
+        fileName: resolvedFileName,
+        localPath: path.resolve(cwd, relativePath),
+        relativePath,
+    };
+}
+export function buildAttachmentPrompt(userText, attachments) {
+    const normalizedText = userText.trim();
+    const lines = [];
+    if (normalizedText) {
+        lines.push(normalizedText, '');
+    }
+    else {
+        lines.push('User sent attachments without a caption.', '');
+    }
+    lines.push('Attachments:');
+    attachments.forEach((attachment, index) => {
+        lines.push(`${index + 1}. ${describeAttachment(attachment)}`);
+        lines.push(`   filename: ${attachment.fileName}`);
+        lines.push(`   path: ${attachment.localPath}`);
+        if (attachment.mimeType)
+            lines.push(`   mime: ${attachment.mimeType}`);
+        if (attachment.fileSize !== null)
+            lines.push(`   size_bytes: ${attachment.fileSize}`);
+        if (attachment.width !== null && attachment.height !== null) {
+            lines.push(`   dimensions: ${attachment.width}x${attachment.height}`);
+        }
+        if (attachment.durationSeconds !== null) {
+            lines.push(`   duration_seconds: ${attachment.durationSeconds}`);
+        }
+        if (attachment.nativeImage) {
+            lines.push('   attached_as: localImage');
+        }
+    });
+    lines.push('', 'Use the local file paths above when you inspect these attachments.');
+    return lines.join('\n');
+}
+export function summarizeInput(text, attachments) {
+    const lines = [];
+    const normalizedText = text.trim();
+    if (normalizedText) {
+        lines.push(normalizedText);
+    }
+    if (attachments.length > 0) {
+        lines.push(`[attachments: ${attachments.map((attachment) => `${attachment.kind}:${attachment.fileName ?? attachment.fileUniqueId}`).join(', ')}]`);
+    }
+    return truncateSummary(lines.join(' '), 500);
+}
+function resolveAttachmentFileName(attachment, remoteFilePath) {
+    const providedName = attachment.fileName ? path.basename(attachment.fileName) : '';
+    const remoteName = remoteFilePath ? path.basename(remoteFilePath) : '';
+    const baseCandidate = providedName || remoteName || `${attachment.kind}-${attachment.fileUniqueId}`;
+    const sanitizedBase = sanitizeFileName(baseCandidate);
+    const extension = extensionFromName(sanitizedBase)
+        || extensionFromName(remoteName)
+        || extensionFromMimeType(attachment.mimeType)
+        || fallbackExtensionByKind(attachment.kind);
+    if (!extension) {
+        return sanitizedBase;
+    }
+    const withoutExtension = sanitizedBase.slice(0, sanitizedBase.length - extensionFromName(sanitizedBase).length) || `${attachment.kind}-${attachment.fileUniqueId}`;
+    return truncateFileName(`${withoutExtension}${extension}`, 120);
+}
+function describeAttachment(attachment) {
+    switch (attachment.kind) {
+        case 'photo':
+            return 'photo';
+        case 'document':
+            return 'document';
+        case 'audio':
+            return 'audio file';
+        case 'voice':
+            return 'voice message';
+        case 'video':
+            return 'video';
+        case 'animation':
+            return 'animation';
+        case 'sticker':
+            return attachment.isAnimated || attachment.isVideo ? 'animated sticker' : 'sticker';
+        case 'videoNote':
+            return 'video note';
+    }
+}
+function sanitizeFileName(fileName) {
+    const trimmed = fileName.trim().replace(/[\\/]+/g, '-');
+    const sanitized = trimmed
+        .replace(/[^\w.\-()+@]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^\.+/, '')
+        .replace(/^-+/, '')
+        .replace(/[.-]+$/, '');
+    return sanitized || 'attachment';
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[^\w.-]+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '') || 'thread';
+}
+function extensionFromMimeType(mimeType) {
+    if (!mimeType)
+        return '';
+    return MIME_EXTENSION_MAP[mimeType.toLowerCase()] ?? '';
+}
+function extensionFromName(fileName) {
+    if (!fileName)
+        return '';
+    const extension = path.extname(fileName).toLowerCase();
+    return extension === '.' ? '' : extension;
+}
+function truncateFileName(fileName, maxLength) {
+    if (fileName.length <= maxLength)
+        return fileName;
+    const extension = extensionFromName(fileName);
+    const base = extension ? fileName.slice(0, -extension.length) : fileName;
+    return `${base.slice(0, Math.max(1, maxLength - extension.length))}${extension}`;
+}
+function truncateSummary(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength - 3)}...`;
+}
+function fallbackExtensionByKind(kind) {
+    return FALLBACK_EXTENSION_BY_KIND[kind] ?? '';
+}

package/dist/core/attachment_types.d.ts

@@ -0,0 +1,22 @@
+export type AttachmentKind = 'photo' | 'document' | 'audio' | 'voice' | 'video' | 'animation' | 'sticker' | 'videoNote';
+export interface InboundAttachment {
+    kind: AttachmentKind;
+    fileId: string;
+    fileUniqueId: string;
+    fileName: string | null;
+    mimeType: string | null;
+    fileSize: number | null;
+    width: number | null;
+    height: number | null;
+    durationSeconds: number | null;
+    isAnimated: boolean;
+    isVideo: boolean;
+    /** When set, {@link stageAttachments} copies this file instead of Telegram Bot API download. */
+    localPath?: string;
+}
+export interface StagedAttachment extends InboundAttachment {
+    fileName: string;
+    localPath: string;
+    relativePath: string;
+    nativeImage: boolean;
+}

package/dist/core/attachment_types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/attachments.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../logger.js';
-import { type StagedTelegramAttachment, type TelegramInboundAttachment } from '../telegram/media.js';
-export interface TelegramFileDownloader {
+import type { StagedAttachment, InboundAttachment } from './attachment_types.js';
+export interface AttachmentDownloader {
     getFile(fileId: string): Promise<{
         file_id: string;
         file_path?: string;
@@ -8,4 +8,6 @@ export interface TelegramFileDownloader {
     }>;
     downloadResolvedFile(filePath: string, destination: string): Promise<unknown>;
 }
-export declare function stageInboundAttachments(downloader: TelegramFileDownloader, cwd: string, threadId: string, attachments: readonly TelegramInboundAttachment[], logger?: Logger): Promise<StagedTelegramAttachment[]>;
+export declare function stageInboundAttachments(downloader: AttachmentDownloader, cwd: string, threadId: string, attachments: readonly InboundAttachment[], logger?: Logger): Promise<StagedAttachment[]>;
+/** Compatibility for existing attachment clients. */
+export type TelegramFileDownloader = AttachmentDownloader;

package/dist/core/attachments.js

@@ -1,6 +1,6 @@
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
-import { planAttachmentStoragePath, isNativeImageAttachment, TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, } from '../telegram/media.js';
+import { planAttachmentStoragePath, isNativeImageAttachment, DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES, } from './attachment_files.js';
 export async function stageInboundAttachments(downloader, cwd, threadId, attachments, logger) {
     const staged = [];
     for (const attachment of attachments) {
@@ -23,7 +23,7 @@ export async function stageInboundAttachments(downloader, cwd, threadId, attachm
             }
             const remoteFile = await downloader.getFile(attachment.fileId);
             const resolvedSize = attachment.fileSize ?? remoteFile.file_size ?? null;
-            if (resolvedSize !== null && resolvedSize > TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES) {
+            if (resolvedSize !== null && resolvedSize > DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES) {
                 logger?.warn('attachments.too_large', {
                     fileId: attachment.fileId,
                     size: resolvedSize,

package/dist/core/backend_registry.d.ts

@@ -0,0 +1,22 @@
+import type { BackendDescriptor } from './engine_spi.js';
+import type { BackendUi, BackendUiHost } from './backend_ui.js';
+/** Owns backend definitions and their panel lifecycle. Discovery may refresh metadata, never execution identity. */
+export declare class BackendRegistry {
+    private readonly host;
+    private readonly entries;
+    private stopping;
+    private readonly interfaces;
+    constructor(host: BackendUiHost);
+    register(backend: BackendDescriptor): void;
+    set(id: string, backend: BackendDescriptor): void;
+    has(id: string): boolean;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<BackendDescriptor>;
+    get(id: string): BackendDescriptor | undefined;
+    list(): BackendDescriptor[];
+    ui(id: string): BackendUi | undefined;
+    callbackOwner(data: string): BackendUi | undefined;
+    getPendingApprovals(): number;
+    stop(): Promise<void>;
+    private stopInterfaces;
+}

package/dist/core/backend_registry.js

@@ -0,0 +1,50 @@
+/** Owns backend definitions and their panel lifecycle. Discovery may refresh metadata, never execution identity. */
+export class BackendRegistry {
+    host;
+    entries = new Map();
+    stopping;
+    interfaces = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    register(backend) {
+        if (this.stopping)
+            throw new Error('Backend registry is stopped');
+        if (!backend.id)
+            throw new Error('Backend id is required');
+        const existing = this.entries.get(backend.id);
+        if (existing && (existing.adapter !== backend.adapter || (backend.createUi !== undefined && existing.createUi !== backend.createUi))) {
+            throw new Error(`Backend '${backend.id}' is already registered with a different runtime`);
+        }
+        const ui = !existing ? backend.createUi?.(this.host) : undefined;
+        this.entries.set(backend.id, { ...existing, ...backend });
+        if (ui)
+            this.interfaces.set(backend.id, ui);
+    }
+    set(id, backend) {
+        if (id !== backend.id)
+            throw new Error('Backend registry key must match its id');
+        this.register(backend);
+    }
+    has(id) { return this.entries.has(id); }
+    keys() { return this.entries.keys(); }
+    values() { return this.entries.values(); }
+    get(id) { return this.entries.get(id); }
+    list() { return [...this.entries.values()]; }
+    ui(id) { return this.interfaces.get(id); }
+    callbackOwner(data) {
+        return [...this.interfaces.values()].find(ui => ui.ownsCallback?.(data));
+    }
+    getPendingApprovals() {
+        return [...this.interfaces.values()].reduce((sum, ui) => sum + (ui.getPendingApprovals?.() ?? 0), 0);
+    }
+    stop() {
+        return this.stopping ??= this.stopInterfaces();
+    }
+    async stopInterfaces() {
+        const results = await Promise.allSettled([...this.interfaces.values()].map(ui => ui.stop?.()));
+        const failure = results.find(result => result.status === 'rejected');
+        if (failure?.status === 'rejected')
+            throw failure.reason;
+    }
+}