@sheepbun/yips 0.1.1

package/dist/downloader-ui.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDownloaderLines = renderDownloaderLines;
+const colors_1 = require("./colors");
+const TAB_INACTIVE = { r: 0x88, g: 0x88, b: 0x88 };
+const BLACK = { r: 0x00, g: 0x00, b: 0x00 };
+const FOCUS_ACCENT_BG = { r: 0xff, g: 0xcc, b: 0xff };
+const DOWNLOADER_MODEL_BODY_ROWS = 10;
+const DOWNLOADER_FILE_BODY_ROWS = 10;
+const ANSI_BOLD_ON = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+function charLength(text) {
+    return Array.from((0, colors_1.stripAnsi)(text)).length;
+}
+function fitRight(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    return chars.slice(chars.length - width).join("");
+}
+function fitLeft(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    if (width <= 3) {
+        return chars.slice(0, width).join("");
+    }
+    return `${chars.slice(0, width - 3).join("")}...`;
+}
+function formatCount(value) {
+    if (value >= 1_000_000) {
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    }
+    if (value >= 1_000) {
+        return `${(value / 1_000).toFixed(1)}k`;
+    }
+    return String(value);
+}
+function formatSize(bytes) {
+    if (bytes === null || bytes <= 0) {
+        return "?";
+    }
+    const gib = bytes / (1024 * 1024 * 1024);
+    return `${gib.toFixed(1)}G`;
+}
+function tabText(tab, activeTab) {
+    const label = ` ${tab} `;
+    if (tab === activeTab) {
+        return `${ANSI_BOLD_ON}${(0, colors_1.horizontalGradientBackground)(label, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, BLACK)}${ANSI_BOLD_OFF}`;
+    }
+    return `${ANSI_BOLD_ON}${(0, colors_1.colorText)(label, TAB_INACTIVE)}${ANSI_BOLD_OFF}`;
+}
+function makeBorderTop(width) {
+    if (width <= 1)
+        return "╭";
+    const prefix = "╭─── ";
+    const titleBrand = "Yips";
+    const titleDetail = " Model Downloader";
+    const titleTail = " ";
+    const prefixLen = charLength(prefix);
+    const titleBrandLen = charLength(titleBrand);
+    const titleDetailLen = charLength(titleDetail);
+    const titleTailLen = charLength(titleTail);
+    const plainTitleLen = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const fill = "─".repeat(Math.max(0, width - plainTitleLen - 1));
+    const fillOffset = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const cornerOffset = width - 1;
+    return `${(0, colors_1.horizontalGradientAtOffset)(prefix, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, 0, width)}${ANSI_BOLD_ON}${(0, colors_1.horizontalGradient)(titleBrand, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)(titleDetail, colors_1.GRADIENT_BLUE)}${ANSI_BOLD_OFF}${(0, colors_1.horizontalGradientAtOffset)(titleTail, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, prefixLen + titleBrandLen + titleDetailLen, width)}${(0, colors_1.horizontalGradientAtOffset)(fill, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, fillOffset, width)}${(0, colors_1.horizontalGradientAtOffset)("╮", colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, cornerOffset, width)}`;
+}
+function makeBorderBottom(width) {
+    if (width <= 1)
+        return "╰";
+    const mid = "─".repeat(Math.max(0, width - 2));
+    return `${(0, colors_1.colorText)("╰", colors_1.GRADIENT_PINK)}${(0, colors_1.horizontalGradient)(mid, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)("╯", colors_1.GRADIENT_YELLOW)}`;
+}
+function lineWithBorders(inner, innerWidth) {
+    let fitted = inner;
+    if (charLength(fitted) > innerWidth) {
+        fitted = fitLeft((0, colors_1.stripAnsi)(inner), innerWidth);
+    }
+    const padding = " ".repeat(Math.max(0, innerWidth - charLength(fitted)));
+    return `${(0, colors_1.colorText)("│", colors_1.GRADIENT_PINK)}${fitted}${padding}${(0, colors_1.colorText)("│", colors_1.GRADIENT_YELLOW)}`;
+}
+function composeSplitFooter(left, right, innerWidth) {
+    const leftLen = charLength(left);
+    const rightLen = charLength(right);
+    if (leftLen + rightLen + 1 > innerWidth) {
+        return `${left} ${fitRight(right, Math.max(1, innerWidth - leftLen - 1))}`;
+    }
+    const gap = " ".repeat(Math.max(1, innerWidth - leftLen - rightLen));
+    return `${left}${gap}${right}`;
+}
+function highlightedRow(row) {
+    const chars = Array.from(row);
+    if (chars.length === 0)
+        return row;
+    const first = (0, colors_1.bgColorText)(chars[0] ?? "", FOCUS_ACCENT_BG, BLACK);
+    const rest = chars.slice(1).join("");
+    if (rest.length === 0) {
+        return first;
+    }
+    return `${first}${(0, colors_1.horizontalGradientBackground)(rest, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, BLACK)}`;
+}
+function buildModelRows(state, contentWidth, rowCount) {
+    const rows = [];
+    if (state.models.length === 0) {
+        rows.push((0, colors_1.colorText)("No compatible models found for current RAM+VRAM.", colors_1.WARNING_YELLOW));
+        return rows;
+    }
+    const dlWidth = 9;
+    const likesWidth = 6;
+    const sizeWidth = 5;
+    const dateWidth = 10;
+    const staticWidth = 2 + 3 + dlWidth + 3 + likesWidth + 3 + sizeWidth + 3 + dateWidth;
+    const modelWidth = Math.max(8, contentWidth - staticWidth);
+    const header = `  ${"Model".padEnd(modelWidth, " ")} | ${"Downloads".padStart(dlWidth, " ")} | ${"Likes".padStart(likesWidth, " ")} | ${"Size".padStart(sizeWidth, " ")} | ${"Updated".padStart(dateWidth, " ")}`;
+    rows.push((0, colors_1.horizontalGradient)(header, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW));
+    const visibleRowCount = Math.max(0, rowCount - 1);
+    const start = state.modelScrollOffset;
+    const end = Math.min(state.models.length, start + visibleRowCount);
+    for (let index = start; index < end; index++) {
+        const model = state.models[index];
+        if (!model)
+            continue;
+        const prefix = index === state.selectedModelIndex ? ">" : " ";
+        const modelCell = fitLeft(model.id, modelWidth).padEnd(modelWidth, " ");
+        const downloadsCell = `${formatCount(model.downloads)}↓`.padStart(dlWidth, " ");
+        const likesCell = `${formatCount(model.likes)}♥`.padStart(likesWidth, " ");
+        const sizeCell = formatSize(model.sizeBytes).padStart(sizeWidth, " ");
+        const dateCell = model.lastModified.slice(0, 10).padStart(dateWidth, " ");
+        const row = `${prefix} ${modelCell} | ${downloadsCell} | ${likesCell} | ${sizeCell} | ${dateCell}`;
+        rows.push(index === state.selectedModelIndex ? highlightedRow(row) : row);
+    }
+    return rows;
+}
+function toFileFitLabel(state, file) {
+    if (!file.canRun) {
+        return file.reason;
+    }
+    if (file.sizeBytes === null || file.sizeBytes <= 0) {
+        return file.reason;
+    }
+    if (!Number.isFinite(state.vramGb) || state.vramGb <= 0) {
+        return file.reason;
+    }
+    const vramBytes = state.vramGb * 1024 ** 3;
+    return file.sizeBytes <= vramBytes ? "Fits on GPU" : "Fits on GPU+CPU";
+}
+function buildFileRows(state, contentWidth, rowCount) {
+    const rows = [];
+    if (state.files.length === 0) {
+        rows.push((0, colors_1.colorText)("No GGUF files found for this model.", colors_1.WARNING_YELLOW));
+        return rows;
+    }
+    const quantWidth = 21;
+    const sizeWidth = 5;
+    const fitWidth = 16;
+    const staticWidth = 2 + 3 + quantWidth + 3 + sizeWidth + 3 + fitWidth;
+    const fileWidth = Math.max(8, contentWidth - staticWidth);
+    const header = `  ${"File".padEnd(fileWidth, " ")} | ${"Quant".padEnd(quantWidth, " ")} | ${"Size".padStart(sizeWidth, " ")} | ${"Fit".padEnd(fitWidth, " ")}`;
+    rows.push((0, colors_1.horizontalGradient)(header, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW));
+    const visibleRowCount = Math.max(0, rowCount - 1);
+    const start = state.fileScrollOffset;
+    const end = Math.min(state.files.length, start + visibleRowCount);
+    for (let index = start; index < end; index++) {
+        const file = state.files[index];
+        if (!file)
+            continue;
+        const prefix = index === state.selectedFileIndex ? ">" : " ";
+        const basename = file.path.includes("/")
+            ? (file.path.split("/").pop() ?? file.path)
+            : file.path;
+        const fileCell = fitLeft(basename, fileWidth).padEnd(fileWidth, " ");
+        const quantCell = fitLeft(file.quant, quantWidth).padEnd(quantWidth, " ");
+        const sizeCell = formatSize(file.sizeBytes).padStart(sizeWidth, " ");
+        const fitCell = fitLeft(toFileFitLabel(state, file), fitWidth).padEnd(fitWidth, " ");
+        const row = `${prefix} ${fileCell} | ${quantCell} | ${sizeCell} | ${fitCell}`;
+        if (index === state.selectedFileIndex) {
+            rows.push(highlightedRow(row));
+            continue;
+        }
+        rows.push((0, colors_1.colorText)(row, file.canRun ? colors_1.SUCCESS_GREEN : colors_1.ERROR_RED));
+    }
+    return rows;
+}
+function fillRows(rows, rowCount) {
+    if (rows.length >= rowCount) {
+        return rows.slice(0, rowCount);
+    }
+    return [...rows, ...new Array(rowCount - rows.length).fill("")];
+}
+function buildProgressBar(innerWidth, bytesDownloaded, totalBytes) {
+    if (totalBytes === null || totalBytes <= 0) {
+        return "Progress: downloading...";
+    }
+    const suffix = ` ${((bytesDownloaded / totalBytes) * 100).toFixed(1)}%`;
+    const barWidth = Math.max(1, innerWidth - suffix.length - 2);
+    const progress = Math.max(0, Math.min(1, bytesDownloaded / totalBytes));
+    const filled = Math.round(barWidth * progress);
+    const empty = Math.max(0, barWidth - filled);
+    return `[${"█".repeat(filled)}${"░".repeat(empty)}]${suffix}`;
+}
+function buildDownloadingRows(state, innerWidth) {
+    if (!state.download) {
+        return [`Loading: ${state.loadingMessage}`];
+    }
+    const filename = state.download.filename.includes("/")
+        ? (state.download.filename.split("/").pop() ?? state.download.filename)
+        : state.download.filename;
+    const rows = [];
+    rows.push((0, colors_1.colorText)(`Downloading ${fitLeft(filename, Math.max(1, innerWidth - 12))}`, colors_1.GRADIENT_BLUE));
+    rows.push((0, colors_1.colorText)(buildProgressBar(innerWidth, state.download.bytesDownloaded, state.download.totalBytes), colors_1.SUCCESS_GREEN));
+    return rows;
+}
+function buildCancelConfirmRows(innerWidth) {
+    const message = fitLeft("Cancel download and delete partial file?", Math.max(1, innerWidth));
+    return [(0, colors_1.colorText)(message, colors_1.WARNING_YELLOW), ""];
+}
+function renderDownloaderLines(options) {
+    const width = Math.max(20, options.width);
+    const state = options.state;
+    const innerWidth = Math.max(1, width - 2);
+    const rows = [];
+    rows.push(makeBorderTop(width));
+    if (state.phase !== "downloading") {
+        const tabs = [
+            tabText("Most Downloaded", state.tab),
+            tabText("Top Rated", state.tab),
+            tabText("Newest", state.tab)
+        ].join(" ");
+        const memText = `RAM: ${state.ramGb.toFixed(1)}GB | VRAM: ${state.vramGb.toFixed(1)}GB | Disk: ${state.diskFreeGb.toFixed(1)}GB`;
+        const memWidth = Math.min(charLength(memText), Math.max(24, innerWidth - 10));
+        const tabsWidth = Math.max(1, innerWidth - memWidth - 1);
+        let tabsCell = tabs;
+        if (charLength(tabsCell) > tabsWidth) {
+            tabsCell = fitLeft(" Most Downloaded   Top Rated   Newest ", tabsWidth);
+        }
+        const tabsPadding = " ".repeat(Math.max(0, tabsWidth - charLength(tabsCell)));
+        rows.push(lineWithBorders(`${tabsCell}${tabsPadding} ${fitRight(memText, memWidth)}`, innerWidth));
+    }
+    let bodyRows = [];
+    if (state.view === "models") {
+        if (state.phase === "loading-models") {
+            bodyRows = fillRows([`Loading: ${state.loadingMessage}`], DOWNLOADER_MODEL_BODY_ROWS);
+        }
+        else if (state.phase === "error" && state.errorMessage.length > 0) {
+            bodyRows = fillRows([`Error: ${state.errorMessage}`], DOWNLOADER_MODEL_BODY_ROWS);
+        }
+        else {
+            bodyRows = fillRows(buildModelRows(state, innerWidth, DOWNLOADER_MODEL_BODY_ROWS), DOWNLOADER_MODEL_BODY_ROWS);
+        }
+    }
+    else if (state.phase === "downloading") {
+        bodyRows = state.cancelConfirmOpen
+            ? buildCancelConfirmRows(innerWidth)
+            : buildDownloadingRows(state, innerWidth);
+    }
+    else if (state.phase === "loading-files") {
+        bodyRows = fillRows([`Loading: ${state.loadingMessage}`], DOWNLOADER_FILE_BODY_ROWS);
+    }
+    else if (state.phase === "error" && state.errorMessage.length > 0) {
+        bodyRows = fillRows([`Error: ${state.errorMessage}`], DOWNLOADER_FILE_BODY_ROWS);
+    }
+    else {
+        const fileRows = [
+            (0, colors_1.colorText)(`Files for ${fitLeft(state.selectedRepoId, Math.max(1, innerWidth - 10))}`, colors_1.GRADIENT_BLUE),
+            ...buildFileRows(state, innerWidth, DOWNLOADER_FILE_BODY_ROWS - 1)
+        ];
+        bodyRows = fillRows(fileRows, DOWNLOADER_FILE_BODY_ROWS);
+    }
+    rows.push(...bodyRows.map((row) => lineWithBorders(row, innerWidth)));
+    if (state.phase === "downloading") {
+        const status = state.download?.statusText ?? "Downloading...";
+        const left = state.cancelConfirmOpen ? "[Enter] Yes  [Esc] No" : "[Esc] Cancel";
+        const statusWidth = Math.max(1, innerWidth - Array.from(left).length - 1);
+        const footer = composeSplitFooter(left, fitRight(status, statusWidth), innerWidth);
+        rows.push(lineWithBorders((0, colors_1.horizontalGradient)(footer, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW), innerWidth));
+    }
+    else {
+        const footer = state.view === "models"
+            ? "[Enter] Select  [↑/↓] Move  [←/→] Sort  [Esc] Close"
+            : "[Enter] Download  [↑/↓] Move  [Esc] Back";
+        rows.push(lineWithBorders((0, colors_1.horizontalGradient)(footer, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW), innerWidth));
+    }
+    rows.push(makeBorderBottom(width));
+    return rows;
+}

