@llblab/pi-telegram 0.46.0 → 0.47.0

package/dist/lib/model.js

@@ -0,0 +1,409 @@
+/**
+ * Telegram model control domain helpers
+ * Zones: pi agent model control, telegram controls, queue continuation
+ * Owns model identity, thinking levels, scoped resolution, current-model state, and in-flight model switching
+ */
+import { TELEGRAM_PREFIX } from "./turns.js";
+export const THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+export function createCurrentModelStore(getContextModel) {
+    let currentModel;
+    return {
+        get: (ctx) => currentModel ?? getContextModel(ctx),
+        getStored: () => currentModel,
+        set: (model) => {
+            currentModel = model;
+        },
+    };
+}
+export function createCurrentModelUpdateRuntime(deps) {
+    const setAndUpdate = (model, ctx) => {
+        deps.setCurrentModel(model);
+        deps.updateStatus(ctx);
+    };
+    return {
+        setCurrentModel: setAndUpdate,
+        onModelSelect: (event, ctx) => {
+            setAndUpdate(event.model, ctx);
+        },
+    };
+}
+export function createCurrentModelRuntime(deps) {
+    const store = createCurrentModelStore(deps.getContextModel);
+    return {
+        ...store,
+        ...createCurrentModelUpdateRuntime({
+            setCurrentModel: store.set,
+            updateStatus: deps.updateStatus,
+        }),
+    };
+}
+export function modelsMatch(a, b) {
+    return !!a && !!b && a.provider === b.provider && a.id === b.id;
+}
+export function getCanonicalModelId(model) {
+    return `${model.provider}/${model.id}`;
+}
+export function isThinkingLevel(value) {
+    return THINKING_LEVELS.includes(value);
+}
+export function parseTelegramScopedModelPatternList(value) {
+    return value
+        .split(",")
+        .map((pattern) => pattern.trim())
+        .filter(Boolean);
+}
+export function parseTelegramCliScopedModelPatterns(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--models") {
+            const patterns = parseTelegramScopedModelPatternList(args[i + 1] ?? "");
+            return patterns.length > 0 ? patterns : undefined;
+        }
+        if (arg.startsWith("--models=")) {
+            const patterns = parseTelegramScopedModelPatternList(arg.slice("--models=".length));
+            return patterns.length > 0 ? patterns : undefined;
+        }
+    }
+    return undefined;
+}
+function escapeRegex(text) {
+    return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globMatches(text, pattern) {
+    let regex = "^";
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (char === "*") {
+            regex += ".*";
+            continue;
+        }
+        if (char === "?") {
+            regex += ".";
+            continue;
+        }
+        if (char === "[") {
+            const end = pattern.indexOf("]", i + 1);
+            if (end !== -1) {
+                const content = pattern.slice(i + 1, end);
+                regex += content.startsWith("!")
+                    ? `[^${content.slice(1)}]`
+                    : `[${content}]`;
+                i = end;
+                continue;
+            }
+        }
+        regex += escapeRegex(char);
+    }
+    regex += "$";
+    return new RegExp(regex, "i").test(text);
+}
+function isAliasModelId(id) {
+    if (id.endsWith("-latest"))
+        return true;
+    return !/-\d{8}$/.test(id);
+}
+function findUniqueModelMatch(availableModels, matches) {
+    let model;
+    for (const candidate of availableModels) {
+        if (!matches(candidate))
+            continue;
+        if (model)
+            return { ambiguous: true };
+        model = candidate;
+    }
+    return { model, ambiguous: false };
+}
+function findExactModelReferenceMatch(modelReference, availableModels) {
+    const trimmedReference = modelReference.trim();
+    if (!trimmedReference)
+        return undefined;
+    const normalizedReference = trimmedReference.toLowerCase();
+    const canonicalMatch = findUniqueModelMatch(availableModels, (model) => getCanonicalModelId(model).toLowerCase() === normalizedReference);
+    if (canonicalMatch.model || canonicalMatch.ambiguous) {
+        return canonicalMatch.model;
+    }
+    const slashIndex = trimmedReference.indexOf("/");
+    if (slashIndex !== -1) {
+        const provider = trimmedReference.substring(0, slashIndex).trim();
+        const modelId = trimmedReference.substring(slashIndex + 1).trim();
+        if (provider && modelId) {
+            const normalizedProvider = provider.toLowerCase();
+            const normalizedModelId = modelId.toLowerCase();
+            const providerMatch = findUniqueModelMatch(availableModels, (model) => model.provider.toLowerCase() === normalizedProvider &&
+                model.id.toLowerCase() === normalizedModelId);
+            if (providerMatch.model || providerMatch.ambiguous) {
+                return providerMatch.model;
+            }
+        }
+    }
+    return findUniqueModelMatch(availableModels, (model) => model.id.toLowerCase() === normalizedReference).model;
+}
+function tryMatchScopedModel(modelPattern, availableModels) {
+    const exactMatch = findExactModelReferenceMatch(modelPattern, availableModels);
+    if (exactMatch)
+        return exactMatch;
+    const normalizedPattern = modelPattern.toLowerCase();
+    let bestAlias;
+    let bestDatedVersion;
+    for (const model of availableModels) {
+        if (!model.id.toLowerCase().includes(normalizedPattern) &&
+            !model.name?.toLowerCase().includes(normalizedPattern)) {
+            continue;
+        }
+        if (isAliasModelId(model.id)) {
+            if (!bestAlias || model.id.localeCompare(bestAlias.id) > 0) {
+                bestAlias = model;
+            }
+        }
+        else if (!bestDatedVersion ||
+            model.id.localeCompare(bestDatedVersion.id) > 0) {
+            bestDatedVersion = model;
+        }
+    }
+    return bestAlias ?? bestDatedVersion;
+}
+function parseScopedModelPattern(pattern, availableModels) {
+    const exactMatch = tryMatchScopedModel(pattern, availableModels);
+    if (exactMatch) {
+        return { model: exactMatch, thinkingLevel: undefined };
+    }
+    const lastColonIndex = pattern.lastIndexOf(":");
+    if (lastColonIndex === -1) {
+        return { model: undefined, thinkingLevel: undefined };
+    }
+    const prefix = pattern.substring(0, lastColonIndex);
+    const suffix = pattern.substring(lastColonIndex + 1);
+    if (isThinkingLevel(suffix)) {
+        const parsedPrefix = parseScopedModelPattern(prefix, availableModels);
+        if (parsedPrefix.model) {
+            return { model: parsedPrefix.model, thinkingLevel: suffix };
+        }
+        return parsedPrefix;
+    }
+    return parseScopedModelPattern(prefix, availableModels);
+}
+export function resolveScopedModelPatterns(patterns, availableModels) {
+    const resolved = [];
+    const seen = new Set();
+    for (const pattern of patterns) {
+        if (pattern.includes("*") ||
+            pattern.includes("?") ||
+            pattern.includes("[")) {
+            const colonIndex = pattern.lastIndexOf(":");
+            let globPattern = pattern;
+            let thinkingLevel;
+            if (colonIndex !== -1) {
+                const suffix = pattern.substring(colonIndex + 1);
+                if (isThinkingLevel(suffix)) {
+                    thinkingLevel = suffix;
+                    globPattern = pattern.substring(0, colonIndex);
+                }
+            }
+            const matches = availableModels.filter((model) => globMatches(getCanonicalModelId(model), globPattern) ||
+                globMatches(model.id, globPattern));
+            for (const model of matches) {
+                const key = getCanonicalModelId(model);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                resolved.push({ model, thinkingLevel });
+            }
+            continue;
+        }
+        const matched = parseScopedModelPattern(pattern, availableModels);
+        if (!matched.model)
+            continue;
+        const key = getCanonicalModelId(matched.model);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        resolved.push({
+            model: matched.model,
+            thinkingLevel: matched.thinkingLevel,
+        });
+    }
+    return resolved;
+}
+export function sortScopedModels(models, currentModel) {
+    const sorted = [...models];
+    sorted.sort((a, b) => {
+        const aIsCurrent = modelsMatch(a.model, currentModel);
+        const bIsCurrent = modelsMatch(b.model, currentModel);
+        if (aIsCurrent && !bIsCurrent)
+            return -1;
+        if (!aIsCurrent && bIsCurrent)
+            return 1;
+        const providerCompare = a.model.provider.localeCompare(b.model.provider);
+        if (providerCompare !== 0)
+            return providerCompare;
+        return a.model.id.localeCompare(b.model.id);
+    });
+    return sorted;
+}
+export function createPendingModelSwitchStore() {
+    let selection;
+    return {
+        get: () => selection,
+        set: (nextSelection) => {
+            selection = nextSelection;
+        },
+        clear: () => {
+            selection = undefined;
+        },
+        has: () => selection !== undefined,
+    };
+}
+export function canRestartTelegramTurnForModelSwitch(state) {
+    return !state.isIdle && state.hasActiveTelegramTurn && state.hasAbortHandler;
+}
+export function shouldTriggerPendingTelegramModelSwitchAbort(state) {
+    return (state.hasPendingModelSwitch &&
+        state.hasActiveTelegramTurn &&
+        state.hasAbortHandler &&
+        state.activeToolExecutions === 0);
+}
+export function restartTelegramModelSwitchContinuation(state) {
+    if (!state.activeTurn || !state.abort)
+        return false;
+    state.queueContinuation(state.activeTurn, state.selection);
+    state.abort();
+    return true;
+}
+function truncateTelegramModelSwitchStatusSummary(text, maxWords = 4, maxLength = 32) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "";
+    const words = normalized.split(" ");
+    let summary = words.slice(0, maxWords).join(" ");
+    if (summary.length === 0)
+        summary = normalized;
+    if (summary.length > maxLength) {
+        summary = summary.slice(0, maxLength).trimEnd();
+    }
+    return summary.length < normalized.length || words.length > maxWords
+        ? `${summary}…`
+        : summary;
+}
+export function buildTelegramModelSwitchContinuationText(telegramPrefix, model, thinkingLevel) {
+    const modelLabel = `${model.provider}/${model.id}`;
+    const thinkingSuffix = thinkingLevel
+        ? ` Keep the selected thinking level (${thinkingLevel}) if it still applies.`
+        : "";
+    return `${telegramPrefix} Continue the interrupted previous Telegram request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
+}
+export function buildTelegramModelSwitchContinuationTurn(options) {
+    const modelLabel = `${options.selection.model.provider}/${options.selection.model.id}`;
+    const statusLabel = truncateTelegramModelSwitchStatusSummary(`continue on ${options.selection.model.id}`);
+    return {
+        kind: "prompt",
+        chatId: options.turn.chatId,
+        ...(options.turn.target ? { target: { ...options.turn.target } } : {}),
+        replyToMessageId: options.turn.replyToMessageId,
+        sourceMessageIds: [],
+        queueOrder: options.queueOrder,
+        queueLane: "control",
+        laneOrder: options.laneOrder,
+        queuedAttachments: [],
+        content: [
+            {
+                type: "text",
+                text: buildTelegramModelSwitchContinuationText(options.telegramPrefix ?? TELEGRAM_PREFIX, options.selection.model, options.selection.thinkingLevel),
+            },
+        ],
+        historyText: `Continue interrupted Telegram request on ${modelLabel}`,
+        statusSummary: `↻ ${statusLabel || "continue"}`,
+    };
+}
+export function createTelegramModelSwitchContinuationTurnBuilder(deps) {
+    return (options) => buildTelegramModelSwitchContinuationTurn({
+        ...options,
+        telegramPrefix: deps.telegramPrefix,
+        queueOrder: deps.allocateItemOrder(),
+        laneOrder: deps.allocateControlOrder(),
+    });
+}
+export function createTelegramModelSwitchContinuationQueue(deps) {
+    return (turn, selection, ctx) => {
+        deps.appendQueuedItem(deps.createContinuationTurn({ turn, selection }), ctx);
+    };
+}
+export function createTelegramModelSwitchContinuationQueueRuntime(deps) {
+    return createTelegramModelSwitchContinuationQueue({
+        createContinuationTurn: createTelegramModelSwitchContinuationTurnBuilder({
+            telegramPrefix: deps.telegramPrefix,
+            allocateItemOrder: deps.allocateItemOrder,
+            allocateControlOrder: deps.allocateControlOrder,
+        }),
+        appendQueuedItem: deps.appendQueuedItem,
+    });
+}
+export function createTelegramModelSwitchControllerRuntime(deps) {
+    return createTelegramModelSwitchController({
+        isIdle: deps.isIdle,
+        getPendingModelSwitch: deps.getPendingModelSwitch,
+        setPendingModelSwitch: deps.setPendingModelSwitch,
+        getActiveTurn: deps.getActiveTurn,
+        getAbortHandler: deps.getAbortHandler,
+        hasAbortHandler: deps.hasAbortHandler,
+        getActiveToolExecutions: deps.getActiveToolExecutions,
+        queueContinuation: createTelegramModelSwitchContinuationQueueRuntime({
+            telegramPrefix: deps.telegramPrefix,
+            allocateItemOrder: deps.allocateItemOrder,
+            allocateControlOrder: deps.allocateControlOrder,
+            appendQueuedItem: deps.appendQueuedItem,
+        }),
+        updateStatus: deps.updateStatus,
+    });
+}
+export function createTelegramModelSwitchController(deps) {
+    return {
+        canOfferInFlightSwitch: (ctx) => canRestartTelegramTurnForModelSwitch({
+            isIdle: deps.isIdle(ctx),
+            hasActiveTelegramTurn: !!deps.getActiveTurn(),
+            hasAbortHandler: deps.hasAbortHandler(),
+        }),
+        stagePendingSwitch: (selection, ctx) => {
+            deps.setPendingModelSwitch(selection);
+            deps.updateStatus(ctx);
+        },
+        clearPendingSwitch: () => {
+            deps.setPendingModelSwitch(undefined);
+        },
+        queueContinuation: deps.queueContinuation,
+        triggerPendingAbort: (ctx) => {
+            if (!shouldTriggerPendingTelegramModelSwitchAbort({
+                hasPendingModelSwitch: !!deps.getPendingModelSwitch(),
+                hasActiveTelegramTurn: !!deps.getActiveTurn(),
+                hasAbortHandler: deps.hasAbortHandler(),
+                activeToolExecutions: deps.getActiveToolExecutions(),
+            })) {
+                return false;
+            }
+            const selection = deps.getPendingModelSwitch();
+            const turn = deps.getActiveTurn();
+            const abort = deps.getAbortHandler();
+            if (!selection || !turn || !abort)
+                return false;
+            deps.setPendingModelSwitch(undefined);
+            deps.queueContinuation(turn, selection, ctx);
+            abort();
+            return true;
+        },
+        restartInterruptedTurn: (selection, ctx) => restartTelegramModelSwitchContinuation({
+            activeTurn: deps.getActiveTurn(),
+            abort: deps.getAbortHandler(),
+            selection,
+            queueContinuation: (turn, nextSelection) => {
+                deps.queueContinuation(turn, nextSelection, ctx);
+            },
+        }),
+    };
+}

package/dist/lib/outbound-attachments.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Telegram outbound attachment helpers
+ * Zones: telegram outbound, pi agent tool, filesystem
+ * Owns telegram_attach registration, outbound attachment queueing, and delivery so Telegram file output stays in one domain module
+ */
+import type { TelegramBusAgentMessage, TelegramBusAgentTargetSelector } from "./bus.ts";
+import type { ExtensionAPI } from "./pi.ts";
+import { type TelegramTarget } from "./target.ts";
+export declare const TELEGRAM_OUTBOUND_ATTACHMENT_DEFAULT_MAX_BYTES: number;
+export declare function getTelegramOutboundAttachmentByteLimitFromEnv(env: NodeJS.ProcessEnv, names: string[], defaultValue?: number): number;
+export declare const TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES: number;
+export interface TelegramOutboundAttachmentToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: {
+        paths: string[];
+    };
+}
+export interface TelegramOutboundAttachmentRuntimeEventRecorderPort {
+    recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
+}
+export interface TelegramOutboundAttachmentToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
+    maxAttachmentsPerTurn?: number;
+    maxAttachmentSizeBytes?: number;
+    getActiveTurn: () => TelegramOutboundAttachmentQueueTargetView | undefined;
+    getDefaultChatId?: () => number | undefined;
+    getDefaultTarget?: () => TelegramTarget | undefined;
+    canSendDirect?: () => boolean;
+    sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+    statPath?: (path: string) => Promise<{
+        isFile(): boolean;
+        size?: number;
+    }>;
+}
+export interface TelegramOutboundMessagePlan {
+    markdown: string;
+    replyMarkup?: unknown;
+}
+export interface TelegramOutboundMessageToolRegistrationDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
+    getDefaultChatId: () => number | undefined;
+    getDefaultTarget?: () => TelegramTarget | undefined;
+    getActiveTurn?: () => {
+        chatId: number;
+        target?: TelegramTarget;
+    } | undefined;
+    resolveAgentTarget?: (selector: TelegramBusAgentTargetSelector) => Promise<TelegramTarget & {
+        threadId: number;
+    }>;
+    routeAgentMessage?: (message: TelegramBusAgentMessage) => Promise<void>;
+    canSendDirect: () => boolean;
+    planMessage: (markdown: string) => TelegramOutboundMessagePlan;
+    sendMarkdownMessage: (chatId: number, markdown: string, options?: {
+        replyMarkup?: unknown;
+        target?: TelegramTarget;
+    }) => Promise<number | undefined>;
+    sendChannelMarkdownMessage?: (channel: number | string, markdown: string, options: {
+        operationId: string;
+        replyMarkup?: unknown;
+    }) => Promise<number | undefined>;
+    sendChannelMediaMessage?: (channel: number | string, mediaPath: string, markdown: string, options: {
+        operationId: string;
+        replyMarkup?: unknown;
+    }) => Promise<number | undefined>;
+}
+export interface TelegramQueuedOutboundAttachmentView {
+    path: string;
+    fileName: string;
+}
+export interface TelegramOutboundAttachmentQueueTargetView {
+    queuedAttachments: TelegramQueuedOutboundAttachmentView[];
+    guestQueryId?: string;
+}
+export interface TelegramQueuedOutboundAttachmentTurnView extends TelegramOutboundAttachmentQueueTargetView {
+    chatId: number;
+    replyToMessageId: number;
+    target?: TelegramTarget;
+}
+export interface TelegramRichOutboundAttachmentPlan {
+    method: "sendRichMessage";
+    fields: Record<string, string>;
+    fileField: "rich_media_upload";
+    filePath: string;
+    fileName: string;
+}
+export interface TelegramRichOutboundAttachmentSenderDeps extends TelegramOutboundAttachmentRuntimeEventRecorderPort {
+    sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+    getRenderingMode: () => "rich" | "html";
+    recordOwnership?: (input: {
+        chatId: number;
+        messageId: number;
+        target?: TelegramTarget;
+    }) => void;
+}
+export declare function planTelegramRichOutboundAttachment(options: {
+    turn: TelegramQueuedOutboundAttachmentTurnView;
+    markdown: string;
+    renderingMode: "rich" | "html";
+    replyMarkup?: unknown;
+}): TelegramRichOutboundAttachmentPlan | undefined;
+export declare function createTelegramRichOutboundAttachmentSender(deps: TelegramRichOutboundAttachmentSenderDeps): (turn: TelegramQueuedOutboundAttachmentTurnView, markdown: string, options?: {
+    replyMarkup?: unknown;
+    isDeliveryActive?: () => boolean;
+}) => Promise<boolean>;
+export type TelegramGuestCachedAttachmentResult = {
+    type: "document";
+    id: string;
+    title: string;
+    document_file_id: string;
+    caption?: string;
+} | {
+    type: "photo";
+    id: string;
+    photo_file_id: string;
+    caption?: string;
+} | {
+    type: "audio";
+    id: string;
+    audio_file_id: string;
+    caption?: string;
+} | {
+    type: "voice";
+    id: string;
+    voice_file_id: string;
+    title: string;
+    caption?: string;
+};
+export declare function registerTelegramOutboundAttachmentTool(pi: ExtensionAPI, deps: TelegramOutboundAttachmentToolRegistrationDeps): void;
+export declare function registerTelegramOutboundMessageTool(pi: ExtensionAPI, deps: TelegramOutboundMessageToolRegistrationDeps): void;
+export interface TelegramQueuedOutboundAttachmentDeliveryDeps {
+    sendMultipart: (method: string, fields: Record<string, string>, fileField: string, filePath: string, fileName: string) => Promise<unknown>;
+    sendTextReply: (chatId: number, replyToMessageId: number, text: string, options?: {
+        target?: TelegramTarget;
+    }) => Promise<unknown>;
+    recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
+    statPath?: (path: string) => Promise<{
+        size: number;
+    }>;
+    maxAttachmentSizeBytes?: number;
+    isDeliveryActive?: () => boolean;
+}
+export declare function queueTelegramOutboundAttachments(options: {
+    activeTurn: TelegramOutboundAttachmentQueueTargetView | undefined;
+    paths: string[];
+    chatId?: number;
+    threadId?: number;
+    caption?: string;
+    maxAttachmentsPerTurn: number;
+    maxAttachmentSizeBytes?: number;
+    sendMultipart?: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+    getDefaultChatId?: () => number | undefined;
+    getDefaultTarget?: () => TelegramTarget | undefined;
+    canSendDirect?: () => boolean;
+    statPath?: (path: string) => Promise<{
+        isFile(): boolean;
+        size?: number;
+    }>;
+}): Promise<TelegramOutboundAttachmentToolResult>;
+export declare function deliverTelegramGuestCachedAttachment(options: {
+    guestQueryId: string;
+    stagingChatId: number;
+    stagingTarget?: TelegramTarget;
+    attachment: TelegramQueuedOutboundAttachmentView;
+    caption?: string;
+    sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+    answerGuestQuery: (guestQueryId: string, result: TelegramGuestCachedAttachmentResult) => Promise<void>;
+    answerGuestText?: (guestQueryId: string, text: string) => Promise<void>;
+    fallbackText?: string;
+    deleteMessage: (chatId: number, messageId: number) => Promise<void>;
+    recordRuntimeEvent?: TelegramOutboundAttachmentRuntimeEventRecorderPort["recordRuntimeEvent"];
+}): Promise<void>;
+export declare function sendTelegramOutboundMessage(options: {
+    text: string;
+    media?: string;
+    operationId?: string;
+    channel?: boolean;
+    chatId?: number | string;
+    threadId?: number;
+    agentThread?: string | number;
+    target?: TelegramTarget;
+    getDefaultChatId?: () => number | undefined;
+    getDefaultTarget?: () => TelegramTarget | undefined;
+    getActiveTurn?: () => {
+        chatId: number;
+        target?: TelegramTarget;
+    } | undefined;
+    resolveAgentTarget?: (selector: TelegramBusAgentTargetSelector) => Promise<TelegramTarget & {
+        threadId: number;
+    }>;
+    routeAgentMessage?: (message: TelegramBusAgentMessage) => Promise<void>;
+    canSendDirect: () => boolean;
+    planMessage: (markdown: string) => TelegramOutboundMessagePlan;
+    sendMarkdownMessage: (chatId: number, markdown: string, options?: {
+        replyMarkup?: unknown;
+        target?: TelegramTarget;
+    }) => Promise<number | undefined>;
+    sendChannelMarkdownMessage?: (channel: number | string, markdown: string, options: {
+        operationId: string;
+        replyMarkup?: unknown;
+    }) => Promise<number | undefined>;
+    sendChannelMediaMessage?: (channel: number | string, mediaPath: string, markdown: string, options: {
+        operationId: string;
+        replyMarkup?: unknown;
+    }) => Promise<number | undefined>;
+}): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: {
+        chatId: number | string;
+        messageId?: number;
+    };
+}>;
+export declare function sendTelegramOutboundFiles(options: {
+    paths: string[];
+    chatId?: number;
+    threadId?: number;
+    target?: TelegramTarget;
+    caption?: string;
+    maxAttachmentsPerTurn: number;
+    maxAttachmentSizeBytes?: number;
+    sendMultipart: TelegramQueuedOutboundAttachmentDeliveryDeps["sendMultipart"];
+    getDefaultChatId?: () => number | undefined;
+    getDefaultTarget?: () => TelegramTarget | undefined;
+    canSendDirect?: () => boolean;
+    statPath?: (path: string) => Promise<{
+        isFile(): boolean;
+        size?: number;
+    }>;
+}): Promise<TelegramOutboundAttachmentToolResult & {
+    details: {
+        paths: string[];
+        chatId: number;
+    };
+}>;
+export declare function createTelegramQueuedOutboundAttachmentSender(deps: TelegramQueuedOutboundAttachmentDeliveryDeps): (turn: TelegramQueuedOutboundAttachmentTurnView, options?: {
+    isDeliveryActive?: () => boolean;
+}) => Promise<void>;
+export declare function sendQueuedTelegramOutboundAttachments(turn: TelegramQueuedOutboundAttachmentTurnView, deps: TelegramQueuedOutboundAttachmentDeliveryDeps): Promise<void>;