@offerpilot/axiomruntime 0.0.1

package/dist/telegram/handlers/document.js

@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { escapeHtml, truncateText } from "../interaction/formatter.js";
+import { completeAgentProfile, showReadyCard } from "./setup.js";
+export const MAX_TEXT_ATTACHMENT_BYTES = 2 * 1024 * 1024;
+export const MAX_IMAGE_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+export const MAX_ATTACHMENTS_PER_PROMPT = 8;
+export function registerDocumentHandler(bot, deps) {
+    bot.on("message:document", async (ctx) => {
+        const document = ctx.message.document;
+        if (!document.file_name) {
+            await ctx.reply("文件必须包含文件名。");
+            return;
+        }
+        const isImage = document.mime_type?.startsWith("image/") ?? false;
+        await receiveAttachment(ctx, deps, {
+            name: document.file_name,
+            kind: isImage ? "image" : "text",
+            mimeType: document.mime_type,
+            declaredSize: document.file_size
+        });
+    });
+    bot.on("message:photo", async (ctx) => {
+        const photo = ctx.message.photo.at(-1);
+        if (!photo)
+            return;
+        await receiveAttachment(ctx, deps, {
+            name: `telegram-photo-${ctx.message.message_id}.jpg`,
+            kind: "image",
+            mimeType: "image/jpeg",
+            declaredSize: photo.file_size
+        });
+    });
+}
+async function receiveAttachment(ctx, deps, incoming) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const current = deps.sessionManager.getOrCreate(chatId);
+    if (current.attachments.length >= MAX_ATTACHMENTS_PER_PROMPT) {
+        await ctx.reply(`一次最多附加 ${MAX_ATTACHMENTS_PER_PROMPT} 个文件；请先发送问题使用现有附件。`);
+        return;
+    }
+    const maxBytes = incoming.kind === "image" ? MAX_IMAGE_ATTACHMENT_BYTES : MAX_TEXT_ATTACHMENT_BYTES;
+    if (incoming.declaredSize && incoming.declaredSize > maxBytes) {
+        await ctx.reply(formatSizeLimit(incoming.kind, maxBytes));
+        return;
+    }
+    try {
+        const buffer = await downloadTelegramFile(ctx, deps.config.token, maxBytes);
+        let text = "";
+        if (incoming.kind === "text") {
+            try {
+                text = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+            }
+            catch {
+                await ctx.reply("该文件不是有效的 UTF-8 文本；二进制文件暂不能作为文本上下文。图片请直接以照片或 image/* 文件发送。");
+                return;
+            }
+        }
+        if (current.setupStep === "agent_profile") {
+            if (incoming.kind === "image") {
+                await ctx.reply("画像设置阶段请发送 UTF-8 文本文档；完成设置后即可发送图片。");
+                return;
+            }
+            const next = await completeAgentProfile(ctx, deps, text, { showReady: false });
+            if (next)
+                await showReadyCard(ctx, deps, next);
+            return;
+        }
+        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "ai-gateway-telegram-"));
+        const filePath = path.join(dir, path.basename(incoming.name));
+        await fs.writeFile(filePath, buffer);
+        const attachment = {
+            name: incoming.name,
+            path: filePath,
+            text: incoming.kind === "text" ? truncateText(text, 24000) : "",
+            kind: incoming.kind,
+            mimeType: incoming.mimeType,
+            sizeBytes: buffer.length,
+            createdAt: new Date().toISOString()
+        };
+        const session = deps.sessionManager.addAttachment(chatId, attachment);
+        const label = incoming.kind === "image" ? "图片" : "文件";
+        await ctx.reply(`已附加${label} <code>${escapeHtml(incoming.name)}</code>，将在下一条请求中使用（${session.attachments.length}/${MAX_ATTACHMENTS_PER_PROMPT}）。`, { parse_mode: "HTML" });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await ctx.reply(`附件处理失败：<code>${escapeHtml(message)}</code>`, { parse_mode: "HTML" });
+    }
+}
+async function downloadTelegramFile(ctx, token, maxBytes) {
+    const file = await ctx.getFile();
+    if (!file.file_path)
+        throw new Error("Telegram 未返回文件路径。");
+    const response = await fetch(`https://api.telegram.org/file/bot${token}/${file.file_path}`);
+    if (!response.ok)
+        throw new Error(`下载失败（HTTP ${response.status}）。`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length > maxBytes)
+        throw new Error(formatSizeLimit("file", maxBytes));
+    return buffer;
+}
+function formatSizeLimit(kind, maxBytes) {
+    const label = kind === "image" ? "图片" : kind === "text" ? "文本文件" : "文件";
+    return `${label}过大，单个附件上限为 ${Math.round(maxBytes / 1024 / 1024)} MB。`;
+}