package/dist/gateway/adapters/discord.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordAdapter = void 0;
+exports.chunkDiscordMessage = chunkDiscordMessage;
+const formatting_1 = require("#gateway/adapters/formatting");
+const DEFAULT_API_BASE_URL = "https://discord.com/api/v10";
+const DEFAULT_MAX_MESSAGE_LENGTH = 2000;
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toDate(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value instanceof Date) {
+        return Number.isNaN(value.valueOf()) ? undefined : value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            return undefined;
+        }
+        return new Date(value);
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.valueOf()) ? undefined : parsed;
+}
+function toDiscordMessageLike(payload) {
+    if (!isObject(payload)) {
+        return null;
+    }
+    return payload;
+}
+function chunkDiscordMessage(text, maxLength = DEFAULT_MAX_MESSAGE_LENGTH) {
+    const normalizedText = (0, formatting_1.normalizeOutboundText)(text);
+    return (0, formatting_1.chunkOutboundText)(normalizedText, maxLength);
+}
+function toInboundMessage(payload) {
+    const message = toDiscordMessageLike(payload);
+    if (!message) {
+        return null;
+    }
+    const senderId = message.author?.id;
+    const username = message.author?.username;
+    const text = message.content;
+    const channelId = message.channelId ?? message.channel?.id;
+    if (typeof senderId !== "string" ||
+        typeof text !== "string" ||
+        typeof channelId !== "string" ||
+        senderId.trim().length === 0 ||
+        text.trim().length === 0 ||
+        channelId.trim().length === 0) {
+        return null;
+    }
+    if (message.author?.bot || message.author?.system || message.webhookId) {
+        return null;
+    }
+    return {
+        platform: "discord",
+        senderId,
+        channelId,
+        text,
+        messageId: message.id,
+        timestamp: toDate(message.createdTimestamp ?? message.createdAt),
+        metadata: {
+            guildId: message.guildId ?? undefined,
+            authorUsername: username,
+            isDm: !message.guildId
+        }
+    };
+}
+class DiscordAdapter {
+    platform = "discord";
+    botToken;
+    apiBaseUrl;
+    maxMessageLength;
+    constructor(options) {
+        this.botToken = options.botToken.trim();
+        this.apiBaseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).trim().replace(/\/+$/, "");
+        this.maxMessageLength = Math.max(1, Math.trunc(options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH));
+    }
+    parseInbound(payload) {
+        const message = toInboundMessage(payload);
+        return message ? [message] : [];
+    }
+    formatOutbound(context, response) {
+        const channelId = context.session.channelId.trim() || context.message.channelId?.trim();
+        if (!channelId) {
+            return null;
+        }
+        const chunks = chunkDiscordMessage(response.text, this.maxMessageLength);
+        if (chunks.length === 0) {
+            return null;
+        }
+        const requests = chunks.map((chunk) => ({
+            method: "POST",
+            endpoint: `${this.apiBaseUrl}/channels/${channelId}/messages`,
+            headers: {
+                authorization: `Bot ${this.botToken}`,
+                "content-type": "application/json"
+            },
+            body: {
+                content: chunk
+            }
+        }));
+        return requests.length === 1 ? (requests[0] ?? null) : requests;
+    }
+}
+exports.DiscordAdapter = DiscordAdapter;

