openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/telegram/draft-stream.js

@@ -1,318 +0,0 @@
-import { createFinalizableDraftLifecycle } from "../channels/draft-stream-controls.js";
-import { buildTelegramThreadParams } from "./bot/helpers.js";
-const TELEGRAM_STREAM_MAX_CHARS = 4096;
-const DEFAULT_THROTTLE_MS = 1000;
-const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
-const THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
-const DRAFT_METHOD_UNAVAILABLE_RE = /(unknown method|method .*not (found|available|supported)|unsupported)/i;
-const DRAFT_CHAT_UNSUPPORTED_RE = /(can't be used|can be used only)/i;
-let nextDraftId = 0;
-function allocateTelegramDraftId() {
-    nextDraftId = nextDraftId >= TELEGRAM_DRAFT_ID_MAX ? 1 : nextDraftId + 1;
-    return nextDraftId;
-}
-function resolveSendMessageDraftApi(api) {
-    const sendMessageDraft = api
-        .sendMessageDraft;
-    if (typeof sendMessageDraft !== "function") {
-        return undefined;
-    }
-    return sendMessageDraft.bind(api);
-}
-function shouldFallbackFromDraftTransport(err) {
-    const text = typeof err === "string"
-        ? err
-        : err instanceof Error
-            ? err.message
-            : typeof err === "object" && err && "description" in err
-                ? typeof err.description === "string"
-                    ? err.description
-                    : ""
-                : "";
-    if (!/sendMessageDraft/i.test(text)) {
-        return false;
-    }
-    return DRAFT_METHOD_UNAVAILABLE_RE.test(text) || DRAFT_CHAT_UNSUPPORTED_RE.test(text);
-}
-export function createTelegramDraftStream(params) {
-    const maxChars = Math.min(params.maxChars ?? TELEGRAM_STREAM_MAX_CHARS, TELEGRAM_STREAM_MAX_CHARS);
-    const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-    const minInitialChars = params.minInitialChars;
-    const chatId = params.chatId;
-    const requestedPreviewTransport = params.previewTransport ?? "auto";
-    const prefersDraftTransport = requestedPreviewTransport === "draft"
-        ? true
-        : requestedPreviewTransport === "message"
-            ? false
-            : params.thread?.scope === "dm";
-    const threadParams = buildTelegramThreadParams(params.thread);
-    const replyParams = params.replyToMessageId != null
-        ? { ...threadParams, reply_to_message_id: params.replyToMessageId }
-        : threadParams;
-    const resolvedDraftApi = prefersDraftTransport
-        ? resolveSendMessageDraftApi(params.api)
-        : undefined;
-    const usesDraftTransport = Boolean(prefersDraftTransport && resolvedDraftApi);
-    if (prefersDraftTransport && !usesDraftTransport) {
-        params.warn?.("telegram stream preview: sendMessageDraft unavailable; falling back to sendMessage/editMessageText");
-    }
-    const streamState = { stopped: false, final: false };
-    let streamMessageId;
-    let streamDraftId = usesDraftTransport ? allocateTelegramDraftId() : undefined;
-    let previewTransport = usesDraftTransport ? "draft" : "message";
-    let lastSentText = "";
-    let lastDeliveredText = "";
-    let lastSentParseMode;
-    let previewRevision = 0;
-    let generation = 0;
-    const sendRenderedMessageWithThreadFallback = async (sendArgs) => {
-        const sendParams = sendArgs.renderedParseMode
-            ? {
-                ...replyParams,
-                parse_mode: sendArgs.renderedParseMode,
-            }
-            : replyParams;
-        const usedThreadParams = "message_thread_id" in (sendParams ?? {}) &&
-            typeof sendParams.message_thread_id === "number";
-        try {
-            return {
-                sent: await params.api.sendMessage(chatId, sendArgs.renderedText, sendParams),
-                usedThreadParams,
-            };
-        }
-        catch (err) {
-            if (!usedThreadParams || !THREAD_NOT_FOUND_RE.test(String(err))) {
-                throw err;
-            }
-            const threadlessParams = {
-                ...sendParams,
-            };
-            delete threadlessParams.message_thread_id;
-            params.warn?.(sendArgs.fallbackWarnMessage);
-            return {
-                sent: await params.api.sendMessage(chatId, sendArgs.renderedText, Object.keys(threadlessParams).length > 0 ? threadlessParams : undefined),
-                usedThreadParams: false,
-            };
-        }
-    };
-    const sendMessageTransportPreview = async ({ renderedText, renderedParseMode, sendGeneration, }) => {
-        if (typeof streamMessageId === "number") {
-            if (renderedParseMode) {
-                await params.api.editMessageText(chatId, streamMessageId, renderedText, {
-                    parse_mode: renderedParseMode,
-                });
-            }
-            else {
-                await params.api.editMessageText(chatId, streamMessageId, renderedText);
-            }
-            return true;
-        }
-        const { sent } = await sendRenderedMessageWithThreadFallback({
-            renderedText,
-            renderedParseMode,
-            fallbackWarnMessage: "telegram stream preview send failed with message_thread_id, retrying without thread",
-        });
-        const sentMessageId = sent?.message_id;
-        if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
-            streamState.stopped = true;
-            params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
-            return false;
-        }
-        const normalizedMessageId = Math.trunc(sentMessageId);
-        if (sendGeneration !== generation) {
-            params.onSupersededPreview?.({
-                messageId: normalizedMessageId,
-                textSnapshot: renderedText,
-                parseMode: renderedParseMode,
-            });
-            return true;
-        }
-        streamMessageId = normalizedMessageId;
-        return true;
-    };
-    const sendDraftTransportPreview = async ({ renderedText, renderedParseMode, }) => {
-        const draftId = streamDraftId ?? allocateTelegramDraftId();
-        streamDraftId = draftId;
-        const draftParams = {
-            ...(threadParams?.message_thread_id != null
-                ? { message_thread_id: threadParams.message_thread_id }
-                : {}),
-            ...(renderedParseMode ? { parse_mode: renderedParseMode } : {}),
-        };
-        await resolvedDraftApi(chatId, draftId, renderedText, Object.keys(draftParams).length > 0 ? draftParams : undefined);
-        return true;
-    };
-    const sendOrEditStreamMessage = async (text) => {
-        // Allow final flush even if stopped (e.g., after clear()).
-        if (streamState.stopped && !streamState.final) {
-            return false;
-        }
-        const trimmed = text.trimEnd();
-        if (!trimmed) {
-            return false;
-        }
-        const rendered = params.renderText?.(trimmed) ?? { text: trimmed };
-        const renderedText = rendered.text.trimEnd();
-        const renderedParseMode = rendered.parseMode;
-        if (!renderedText) {
-            return false;
-        }
-        if (renderedText.length > maxChars) {
-            // Telegram text messages/edits cap at 4096 chars.
-            // Stop streaming once we exceed the cap to avoid repeated API failures.
-            streamState.stopped = true;
-            params.warn?.(`telegram stream preview stopped (text length ${renderedText.length} > ${maxChars})`);
-            return false;
-        }
-        if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) {
-            return true;
-        }
-        const sendGeneration = generation;
-        // Debounce first preview send for better push notification quality.
-        if (typeof streamMessageId !== "number" && minInitialChars != null && !streamState.final) {
-            if (renderedText.length < minInitialChars) {
-                return false;
-            }
-        }
-        lastSentText = renderedText;
-        lastSentParseMode = renderedParseMode;
-        try {
-            let sent = false;
-            if (previewTransport === "draft") {
-                try {
-                    sent = await sendDraftTransportPreview({
-                        renderedText,
-                        renderedParseMode,
-                        sendGeneration,
-                    });
-                }
-                catch (err) {
-                    if (!shouldFallbackFromDraftTransport(err)) {
-                        throw err;
-                    }
-                    previewTransport = "message";
-                    streamDraftId = undefined;
-                    params.warn?.("telegram stream preview: sendMessageDraft rejected by API; falling back to sendMessage/editMessageText");
-                    sent = await sendMessageTransportPreview({
-                        renderedText,
-                        renderedParseMode,
-                        sendGeneration,
-                    });
-                }
-            }
-            else {
-                sent = await sendMessageTransportPreview({
-                    renderedText,
-                    renderedParseMode,
-                    sendGeneration,
-                });
-            }
-            if (sent) {
-                previewRevision += 1;
-                lastDeliveredText = trimmed;
-            }
-            return sent;
-        }
-        catch (err) {
-            streamState.stopped = true;
-            params.warn?.(`telegram stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
-        }
-    };
-    const { loop, update, stop, clear } = createFinalizableDraftLifecycle({
-        throttleMs,
-        state: streamState,
-        sendOrEditStreamMessage,
-        readMessageId: () => streamMessageId,
-        clearMessageId: () => {
-            streamMessageId = undefined;
-        },
-        isValidMessageId: (value) => typeof value === "number" && Number.isFinite(value),
-        deleteMessage: async (messageId) => {
-            await params.api.deleteMessage(chatId, messageId);
-        },
-        onDeleteSuccess: (messageId) => {
-            params.log?.(`telegram stream preview deleted (chat=${chatId}, message=${messageId})`);
-        },
-        warn: params.warn,
-        warnPrefix: "telegram stream preview cleanup failed",
-    });
-    const forceNewMessage = () => {
-        // Boundary rotation may call stop() to finalize the previous draft.
-        // Re-open the stream lifecycle for the next assistant segment.
-        streamState.final = false;
-        generation += 1;
-        streamMessageId = undefined;
-        if (previewTransport === "draft") {
-            streamDraftId = allocateTelegramDraftId();
-        }
-        lastSentText = "";
-        lastSentParseMode = undefined;
-        loop.resetPending();
-        loop.resetThrottleWindow();
-    };
-    /**
-     * Materialize the current draft into a permanent message.
-     * For draft transport: sends the accumulated text as a real sendMessage.
-     * For message transport: the message is already permanent (noop).
-     * Returns the permanent message id, or undefined if nothing to materialize.
-     */
-    const materialize = async () => {
-        await stop();
-        // If using message transport, the streamMessageId is already a real message.
-        if (previewTransport === "message" && typeof streamMessageId === "number") {
-            return streamMessageId;
-        }
-        // For draft transport, use the rendered snapshot first so parse_mode stays
-        // aligned with the text being materialized.
-        const renderedText = lastSentText || lastDeliveredText;
-        if (!renderedText) {
-            return undefined;
-        }
-        const renderedParseMode = lastSentText ? lastSentParseMode : undefined;
-        try {
-            const { sent, usedThreadParams } = await sendRenderedMessageWithThreadFallback({
-                renderedText,
-                renderedParseMode,
-                fallbackWarnMessage: "telegram stream preview materialize send failed with message_thread_id, retrying without thread",
-            });
-            const sentId = sent?.message_id;
-            if (typeof sentId === "number" && Number.isFinite(sentId)) {
-                streamMessageId = Math.trunc(sentId);
-                // Clear the draft so Telegram's input area doesn't briefly show a
-                // stale copy alongside the newly materialized real message.
-                if (resolvedDraftApi != null && streamDraftId != null) {
-                    const clearDraftId = streamDraftId;
-                    const clearThreadParams = usedThreadParams && threadParams?.message_thread_id != null
-                        ? { message_thread_id: threadParams.message_thread_id }
-                        : undefined;
-                    try {
-                        await resolvedDraftApi(chatId, clearDraftId, "", clearThreadParams);
-                    }
-                    catch {
-                        // Best-effort cleanup; draft clear failure is cosmetic.
-                    }
-                }
-                return streamMessageId;
-            }
-        }
-        catch (err) {
-            params.warn?.(`telegram stream preview materialize failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return undefined;
-    };
-    params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
-    return {
-        update,
-        flush: loop.flush,
-        messageId: () => streamMessageId,
-        previewMode: () => previewTransport,
-        previewRevision: () => previewRevision,
-        lastDeliveredText: () => lastDeliveredText,
-        clear,
-        stop,
-        materialize,
-        forceNewMessage,
-    };
-}
-//# sourceMappingURL=draft-stream.js.map

package/dist/openclaw/src/telegram/fetch.d.ts

@@ -1,6 +0,0 @@
-import type { TelegramNetworkConfig } from "../config/types.telegram.js";
-export declare function resolveTelegramFetch(proxyFetch?: typeof fetch, options?: {
-    network?: TelegramNetworkConfig;
-}): typeof fetch | undefined;
-export declare function resetTelegramFetchStateForTests(): void;
-//# sourceMappingURL=fetch.d.ts.map

package/dist/openclaw/src/telegram/fetch.js

@@ -1,177 +0,0 @@
-import * as dns from "node:dns";
-import * as net from "node:net";
-import { EnvHttpProxyAgent, getGlobalDispatcher, setGlobalDispatcher } from "undici";
-import { resolveFetch } from "../infra/fetch.js";
-import { hasProxyEnvConfigured } from "../infra/net/proxy-env.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-import { resolveTelegramAutoSelectFamilyDecision, resolveTelegramDnsResultOrderDecision, } from "./network-config.js";
-let appliedAutoSelectFamily = null;
-let appliedDnsResultOrder = null;
-let appliedGlobalDispatcherAutoSelectFamily = null;
-const log = createSubsystemLogger("telegram/network");
-function isProxyLikeDispatcher(dispatcher) {
-    const ctorName = dispatcher?.constructor?.name;
-    return typeof ctorName === "string" && ctorName.includes("ProxyAgent");
-}
-const FALLBACK_RETRY_ERROR_CODES = [
-    "ETIMEDOUT",
-    "ENETUNREACH",
-    "EHOSTUNREACH",
-    "UND_ERR_CONNECT_TIMEOUT",
-    "UND_ERR_SOCKET",
-];
-const IPV4_FALLBACK_RULES = [
-    {
-        name: "fetch-failed-envelope",
-        matches: ({ message }) => message.includes("fetch failed"),
-    },
-    {
-        name: "known-network-code",
-        matches: ({ codes }) => FALLBACK_RETRY_ERROR_CODES.some((code) => codes.has(code)),
-    },
-];
-// Node 22 workaround: enable autoSelectFamily to allow IPv4 fallback on broken IPv6 networks.
-// Many networks have IPv6 configured but not routed, causing "Network is unreachable" errors.
-// See: https://github.com/nodejs/node/issues/54359
-function applyTelegramNetworkWorkarounds(network) {
-    // Apply autoSelectFamily workaround
-    const autoSelectDecision = resolveTelegramAutoSelectFamilyDecision({ network });
-    if (autoSelectDecision.value !== null && autoSelectDecision.value !== appliedAutoSelectFamily) {
-        if (typeof net.setDefaultAutoSelectFamily === "function") {
-            try {
-                net.setDefaultAutoSelectFamily(autoSelectDecision.value);
-                appliedAutoSelectFamily = autoSelectDecision.value;
-                const label = autoSelectDecision.source ? ` (${autoSelectDecision.source})` : "";
-                log.info(`autoSelectFamily=${autoSelectDecision.value}${label}`);
-            }
-            catch {
-                // ignore if unsupported by the runtime
-            }
-        }
-    }
-    // Node 22's built-in globalThis.fetch uses undici's internal Agent whose
-    // connect options are frozen at construction time. Calling
-    // net.setDefaultAutoSelectFamily() after that agent is created has no
-    // effect on it. Replace the global dispatcher with one that carries the
-    // current autoSelectFamily setting so subsequent globalThis.fetch calls
-    // inherit the same decision.
-    // See: https://github.com/openclaw/openclaw/issues/25676
-    if (autoSelectDecision.value !== null &&
-        autoSelectDecision.value !== appliedGlobalDispatcherAutoSelectFamily) {
-        const existingGlobalDispatcher = getGlobalDispatcher();
-        const shouldPreserveExistingProxy = isProxyLikeDispatcher(existingGlobalDispatcher) && !hasProxyEnvConfigured();
-        if (!shouldPreserveExistingProxy) {
-            try {
-                setGlobalDispatcher(new EnvHttpProxyAgent({
-                    connect: {
-                        autoSelectFamily: autoSelectDecision.value,
-                        autoSelectFamilyAttemptTimeout: 300,
-                    },
-                }));
-                appliedGlobalDispatcherAutoSelectFamily = autoSelectDecision.value;
-                log.info(`global undici dispatcher autoSelectFamily=${autoSelectDecision.value}`);
-            }
-            catch {
-                // ignore if setGlobalDispatcher is unavailable
-            }
-        }
-    }
-    // Apply DNS result order workaround for IPv4/IPv6 issues.
-    // Some APIs (including Telegram) may fail with IPv6 on certain networks.
-    // See: https://github.com/openclaw/openclaw/issues/5311
-    const dnsDecision = resolveTelegramDnsResultOrderDecision({ network });
-    if (dnsDecision.value !== null && dnsDecision.value !== appliedDnsResultOrder) {
-        if (typeof dns.setDefaultResultOrder === "function") {
-            try {
-                dns.setDefaultResultOrder(dnsDecision.value);
-                appliedDnsResultOrder = dnsDecision.value;
-                const label = dnsDecision.source ? ` (${dnsDecision.source})` : "";
-                log.info(`dnsResultOrder=${dnsDecision.value}${label}`);
-            }
-            catch {
-                // ignore if unsupported by the runtime
-            }
-        }
-    }
-}
-function collectErrorCodes(err) {
-    const codes = new Set();
-    const queue = [err];
-    const seen = new Set();
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current || seen.has(current)) {
-            continue;
-        }
-        seen.add(current);
-        if (typeof current === "object") {
-            const code = current.code;
-            if (typeof code === "string" && code.trim()) {
-                codes.add(code.trim().toUpperCase());
-            }
-            const cause = current.cause;
-            if (cause && !seen.has(cause)) {
-                queue.push(cause);
-            }
-            const errors = current.errors;
-            if (Array.isArray(errors)) {
-                for (const nested of errors) {
-                    if (nested && !seen.has(nested)) {
-                        queue.push(nested);
-                    }
-                }
-            }
-        }
-    }
-    return codes;
-}
-function shouldRetryWithIpv4Fallback(err) {
-    const ctx = {
-        message: err && typeof err === "object" && "message" in err ? String(err.message).toLowerCase() : "",
-        codes: collectErrorCodes(err),
-    };
-    for (const rule of IPV4_FALLBACK_RULES) {
-        if (!rule.matches(ctx)) {
-            return false;
-        }
-    }
-    return true;
-}
-function applyTelegramIpv4Fallback() {
-    applyTelegramNetworkWorkarounds({
-        autoSelectFamily: false,
-        dnsResultOrder: "ipv4first",
-    });
-    log.warn("fetch fallback: forcing autoSelectFamily=false + dnsResultOrder=ipv4first");
-}
-// Prefer wrapped fetch when available to normalize AbortSignal across runtimes.
-export function resolveTelegramFetch(proxyFetch, options) {
-    applyTelegramNetworkWorkarounds(options?.network);
-    const sourceFetch = proxyFetch ? resolveFetch(proxyFetch) : resolveFetch();
-    if (!sourceFetch) {
-        throw new Error("fetch is not available; set channels.telegram.proxy in config");
-    }
-    // When Telegram media fetch hits dual-stack edge cases (ENETUNREACH/ETIMEDOUT),
-    // switch to IPv4-safe network mode and retry once.
-    if (proxyFetch) {
-        return sourceFetch;
-    }
-    return (async (input, init) => {
-        try {
-            return await sourceFetch(input, init);
-        }
-        catch (err) {
-            if (shouldRetryWithIpv4Fallback(err)) {
-                applyTelegramIpv4Fallback();
-                return sourceFetch(input, init);
-            }
-            throw err;
-        }
-    });
-}
-export function resetTelegramFetchStateForTests() {
-    appliedAutoSelectFamily = null;
-    appliedDnsResultOrder = null;
-    appliedGlobalDispatcherAutoSelectFamily = null;
-}
-//# sourceMappingURL=fetch.js.map

package/dist/openclaw/src/telegram/format.d.ts

@@ -1,19 +0,0 @@
-import type { MarkdownTableMode } from "../config/types.base.js";
-export type TelegramFormattedChunk = {
-    html: string;
-    text: string;
-};
-export declare function markdownToTelegramHtml(markdown: string, options?: {
-    tableMode?: MarkdownTableMode;
-    wrapFileRefs?: boolean;
-}): string;
-export declare function wrapFileReferencesInHtml(html: string): string;
-export declare function renderTelegramHtmlText(text: string, options?: {
-    textMode?: "markdown" | "html";
-    tableMode?: MarkdownTableMode;
-}): string;
-export declare function markdownToTelegramChunks(markdown: string, limit: number, options?: {
-    tableMode?: MarkdownTableMode;
-}): TelegramFormattedChunk[];
-export declare function markdownToTelegramHtmlChunks(markdown: string, limit: number): string[];
-//# sourceMappingURL=format.d.ts.map