package/dist/telegram/handlers/memory.js

@@ -0,0 +1,305 @@
+import { escapeHtml } from "../interaction/formatter.js";
+import { buildMemoryClearConfirmKeyboard, buildMemoryManageKeyboard, buildRememberScopeKeyboard } from "../interaction/keyboards.js";
+export async function handleRememberCommand(ctx, deps) {
+    const memory = deps.memoryService;
+    if (!memory) {
+        await ctx.reply("Bot Memory 未启用。");
+        return;
+    }
+    const text = String(ctx.match ?? "").trim();
+    if (!text) {
+        await ctx.reply("🤖 这条记忆保存到哪里？", {
+            reply_markup: buildRememberScopeKeyboard()
+        });
+        return;
+    }
+    try {
+        const parsed = parseRememberInput(text);
+        if (parsed.kind === "pin") {
+            await ctx.reply("加密记忆尚未启用，凭证类内容不会明文保存。");
+            return;
+        }
+        if (parsed.kind === "profile") {
+            const entry = memory.saveProfile(ctx.chat.id, parsed.content);
+            await replySaved(ctx, entry, "用户画像已更新");
+            return;
+        }
+        if (parsed.kind === "persona") {
+            const entry = memory.savePersona(ctx.chat.id, parsed.content);
+            await replySaved(ctx, entry, "Bot 人设已更新");
+            return;
+        }
+        const entry = memory.remember(ctx.chat.id, parsed);
+        await replySaved(ctx, entry, "记住了");
+    }
+    catch (error) {
+        await ctx.reply(`记忆失败：<code>${escapeHtml(error instanceof Error ? error.message : String(error))}</code>`, {
+            parse_mode: "HTML"
+        });
+    }
+}
+export async function handleRememberScopeCallback(ctx, deps, mode) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    if (!deps.memoryService) {
+        await editOrReply(ctx, "Bot Memory 未启用。", undefined, { edit: true });
+        return;
+    }
+    const session = deps.sessionManager.getOrCreate(chatId);
+    deps.sessionManager.update(session.id, { setupStep: rememberModeToStep(mode) });
+    await editOrReply(ctx, "🤖 输入要记录的记忆吧", undefined, { edit: true });
+}
+export async function handleRememberInput(ctx, deps, text, session) {
+    const mode = rememberStepToMode(session.setupStep);
+    if (!mode)
+        return false;
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return false;
+    const memory = deps.memoryService;
+    if (!memory) {
+        deps.sessionManager.update(session.id, { setupStep: "ready" });
+        await ctx.reply("Bot Memory 未启用。");
+        return true;
+    }
+    const content = text.trim();
+    if (!content) {
+        await ctx.reply("🤖 输入要记录的记忆吧");
+        return true;
+    }
+    deps.sessionManager.update(session.id, { setupStep: "ready" });
+    try {
+        const entry = memory.remember(chatId, {
+            content,
+            scope: mode === "auto" ? undefined : mode
+        });
+        await replySaved(ctx, entry, "记住了");
+    }
+    catch (error) {
+        await ctx.reply(`记忆失败：<code>${escapeHtml(error instanceof Error ? error.message : String(error))}</code>`, {
+            parse_mode: "HTML"
+        });
+    }
+    return true;
+}
+export function isRememberSetupStep(step) {
+    return rememberStepToMode(step) !== null;
+}
+export async function handleMemoryManageInput(ctx, deps, text, session) {
+    if (session.setupStep !== "memory_promote")
+        return false;
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return false;
+    const memory = deps.memoryService;
+    if (!memory) {
+        deps.sessionManager.update(session.id, { setupStep: "ready" });
+        await ctx.reply("Bot Memory 未启用。");
+        return true;
+    }
+    const id = Number(text.trim().replace(/^#/, ""));
+    if (!Number.isInteger(id) || id <= 0) {
+        await ctx.reply("🤖 请输入要升级的记忆编号，例如 12");
+        return true;
+    }
+    deps.sessionManager.update(session.id, { setupStep: "ready" });
+    try {
+        const entry = memory.promote(chatId, id);
+        await ctx.reply(entry ? `🤖 已升级为 global：<code>#${entry.id}</code>` : "🤖 只能升级当前 bot 的记忆。", {
+            parse_mode: "HTML"
+        });
+    }
+    catch (error) {
+        await ctx.reply(`升级失败：<code>${escapeHtml(error instanceof Error ? error.message : String(error))}</code>`, {
+            parse_mode: "HTML"
+        });
+    }
+    return true;
+}
+export async function handleForgetCommand(ctx, deps) {
+    const memory = deps.memoryService;
+    if (!memory) {
+        await ctx.reply("Bot Memory 未启用。");
+        return;
+    }
+    const selector = String(ctx.match ?? "").trim();
+    if (!selector) {
+        await ctx.reply("用法：/forget <编号或关键词>");
+        return;
+    }
+    const count = memory.delete(ctx.chat.id, selector);
+    await ctx.reply(count > 0 ? `🤖 已删除 ${count} 条记忆。` : "🤖 没有找到匹配的记忆。");
+}
+export async function handleMemoriesCommand(ctx, deps) {
+    const memory = deps.memoryService;
+    if (!memory) {
+        await ctx.reply("Bot Memory 未启用。");
+        return;
+    }
+    const text = String(ctx.match ?? "").trim();
+    const query = text.startsWith("search ") ? text.slice("search ".length).trim() : text;
+    await ctx.reply(memory.formatList(ctx.chat.id, query || undefined), { parse_mode: "HTML" });
+}
+export async function handleMemoryCommand(ctx, deps) {
+    const memory = deps.memoryService;
+    if (!memory) {
+        await ctx.reply("Bot Memory 未启用。");
+        return;
+    }
+    const text = String(ctx.match ?? "").trim();
+    if (!text) {
+        await showMemoryPanel(ctx);
+        return;
+    }
+    const [command, first, second] = text.split(/\s+/);
+    if (command === "promote" && /^\d+$/.test(first ?? "")) {
+        try {
+            const entry = memory.promote(ctx.chat.id, Number(first));
+            await ctx.reply(entry ? `🤖 已升级为 global：<code>#${entry.id}</code>` : "🤖 只能升级当前 bot 的记忆。", {
+                parse_mode: "HTML"
+            });
+        }
+        catch (error) {
+            await ctx.reply(`升级失败：<code>${escapeHtml(error instanceof Error ? error.message : String(error))}</code>`, {
+                parse_mode: "HTML"
+            });
+        }
+        return;
+    }
+    if (command === "clear" && (first === "bot" || first === "global")) {
+        if (second !== "confirm") {
+            await askMemoryClearConfirm(ctx, first);
+            return;
+        }
+        const count = memory.clearScope(ctx.chat.id, first);
+        await ctx.reply(`🤖 已清空 ${first} 记忆 ${count} 条。`);
+        return;
+    }
+    if (command === "pin" || command === "unlock" || command === "lock") {
+        await ctx.reply("加密记忆尚未启用。");
+        return;
+    }
+    if (command === "export" || command === "import") {
+        await ctx.reply("Memory export/import 将在后续阶段启用。");
+        return;
+    }
+    await showMemoryPanel(ctx);
+}
+export async function handleMemoryManageCallback(ctx, deps, action, scope) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const memory = deps.memoryService;
+    if (!memory) {
+        await editOrReply(ctx, "Bot Memory 未启用。", undefined, { edit: true });
+        return;
+    }
+    if (action === "panel") {
+        await showMemoryPanel(ctx, { edit: true });
+        return;
+    }
+    if (action === "promote") {
+        const session = deps.sessionManager.getOrCreate(chatId);
+        deps.sessionManager.update(session.id, { setupStep: "memory_promote" });
+        await editOrReply(ctx, "🤖 输入要升级为 global 的记忆编号吧", undefined, { edit: true });
+        return;
+    }
+    if (action === "clear" && isMemoryScope(scope)) {
+        await askMemoryClearConfirm(ctx, scope, { edit: true });
+        return;
+    }
+    if (action === "clear_confirm" && isMemoryScope(scope)) {
+        const session = deps.sessionManager.getOrCreate(chatId);
+        deps.sessionManager.update(session.id, { setupStep: "ready" });
+        const count = memory.clearScope(chatId, scope);
+        await editOrReply(ctx, `🤖 已清空 ${scope} 记忆 ${count} 条。`, {
+            parse_mode: "HTML",
+            reply_markup: buildMemoryManageKeyboard()
+        }, { edit: true });
+        return;
+    }
+    await showMemoryPanel(ctx, { edit: true });
+}
+function parseRememberInput(text) {
+    const [command, ...rest] = text.split(/\s+/);
+    const content = rest.join(" ").trim();
+    if (command === "profile" && content)
+        return { kind: "profile", content };
+    if (command === "persona" && content)
+        return { kind: "persona", content };
+    if (command === "pin" && content)
+        return { kind: "pin", content };
+    if (command === "global" && content)
+        return { scope: "global", content };
+    if (command === "bot" && content)
+        return { scope: "bot", content };
+    if (command === "temp") {
+        const parsed = parseTempMemory(rest.join(" "));
+        if (parsed)
+            return parsed;
+    }
+    return { content: text };
+}
+function parseTempMemory(value) {
+    const text = value.trim();
+    const match = text.match(/^(\d+)([hd])\s+([\s\S]+)$/);
+    if (!match)
+        return text ? { content: text, scope: "bot", duration: "short_term" } : null;
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const content = match[3]?.trim();
+    if (!content || !Number.isFinite(amount) || amount <= 0)
+        return null;
+    const ttlMs = amount * (unit === "h" ? 60 * 60 * 1000 : 24 * 60 * 60 * 1000);
+    return { content, scope: "bot", duration: "short_term", ttlMs };
+}
+function rememberModeToStep(mode) {
+    if (mode === "global")
+        return "remember_global";
+    if (mode === "bot")
+        return "remember_bot";
+    return "remember_auto";
+}
+function rememberStepToMode(step) {
+    if (step === "remember_global")
+        return "global";
+    if (step === "remember_bot")
+        return "bot";
+    if (step === "remember_auto")
+        return "auto";
+    return null;
+}
+function isMemoryScope(value) {
+    return value === "bot" || value === "global";
+}
+async function showMemoryPanel(ctx, options = {}) {
+    await editOrReply(ctx, "🤖 选择你要管理的记忆操作吧", {
+        reply_markup: buildMemoryManageKeyboard()
+    }, options);
+}
+async function askMemoryClearConfirm(ctx, scope, options = {}) {
+    await editOrReply(ctx, `🤖 确认清空 ${scope} 记忆吗？`, {
+        reply_markup: buildMemoryClearConfirmKeyboard(scope)
+    }, options);
+}
+async function editOrReply(ctx, text, extra, options = {}) {
+    if (!options.edit) {
+        await ctx.reply(text, extra);
+        return;
+    }
+    try {
+        await ctx.editMessageText(text, extra);
+        return;
+    }
+    catch {
+        // The source message may not be editable; replying keeps the flow usable.
+    }
+    await ctx.reply(text, extra);
+}
+async function replySaved(ctx, entry, message) {
+    await ctx.reply([
+        `🤖 ${escapeHtml(message)}：<code>#${entry.id}</code>`,
+        `Scope：<code>${escapeHtml(entry.scope)}</code> · Category：<code>${escapeHtml(entry.category)}</code>`
+    ].join("\n"), { parse_mode: "HTML" });
+}