@offerpilot/axiomruntime 0.0.1

package/dist/telegram/interaction/formatter.js

@@ -0,0 +1,487 @@
+import { parseToolName } from "./tool-name.js";
+export const TELEGRAM_MESSAGE_LIMIT = 4096;
+export function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+export function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 3)
+        return value.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+export function formatCodeBlock(code, language = "") {
+    const className = language ? ` class="language-${escapeHtml(language)}"` : "";
+    return `<pre><code${className}>${escapeHtml(truncateText(code, 3500))}</code></pre>`;
+}
+export function markdownToTelegramHtml(value, maxLength = 2500) {
+    const text = truncateText((value || "(empty)").trim(), maxLength);
+    if (!text)
+        return "(empty)";
+    return renderMarkdownBlocks(text);
+}
+export function splitPlainText(value, maxLength = 3800) {
+    if (value.length <= maxLength)
+        return [value];
+    const chunks = [];
+    let remaining = value;
+    while (remaining.length > maxLength) {
+        const newlineIndex = remaining.lastIndexOf("\n", maxLength);
+        const splitAt = newlineIndex > maxLength * 0.6 ? newlineIndex + 1 : maxLength;
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt);
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}
+export const Formatter = {
+    modelPrompt(reselect = false) {
+        return reselect
+            ? "🤖 重新选择你要使用的大模型吧"
+            : "🤖 确定你要使用的大模型吧";
+    },
+    modelRequired() {
+        return "🤖 先确定你要使用的大模型吧";
+    },
+    workdirPrompt() {
+        return "🤖 你好呀，先确定工作路径吧";
+    },
+    workdirChangePrompt() {
+        return "🤖 输入你要设置的工作路径吧";
+    },
+    commandNamePrompt() {
+        return "🤖 请输入命令名称，如：/ci [type] [channel]";
+    },
+    commandTemplatePrompt(params) {
+        if (params.length === 0) {
+            return "🤖 请输入对应终端命令";
+        }
+        const example = params.map((p) => `[${p}]`).join(" ");
+        return `🤖 请输入对应终端命令，用 ${example} 作为占位符\n\n如：./gradlew createReleaseTag -Pmessage="[message]" -PbuildType=[type]`;
+    },
+    commandRegistered(name, description) {
+        return `✅ 命令已注册：<code>/${name}</code>\n用法：<code>${description}</code>`;
+    },
+    workdirRequired() {
+        return "🤖 请选确定工作路径哦";
+    },
+    workdirList(workdirs) {
+        if (!workdirs.length) {
+            return "🤖 还没有记录过工作路径。";
+        }
+        return "🤖 选择一个已存在的工作路径吧";
+    },
+    customWorkdirPrompt() {
+        return [
+            "✏️ <b>输入工作目录名称</b>",
+            "",
+            "我会固定创建或使用：",
+            "<code>~/你输入的名称</code>"
+        ].join("\n");
+    },
+    cliPrompt(_cwd) {
+        return "🤖 确定你要使用的CLI吧";
+    },
+    cliRequired() {
+        return "🤖 先确定你想使用的CLI哦。";
+    },
+    agentProfilePrompt() {
+        return "🤖 介绍一下我和你吧，可以帮你构建画像哦";
+    },
+    sessionCard(session, provider, error) {
+        const suffix = error && !provider ? `\n\n<i>${escapeHtml(truncateText(error, 160))}</i>` : "";
+        return `🤖 会话<code>${escapeHtml(session.id.slice(0, 8))}</code>已就绪，可以开始和我聊天啦${suffix}`;
+    },
+    sessionCleared(session) {
+        return `🤖 会话<code>${escapeHtml(session.id.slice(0, 8))}</code>聊天记录已清理`;
+    },
+    configPanel() {
+        return "🤖 Telegram Bot 配置";
+    },
+    agentProfile(content) {
+        return [
+            "<b>Bot Memory</b>",
+            "",
+            formatCodeBlock(content, "markdown")
+        ].join("\n");
+    },
+    sessionUsage(session, provider, error, options = {}) {
+        const providerName = provider?.name ?? "(unknown)";
+        const model = provider?.model ?? "(unknown)";
+        const usage = provider ? session.providerUsage.find((item) => item.provider === provider.name) : undefined;
+        if (options.tokenOnly && usage) {
+            return [
+                "🤖 当前会话 Token",
+                "",
+                `Session：<code>${escapeHtml(session.id.slice(0, 8))}</code>`,
+                `Provider：<code>${escapeHtml(providerName)}</code>`,
+                `Model：<code>${escapeHtml(model)}</code>`,
+                `Tokens：<code>${escapeHtml(formatTokenCount(usage.totalTokens))}</code>`
+            ].join("\n");
+        }
+        const lines = [
+            "🤖 当前会话用量",
+            "",
+            `Session：<code>${escapeHtml(session.id.slice(0, 8))}</code>`,
+            `Provider：<code>${escapeHtml(providerName)}</code>`,
+            `Model：<code>${escapeHtml(model)}</code>`,
+            `额度：<code>${escapeHtml(formatProviderCost(usage, options))}</code>`
+        ];
+        if (usage?.totalTokens) {
+            lines.push(`Tokens：<code>${escapeHtml(formatTokenCount(usage.totalTokens))}</code>`);
+        }
+        if (usage?.cacheReadInputTokens) {
+            lines.push(`Cache Read：<code>${escapeHtml(formatTokenCount(usage.cacheReadInputTokens))}</code>`);
+        }
+        if (options.missingPrice && usage) {
+            lines.push("", "当前模型还没有价格表。可以输入价格后计算额度，或选择未知只查看 token。");
+        }
+        if (error && !provider) {
+            lines.push("", `<i>${escapeHtml(truncateText(error, 160))}</i>`);
+        }
+        return lines.join("\n");
+    },
+    taskCompleted(engine, result, maxOutputLength = 2500) {
+        void engine;
+        return markdownToTelegramHtml(result.response || "(empty)", maxOutputLength);
+    },
+    resultCard(result) {
+        const lines = [];
+        const parts = [];
+        if (result.duration && result.duration > 0) {
+            const seconds = Math.round(result.duration / 1000);
+            parts.push(seconds >= 60 ? `${Math.floor(seconds / 60)}m${seconds % 60}s` : `${seconds}s`);
+        }
+        if (result.provider)
+            parts.push(result.provider);
+        if (result.model)
+            parts.push(result.model);
+        lines.push(`✅ <b>完成</b>${parts.length ? ` · ${parts.map(escapeHtml).join(" · ")}` : ""}`);
+        const summary = extractSummary(result.response, 200);
+        if (summary) {
+            lines.push("");
+            lines.push(escapeHtml(summary));
+        }
+        if (result.filesChanged?.length) {
+            lines.push("");
+            const stats = parseDiffStats(result.diff);
+            const header = stats
+                ? `📁 ${result.filesChanged.length} file(s) changed · <code>${stats}</code>`
+                : `📁 ${result.filesChanged.length} file(s) changed`;
+            lines.push(header);
+            const maxFiles = 6;
+            const shown = result.filesChanged.slice(0, maxFiles);
+            const fileLines = shown.map((f) => `  ${escapeHtml(f)}`);
+            if (result.filesChanged.length > maxFiles) {
+                fileLines.push(`  … +${result.filesChanged.length - maxFiles} more`);
+            }
+            lines.push(`<pre>${fileLines.join("\n")}</pre>`);
+        }
+        return lines.join("\n");
+    },
+    taskFailed(error) {
+        return [`<b>Failed</b>`, "", `<pre>${escapeHtml(truncateText(error, 1500))}</pre>`].join("\n");
+    },
+    progress(update, options = {}) {
+        if (update.phase === "thinking") {
+            if (update.message && /fallback|切换|provider/i.test(update.message)) {
+                return `↻ ${escapeHtml(truncateText(update.message, 80))}`;
+            }
+            return "⏱️ 思考中…";
+        }
+        if (update.phase === "writing") {
+            return "✍️ 正在整理回复…";
+        }
+        if (update.phase === "tool_calling") {
+            const tool = parseToolName(update.tool, {
+                kind: update.toolKind,
+                mcpServer: update.mcpServer
+            });
+            const count = options.toolCount && options.toolCount > 0 ? `（第 ${options.toolCount} 个操作）` : "";
+            if (tool.kind === "mcp") {
+                const server = tool.mcpServer ? `${escapeHtml(tool.mcpServer)} / ` : "";
+                return `🔌 调用 MCP · <code>${server}${escapeHtml(tool.name)}</code>${count}`;
+            }
+            if (tool.kind === "command") {
+                return `⌨️ 执行命令 · <code>${escapeHtml(tool.name)}</code>`;
+            }
+            if (isEditingTool(tool.raw)) {
+                return `✏️ 编辑文件 · <code>${escapeHtml(tool.name)}</code>`;
+            }
+            return `🔧 运行 <code>${escapeHtml(tool.name)}</code>${count}`;
+        }
+        return "⏱️ 思考中…";
+    },
+    progressTimeline(entries) {
+        return entries.join("\n");
+    },
+    fileChangeSummary(filesChanged, diff) {
+        if (!filesChanged?.length)
+            return "";
+        const maxFiles = 10;
+        const shown = filesChanged.slice(0, maxFiles);
+        const lines = shown.map((f) => `  ${escapeHtml(f)}`);
+        if (filesChanged.length > maxFiles) {
+            lines.push(`  … +${filesChanged.length - maxFiles} more`);
+        }
+        const stats = parseDiffStats(diff);
+        const header = stats
+            ? `📁 ${filesChanged.length} file(s) changed · <code>${stats}</code>`
+            : `📁 ${filesChanged.length} file(s) changed`;
+        return [header, `<pre>${lines.join("\n")}</pre>`].join("\n");
+    },
+    taskAborted() {
+        return "<b>Stopped</b>";
+    },
+    help() {
+        return [
+            "<b>AI Gateway Telegram Bot</b>",
+            "",
+            "首次使用会先选择大模型、工作路径和会话信息。",
+            "",
+            "<b>Commands</b>",
+            "/claude - 切换 Claude Code 并重新选择模型",
+            "/codex - 切换 Codex 并重新选择模型",
+            "/reset - 重置会话信息",
+            "/fresh - 清空聊天窗口",
+            "/cwd path - 查看或切换工作路径",
+            "/config - 查看或编辑 Bot 配置",
+            "/usage - 查看当前会话额度",
+            "/remember - 保存一条 Bot 记忆",
+            "/forget - 删除 Bot 记忆",
+            "/memories - 查看 Bot 记忆",
+            "/memory - 管理 Bot 记忆",
+            "/pin - 回复一条 Bot 回答并固定为关键上下文",
+            "/unpin - 取消固定上下文",
+            "/terminal command - 在当前工作目录执行终端命令",
+            "/restart - 重启 Bot",
+            "/help - 查看帮助"
+        ].join("\n");
+    },
+    welcome(name) {
+        return [
+            `Hello <b>${escapeHtml(name)}</b>`,
+            "",
+            "AI Gateway Bot is ready. Send /reset to reset session info."
+        ].join("\n");
+    }
+};
+function isEditingTool(tool) {
+    return /^(Write|Edit|MultiEdit|NotebookEdit|apply_patch|patch)$/i.test(tool);
+}
+function extractSummary(response, maxLength) {
+    if (!response)
+        return "";
+    const lines = response.trim().split("\n");
+    const contentLines = lines.filter((l) => l.trim() && !l.startsWith("#") && !l.startsWith("```"));
+    if (!contentLines.length)
+        return truncateText(lines.join(" ").trim(), maxLength);
+    let summary = contentLines[0].trim();
+    if (/[：:…]$/.test(summary)) {
+        for (let i = 1; i < contentLines.length && summary.length < maxLength; i++) {
+            const line = contentLines[i].trim().replace(/^[-*\d.]+\s*/, "");
+            if (!line)
+                break;
+            summary += " " + line;
+        }
+    }
+    return truncateText(summary.trim(), maxLength);
+}
+function renderMarkdownBlocks(value) {
+    const lines = value.replace(/\r\n?/g, "\n").split("\n");
+    const output = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        const fence = line.match(/^\s*```([A-Za-z0-9_-]*)\s*$/);
+        if (fence) {
+            const language = fence[1] ?? "";
+            const codeLines = [];
+            index += 1;
+            while (index < lines.length && !/^\s*```\s*$/.test(lines[index])) {
+                codeLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length)
+                index += 1;
+            output.push(formatCodeBlock(codeLines.join("\n"), language));
+            continue;
+        }
+        if (!line.trim()) {
+            output.push("");
+            index += 1;
+            continue;
+        }
+        if (isMarkdownTableStart(lines, index)) {
+            const tableLines = [];
+            while (index < lines.length && lines[index].includes("|") && lines[index].trim()) {
+                tableLines.push(lines[index]);
+                index += 1;
+            }
+            output.push(renderMarkdownTable(tableLines));
+            continue;
+        }
+        const heading = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*#*\s*$/);
+        if (heading) {
+            output.push(`<b>${renderMarkdownInline(heading[1])}</b>`);
+            index += 1;
+            continue;
+        }
+        const unordered = line.match(/^(\s*)[-*+]\s+(.+)$/);
+        if (unordered) {
+            const indent = "  ".repeat(Math.floor(unordered[1].length / 2));
+            output.push(`${indent}• ${renderMarkdownInline(unordered[2])}`);
+            index += 1;
+            continue;
+        }
+        const ordered = line.match(/^(\s*)\d+[.)]\s+(.+)$/);
+        if (ordered) {
+            const indent = "  ".repeat(Math.floor(ordered[1].length / 2));
+            output.push(`${indent}${line.trimStart().match(/^\d+[.)]/)?.[0] ?? "1."} ${renderMarkdownInline(ordered[2])}`);
+            index += 1;
+            continue;
+        }
+        output.push(renderMarkdownInline(line));
+        index += 1;
+    }
+    return output.join("\n");
+}
+function renderMarkdownInline(value) {
+    const placeholders = [];
+    const protect = (html) => {
+        const token = `\u0000${placeholders.length}\u0000`;
+        placeholders.push(html);
+        return token;
+    };
+    let text = value.replace(/`([^`\n]+)`/g, (_match, code) => protect(`<code>${escapeHtml(code)}</code>`));
+    text = text.replace(/\[([^\]\n]+)]\((https?:\/\/[^\s)]+)\)/g, (_match, label, href) => {
+        const safeHref = escapeHtmlAttribute(href);
+        return protect(`<a href="${safeHref}">${escapeHtml(label)}</a>`);
+    });
+    text = escapeHtml(text);
+    text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+    text = text.replace(/__(.+?)__/g, "<b>$1</b>");
+    text = text.replace(/~~(.+?)~~/g, "<s>$1</s>");
+    text = text.replace(/(^|[^\*])\*([^*\n]+)\*(?!\*)/g, "$1<i>$2</i>");
+    return text.replace(/\u0000(\d+)\u0000/g, (_match, indexText) => placeholders[Number(indexText)] ?? "");
+}
+function escapeHtmlAttribute(value) {
+    return escapeHtml(value).replace(/"/g, "&quot;");
+}
+function isMarkdownTableStart(lines, index) {
+    const current = lines[index];
+    const next = lines[index + 1];
+    return Boolean(current?.includes("|") &&
+        next &&
+        /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(next));
+}
+function renderMarkdownTable(lines) {
+    const rows = lines
+        .filter((_line, index) => index !== 1)
+        .map(parseMarkdownTableRow)
+        .filter((row) => row.length > 0);
+    if (!rows.length)
+        return "";
+    const headers = rows[0] ?? [];
+    const dataRows = rows.slice(1);
+    if (!headers.length || !dataRows.length) {
+        return rows.map((row) => row.map(renderMarkdownInline).join(" / ")).join("\n");
+    }
+    return dataRows
+        .map((row, rowIndex) => renderMarkdownTableItem(headers, row, rowIndex))
+        .filter(Boolean)
+        .join("\n\n");
+}
+function parseMarkdownTableRow(line) {
+    const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    return trimmed.split("|").map((cell) => cell.trim());
+}
+function renderMarkdownTableItem(headers, row, rowIndex) {
+    const title = row[0]?.trim() || `${stripInlineMarkdown(headers[0] ?? "项目")}${rowIndex + 1}`;
+    const lines = [`<b>${renderMarkdownInline(title)}</b>`];
+    headers.slice(1).forEach((header, index) => {
+        const value = row[index + 1]?.trim();
+        if (!value)
+            return;
+        lines.push(`${escapeHtml(stripInlineMarkdown(header))}：${renderMarkdownInline(value)}`);
+    });
+    return lines.join("\n");
+}
+function stripInlineMarkdown(value) {
+    return value
+        .replace(/\[([^\]\n]+)]\(([^)]+)\)/g, "$1")
+        .replace(/`([^`\n]+)`/g, "$1")
+        .replace(/\*\*(.+?)\*\*/g, "$1")
+        .replace(/__(.+?)__/g, "$1")
+        .replace(/~~(.+?)~~/g, "$1")
+        .replace(/(^|[^\*])\*([^*\n]+)\*(?!\*)/g, "$1$2");
+}
+export function formatUsagePricePrompt(provider) {
+    return [
+        "🤖 输入当前模型价格吧",
+        "",
+        `Provider：<code>${escapeHtml(provider.name)}</code>`,
+        `Model：<code>${escapeHtml(provider.model)}</code>`,
+        "",
+        "格式：<code>输入价格/输出价格/缓存读取价格</code>",
+        "单位：美元 / 百万 tokens",
+        "示例：<code>1/3/0.1</code>"
+    ].join("\n");
+}
+export function formatUsagePriceSaved(provider, inputPrice, outputPrice, cacheReadPrice) {
+    return [
+        "🤖 价格已保存",
+        "",
+        `Provider：<code>${escapeHtml(provider.name)}</code>`,
+        `Model：<code>${escapeHtml(provider.model)}</code>`,
+        `Input：<code>$${inputPrice}/1M tokens</code>`,
+        `Output：<code>$${outputPrice}/1M tokens</code>`,
+        `Cache Read：<code>$${cacheReadPrice}/1M tokens</code>`
+    ].join("\n");
+}
+export function formatUsagePriceInvalid() {
+    return [
+        "🤖 价格格式不对",
+        "",
+        "请按 <code>输入价格/输出价格/缓存读取价格</code> 输入，例如 <code>1/3/0.1</code>。"
+    ].join("\n");
+}
+function formatProviderCost(usage, options = {}) {
+    if (!usage)
+        return "$0.0000";
+    if (typeof options.estimatedCostUsd === "number" && Number.isFinite(options.estimatedCostUsd)) {
+        return `$${options.estimatedCostUsd.toFixed(4)}${options.estimatedCostLabel ?? "（按价格表估算）"}`;
+    }
+    if (usage.costUsd > 0) {
+        const suffix = usage.unknownCostCount > 0 ? ` + ${usage.unknownCostCount} 次未知` : "";
+        return `$${usage.costUsd.toFixed(4)}${suffix}`;
+    }
+    if (usage.unknownCostCount > 0) {
+        return usage.totalTokens > 0
+            ? `缺少价格表`
+            : "额度未知";
+    }
+    return "$0.0000";
+}
+function formatTokenCount(tokens) {
+    return Math.round(tokens).toLocaleString("en-US");
+}
+function parseDiffStats(diff) {
+    if (!diff)
+        return null;
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added++;
+        else if (line.startsWith("-") && !line.startsWith("---"))
+            removed++;
+    }
+    if (added === 0 && removed === 0)
+        return null;
+    return `+${added} -${removed}`;
+}

