@poolzin/pool-bot 2026.2.23 → 2026.2.25

package/dist/telegram/draft-stream.js

@@ -13,6 +13,7 @@ export function createTelegramDraftStream(params) {
         : threadParams;
     let streamMessageId;
     let lastSentText = "";
+    let lastSentParseMode;
     let stopped = false;
     let isFinal = false;
     const sendOrEditStreamMessage = async (text) => {
@@ -24,29 +25,49 @@ export function createTelegramDraftStream(params) {
         if (!trimmed) {
             return false;
         }
-        if (trimmed.length > maxChars) {
+        const rendered = params.renderText?.(trimmed) ?? { text: trimmed };
+        const renderedText = rendered.text.trimEnd();
+        const renderedParseMode = rendered.parseMode;
+        if (!renderedText) {
+            return false;
+        }
+        if (renderedText.length > maxChars) {
             // Telegram text messages/edits cap at 4096 chars.
             // Stop streaming once we exceed the cap to avoid repeated API failures.
             stopped = true;
-            params.warn?.(`telegram stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+            params.warn?.(`telegram stream preview stopped (text length ${renderedText.length} > ${maxChars})`);
             return false;
         }
-        if (trimmed === lastSentText) {
+        if (renderedText === lastSentText && renderedParseMode === lastSentParseMode) {
             return true;
         }
         // Debounce first preview send for better push notification quality.
         if (typeof streamMessageId !== "number" && minInitialChars != null && !isFinal) {
-            if (trimmed.length < minInitialChars) {
+            if (renderedText.length < minInitialChars) {
                 return false;
             }
         }
-        lastSentText = trimmed;
+        lastSentText = renderedText;
+        lastSentParseMode = renderedParseMode;
         try {
             if (typeof streamMessageId === "number") {
-                await params.api.editMessageText(chatId, streamMessageId, trimmed);
+                if (renderedParseMode) {
+                    await params.api.editMessageText(chatId, streamMessageId, renderedText, {
+                        parse_mode: renderedParseMode,
+                    });
+                }
+                else {
+                    await params.api.editMessageText(chatId, streamMessageId, renderedText);
+                }
                 return true;
             }
-            const sent = await params.api.sendMessage(chatId, trimmed, replyParams);
+            const sendParams = renderedParseMode
+                ? {
+                    ...replyParams,
+                    parse_mode: renderedParseMode,
+                }
+                : replyParams;
+            const sent = await params.api.sendMessage(chatId, renderedText, sendParams);
             const sentMessageId = sent?.message_id;
             if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
                 stopped = true;
@@ -88,6 +109,7 @@ export function createTelegramDraftStream(params) {
         }
         try {
             await params.api.deleteMessage(chatId, messageId);
+            params.log?.(`telegram stream preview deleted (chat=${chatId}, message=${messageId})`);
         }
         catch (err) {
             params.warn?.(`telegram stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -96,6 +118,7 @@ export function createTelegramDraftStream(params) {
     const forceNewMessage = () => {
         streamMessageId = undefined;
         lastSentText = "";
+        lastSentParseMode = undefined;
         loop.resetPending();
     };
     params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);

package/dist/telegram/reasoning-lane-coordinator.js

@@ -0,0 +1,128 @@
+import { formatReasoningMessage } from "../agents/pi-embedded-utils.js";
+import { stripReasoningTagsFromText } from "../shared/text/reasoning-tags.js";
+const REASONING_MESSAGE_PREFIX = "Reasoning:\n";
+const REASONING_TAG_PREFIXES = [
+    "<think",
+    "<thinking",
+    "<thought",
+    "<antthinking",
+    "</think",
+    "</thinking",
+    "</thought",
+    "</antthinking",
+];
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function findCodeRegions(text) {
+    const regions = [];
+    const fencedRe = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?(?:\n\2(?:\n|$)|$)/g;
+    for (const match of text.matchAll(fencedRe)) {
+        const start = (match.index ?? 0) + match[1].length;
+        regions.push({ start, end: start + match[0].length - match[1].length });
+    }
+    const inlineRe = /`+[^`]+`+/g;
+    for (const match of text.matchAll(inlineRe)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        const insideFenced = regions.some((r) => start >= r.start && end <= r.end);
+        if (!insideFenced) {
+            regions.push({ start, end });
+        }
+    }
+    regions.sort((a, b) => a.start - b.start);
+    return regions;
+}
+function isInsideCode(pos, regions) {
+    return regions.some((r) => pos >= r.start && pos < r.end);
+}
+function extractThinkingFromTaggedStreamOutsideCode(text) {
+    if (!text) {
+        return "";
+    }
+    const codeRegions = findCodeRegions(text);
+    let result = "";
+    let lastIndex = 0;
+    let inThinking = false;
+    THINKING_TAG_RE.lastIndex = 0;
+    for (const match of text.matchAll(THINKING_TAG_RE)) {
+        const idx = match.index ?? 0;
+        if (isInsideCode(idx, codeRegions)) {
+            continue;
+        }
+        if (inThinking) {
+            result += text.slice(lastIndex, idx);
+        }
+        const isClose = match[1] === "/";
+        inThinking = !isClose;
+        lastIndex = idx + match[0].length;
+    }
+    if (inThinking) {
+        result += text.slice(lastIndex);
+    }
+    return result.trim();
+}
+function isPartialReasoningTagPrefix(text) {
+    const trimmed = text.trimStart().toLowerCase();
+    if (!trimmed.startsWith("<")) {
+        return false;
+    }
+    if (trimmed.includes(">")) {
+        return false;
+    }
+    return REASONING_TAG_PREFIXES.some((prefix) => prefix.startsWith(trimmed));
+}
+export function splitTelegramReasoningText(text) {
+    if (typeof text !== "string") {
+        return {};
+    }
+    const trimmed = text.trim();
+    if (isPartialReasoningTagPrefix(trimmed)) {
+        return {};
+    }
+    if (trimmed.startsWith(REASONING_MESSAGE_PREFIX) &&
+        trimmed.length > REASONING_MESSAGE_PREFIX.length) {
+        return { reasoningText: trimmed };
+    }
+    const taggedReasoning = extractThinkingFromTaggedStreamOutsideCode(text);
+    const strippedAnswer = stripReasoningTagsFromText(text, { mode: "strict", trim: "both" });
+    if (!taggedReasoning && strippedAnswer === text) {
+        return { answerText: text };
+    }
+    const reasoningText = taggedReasoning ? formatReasoningMessage(taggedReasoning) : undefined;
+    const answerText = strippedAnswer || undefined;
+    return { reasoningText, answerText };
+}
+export function createTelegramReasoningStepState() {
+    let reasoningStatus = "none";
+    let bufferedFinalAnswer;
+    const noteReasoningHint = () => {
+        if (reasoningStatus === "none") {
+            reasoningStatus = "hinted";
+        }
+    };
+    const noteReasoningDelivered = () => {
+        reasoningStatus = "delivered";
+    };
+    const shouldBufferFinalAnswer = () => {
+        return reasoningStatus === "hinted" && !bufferedFinalAnswer;
+    };
+    const bufferFinalAnswer = (value) => {
+        bufferedFinalAnswer = value;
+    };
+    const takeBufferedFinalAnswer = () => {
+        const value = bufferedFinalAnswer;
+        bufferedFinalAnswer = undefined;
+        return value;
+    };
+    const resetForNextStep = () => {
+        reasoningStatus = "none";
+        bufferedFinalAnswer = undefined;
+    };
+    return {
+        noteReasoningHint,
+        noteReasoningDelivered,
+        shouldBufferFinalAnswer,
+        bufferFinalAnswer,
+        takeBufferedFinalAnswer,
+        resetForNextStep,
+    };
+}

package/dist/terminal/prompt-select-styled.js

@@ -0,0 +1,9 @@
+import { select } from "@clack/prompts";
+import { stylePromptHint, stylePromptMessage } from "./prompt-style.js";
+export function selectStyled(params) {
+    return select({
+        ...params,
+        message: stylePromptMessage(params.message),
+        options: params.options.map((opt) => opt.hint === undefined ? opt : { ...opt, hint: stylePromptHint(opt.hint) }),
+    });
+}

package/dist/test-utils/command-runner.js

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+export async function runRegisteredCli(params) {
+    const program = new Command();
+    params.register(program);
+    await program.parseAsync(params.argv, { from: "user" });
+}

package/dist/test-utils/internal-hook-event-payload.js

@@ -0,0 +1,10 @@
+export function createInternalHookEventPayload(type, action, sessionKey, context) {
+    return {
+        type,
+        action,
+        sessionKey,
+        context,
+        timestamp: new Date(),
+        messages: [],
+    };
+}

package/dist/test-utils/model-auth-mock.js

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+export function createModelAuthMockModule() {
+    return {
+        resolveApiKeyForProvider: vi.fn(),
+        requireApiKey: (auth, provider) => {
+            if (auth?.apiKey) {
+                return auth.apiKey;
+            }
+            throw new Error(`No API key resolved for provider "${provider}" (auth mode: ${auth?.mode}).`);
+        },
+    };
+}

package/dist/test-utils/provider-usage-fetch.js

@@ -0,0 +1,14 @@
+import { vi } from "vitest";
+import { withFetchPreconnect } from "./fetch-mock.js";
+export function makeResponse(status, body) {
+    const payload = typeof body === "string" ? body : JSON.stringify(body);
+    const headers = typeof body === "string" ? undefined : { "Content-Type": "application/json" };
+    return new Response(payload, { status, headers });
+}
+export function toRequestUrl(input) {
+    return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+}
+export function createProviderUsageFetch(handler) {
+    const mockFetch = vi.fn(async (input, init) => handler(toRequestUrl(input), init));
+    return withFetchPreconnect(mockFetch);
+}

package/dist/test-utils/temp-home.js

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { captureEnv } from "./env.js";
+const HOME_ENV_KEYS = [
+    "HOME",
+    "USERPROFILE",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "CLAWDBOT_STATE_DIR",
+];
+export async function createTempHomeEnv(prefix) {
+    const home = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+    await fs.mkdir(path.join(home, ".poolbot"), { recursive: true });
+    const snapshot = captureEnv([...HOME_ENV_KEYS]);
+    process.env.HOME = home;
+    process.env.USERPROFILE = home;
+    process.env.CLAWDBOT_STATE_DIR = path.join(home, ".poolbot");
+    if (process.platform === "win32") {
+        const match = home.match(/^([A-Za-z]:)(.*)$/);
+        if (match) {
+            process.env.HOMEDRIVE = match[1];
+            process.env.HOMEPATH = match[2] || "\\";
+        }
+    }
+    return {
+        home,
+        restore: async () => {
+            snapshot.restore();
+            await fs.rm(home, { recursive: true, force: true });
+        },
+    };
+}

package/dist/tui/components/chat-log.js

@@ -47,6 +47,15 @@ export class ChatLog extends Container {
         }
         this.addChild(new AssistantMessageComponent(text));
     }
+    dropAssistant(runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (!existing) {
+            return;
+        }
+        this.removeChild(existing);
+        this.streamingRuns.delete(effectiveRunId);
+    }
     startTool(toolCallId, toolName, args) {
         const existing = this.toolById.get(toolCallId);
         if (existing) {

package/dist/tui/tui-command-handlers.js

@@ -1,20 +1,15 @@
-import { truncateToWidth } from "@mariozechner/pi-tui";
 import { formatThinkingLevels, normalizeUsageDisplay, resolveResponseUsageMode, } from "../auto-reply/thinking.js";
+import { formatRelativeTimestamp } from "../infra/format-time/format-relative.js";
 import { normalizeAgentId } from "../routing/session-key.js";
-import { formatRelativeTime } from "../utils/time-format.js";
 import { helpText, parseCommand } from "./commands.js";
 import { createFilterableSelectList, createSearchableSelectList, createSettingsList, } from "./components/selectors.js";
 import { formatStatusSummary } from "./tui-status-summary.js";
 export function createCommandHandlers(context) {
-    const { client, chatLog, tui, opts, state, deliverDefault, openOverlay, closeOverlay, refreshSessionInfo, loadHistory, setSession, refreshAgents, abortActive, setActivityStatus, formatSessionKey, } = context;
+    const { client, chatLog, tui, opts, state, deliverDefault, openOverlay, closeOverlay, refreshSessionInfo, loadHistory, setSession, refreshAgents, abortActive, setActivityStatus, formatSessionKey, applySessionInfoFromPatch, noteLocalRunId, forgetLocalRunId, } = context;
     const setAgent = async (id) => {
         state.currentAgentId = normalizeAgentId(id);
         await setSession("");
     };
-    // Maximum visible width for overlay item strings. The overlay has its own
-    // padding/chrome (~4 chars). We subtract a generous margin so that even
-    // after ANSI formatting, lines stay within terminal bounds.
-    const overlayItemWidth = () => Math.max(30, (tui.terminal.columns ?? 80) - 6);
     const openModelSelector = async () => {
         try {
             const models = await client.listModels();
@@ -23,21 +18,21 @@ export function createCommandHandlers(context) {
                 tui.requestRender();
                 return;
             }
-            const maxW = overlayItemWidth();
             const items = models.map((model) => ({
                 value: `${model.provider}/${model.id}`,
-                label: truncateToWidth(`${model.provider}/${model.id}`, maxW),
-                description: model.name && model.name !== model.id ? truncateToWidth(model.name, maxW) : "",
+                label: `${model.provider}/${model.id}`,
+                description: model.name && model.name !== model.id ? model.name : "",
             }));
             const selector = createSearchableSelectList(items, 9);
             selector.onSelect = (item) => {
                 void (async () => {
                     try {
-                        await client.patchSession({
+                        const result = await client.patchSession({
                             key: state.currentSessionKey,
                             model: item.value,
                         });
                         chatLog.addSystem(`model set to ${item.value}`);
+                        applySessionInfoFromPatch(result);
                         await refreshSessionInfo();
                     }
                     catch (err) {
@@ -66,10 +61,9 @@ export function createCommandHandlers(context) {
             tui.requestRender();
             return;
         }
-        const maxW = overlayItemWidth();
         const items = state.agents.map((agent) => ({
             value: agent.id,
-            label: truncateToWidth(agent.name ? `${agent.id} (${agent.name})` : agent.id, maxW),
+            label: agent.name ? `${agent.id} (${agent.name})` : agent.id,
             description: agent.id === state.agentDefaultId ? "default" : "",
         }));
         const selector = createSearchableSelectList(items, 9);
@@ -96,20 +90,21 @@ export function createCommandHandlers(context) {
                 includeLastMessage: true,
                 agentId: state.currentAgentId,
             });
-            const maxW = overlayItemWidth();
             const items = result.sessions.map((session) => {
                 const title = session.derivedTitle ?? session.displayName;
                 const formattedKey = formatSessionKey(session.key);
                 // Avoid redundant "title (key)" when title matches key
                 const label = title && title !== formattedKey ? `${title} (${formattedKey})` : formattedKey;
                 // Build description: time + message preview
-                const timePart = session.updatedAt ? formatRelativeTime(session.updatedAt) : "";
+                const timePart = session.updatedAt
+                    ? formatRelativeTimestamp(session.updatedAt, { dateFallback: true, fallback: "" })
+                    : "";
                 const preview = session.lastMessagePreview?.replace(/\s+/g, " ").trim();
                 const description = timePart && preview ? `${timePart} · ${preview}` : (preview ?? timePart);
                 return {
                     value: session.key,
-                    label: truncateToWidth(label, maxW),
-                    description: truncateToWidth(description, maxW),
+                    label,
+                    description,
                     searchText: [
                         session.displayName,
                         session.label,
@@ -176,8 +171,9 @@ export function createCommandHandlers(context) {
     };
     const handleCommand = async (raw) => {
         const { name, args } = parseCommand(raw);
-        if (!name)
+        if (!name) {
             return;
+        }
         switch (name) {
             case "help":
                 chatLog.addSystem(helpText({
@@ -194,8 +190,9 @@ export function createCommandHandlers(context) {
                     }
                     if (status && typeof status === "object") {
                         const lines = formatStatusSummary(status);
-                        for (const line of lines)
+                        for (const line of lines) {
                             chatLog.addSystem(line);
+                        }
                         break;
                     }
                     chatLog.addSystem("status: unknown response");
@@ -232,11 +229,12 @@ export function createCommandHandlers(context) {
                 }
                 else {
                     try {
-                        await client.patchSession({
+                        const result = await client.patchSession({
                             key: state.currentSessionKey,
                             model: args,
                         });
                         chatLog.addSystem(`model set to ${args}`);
+                        applySessionInfoFromPatch(result);
                         await refreshSessionInfo();
                     }
                     catch (err) {
@@ -254,11 +252,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         thinkingLevel: args,
                     });
                     chatLog.addSystem(`thinking set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -271,12 +270,13 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         verboseLevel: args,
                     });
                     chatLog.addSystem(`verbose set to ${args}`);
-                    await refreshSessionInfo();
+                    applySessionInfoFromPatch(result);
+                    await loadHistory();
                 }
                 catch (err) {
                     chatLog.addSystem(`verbose failed: ${String(err)}`);
@@ -288,11 +288,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         reasoningLevel: args,
                     });
                     chatLog.addSystem(`reasoning set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -309,11 +310,12 @@ export function createCommandHandlers(context) {
                 const current = resolveResponseUsageMode(currentRaw);
                 const next = normalized ?? (current === "off" ? "tokens" : current === "tokens" ? "full" : "off");
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         responseUsage: next === "off" ? null : next,
                     });
                     chatLog.addSystem(`usage footer: ${next}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -331,11 +333,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         elevatedLevel: args,
                     });
                     chatLog.addSystem(`elevated set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -348,11 +351,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         groupActivation: args === "always" ? "always" : "mention",
                     });
                     chatLog.addSystem(`activation set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -405,10 +409,15 @@ export function createCommandHandlers(context) {
                 deliver: deliverDefault,
                 timeoutMs: opts.timeoutMs,
             });
+            noteLocalRunId(runId);
             state.activeChatRunId = runId;
             setActivityStatus("waiting");
         }
         catch (err) {
+            if (state.activeChatRunId) {
+                forgetLocalRunId?.(state.activeChatRunId);
+            }
+            state.activeChatRunId = null;
             chatLog.addSystem(`send failed: ${String(err)}`);
             setActivityStatus("error");
         }