openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/telegram/sticker-cache.js

@@ -1,210 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { resolveApiKeyForProvider } from "../agents/model-auth.js";
-import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
-import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
-import { STATE_DIR } from "../config/paths.js";
-import { logVerbose } from "../globals.js";
-import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
-import { resolveAutoImageModel } from "../media-understanding/runner.js";
-const CACHE_FILE = path.join(STATE_DIR, "telegram", "sticker-cache.json");
-const CACHE_VERSION = 1;
-function loadCache() {
-    const data = loadJsonFile(CACHE_FILE);
-    if (!data || typeof data !== "object") {
-        return { version: CACHE_VERSION, stickers: {} };
-    }
-    const cache = data;
-    if (cache.version !== CACHE_VERSION) {
-        // Future: handle migration if needed
-        return { version: CACHE_VERSION, stickers: {} };
-    }
-    return cache;
-}
-function saveCache(cache) {
-    saveJsonFile(CACHE_FILE, cache);
-}
-/**
- * Get a cached sticker by its unique ID.
- */
-export function getCachedSticker(fileUniqueId) {
-    const cache = loadCache();
-    return cache.stickers[fileUniqueId] ?? null;
-}
-/**
- * Add or update a sticker in the cache.
- */
-export function cacheSticker(sticker) {
-    const cache = loadCache();
-    cache.stickers[sticker.fileUniqueId] = sticker;
-    saveCache(cache);
-}
-/**
- * Search cached stickers by text query (fuzzy match on description + emoji + setName).
- */
-export function searchStickers(query, limit = 10) {
-    const cache = loadCache();
-    const queryLower = query.toLowerCase();
-    const results = [];
-    for (const sticker of Object.values(cache.stickers)) {
-        let score = 0;
-        const descLower = sticker.description.toLowerCase();
-        // Exact substring match in description
-        if (descLower.includes(queryLower)) {
-            score += 10;
-        }
-        // Word-level matching
-        const queryWords = queryLower.split(/\s+/).filter(Boolean);
-        const descWords = descLower.split(/\s+/);
-        for (const qWord of queryWords) {
-            if (descWords.some((dWord) => dWord.includes(qWord))) {
-                score += 5;
-            }
-        }
-        // Emoji match
-        if (sticker.emoji && query.includes(sticker.emoji)) {
-            score += 8;
-        }
-        // Set name match
-        if (sticker.setName?.toLowerCase().includes(queryLower)) {
-            score += 3;
-        }
-        if (score > 0) {
-            results.push({ sticker, score });
-        }
-    }
-    return results
-        .toSorted((a, b) => b.score - a.score)
-        .slice(0, limit)
-        .map((r) => r.sticker);
-}
-/**
- * Get all cached stickers (for debugging/listing).
- */
-export function getAllCachedStickers() {
-    const cache = loadCache();
-    return Object.values(cache.stickers);
-}
-/**
- * Get cache statistics.
- */
-export function getCacheStats() {
-    const cache = loadCache();
-    const stickers = Object.values(cache.stickers);
-    if (stickers.length === 0) {
-        return { count: 0 };
-    }
-    const sorted = [...stickers].toSorted((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
-    return {
-        count: stickers.length,
-        oldestAt: sorted[0]?.cachedAt,
-        newestAt: sorted[sorted.length - 1]?.cachedAt,
-    };
-}
-const STICKER_DESCRIPTION_PROMPT = "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective.";
-const VISION_PROVIDERS = ["openai", "anthropic", "google", "minimax"];
-let imageRuntimePromise = null;
-function loadImageRuntime() {
-    imageRuntimePromise ??= import("../media-understanding/providers/image-runtime.js");
-    return imageRuntimePromise;
-}
-/**
- * Describe a sticker image using vision API.
- * Auto-detects an available vision provider based on configured API keys.
- * Returns null if no vision provider is available.
- */
-export async function describeStickerImage(params) {
-    const { imagePath, cfg, agentDir, agentId } = params;
-    const defaultModel = resolveDefaultModelForAgent({ cfg, agentId });
-    let activeModel = undefined;
-    let catalog = [];
-    try {
-        catalog = await loadModelCatalog({ config: cfg });
-        const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
-        const supportsVision = modelSupportsVision(entry);
-        if (supportsVision) {
-            activeModel = { provider: defaultModel.provider, model: defaultModel.model };
-        }
-    }
-    catch {
-        // Ignore catalog failures; fall back to auto selection.
-    }
-    const hasProviderKey = async (provider) => {
-        try {
-            await resolveApiKeyForProvider({ provider, cfg, agentDir });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    const selectCatalogModel = (provider) => {
-        const entries = catalog.filter((entry) => entry.provider.toLowerCase() === provider.toLowerCase() && modelSupportsVision(entry));
-        if (entries.length === 0) {
-            return undefined;
-        }
-        const defaultId = provider === "openai"
-            ? "gpt-5-mini"
-            : provider === "anthropic"
-                ? "claude-opus-4-6"
-                : provider === "google"
-                    ? "gemini-3-flash-preview"
-                    : "MiniMax-VL-01";
-        const preferred = entries.find((entry) => entry.id === defaultId);
-        return preferred ?? entries[0];
-    };
-    let resolved = null;
-    if (activeModel &&
-        VISION_PROVIDERS.includes(activeModel.provider) &&
-        (await hasProviderKey(activeModel.provider))) {
-        resolved = activeModel;
-    }
-    if (!resolved) {
-        for (const provider of VISION_PROVIDERS) {
-            if (!(await hasProviderKey(provider))) {
-                continue;
-            }
-            const entry = selectCatalogModel(provider);
-            if (entry) {
-                resolved = { provider, model: entry.id };
-                break;
-            }
-        }
-    }
-    if (!resolved) {
-        resolved = await resolveAutoImageModel({
-            cfg,
-            agentDir,
-            activeModel,
-        });
-    }
-    if (!resolved?.model) {
-        logVerbose("telegram: no vision provider available for sticker description");
-        return null;
-    }
-    const { provider, model } = resolved;
-    logVerbose(`telegram: describing sticker with ${provider}/${model}`);
-    try {
-        const buffer = await fs.readFile(imagePath);
-        // Lazy import to avoid circular dependency
-        const { describeImageWithModel } = await loadImageRuntime();
-        const result = await describeImageWithModel({
-            buffer,
-            fileName: "sticker.webp",
-            mime: "image/webp",
-            prompt: STICKER_DESCRIPTION_PROMPT,
-            cfg,
-            agentDir: agentDir ?? "",
-            provider,
-            model,
-            maxTokens: 150,
-            timeoutMs: 30000,
-        });
-        return result.text;
-    }
-    catch (err) {
-        logVerbose(`telegram: failed to describe sticker: ${String(err)}`);
-        return null;
-    }
-}
-//# sourceMappingURL=sticker-cache.js.map

package/dist/openclaw/src/telegram/target-writeback.d.ts

@@ -1,8 +0,0 @@
-import type { OpenClawConfig } from "../config/config.js";
-export declare function maybePersistResolvedTelegramTarget(params: {
-    cfg: OpenClawConfig;
-    rawTarget: string;
-    resolvedChatId: string;
-    verbose?: boolean;
-}): Promise<void>;
-//# sourceMappingURL=target-writeback.d.ts.map

package/dist/openclaw/src/telegram/target-writeback.js

@@ -1,166 +0,0 @@
-import { readConfigFileSnapshotForWrite, writeConfigFile } from "../config/config.js";
-import { loadCronStore, resolveCronStorePath, saveCronStore } from "../cron/store.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
-import { normalizeTelegramChatId, normalizeTelegramLookupTarget, parseTelegramTarget, } from "./targets.js";
-const writebackLogger = createSubsystemLogger("telegram/target-writeback");
-function asObjectRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    return value;
-}
-function normalizeTelegramLookupTargetForMatch(raw) {
-    const normalized = normalizeTelegramLookupTarget(raw);
-    if (!normalized) {
-        return undefined;
-    }
-    return normalized.startsWith("@") ? normalized.toLowerCase() : normalized;
-}
-function normalizeTelegramTargetForMatch(raw) {
-    const parsed = parseTelegramTarget(raw);
-    const normalized = normalizeTelegramLookupTargetForMatch(parsed.chatId);
-    if (!normalized) {
-        return undefined;
-    }
-    const threadKey = parsed.messageThreadId == null ? "" : String(parsed.messageThreadId);
-    return `${normalized}|${threadKey}`;
-}
-function buildResolvedTelegramTarget(params) {
-    const { raw, parsed, resolvedChatId } = params;
-    if (parsed.messageThreadId == null) {
-        return resolvedChatId;
-    }
-    return raw.includes(":topic:")
-        ? `${resolvedChatId}:topic:${parsed.messageThreadId}`
-        : `${resolvedChatId}:${parsed.messageThreadId}`;
-}
-function resolveLegacyRewrite(params) {
-    const parsed = parseTelegramTarget(params.raw);
-    if (normalizeTelegramChatId(parsed.chatId)) {
-        return null;
-    }
-    const normalized = normalizeTelegramLookupTargetForMatch(parsed.chatId);
-    if (!normalized) {
-        return null;
-    }
-    const threadKey = parsed.messageThreadId == null ? "" : String(parsed.messageThreadId);
-    return {
-        matchKey: `${normalized}|${threadKey}`,
-        resolvedTarget: buildResolvedTelegramTarget({
-            raw: params.raw,
-            parsed,
-            resolvedChatId: params.resolvedChatId,
-        }),
-    };
-}
-function rewriteTargetIfMatch(params) {
-    if (typeof params.rawValue !== "string" && typeof params.rawValue !== "number") {
-        return null;
-    }
-    const value = String(params.rawValue).trim();
-    if (!value) {
-        return null;
-    }
-    if (normalizeTelegramTargetForMatch(value) !== params.matchKey) {
-        return null;
-    }
-    return params.resolvedTarget;
-}
-function replaceTelegramDefaultToTargets(params) {
-    let changed = false;
-    const telegram = asObjectRecord(params.cfg.channels?.telegram);
-    if (!telegram) {
-        return changed;
-    }
-    const maybeReplace = (holder, key) => {
-        const nextTarget = rewriteTargetIfMatch({
-            rawValue: holder[key],
-            matchKey: params.matchKey,
-            resolvedTarget: params.resolvedTarget,
-        });
-        if (!nextTarget) {
-            return;
-        }
-        holder[key] = nextTarget;
-        changed = true;
-    };
-    maybeReplace(telegram, "defaultTo");
-    const accounts = asObjectRecord(telegram.accounts);
-    if (!accounts) {
-        return changed;
-    }
-    for (const accountId of Object.keys(accounts)) {
-        const account = asObjectRecord(accounts[accountId]);
-        if (!account) {
-            continue;
-        }
-        maybeReplace(account, "defaultTo");
-    }
-    return changed;
-}
-export async function maybePersistResolvedTelegramTarget(params) {
-    const raw = params.rawTarget.trim();
-    if (!raw) {
-        return;
-    }
-    const rewrite = resolveLegacyRewrite({
-        raw,
-        resolvedChatId: params.resolvedChatId,
-    });
-    if (!rewrite) {
-        return;
-    }
-    const { matchKey, resolvedTarget } = rewrite;
-    try {
-        const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
-        const nextConfig = structuredClone(snapshot.config ?? {});
-        const configChanged = replaceTelegramDefaultToTargets({
-            cfg: nextConfig,
-            matchKey,
-            resolvedTarget,
-        });
-        if (configChanged) {
-            await writeConfigFile(nextConfig, writeOptions);
-            if (params.verbose) {
-                writebackLogger.warn(`resolved Telegram defaultTo target ${raw} -> ${resolvedTarget}`);
-            }
-        }
-    }
-    catch (err) {
-        if (params.verbose) {
-            writebackLogger.warn(`failed to persist Telegram defaultTo target ${raw}: ${String(err)}`);
-        }
-    }
-    try {
-        const storePath = resolveCronStorePath(params.cfg.cron?.store);
-        const store = await loadCronStore(storePath);
-        let cronChanged = false;
-        for (const job of store.jobs) {
-            if (job.delivery?.channel !== "telegram") {
-                continue;
-            }
-            const nextTarget = rewriteTargetIfMatch({
-                rawValue: job.delivery.to,
-                matchKey,
-                resolvedTarget,
-            });
-            if (!nextTarget) {
-                continue;
-            }
-            job.delivery.to = nextTarget;
-            cronChanged = true;
-        }
-        if (cronChanged) {
-            await saveCronStore(storePath, store);
-            if (params.verbose) {
-                writebackLogger.warn(`resolved Telegram cron delivery target ${raw} -> ${resolvedTarget}`);
-            }
-        }
-    }
-    catch (err) {
-        if (params.verbose) {
-            writebackLogger.warn(`failed to persist Telegram cron target ${raw}: ${String(err)}`);
-        }
-    }
-}
-//# sourceMappingURL=target-writeback.js.map

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

@@ -1,12 +0,0 @@
-export type TelegramTarget = {
-    chatId: string;
-    messageThreadId?: number;
-    chatType: "direct" | "group" | "unknown";
-};
-export declare function stripTelegramInternalPrefixes(to: string): string;
-export declare function normalizeTelegramChatId(raw: string): string | undefined;
-export declare function isNumericTelegramChatId(raw: string): boolean;
-export declare function normalizeTelegramLookupTarget(raw: string): string | undefined;
-export declare function parseTelegramTarget(to: string): TelegramTarget;
-export declare function resolveTelegramTargetChatType(target: string): "direct" | "group" | "unknown";
-//# sourceMappingURL=targets.d.ts.map

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

@@ -1,105 +0,0 @@
-const TELEGRAM_NUMERIC_CHAT_ID_REGEX = /^-?\d+$/;
-const TELEGRAM_USERNAME_REGEX = /^[A-Za-z0-9_]{5,}$/i;
-export function stripTelegramInternalPrefixes(to) {
-    let trimmed = to.trim();
-    let strippedTelegramPrefix = false;
-    while (true) {
-        const next = (() => {
-            if (/^(telegram|tg):/i.test(trimmed)) {
-                strippedTelegramPrefix = true;
-                return trimmed.replace(/^(telegram|tg):/i, "").trim();
-            }
-            // Legacy internal form: `telegram:group:<id>` (still emitted by session keys).
-            if (strippedTelegramPrefix && /^group:/i.test(trimmed)) {
-                return trimmed.replace(/^group:/i, "").trim();
-            }
-            return trimmed;
-        })();
-        if (next === trimmed) {
-            return trimmed;
-        }
-        trimmed = next;
-    }
-}
-export function normalizeTelegramChatId(raw) {
-    const stripped = stripTelegramInternalPrefixes(raw);
-    if (!stripped) {
-        return undefined;
-    }
-    if (TELEGRAM_NUMERIC_CHAT_ID_REGEX.test(stripped)) {
-        return stripped;
-    }
-    return undefined;
-}
-export function isNumericTelegramChatId(raw) {
-    return TELEGRAM_NUMERIC_CHAT_ID_REGEX.test(raw.trim());
-}
-export function normalizeTelegramLookupTarget(raw) {
-    const stripped = stripTelegramInternalPrefixes(raw);
-    if (!stripped) {
-        return undefined;
-    }
-    if (isNumericTelegramChatId(stripped)) {
-        return stripped;
-    }
-    const tmeMatch = /^(?:https?:\/\/)?t\.me\/([A-Za-z0-9_]+)$/i.exec(stripped);
-    if (tmeMatch?.[1]) {
-        return `@${tmeMatch[1]}`;
-    }
-    if (stripped.startsWith("@")) {
-        const handle = stripped.slice(1);
-        if (!handle || !TELEGRAM_USERNAME_REGEX.test(handle)) {
-            return undefined;
-        }
-        return `@${handle}`;
-    }
-    if (TELEGRAM_USERNAME_REGEX.test(stripped)) {
-        return `@${stripped}`;
-    }
-    return undefined;
-}
-/**
- * Parse a Telegram delivery target into chatId and optional topic/thread ID.
- *
- * Supported formats:
- * - `chatId` (plain chat ID, t.me link, @username, or internal prefixes like `telegram:...`)
- * - `chatId:topicId` (numeric topic/thread ID)
- * - `chatId:topic:topicId` (explicit topic marker; preferred)
- */
-function resolveTelegramChatType(chatId) {
-    const trimmed = chatId.trim();
-    if (!trimmed) {
-        return "unknown";
-    }
-    if (isNumericTelegramChatId(trimmed)) {
-        return trimmed.startsWith("-") ? "group" : "direct";
-    }
-    return "unknown";
-}
-export function parseTelegramTarget(to) {
-    const normalized = stripTelegramInternalPrefixes(to);
-    const topicMatch = /^(.+?):topic:(\d+)$/.exec(normalized);
-    if (topicMatch) {
-        return {
-            chatId: topicMatch[1],
-            messageThreadId: Number.parseInt(topicMatch[2], 10),
-            chatType: resolveTelegramChatType(topicMatch[1]),
-        };
-    }
-    const colonMatch = /^(.+):(\d+)$/.exec(normalized);
-    if (colonMatch) {
-        return {
-            chatId: colonMatch[1],
-            messageThreadId: Number.parseInt(colonMatch[2], 10),
-            chatType: resolveTelegramChatType(colonMatch[1]),
-        };
-    }
-    return {
-        chatId: normalized,
-        chatType: resolveTelegramChatType(normalized),
-    };
-}
-export function resolveTelegramTargetChatType(target) {
-    return parseTelegramTarget(target).chatType;
-}
-//# sourceMappingURL=targets.js.map

package/dist/openclaw/src/telegram/thread-bindings.d.ts

@@ -1,58 +0,0 @@
-type TelegramBindingTargetKind = "subagent" | "acp";
-export type TelegramThreadBindingRecord = {
-    accountId: string;
-    conversationId: string;
-    targetKind: TelegramBindingTargetKind;
-    targetSessionKey: string;
-    agentId?: string;
-    label?: string;
-    boundBy?: string;
-    boundAt: number;
-    lastActivityAt: number;
-    idleTimeoutMs?: number;
-    maxAgeMs?: number;
-};
-export type TelegramThreadBindingManager = {
-    accountId: string;
-    shouldPersistMutations: () => boolean;
-    getIdleTimeoutMs: () => number;
-    getMaxAgeMs: () => number;
-    getByConversationId: (conversationId: string) => TelegramThreadBindingRecord | undefined;
-    listBySessionKey: (targetSessionKey: string) => TelegramThreadBindingRecord[];
-    listBindings: () => TelegramThreadBindingRecord[];
-    touchConversation: (conversationId: string, at?: number) => TelegramThreadBindingRecord | null;
-    unbindConversation: (params: {
-        conversationId: string;
-        reason?: string;
-        sendFarewell?: boolean;
-    }) => TelegramThreadBindingRecord | null;
-    unbindBySessionKey: (params: {
-        targetSessionKey: string;
-        reason?: string;
-        sendFarewell?: boolean;
-    }) => TelegramThreadBindingRecord[];
-    stop: () => void;
-};
-export declare function createTelegramThreadBindingManager(params?: {
-    accountId?: string;
-    persist?: boolean;
-    idleTimeoutMs?: number;
-    maxAgeMs?: number;
-    enableSweeper?: boolean;
-}): TelegramThreadBindingManager;
-export declare function getTelegramThreadBindingManager(accountId?: string): TelegramThreadBindingManager | null;
-export declare function setTelegramThreadBindingIdleTimeoutBySessionKey(params: {
-    targetSessionKey: string;
-    accountId?: string;
-    idleTimeoutMs: number;
-}): TelegramThreadBindingRecord[];
-export declare function setTelegramThreadBindingMaxAgeBySessionKey(params: {
-    targetSessionKey: string;
-    accountId?: string;
-    maxAgeMs: number;
-}): TelegramThreadBindingRecord[];
-export declare const __testing: {
-    resetTelegramThreadBindingsForTests(): void;
-};
-export {};
-//# sourceMappingURL=thread-bindings.d.ts.map