package/dist/telegram/interaction/keyboards.js

@@ -0,0 +1,145 @@
+import { InlineKeyboard } from "grammy";
+export function buildApprovalKeyboard(id) {
+    return new InlineKeyboard()
+        .text("Allow", `perm:approve:${id}`)
+        .text("Deny", `perm:deny:${id}`)
+        .row()
+        .text("Allow all", `perm:approve_all:${id}`)
+        .text("Skip", `perm:skip:${id}`);
+}
+export function buildWorkdirStartKeyboard(workdirs, scope = "setup") {
+    const keyboard = new InlineKeyboard();
+    for (const [index, cwd] of workdirs.slice(0, 8).entries()) {
+        keyboard.text(cwd, `${scope}:workdir:pick:${index}`).row();
+    }
+    return keyboard.text("自定义", `${scope}:workdir:custom`);
+}
+export function buildWorkdirListKeyboard(workdirs, scope = "setup") {
+    const keyboard = new InlineKeyboard();
+    for (const [index, cwd] of workdirs.slice(0, 8).entries()) {
+        keyboard.text(cwd, `${scope}:workdir:pick:${index}`).row();
+    }
+    return keyboard.text("back", `${scope}:workdir:back`);
+}
+export function buildCliKeyboard() {
+    return new InlineKeyboard()
+        .text("Claude Code", "setup:cli:claude")
+        .text("Codex", "setup:cli:codex");
+}
+export function buildProviderPickerKeyboard(providers, scope, forcedEngine) {
+    const keyboard = new InlineKeyboard();
+    for (const [index, provider] of providers.entries()) {
+        keyboard.text(provider, buildProviderPickCallback(scope, index, forcedEngine));
+        if (index < providers.length - 1 || scope === "ready") {
+            keyboard.row();
+        }
+    }
+    if (scope === "ready") {
+        return keyboard.text("back", "ready:back");
+    }
+    return keyboard;
+}
+export function buildModelPickerKeyboard(models, providerIndex, scope, forcedEngine) {
+    const keyboard = new InlineKeyboard();
+    for (const [index, model] of models.entries()) {
+        keyboard.text(model, buildModelPickCallback(scope, providerIndex, index, forcedEngine)).row();
+    }
+    return keyboard.text("back", buildModelBackCallback(scope, forcedEngine));
+}
+export function buildAgentProfileKeyboard() {
+    return new InlineKeyboard()
+        .text("暂不提供", "setup:agent:skip");
+}
+export function buildAgentProfileBackKeyboard() {
+    return new InlineKeyboard()
+        .text("back", "ready:back");
+}
+export function buildReadyKeyboard(input) {
+    return new InlineKeyboard()
+        .text(input.cli, "ready:cli")
+        .row()
+        .text(input.providerModel, "ready:provider")
+        .row()
+        .text(formatPermissionModeLabel(input.permissionMode), "ready:mode")
+        .row()
+        .text(input.cwd, "ready:workdir");
+}
+export function buildReadyCliKeyboard() {
+    return new InlineKeyboard()
+        .text("Claude Code", "ready:cli:pick:claude")
+        .text("Codex", "ready:cli:pick:codex")
+        .row()
+        .text("back", "ready:back");
+}
+export function buildReadyProviderKeyboard(providers) {
+    return buildProviderPickerKeyboard(providers, "ready");
+}
+export function buildReadyModelKeyboard(models, providerIndex) {
+    return buildModelPickerKeyboard(models, providerIndex, "ready");
+}
+export function buildReadyModeKeyboard() {
+    return new InlineKeyboard()
+        .text("默认权限", "ready:mode:pick:default")
+        .row()
+        .text("接受编辑", "ready:mode:pick:acceptEdits")
+        .row()
+        .text("跳过权限", "ready:mode:pick:bypassPermissions")
+        .row()
+        .text("back", "ready:back");
+}
+export function buildUsagePricingKeyboard() {
+    return new InlineKeyboard()
+        .text("输入价格", "usage:price:input")
+        .text("未知", "usage:price:unknown");
+}
+export function buildRememberScopeKeyboard() {
+    return new InlineKeyboard()
+        .text("global", "memory:remember:scope:global")
+        .text("bot", "memory:remember:scope:bot")
+        .text("auto", "memory:remember:scope:auto");
+}
+export function buildMemoryManageKeyboard() {
+    return new InlineKeyboard()
+        .text("升级为 global", "memory:manage:promote")
+        .row()
+        .text("清空 bot 记忆", "memory:manage:clear:bot")
+        .row()
+        .text("清空 global 记忆", "memory:manage:clear:global");
+}
+export function buildMemoryClearConfirmKeyboard(scope) {
+    return new InlineKeyboard()
+        .text("确认清空", `memory:manage:clear_confirm:${scope}`)
+        .text("取消", "memory:manage:panel");
+}
+export function formatPermissionModeLabel(mode) {
+    if (mode === "acceptEdits")
+        return "接受编辑";
+    if (mode === "bypassPermissions")
+        return "跳过权限";
+    return "默认权限";
+}
+export function buildResultKeyboard(hasFullOutput, hasDiff) {
+    const kb = new InlineKeyboard();
+    if (hasFullOutput)
+        kb.text("📄 完整输出", "result:full");
+    if (hasDiff)
+        kb.text("📝 查看 Diff", "result:diff");
+    return kb;
+}
+function buildProviderPickCallback(scope, index, forcedEngine) {
+    return ["setup", "ready"].includes(scope) && forcedEngine
+        ? `${scope}:provider:pick:${index}:${forcedEngine}`
+        : `${scope}:provider:pick:${index}`;
+}
+function buildModelPickCallback(scope, providerIndex, modelIndex, forcedEngine) {
+    return forcedEngine
+        ? `${scope}:model:pick:${providerIndex}:${modelIndex}:${forcedEngine}`
+        : `${scope}:model:pick:${providerIndex}:${modelIndex}`;
+}
+function buildModelBackCallback(scope, forcedEngine) {
+    if (forcedEngine)
+        return `${scope}:provider:show:${forcedEngine}`;
+    if (scope === "setup")
+        return "setup:provider:show";
+    return `${scope}:provider`;
+}