package/dist/gateway/adapters/formatting.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripCommonMarkdown = stripCommonMarkdown;
+exports.sanitizeMentions = sanitizeMentions;
+exports.normalizeOutboundText = normalizeOutboundText;
+exports.chunkOutboundText = chunkOutboundText;
+const MENTION_GUARD = "\u200B";
+function splitByLimit(value, maxLength) {
+    if (value.length <= maxLength) {
+        return [value];
+    }
+    const chunks = [];
+    let current = value;
+    while (current.length > maxLength) {
+        chunks.push(current.slice(0, maxLength));
+        current = current.slice(maxLength);
+    }
+    if (current.length > 0) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+function stripCommonMarkdown(input) {
+    let output = input;
+    output = output.replace(/```[^\n]*\n?/gu, "");
+    output = output.replace(/```/gu, "");
+    output = output.replace(/`([^`]+)`/gu, "$1");
+    output = output.replace(/`/gu, "");
+    const pairedPatterns = [
+        [/\*\*([^*\n][^*]*?)\*\*/gu, "$1"],
+        [/__([^_\n][^_]*?)__/gu, "$1"],
+        [/~~([^~\n][^~]*?)~~/gu, "$1"],
+        [/\*([^*\n]+)\*/gu, "$1"],
+        [/_([^_\n]+)_/gu, "$1"]
+    ];
+    for (const [pattern, replacement] of pairedPatterns) {
+        let previous = "";
+        while (previous !== output) {
+            previous = output;
+            output = output.replace(pattern, replacement);
+        }
+    }
+    return output;
+}
+function sanitizeMentions(input) {
+    let output = input;
+    output = output.replace(/@(everyone|here)\b/giu, (_match, group) => `@${MENTION_GUARD}${group}`);
+    output = output.replace(/<@([!&]?\d+)>/gu, `<@${MENTION_GUARD}$1>`);
+    output = output.replace(/(^|[\s([{'"`])@([A-Za-z0-9_.-]{1,64})/gu, (_match, prefix, mention) => `${prefix}@${MENTION_GUARD}${mention}`);
+    return output;
+}
+function normalizeOutboundText(input) {
+    let output = input.replace(/\r\n?/gu, "\n");
+    output = output.trim();
+    output = output.replace(/\n{3,}/gu, "\n\n");
+    output = stripCommonMarkdown(output);
+    output = sanitizeMentions(output);
+    output = output.replace(/\n{3,}/gu, "\n\n");
+    return output.trim();
+}
+function chunkOutboundText(input, maxLength) {
+    const normalizedMaxLength = Math.max(1, Math.trunc(maxLength));
+    const text = input.trim();
+    if (text.length === 0) {
+        return [];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        if (text.length - start <= normalizedMaxLength) {
+            const lastChunk = text.slice(start).trim();
+            if (lastChunk.length > 0) {
+                chunks.push(lastChunk);
+            }
+            break;
+        }
+        const window = text.slice(start, start + normalizedMaxLength + 1);
+        const breakOnNewline = window.lastIndexOf("\n");
+        const breakOnSpace = window.lastIndexOf(" ");
+        const breakOffset = Math.max(breakOnNewline, breakOnSpace);
+        let end = breakOffset > 0 ? start + breakOffset : start + normalizedMaxLength;
+        let chunk = text.slice(start, end).trim();
+        if (chunk.length === 0) {
+            end = start + normalizedMaxLength;
+            chunk = text.slice(start, end).trim();
+        }
+        if (chunk.length > 0) {
+            chunks.push(...splitByLimit(chunk, normalizedMaxLength));
+        }
+        start = end;
+        while (start < text.length && /\s/u.test(text[start] ?? "")) {
+            start += 1;
+        }
+    }
+    return chunks.filter((chunk) => chunk.length > 0);
+}

package/dist/gateway/adapters/telegram.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAdapter = void 0;
+const formatting_1 = require("#gateway/adapters/formatting");
+const DEFAULT_API_BASE_URL = "https://api.telegram.org";
+const DEFAULT_MAX_MESSAGE_LENGTH = 4000;
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function asTelegramUpdate(value) {
+    if (!isObject(value)) {
+        return null;
+    }
+    return value;
+}
+function toInboundMessage(update) {
+    const message = update.message;
+    if (!message) {
+        return null;
+    }
+    const text = message?.text;
+    const fromId = message?.from?.id;
+    const chatId = message?.chat?.id;
+    if (typeof text !== "string" || typeof fromId !== "number" || typeof chatId !== "number") {
+        return null;
+    }
+    return {
+        platform: "telegram",
+        senderId: fromId.toString(),
+        channelId: chatId.toString(),
+        text,
+        messageId: message.message_id?.toString(),
+        timestamp: typeof message.date === "number" ? new Date(message.date * 1000) : undefined,
+        metadata: {
+            updateId: update.update_id,
+            chatType: message.chat?.type,
+            username: message.from?.username
+        }
+    };
+}
+function parseUpdates(payload) {
+    if (!isObject(payload)) {
+        return [];
+    }
+    const envelope = payload;
+    if (Array.isArray(envelope.result)) {
+        return envelope.result.map((item) => asTelegramUpdate(item)).filter((item) => item !== null);
+    }
+    const single = asTelegramUpdate(payload);
+    return single ? [single] : [];
+}
+function parseReplyMessageId(messageId) {
+    if (!messageId) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(messageId, 10);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+class TelegramAdapter {
+    platform = "telegram";
+    botToken;
+    apiBaseUrl;
+    maxMessageLength;
+    constructor(options) {
+        this.botToken = options.botToken.trim();
+        this.apiBaseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+        this.maxMessageLength = Math.max(1, Math.trunc(options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH));
+    }
+    parseInbound(payload) {
+        const updates = parseUpdates(payload);
+        return updates
+            .map((update) => toInboundMessage(update))
+            .filter((message) => message !== null);
+    }
+    formatOutbound(context, response) {
+        const normalizedText = (0, formatting_1.normalizeOutboundText)(response.text);
+        const chunks = (0, formatting_1.chunkOutboundText)(normalizedText, this.maxMessageLength);
+        if (chunks.length === 0) {
+            return null;
+        }
+        const chatId = context.session.channelId.trim() || context.message.channelId?.trim() || context.message.senderId;
+        const replyToMessageId = parseReplyMessageId(context.message.messageId);
+        const requests = chunks.map((chunk, index) => {
+            const body = {
+                chat_id: chatId,
+                text: chunk
+            };
+            if (index === 0 && replyToMessageId !== undefined) {
+                body.reply_to_message_id = replyToMessageId;
+            }
+            return {
+                method: "POST",
+                endpoint: `${this.apiBaseUrl}/bot${this.botToken}/sendMessage`,
+                headers: {
+                    "content-type": "application/json"
+                },
+                body
+            };
+        });
+        return requests.length === 1 ? (requests[0] ?? null) : requests;
+    }
+}
+exports.TelegramAdapter = TelegramAdapter;

package/dist/gateway/adapters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });