charness 3.4.0 → 3.5.0

package/dist/bot.js

@@ -215,6 +215,8 @@ const claudeUsageRefresher_1 = require("./utils/claudeUsageRefresher");
 const openCodeUsage_1 = require("./utils/openCodeUsage");
 const usageRefreshBudget_1 = require("./utils/usageRefreshBudget");
 const claudeLimitSwitch_1 = require("./utils/claudeLimitSwitch");
+const anthropicApiKeyCheck_1 = require("./utils/anthropicApiKeyCheck");
+const claudeApiKeyHelper_1 = require("./utils/claudeApiKeyHelper");
 const fallbackSwitchNotice_1 = require("./utils/fallbackSwitchNotice");
 const adapterSwitchSessionIds_1 = require("./utils/adapterSwitchSessionIds");
 const fallbackChain_1 = require("./utils/fallbackChain");
@@ -226,6 +228,8 @@ const operatorSwitchPlan_1 = require("./utils/operatorSwitchPlan");
 const backendSwitchPlan_1 = require("./utils/backendSwitchPlan");
 const selfUpdate_1 = require("./connectors/telegram/commands/selfUpdate");
 const stt_1 = require("./connectors/telegram/commands/stt");
+const claudeApiSpend_1 = require("./utils/claudeApiSpend");
+const claudeProfileUsageLines_1 = require("./utils/claudeProfileUsageLines");
 const resolveBinary_1 = require("./utils/resolveBinary");
 // ═══════════════════════════════════════════════════════════════════════════════
 //  ENV parsing & fatal validation
@@ -877,6 +881,12 @@ const limitResumeNoticePinnedMessageId = new Map();
  * Cleared by {@link cancelApiRetry} (the user took over / the session went away).
  */
 const autoContinueOffNoticedThreads = new Set();
+/**
+ * @description Threads that already got the «API credits used up» notice for the CURRENT episode
+ * ({@link handleBalanceExhausted}): that flow arms no retry either, so — like the OFF notice above — a repeated frame
+ * of the same error needs its own guard. Cleared by {@link cancelApiRetry} (the user took over / the session went away).
+ */
+const balanceExhaustedNoticedThreads = new Set();
 /**
  * The OPEN «switch» offer per thread (`utils/fallbackChain.ts`): the limit episode the buttons on the notice
  * were posted for, the rung the topic was on and the candidate list the buttons index into. A tap is honoured
@@ -1142,6 +1152,11 @@ const wedgeRecoveriesInFlight = new Set();
  */
 function handleApiError(key, cls, options = {}) {
     const k = (0, sessionKey_1.keyToString)(key);
+    // A used-up API credit balance: no wait refills it — the account is marked, and the chain or the operator takes over.
+    if (cls.kind === 'usageLimit' && cls.isBalanceExhausted === true) {
+        void handleBalanceExhausted(key, cls);
+        return;
+    }
     // An unconfirmed usage limit is probed first; it reaches the wait below only once confirmed.
     if (cls.kind === 'usageLimit' && cls.isUnconfirmed === true && handleUnconfirmedLimit(key))
         return;
@@ -1236,7 +1251,7 @@ function armApiRetryTimer(key, arming) {
     // bottom (debounced; no-op when no question is pending).
     onThreadActivityWhileQuestionPending(key);
     void state
-        .setApiRetry(key, { kind: arming.kind, attempt: arming.attempt, fireAt: arming.fireAt, ...(arming.isLimitProbe ? { isLimitProbe: true } : {}) })
+        .setApiRetry(key, { kind: arming.kind, attempt: arming.attempt, fireAt: arming.fireAt, ...(arming.isLimitProbe ? { isLimitProbe: true } : {}), ...(arming.resumeOn ? { resumeOn: arming.resumeOn } : {}) })
         .catch(e => console.error('[apiRetry] persist failed:', e));
     clearSavedFiredLimitProbe(key);
     const timer = setTimeout(() => {
@@ -1252,6 +1267,7 @@ function armApiRetryTimer(key, arming) {
         fireAt: arming.fireAt,
         limitWait: arming.limitWait,
         isLimitProbe: arming.isLimitProbe,
+        resumeOn: arming.resumeOn,
     });
 }
 /**
@@ -1443,15 +1459,90 @@ async function announceUsageLimitOrSwitch(key, cls, episodeId, initialWait, atte
         }
     }
     const texts = getLimitWaitTexts(key, wait, attempt, resumeOn);
-    const keyboard = plan.action === 'offer'
-        ? telegraf_1.Markup.inlineKeyboard(plan.candidates.map((entry, index) => [
-            telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.switchButton', { label: formatFallbackEntry(entry) }), (0, fallbackChain_1.buildFallbackSwitchCallbackData)(episodeId, index)),
-        ]))
-        : undefined;
+    const keyboard = plan.action === 'offer' ? buildFallbackSwitchKeyboard(episodeId, plan.candidates) : undefined;
     const { isPlainNoticePosted } = await announceLimitWait(key, wait, texts, isPlainNoticeDue, keyboard);
     if (keyboard && !isPlainNoticePosted)
         await replyToThread(key, (0, i18n_1.t)('fallback.switchOffer'), keyboard);
 }
+/** The «🔁 Switch to …» buttons of a limit episode's notice, one per candidate (best first; the index is into that episode's list). */
+function buildFallbackSwitchKeyboard(episodeId, candidates) {
+    return telegraf_1.Markup.inlineKeyboard(candidates.map((entry, index) => [
+        telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.switchButton', { label: formatFallbackEntry(entry) }), (0, fallbackChain_1.buildFallbackSwitchCallbackData)(episodeId, index)),
+    ]));
+}
+/** Whose API credits a balance notice names: a Claude account `«console»`, an OpenCode `provider/model`. */
+function formatBalanceOwner(from) {
+    if (from === null)
+        return (0, i18n_1.t)('fallback.backendClaude');
+    return from.backend === 'claude' ? `«${from.profile}»` : (0, fallbackChain_1.buildOpenCodeModelLabel)(from);
+}
+/**
+ * @description A used-up API credit balance on `key` («Credit balance is too low», `isBalanceExhausted`): nothing resets
+ * it, so no wait for a reset is armed and no hourly retry runs. The Claude account is marked out of credits
+ * (`creditExhaustedAt`, until the operator picks it or signs it in again, or a billed turn on it goes through), the parked
+ * episode is settled (a restart does not run this again), and the fallback chain decides as for a limit, with that
+ * account out: switching ON moves the topic at once; OFF puts «switch to …» buttons on the notice. With no rung free
+ * now, the topic waits only for a rung that comes back at a KNOWN time (the earliest reset, and only with «wait for
+ * reset» on) and resumes there; otherwise the notice is all, and an open request is answered and no longer woken. A
+ * repeat of the same episode (another frame, another scrape of the line, a scheduled run into the same balance) says
+ * nothing in the topic again; a request opened since — a scheduled run's — is still answered and no longer woken, unless
+ * a wait for another rung's reset is armed.
+ */
+async function handleBalanceExhausted(key, cls) {
+    const k = (0, sessionKey_1.keyToString)(key);
+    markLimitEpisodeSettled(key);
+    const position = getTopicFallbackPosition(key);
+    if (position?.backend === 'claude')
+        state.setClaudeProfileCreditExhausted(position.profile, new Date().toISOString());
+    const notice = `${(0, i18n_1.t)('apiRetry.balanceExhaustedNotice', { name: formatBalanceOwner(position) })}${getBalanceSpentLine(position)}`;
+    const texts = { plainNotice: notice, answerBody: (0, i18n_1.t)('requests.limit.answerBalanceExhaustedNotice') };
+    const stopped = { kind: 'autoResumeOff' };
+    if (balanceExhaustedNoticedThreads.has(k)) {
+        // Like the «wait for reset» OFF repeat: without it the wake-up engine re-prods that request into the same refused
+        // balance and ends in an alert.
+        if (getArmedApiRetry(key) === null)
+            await announceLimitWait(key, stopped, texts, false);
+        return;
+    }
+    balanceExhaustedNoticedThreads.add(k);
+    const episodeId = Date.now();
+    let plan = { action: 'none', from: position, earliest: null };
+    try {
+        plan = await planFallbackSwitch(key, cls, episodeId);
+    }
+    catch (e) {
+        console.warn(`[fallback] ${k}: the switch plan after a used-up balance failed:`, e instanceof Error ? e.message : e);
+    }
+    if (plan.action === 'auto') {
+        const to = plan.to;
+        await replyToThread(key, notice);
+        const outcome = await switchTopicToFallbackEntry(key, plan.from, to, { isAnnounced: true }).catch((e) => {
+            console.warn(`[fallback] ${k}: the auto-switch to ${formatFallbackEntry(to)} failed:`, e instanceof Error ? e.message : e);
+            return { isSwitched: false };
+        });
+        // The notice is already in the topic; an open request still hears that the work stopped.
+        if (!outcome.isSwitched)
+            await announceLimitWait(key, stopped, texts, false);
+        return;
+    }
+    if (plan.action === 'offer') {
+        const keyboard = buildFallbackSwitchKeyboard(episodeId, plan.candidates);
+        const { isPlainNoticePosted } = await announceLimitWait(key, stopped, texts, true, keyboard);
+        if (!isPlainNoticePosted)
+            await replyToThread(key, (0, i18n_1.t)('fallback.switchOffer'), keyboard);
+        return;
+    }
+    if (plan.earliest && state.checkIsAutoContinueOnLimitEnabled(key)) {
+        const fireAt = plan.earliest.untilMs + apiErrorRetry_1.resetBufferMs;
+        const wait = { kind: 'afterReset', resetAt: plan.earliest.untilMs, fireAt };
+        clearLimitResumeNotice(key);
+        armApiRetryTimer(key, { kind: 'usageLimit', attempt: 1, fireAt, delayMs: Math.max(fireAt - Date.now(), 0), limitWait: wait, resumeOn: plan.earliest.entry });
+        const waitTexts = getLimitWaitTexts(key, wait, 1, plan.earliest.entry);
+        await announceLimitWait(key, wait, { plainNotice: `${notice}\n\n${waitTexts.plainNotice}`, answerBody: waitTexts.answerBody }, true);
+        return;
+    }
+    await announceLimitWait(key, stopped, texts, true);
+}
 /**
  * @description Re-aim the ARMED usage-limit wait of `key` at the rung that comes back first: the timer moves to
  * that rung's reset (+ the usual buffer), and the persisted retry record carries the rung (`resumeOn`), so the
@@ -1550,6 +1641,7 @@ function cancelApiRetry(key) {
     // error — so neither can re-notify per message.
     clearLimitResumeNotice(key);
     autoContinueOffNoticedThreads.delete(k);
+    balanceExhaustedNoticedThreads.delete(k);
     fallbackSwitchOffers.delete(k);
     // NOTE: intentionally does NOT touch the logged-out notice. `cancelApiRetry`
     // fires on EVERY inbound message (user takeover); clearing the auth notice here
@@ -1741,6 +1833,8 @@ function clearLimitResumeNotice(key) {
  * sign-in driver built here), so the driver reaches it through this late-bound slot.
  */
 let claudeProfileAuthStatusSink = null;
+/** Where an API key pasted into an API account's sign-in goes: the `/account` module too, through the same late-bound idiom. */
+let claudeProfileApiKeySink = null;
 // Out-of-band sign-in drivers (`/login`, `/connect` OAuth): `agentLogin/README.md`.
 const { cancelPendingLogin, checkIsAuthLoginAwaitingCode, cancelClaudeAuthLogin, startClaudeAuthLogin, submitClaudeAuthLoginCode, checkIsOpenCodeOAuthAwaitingReply, cancelOpenCodeOAuthLogin, startOpenCodeOAuthLogin, submitOpenCodeOAuthReply, checkIsAnyLoginInProgress, } = (0, agentLogin_1.createAgentLogin)({
     replyToThread,
@@ -1748,6 +1842,7 @@ const { cancelPendingLogin, checkIsAuthLoginAwaitingCode, cancelClaudeAuthLogin,
     clearAuthNotice,
     execFileAsync,
     onClaudeProfileAuthStatus: (key, profile, status) => claudeProfileAuthStatusSink?.(key, profile, status) ?? Promise.resolve(),
+    onClaudeProfileApiKey: (key, profile, apiKey) => claudeProfileApiKeySink?.(key, profile, apiKey) ?? Promise.resolve((0, i18n_1.t)('account.apiKeyNoDirectory', { name: profile.name })),
 });
 /**
  * @description Buffers prompts typed while an agent session is still booting so
@@ -5773,14 +5868,19 @@ function resolveThreadClaudeConfigDir(key) {
     }
     return dir;
 }
-/** `claude auth status --json` under `configDir` (`null` = `~/.claude`), the subscription login only; `null` when the probe fails. */
+/**
+ * `claude auth status --json` under `configDir` (`null` = `~/.claude`) as its sessions see it: never through an
+ * `ANTHROPIC_API_KEY` of the bot's own, with the `apiKeyHelper` of a profile that holds a pasted API key; `null` when
+ * the probe fails.
+ */
 async function readClaudeAuthStatusUnder(configDir) {
     const env = { ...process.env };
     delete env.ANTHROPIC_API_KEY;
     if (configDir !== null)
         env[claudeProfiles_1.claudeConfigDirVariableName] = configDir;
     try {
-        const { stdout } = await execFileAsync((0, resolveBinary_1.resolveClaudeBinary)(), ['auth', 'status', '--json'], { timeout: claudeAuthStatusProbeTimeoutMs, env });
+        const args = [...(0, claudeApiKeyHelper_1.buildClaudeAuthProbeSettingsArgs)(configDir), 'auth', 'status', '--json'];
+        const { stdout } = await execFileAsync((0, resolveBinary_1.resolveClaudeBinary)(), args, { timeout: claudeAuthStatusProbeTimeoutMs, env });
         return (0, claudeProfiles_1.parseClaudeAuthStatus)(stdout);
     }
     catch (e) {
@@ -5843,9 +5943,12 @@ const openCodeUsagePoller = (0, openCodeUsage_1.createOpenCodeUsagePoller)({
  */
 const claudeUsageRefresher = (0, claudeUsageRefresher_1.createClaudeUsageRefresher)({
     listProfiles: () => [
-        { name: claudeProfiles_1.defaultClaudeProfileName, configDir: null, loggedIn: state.getClaudeProfileInfo(claudeProfiles_1.defaultClaudeProfileName)?.loggedIn },
+        {
+            name: claudeProfiles_1.defaultClaudeProfileName, configDir: null,
+            loggedIn: state.getClaudeProfileInfo(claudeProfiles_1.defaultClaudeProfileName)?.loggedIn, billing: state.getClaudeProfileInfo(claudeProfiles_1.defaultClaudeProfileName)?.billing,
+        },
         ...Object.entries(state.getClaudeProfileRecords()).map(([name, record]) => ({
-            name, configDir: (0, claudeProfiles_1.resolveClaudeProfileDir)((0, state_1.resolveDataDir)(), name), loggedIn: record.loggedIn,
+            name, configDir: (0, claudeProfiles_1.resolveClaudeProfileDir)((0, state_1.resolveDataDir)(), name), loggedIn: record.loggedIn, billing: record.billing,
         })),
     ],
     getSnapshot: (name) => state.getClaudeProfileInfo(name)?.usage,
@@ -5881,6 +5984,27 @@ function onClaudeRateLimitEvent(configDir, event) {
         state.setClaudeProfileLimitedUntil(name, null);
     }
 }
+/**
+ * A json-stream turn's cost (`utils/claudeApiSpend.ts`): the topic's conversation baseline moves on for EVERY account
+ * (a later API turn of the same conversation must count only itself), and the turn's spend adds to the account's only
+ * when it is billed to API credits. A billed turn that went through ends a used-up-credits mark on whatever account it
+ * ran on: the balance is back.
+ */
+function onClaudeTurnCost(key, configDir, report) {
+    const turnCostUsd = (0, claudeApiSpend_1.computeClaudeTurnCostUsd)({ previous: state.getClaudeCostBaseline(key), ...report });
+    state.setClaudeCostBaseline(key, { sessionId: report.sessionId, totalCostUsd: report.totalCostUsd });
+    const name = resolveClaudeProfileNameForDir(configDir);
+    if (name === null)
+        return;
+    const info = state.getClaudeProfileInfo(name);
+    const outcome = (0, claudeApiSpend_1.getClaudeTurnCostOutcome)({
+        billing: info?.billing ?? null, isCreditExhausted: info?.creditExhaustedAt !== undefined, isError: report.isError, turnCostUsd,
+    });
+    if (outcome.isCreditMarkCleared)
+        state.setClaudeProfileCreditExhausted(name, null);
+    if (outcome.spendUsd !== null)
+        state.setClaudeProfileApiSpend(name, (0, claudeApiSpend_1.addClaudeApiSpend)(info?.apiSpend, outcome.spendUsd, new Date().toISOString()));
+}
 /** The model a topic's Claude session runs (or last ran), for the usage ranking's choice of windows. */
 function getThreadClaudeModel(key) {
     return (0, createAdapter_1.getThreadAdapter)(key).getCurrentModel?.(key) ?? state.getAgent(key)?.model ?? null;
@@ -5888,7 +6012,10 @@ function getThreadClaudeModel(key) {
 /** What `/status` names of a Claude profile: its last probed sign-in and email, and its limit mark (none until probed). */
 function readStatusAccountSource(name) {
     const info = state.getClaudeProfileInfo(name);
-    return { name, email: info?.email ?? null, loggedIn: info?.loggedIn, limitedUntil: info?.limitedUntil ?? null };
+    return {
+        name, email: info?.email ?? null, loggedIn: info?.loggedIn, limitedUntil: info?.limitedUntil ?? null,
+        billing: info?.billing ?? null, creditExhaustedAt: info?.creditExhaustedAt ?? null, ...(info?.apiSpend ? { apiSpend: info.apiSpend } : {}),
+    };
 }
 /** Whether the topic's agent is a Claude backend (a usage limit there is a limit of its account profile). */
 function checkIsClaudeProfileBackend(key) {
@@ -5987,13 +6114,15 @@ async function planFallbackSwitch(key, cls, episodeId) {
     const nowMs = Date.now();
     const resetAtMs = cls.kind === 'usageLimit' ? cls.resetAt : undefined;
     if (from.backend === 'claude') {
-        state.setClaudeProfileLimitedUntil(from.profile, (0, claudeLimitSwitch_1.resolveClaudeLimitedUntil)({
-            resetAtMs,
-            usage: state.getClaudeProfileInfo(from.profile)?.usage,
-            existingLimitedUntil: state.getClaudeProfileInfo(from.profile)?.limitedUntil ?? null,
-            nowMs,
-            fallbackMs: apiErrorRetry_1.usageLimitDefaultMs,
-        }));
+        // A used-up balance has no reset: its own flow marks the account (`creditExhaustedAt`) instead.
+        if (cls.isBalanceExhausted !== true)
+            state.setClaudeProfileLimitedUntil(from.profile, (0, claudeLimitSwitch_1.resolveClaudeLimitedUntil)({
+                resetAtMs,
+                usage: state.getClaudeProfileInfo(from.profile)?.usage,
+                existingLimitedUntil: state.getClaudeProfileInfo(from.profile)?.limitedUntil ?? null,
+                nowMs,
+                fallbackMs: apiErrorRetry_1.usageLimitDefaultMs,
+            }));
     }
     else {
         const label = (0, fallbackChain_1.buildOpenCodeModelLabel)(from);
@@ -6023,8 +6152,11 @@ async function planFallbackSwitch(key, cls, episodeId) {
     let earliest = null;
     if (plan.action === 'none') {
         const explicit = state.getFallbackChain();
+        // Without a chain the implicit one is the signed-in SUBSCRIPTIONS: an account billed to API credits never ends a wait by itself.
         const rungs = explicit.length > 0 ? explicit : from.backend === 'claude'
-            ? detection.claudeProfiles.filter((profile) => profile.loggedIn !== false).map((profile) => ({ backend: 'claude', profile: profile.name, model: null }))
+            ? detection.claudeProfiles
+                .filter((profile) => profile.loggedIn !== false && profile.billing !== 'api')
+                .map((profile) => ({ backend: 'claude', profile: profile.name, model: null }))
             : [];
         const found = (0, fallbackChain_1.pickEarliestResetRung)({ chain: rungs, current: from, detection, nowMs: Date.now() });
         if (found && !found.isCurrent)
@@ -6045,9 +6177,23 @@ function getFallbackResetTime(from) {
         return null;
     return (0, localClock_1.formatLocalClockWithDateIfNotToday)(untilMs, Date.now());
 }
-/** The «switched» notice (`utils/fallbackSwitchNotice.ts`), with the reset of the exhausted rung when known. */
+/**
+ * The «switched» notice (`utils/fallbackSwitchNotice.ts`), with the reset of the exhausted rung when known — and, onto
+ * an account billed to API credits, the line that it costs money per request and what it has spent so far.
+ */
 function getFallbackSwitchedNotice(from, to, runningModel) {
-    return (0, fallbackSwitchNotice_1.buildFallbackSwitchedNotice)({ from, to, resetTime: getFallbackResetTime(from), runningModel });
+    const notice = (0, fallbackSwitchNotice_1.buildFallbackSwitchedNotice)({ from, to, resetTime: getFallbackResetTime(from), runningModel });
+    const info = to.backend === 'claude' ? state.getClaudeProfileInfo(to.profile) : undefined;
+    if (to.backend !== 'claude' || info?.billing !== 'api')
+        return notice;
+    return `${notice}\n${(0, i18n_1.t)('fallback.switchedToApi', { name: to.profile, spent: (0, claudeApiSpend_1.formatUsd)(info.apiSpend?.totalUsd ?? 0) })}`;
+}
+/** The spend line a «credits used up» notice ends with (what the account spent through the bot); `''` before any spend. */
+function getBalanceSpentLine(from) {
+    const spend = from?.backend === 'claude' ? state.getClaudeProfileInfo(from.profile)?.apiSpend : undefined;
+    if (!spend)
+        return '';
+    return `\n${(0, i18n_1.t)('apiRetry.balanceSpent', (0, claudeProfileUsageLines_1.formatClaudeApiSpendWords)(spend, getCurrentTimezone(), Date.now()))}`;
 }
 /**
  * @description The model the topic's Claude session runs ACROSS a move onto `to`, for deciding whether the move
@@ -6314,6 +6460,10 @@ function buildBackendSwitchTargetOfRung(to) {
  * The outcome tells the screen what to say; the question and the limit move's notice are already posted.
  */
 async function switchTopicByOperator(key, to) {
+    // The operator's own pick of an account whose API credits were used up is the act that ends that mark (topped up, or
+    // trying anyway): a failing request marks it again.
+    if (to.backend === 'claude')
+        state.setClaudeProfileCreditExhausted(to.profile, null);
     const currentFamily = getTopicBackendFamily(key);
     const from = getTopicFallbackPosition(key);
     const isUsageLimitWaitArmed = getArmedApiRetry(key)?.kind === 'usageLimit';
@@ -6418,7 +6568,7 @@ const { registerLimitsBoardCommands, registerLimitsBoardCallbacks } = (0, limits
     runAutoSwitchCommand,
     getArmedLimitRetryFireAt,
 });
-const { registerClaudeAccountCommands, registerClaudeAccountCallbacks, checkIsAwaitingProfileName, cancelProfileNameCapture, submitProfileName, pickClaudeAccount, onClaudeProfileAuthStatus: recordClaudeProfileAuthStatus, } = (0, claudeAccounts_1.createClaudeAccounts)({
+const { registerClaudeAccountCommands, registerClaudeAccountCallbacks, checkIsAwaitingProfileName, cancelProfileNameCapture, submitProfileName, pickClaudeAccount, onClaudeProfileAuthStatus: recordClaudeProfileAuthStatus, onClaudeProfileApiKey: storeClaudeProfileApiKey, } = (0, claudeAccounts_1.createClaudeAccounts)({
     ...botCore,
     getDataDir: state_1.resolveDataDir,
     getInstanceTimezone: getCurrentTimezone,
@@ -6434,8 +6584,10 @@ const { registerClaudeAccountCommands, registerClaudeAccountCallbacks, checkIsAw
     disconnectOpenCodeProvider: applyProviderDisconnect,
     startOpenCodeConnect: showConnectMethodPicker,
     applyAutoSwitch,
+    verifyAnthropicApiKey: (apiKey) => (0, anthropicApiKeyCheck_1.verifyAnthropicApiKey)(apiKey),
 });
 claudeProfileAuthStatusSink = recordClaudeProfileAuthStatus;
+claudeProfileApiKeySink = storeClaudeProfileApiKey;
 const { registerSttCommands, registerSttCallbacks, startSttAutoInstall, resumeSttInstallAtBoot, getAwaitedSttStep, checkIsAnySttInputAwaited, submitSttInput, cancelSttInput, } = (0, stt_1.createStt)({
     ...botCore,
     getConfigPath: () => (0, sttSettings_1.getSttConfigPath)(),
@@ -7147,7 +7299,7 @@ bot.on((0, filters_1.message)('text'), async (ctx) => {
     // `/account` «Add» asked for the new profile's name → this message is it (a bad name keeps the prompt
     // armed and says so; a slash command above already disarmed it).
     if (checkIsAwaitingProfileName(key) && !text.startsWith('/')) {
-        await submitProfileName(key, text);
+        await submitProfileName(key, text, ctx.message.message_id);
         return;
     }
     // `/topic` asked for the new topic's name, or for the name of a folder to create → this message is the answer (a bad
@@ -11336,6 +11488,7 @@ async function startBot() {
     // Every Claude spawn from here on reads the conversation's account profile (`/account`).
     (0, createAdapter_1.registerClaudeConfigDirReader)(resolveThreadClaudeConfigDir);
     (0, createAdapter_1.registerClaudeRateLimitSink)(onClaudeRateLimitEvent);
+    (0, createAdapter_1.registerClaudeTurnCostSink)(onClaudeTurnCost);
     // The usage cache: a first poll now (off the boot path), then the timer.
     claudeUsageRefresher.start();
     void claudeUsageRefresher.refreshAll();