@offerpilot/axiomruntime 0.0.1

package/dist/telegram/handlers/setup.js

@@ -0,0 +1,527 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { readCache } from "../../core/config/cache-store.js";
+import { listProviders } from "../../core/providers/provider-service.js";
+import { resolveProviderForTool } from "../../core/runner/fallback.js";
+import { updateTelegramConfig } from "../config.js";
+import { safeSetChatCommandMenu } from "../interaction/command-menu.js";
+import { Formatter } from "../interaction/formatter.js";
+import { buildAgentProfileBackKeyboard, buildAgentProfileKeyboard, buildModelPickerKeyboard, buildProviderPickerKeyboard, buildReadyKeyboard, buildReadyModeKeyboard, buildWorkdirListKeyboard, buildWorkdirStartKeyboard } from "../interaction/keyboards.js";
+import { buildFullProfilePrompt, buildPersonaPrompt, splitProfileAndPersona } from "../memory/memory-service.js";
+export const AGENT_PROFILE_GENERATION_TIMEOUT_MS = 3 * 60 * 1000;
+export async function startSetup(ctx, deps) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    deps.sessionManager.startSetup(chatId);
+    await showSetupProviderPicker(ctx, deps);
+}
+export async function showSetupProviderPicker(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    if (session.setupStep !== "ready") {
+        deps.sessionManager.update(session.id, { setupStep: "model" });
+    }
+    const choices = await getProviderChoices(options.forcedEngine);
+    const extra = {
+        parse_mode: "HTML",
+        reply_markup: buildProviderPickerKeyboard(choices.map((choice) => choice.provider.name), session.setupStep === "ready" ? "ready" : "setup", options.forcedEngine)
+    };
+    const text = choices.length
+        ? Formatter.modelPrompt(options.reselect)
+        : "🤖 没有可用的 Provider / Model";
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(text, extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh prompt.
+        }
+    }
+    await ctx.reply(text, extra);
+}
+export async function showSetupModelPicker(ctx, deps, providerIndex, options = {}) {
+    const choices = await getProviderChoices(options.forcedEngine);
+    const choice = choices[providerIndex];
+    if (!choice) {
+        await ctx.answerCallbackQuery?.({ text: "Provider 不存在" }).catch(() => undefined);
+        await showSetupProviderPicker(ctx, deps, { edit: true, forcedEngine: options.forcedEngine });
+        return;
+    }
+    if (!choice.models.length) {
+        await ctx.answerCallbackQuery?.({ text: "没有可用模型" }).catch(() => undefined);
+        await showSetupProviderPicker(ctx, deps, { edit: true, forcedEngine: options.forcedEngine });
+        return;
+    }
+    await editOrReply(ctx, `🤖 选择 ${choice.provider.name} 的模型吧`, {
+        parse_mode: "HTML",
+        reply_markup: buildModelPickerKeyboard(choice.models, providerIndex, "setup", options.forcedEngine)
+    });
+}
+export async function selectSetupModel(ctx, deps, providerIndex, modelIndex, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const choices = await getProviderChoices(options.forcedEngine);
+    const choice = choices[providerIndex];
+    const model = choice?.models[modelIndex];
+    if (!choice || !model) {
+        await ctx.answerCallbackQuery?.({ text: "模型不存在" }).catch(() => undefined);
+        await showSetupProviderPicker(ctx, deps, { edit: true, forcedEngine: options.forcedEngine });
+        return;
+    }
+    const engine = options.forcedEngine ?? inferEngineFromModel(model);
+    await updateRuntimeTelegramConfig(deps, {
+        provider: choice.provider.name,
+        model,
+        defaultEngine: engine
+    });
+    deps.sessionManager.update(session.id, {
+        engine,
+        engineSessionId: null,
+        botContextFingerprint: null,
+        setupStep: "workdir"
+    });
+    await showWorkdirStart(ctx, deps, { edit: true });
+}
+export async function showWorkdirStart(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const workdirs = deps.sessionManager.getWorkdirs(chatId);
+    const text = options.prompt ?? Formatter.workdirList(workdirs);
+    const extra = {
+        parse_mode: "HTML",
+        reply_markup: buildWorkdirStartKeyboard(workdirs, options.scope ?? "setup")
+    };
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(text, extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh prompt.
+        }
+    }
+    await ctx.reply(text, extra);
+}
+export async function showWorkdirList(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const workdirs = deps.sessionManager.getWorkdirs(chatId);
+    const extra = {
+        parse_mode: "HTML",
+        reply_markup: buildWorkdirListKeyboard(workdirs, options.scope ?? "setup")
+    };
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(Formatter.workdirList(workdirs), extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh prompt.
+        }
+    }
+    await ctx.reply(Formatter.workdirList(workdirs), extra);
+}
+export async function askCustomWorkdir(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    deps.sessionManager.update(session.id, { setupStep: options.returnToReady ? "edit_custom_workdir" : "custom_workdir" });
+    const extra = { parse_mode: "HTML" };
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(Formatter.customWorkdirPrompt(), extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh prompt.
+        }
+    }
+    await ctx.reply(Formatter.customWorkdirPrompt(), extra);
+}
+export async function setWorkdir(ctx, deps, rawPath, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return null;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const cwd = options.fromCustomInput ? resolveHomeChild(rawPath) : expandHome(rawPath.trim());
+    if (!cwd || cwd === os.homedir()) {
+        await ctx.reply(Formatter.workdirRequired(), { parse_mode: "HTML" });
+        return null;
+    }
+    fs.mkdirSync(cwd, { recursive: true });
+    const next = deps.sessionManager.update(session.id, {
+        cwd,
+        engineSessionId: null,
+        botContextFingerprint: null,
+        setupStep: options.returnToReady ? "ready" : "agent_profile"
+    });
+    deps.sessionManager.rememberWorkdir(chatId, cwd);
+    await options.afterSet?.(next);
+    if (deps.bot) {
+        const customCommands = deps.sessionManager.listCustomCommands(chatId, cwd);
+        await safeSetChatCommandMenu(deps.bot, chatId, next.engine, customCommands);
+    }
+    if (options.returnToReady) {
+        await showReadyCard(ctx, deps, next, { edit: options.edit });
+        return next;
+    }
+    await showAgentProfilePrompt(ctx, { edit: options.edit });
+    return next;
+}
+export async function selectCli(ctx, deps, engine) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    await showSetupProviderPicker(ctx, deps, {
+        forcedEngine: engine,
+        reselect: true,
+        edit: session.setupStep === "ready"
+    });
+}
+export async function showAgentProfilePrompt(ctx, options = {}) {
+    const extra = {
+        parse_mode: "HTML",
+        reply_markup: buildAgentProfileKeyboard()
+    };
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(Formatter.agentProfilePrompt(), extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh prompt.
+        }
+    }
+    await ctx.reply(Formatter.agentProfilePrompt(), extra);
+}
+export async function completeAgentProfile(ctx, deps, description, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return null;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const rawDescription = description?.trim();
+    if (rawDescription && deps.memoryService) {
+        await saveGeneratedProfileMemory(ctx, deps, session, rawDescription);
+    }
+    const next = deps.sessionManager.update(session.id, { setupStep: "ready" });
+    if (deps.bot) {
+        const customCommands = deps.sessionManager.listCustomCommands(chatId, next.cwd);
+        await safeSetChatCommandMenu(deps.bot, chatId, next.engine, customCommands);
+    }
+    if (options.showReady !== false) {
+        await showReadyCard(ctx, deps, next, { edit: options.edit });
+    }
+    return next;
+}
+export async function remindSetup(ctx, deps, session) {
+    if (session.setupStep === "model") {
+        await showSetupProviderPicker(ctx, deps);
+        return true;
+    }
+    if (session.setupStep === "workdir" || session.setupStep === "custom_workdir" || session.setupStep === "edit_custom_workdir") {
+        await ctx.reply(Formatter.workdirRequired(), { parse_mode: "HTML" });
+        return true;
+    }
+    if (session.setupStep === "cli") {
+        await showSetupProviderPicker(ctx, deps);
+        return true;
+    }
+    if (session.setupStep === "agent_profile") {
+        await ctx.reply(Formatter.agentProfilePrompt(), {
+            parse_mode: "HTML",
+            reply_markup: buildAgentProfileKeyboard()
+        });
+        return true;
+    }
+    return false;
+}
+export async function showReadyCard(ctx, deps, session, options = {}) {
+    const resolved = await getResolvedProvider(session.engine, deps.config);
+    const extra = buildConfigExtra(session, resolved.provider);
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(Formatter.sessionCard(session, resolved.provider, resolved.error), extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh card.
+        }
+    }
+    await ctx.reply(Formatter.sessionCard(session, resolved.provider, resolved.error), extra);
+}
+export async function showConfigPanel(ctx, deps, session, options = {}) {
+    const resolved = await getResolvedProvider(session.engine, deps.config);
+    const extra = buildConfigExtra(session, resolved.provider);
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(Formatter.configPanel(), extra);
+            return;
+        }
+        catch {
+            // The original message may no longer be editable; fall back to a fresh panel.
+        }
+    }
+    await ctx.reply(Formatter.configPanel(), extra);
+}
+export async function showAgentProfile(ctx, deps) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const content = deps.memoryService
+        ? formatProfileMemory(deps.memoryService, chatId)
+        : "暂未启用 Bot Memory。";
+    await editOrReply(ctx, Formatter.agentProfile(content), {
+        parse_mode: "HTML",
+        reply_markup: buildAgentProfileBackKeyboard()
+    });
+}
+export async function showReadyCliPicker(ctx, deps) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    await showReadyProviderPicker(ctx, deps, { forcedEngine: session.engine, reselect: true });
+}
+export async function selectReadyCli(ctx, deps, engine) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    await showReadyProviderPicker(ctx, deps, { forcedEngine: engine, reselect: true });
+}
+export async function showReadyProviderPicker(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const choices = await getProviderChoices(options.forcedEngine);
+    if (!choices.length) {
+        await editOrReply(ctx, "🤖 没有可用的 Provider / Model", {
+            parse_mode: "HTML",
+            reply_markup: buildProviderPickerKeyboard([], "ready", options.forcedEngine)
+        });
+        return;
+    }
+    await editOrReply(ctx, Formatter.modelPrompt(options.reselect), {
+        parse_mode: "HTML",
+        reply_markup: buildProviderPickerKeyboard(choices.map((choice) => choice.provider.name), "ready", options.forcedEngine)
+    });
+}
+export async function showReadyModelPicker(ctx, deps, providerIndex, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const choices = await getProviderChoices(options.forcedEngine);
+    const choice = choices[providerIndex];
+    if (!choice) {
+        await ctx.answerCallbackQuery?.({ text: "Provider 不存在" }).catch(() => undefined);
+        await showReadyProviderPicker(ctx, deps, { forcedEngine: options.forcedEngine });
+        return;
+    }
+    if (!choice.models.length) {
+        await ctx.answerCallbackQuery?.({ text: "没有可用模型" }).catch(() => undefined);
+        await showReadyProviderPicker(ctx, deps, { forcedEngine: options.forcedEngine });
+        return;
+    }
+    await editOrReply(ctx, `🤖 选择 ${choice.provider.name} 的默认模型吧`, {
+        parse_mode: "HTML",
+        reply_markup: buildModelPickerKeyboard(choice.models, providerIndex, "ready", options.forcedEngine)
+    });
+}
+export async function selectReadyModel(ctx, deps, providerIndex, modelIndex, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const choices = await getProviderChoices(options.forcedEngine);
+    const choice = choices[providerIndex];
+    const model = choice?.models[modelIndex];
+    if (!choice || !model) {
+        await ctx.answerCallbackQuery?.({ text: "模型不存在" }).catch(() => undefined);
+        await showReadyProviderPicker(ctx, deps, { forcedEngine: options.forcedEngine });
+        return;
+    }
+    const engine = options.forcedEngine ?? inferEngineFromModel(model);
+    await updateRuntimeTelegramConfig(deps, {
+        provider: choice.provider.name,
+        model,
+        defaultEngine: engine
+    });
+    const next = deps.sessionManager.update(session.id, {
+        engine,
+        engineSessionId: null,
+        botContextFingerprint: null,
+        setupStep: "ready"
+    });
+    if (deps.bot) {
+        const customCommands = deps.sessionManager.listCustomCommands(chatId, next.cwd);
+        await safeSetChatCommandMenu(deps.bot, chatId, engine, customCommands);
+    }
+    await showReadyCard(ctx, deps, next, { edit: true });
+}
+export async function showReadyModePicker(ctx) {
+    await editOrReply(ctx, "🤖 选择权限模式吧", {
+        parse_mode: "HTML",
+        reply_markup: buildReadyModeKeyboard()
+    });
+}
+export async function selectReadyMode(ctx, deps, mode) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const next = deps.sessionManager.update(session.id, { permissionMode: mode, setupStep: "ready" });
+    await updateRuntimeTelegramConfig(deps, { defaultPermissionMode: mode });
+    await showReadyCard(ctx, deps, next, { edit: true });
+}
+async function getResolvedProvider(engine, config) {
+    try {
+        const resolved = await resolveProviderForTool(engine, config?.provider, config?.model);
+        return { provider: { name: resolved.provider.name, model: resolved.model } };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function buildConfigExtra(session, provider) {
+    const providerModel = provider
+        ? `${provider.name} · ${provider.model}`
+        : "配置 Provider / Model";
+    return {
+        parse_mode: "HTML",
+        reply_markup: buildReadyKeyboard({
+            cli: session.engine === "claude" ? "Claude Code" : "Codex",
+            providerModel,
+            permissionMode: session.permissionMode,
+            cwd: session.cwd
+        })
+    };
+}
+async function getProviderChoices(engine) {
+    const [providers, cache] = await Promise.all([listProviders(), readCache()]);
+    return providers
+        .map((provider) => ({
+        provider,
+        models: getSelectableModels(provider, cache.providers[provider.name]?.models ?? [], engine)
+    }))
+        .filter((choice) => choice.models.length > 0);
+}
+function getSelectableModels(provider, cachedModels, engine) {
+    const models = [
+        provider.model,
+        ...cachedModels
+    ].filter((model) => Boolean(model));
+    const unique = [...new Set(models)];
+    if (!engine)
+        return unique;
+    return unique.filter((model) => inferEngineFromModel(model) === engine);
+}
+export function inferEngineFromModel(model) {
+    return isGptLikeModel(model) ? "codex" : "claude";
+}
+function isGptLikeModel(model) {
+    const value = model.toLowerCase();
+    return value.includes("gpt")
+        || value.includes("codex")
+        || value.includes("openai")
+        || /^o\d/.test(value);
+}
+async function updateRuntimeTelegramConfig(deps, patch) {
+    const updated = deps.updateConfig
+        ? await deps.updateConfig(patch)
+        : await updateTelegramConfig(patch);
+    if (deps.config) {
+        Object.assign(deps.config, updated);
+    }
+}
+async function editOrReply(ctx, text, extra) {
+    try {
+        await ctx.editMessageText(text, extra);
+        return;
+    }
+    catch {
+        // The original message may no longer be editable; fall back to a fresh message.
+    }
+    await ctx.reply(text, extra);
+}
+async function saveGeneratedProfileMemory(ctx, deps, session, rawDescription) {
+    const memoryService = deps.memoryService;
+    if (!memoryService)
+        return;
+    memoryService.saveRawDescription(session.chatId, rawDescription);
+    const existingProfile = memoryService.getProfile(session.chatId);
+    if (existingProfile) {
+        const prompt = buildPersonaPrompt(rawDescription, existingProfile.content);
+        const generated = await generateProfileText(ctx, deps, session, prompt);
+        memoryService.savePersona(session.chatId, generated || rawDescription);
+        return;
+    }
+    const prompt = buildFullProfilePrompt(rawDescription);
+    const generated = await generateProfileText(ctx, deps, session, prompt);
+    if (!generated) {
+        memoryService.saveProfile(session.chatId, rawDescription);
+        return;
+    }
+    const { profile, persona } = splitProfileAndPersona(generated);
+    memoryService.saveProfile(session.chatId, profile || rawDescription);
+    if (persona) {
+        memoryService.savePersona(session.chatId, persona);
+    }
+}
+async function generateProfileText(ctx, deps, session, prompt) {
+    const engine = resolveSetupEngine(deps, session.engine);
+    if (!engine)
+        return null;
+    try {
+        const result = await engine.execute({
+            chatId: ctx.chat?.id ?? session.chatId,
+            prompt,
+            cwd: session.cwd,
+            resume: null,
+            permissionMode: session.permissionMode,
+            providerName: deps.config?.provider,
+            modelName: deps.config?.model,
+            timeoutMs: AGENT_PROFILE_GENERATION_TIMEOUT_MS,
+            onPermission: async () => true
+        });
+        return result.response.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSetupEngine(deps, engine) {
+    if (deps.engines?.[engine])
+        return deps.engines[engine];
+    return engine === "codex" ? deps.codexEngine : deps.claudeEngine;
+}
+function formatProfileMemory(memoryService, chatId) {
+    const profile = memoryService.getProfile(chatId);
+    const persona = memoryService.getPersona(chatId);
+    if (!profile && !persona)
+        return "暂未生成记忆画像。";
+    return [
+        profile ? ["# 用户画像", "", profile.content].join("\n") : "",
+        persona ? ["# Bot 人设", "", persona.content].join("\n") : ""
+    ].filter(Boolean).join("\n\n");
+}
+function resolveHomeChild(value) {
+    const name = value.trim().replace(/^~\//, "").replace(/^\/+/, "");
+    return path.join(os.homedir(), name);
+}
+function expandHome(value) {
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/"))
+        return path.join(os.homedir(), value.slice(2));
+    return value;
+}

package/dist/telegram/handlers/usage.js

@@ -0,0 +1,124 @@
+import { resolveProviderForTool } from "../../core/runner/fallback.js";
+import { estimateTokenCostUsdFromConfig, upsertModelPrice } from "../../core/usage/pricing.js";
+import { Formatter, formatUsagePriceInvalid, formatUsagePricePrompt, formatUsagePriceSaved } from "../interaction/formatter.js";
+import { buildUsagePricingKeyboard } from "../interaction/keyboards.js";
+export async function showUsagePanel(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const resolved = await getResolvedProvider(session, deps.config);
+    const usage = resolved.provider ? findProviderUsage(session, resolved.provider.name) : undefined;
+    const estimatedCostUsd = resolved.provider && usage
+        ? await estimateStoredUsageCost(resolved.provider.name, resolved.provider.model, usage)
+        : undefined;
+    const missingPrice = Boolean(resolved.provider
+        && usage
+        && usage.costUsd <= 0
+        && usage.unknownCostCount > 0
+        && estimatedCostUsd === undefined
+        && !options.tokenOnly);
+    const extra = {
+        parse_mode: "HTML",
+        ...(missingPrice ? { reply_markup: buildUsagePricingKeyboard() } : {})
+    };
+    const text = Formatter.sessionUsage(session, resolved.provider, resolved.error, {
+        estimatedCostUsd,
+        tokenOnly: options.tokenOnly,
+        missingPrice
+    });
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(text, extra);
+            return;
+        }
+        catch {
+            // The original usage message may no longer be editable.
+        }
+    }
+    await ctx.reply(text, extra);
+}
+export async function askUsagePrice(ctx, deps, options = {}) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const resolved = await getResolvedProvider(session, deps.config);
+    if (!resolved.provider) {
+        await ctx.reply(Formatter.sessionUsage(session, undefined, resolved.error), { parse_mode: "HTML" });
+        return;
+    }
+    deps.sessionManager.update(session.id, { setupStep: "usage_price_input" });
+    const text = formatUsagePricePrompt(resolved.provider);
+    const extra = { parse_mode: "HTML" };
+    if (options.edit) {
+        try {
+            await ctx.editMessageText(text, extra);
+            return;
+        }
+        catch {
+            // The original usage message may no longer be editable.
+        }
+    }
+    await ctx.reply(text, extra);
+}
+export async function handleUsagePriceInput(ctx, deps, rawText) {
+    const chatId = ctx.chat?.id;
+    if (!chatId)
+        return;
+    const session = deps.sessionManager.getOrCreate(chatId);
+    const resolved = await getResolvedProvider(session, deps.config);
+    if (!resolved.provider) {
+        deps.sessionManager.update(session.id, { setupStep: "ready" });
+        await ctx.reply(Formatter.sessionUsage(session, undefined, resolved.error), { parse_mode: "HTML" });
+        return;
+    }
+    const parsed = parseModelPriceInput(rawText);
+    if (!parsed) {
+        await ctx.reply(formatUsagePriceInvalid(), { parse_mode: "HTML" });
+        return;
+    }
+    await upsertModelPrice(resolved.provider.name, resolved.provider.model, {
+        inputPerMillionUsd: parsed.inputPerMillionUsd,
+        outputPerMillionUsd: parsed.outputPerMillionUsd,
+        cacheReadPerMillionUsd: parsed.cacheReadPerMillionUsd
+    });
+    deps.sessionManager.update(session.id, { setupStep: "ready" });
+    await ctx.reply(formatUsagePriceSaved(resolved.provider, parsed.inputPerMillionUsd, parsed.outputPerMillionUsd, parsed.cacheReadPerMillionUsd), { parse_mode: "HTML" });
+    await showUsagePanel(ctx, deps);
+}
+export function parseModelPriceInput(rawText) {
+    const numbers = rawText
+        .replace(/\$/g, "")
+        .match(/\d+(?:\.\d+)?/g)
+        ?.map((item) => Number(item))
+        .filter((item) => Number.isFinite(item) && item >= 0) ?? [];
+    if (numbers.length < 3)
+        return null;
+    return {
+        inputPerMillionUsd: numbers[0],
+        outputPerMillionUsd: numbers[1],
+        cacheReadPerMillionUsd: numbers[2]
+    };
+}
+async function getResolvedProvider(session, config) {
+    try {
+        const resolved = await resolveProviderForTool(session.engine, config?.provider, config?.model);
+        return { provider: { name: resolved.provider.name, model: resolved.model } };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function findProviderUsage(session, providerName) {
+    return session.providerUsage.find((item) => item.provider === providerName);
+}
+async function estimateStoredUsageCost(providerName, model, usage) {
+    const tokenUsage = {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        totalTokens: usage.totalTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens
+    };
+    return estimateTokenCostUsdFromConfig(providerName, model, tokenUsage);
+}