@gguf/pigbot 0.0.1 → 0.0.3

package/dist/auto-reply/reply/commands-tts.js

@@ -1,6 +1,5 @@
 import { logVerbose } from "../../globals.js";
-import { getLastTtsAttempt, getTtsMaxLength, getTtsProvider, isSummarizationEnabled, isTtsProviderConfigured, normalizeTtsAutoMode, resolveTtsAutoMode, resolveTtsApiKey, resolveTtsConfig, resolveTtsPrefsPath, resolveTtsProviderOrder, setLastTtsAttempt, setSummarizationEnabled, setTtsMaxLength, setTtsProvider, textToSpeech, } from "../../tts/tts.js";
-import { updateSessionStore } from "../../config/sessions.js";
+import { getLastTtsAttempt, getTtsMaxLength, getTtsProvider, isSummarizationEnabled, isTtsEnabled, isTtsProviderConfigured, resolveTtsApiKey, resolveTtsConfig, resolveTtsPrefsPath, setLastTtsAttempt, setSummarizationEnabled, setTtsEnabled, setTtsMaxLength, setTtsProvider, textToSpeech, } from "../../tts/tts.js";
 function parseTtsCommand(normalized) {
     // Accept `/tts` and `/tts <action> [args]` as a single control surface.
     if (normalized === "/tts")
@@ -16,14 +15,27 @@ function parseTtsCommand(normalized) {
 function ttsUsage() {
     // Keep usage in one place so help/validation stays consistent.
     return {
-        text: "⚙️ Usage: /tts <off|always|inbound|tagged|status|provider|limit|summary|audio> [value]" +
-            "\nExamples:\n" +
-            "/tts always\n" +
-            "/tts provider openai\n" +
-            "/tts provider edge\n" +
-            "/tts limit 2000\n" +
-            "/tts summary off\n" +
-            "/tts audio Hello from Pigbot",
+        text: `🔊 **TTS (Text-to-Speech) Help**\n\n` +
+            `**Commands:**\n` +
+            `• /tts on — Enable automatic TTS for replies\n` +
+            `• /tts off — Disable TTS\n` +
+            `• /tts status — Show current settings\n` +
+            `• /tts provider [name] — View/change provider\n` +
+            `• /tts limit [number] — View/change text limit\n` +
+            `• /tts summary [on|off] — View/change auto-summary\n` +
+            `• /tts audio <text> — Generate audio from text\n\n` +
+            `**Providers:**\n` +
+            `• edge — Free, fast (default)\n` +
+            `• openai — High quality (requires API key)\n` +
+            `• elevenlabs — Premium voices (requires API key)\n\n` +
+            `**Text Limit (default: 1500, max: 4096):**\n` +
+            `When text exceeds the limit:\n` +
+            `• Summary ON: AI summarizes, then generates audio\n` +
+            `• Summary OFF: Truncates text, then generates audio\n\n` +
+            `**Examples:**\n` +
+            `/tts provider edge\n` +
+            `/tts limit 2000\n` +
+            `/tts audio Hello, this is a test!`,
     };
 }
 export const handleTtsCommands = async (params, allowTextCommands) => {
@@ -43,32 +55,24 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
     if (action === "help") {
         return { shouldContinue: false, reply: ttsUsage() };
     }
-    const requestedAuto = normalizeTtsAutoMode(action === "on" ? "always" : action === "off" ? "off" : action);
-    if (requestedAuto) {
-        const entry = params.sessionEntry;
-        const sessionKey = params.sessionKey;
-        const store = params.sessionStore;
-        if (entry && store && sessionKey) {
-            entry.ttsAuto = requestedAuto;
-            entry.updatedAt = Date.now();
-            store[sessionKey] = entry;
-            if (params.storePath) {
-                await updateSessionStore(params.storePath, (store) => {
-                    store[sessionKey] = entry;
-                });
-            }
-        }
-        const label = requestedAuto === "always" ? "enabled (always)" : requestedAuto;
-        return {
-            shouldContinue: false,
-            reply: {
-                text: requestedAuto === "off" ? "🔇 TTS disabled." : `🔊 TTS ${label}.`,
-            },
-        };
+    if (action === "on") {
+        setTtsEnabled(prefsPath, true);
+        return { shouldContinue: false, reply: { text: "🔊 TTS enabled." } };
+    }
+    if (action === "off") {
+        setTtsEnabled(prefsPath, false);
+        return { shouldContinue: false, reply: { text: "🔇 TTS disabled." } };
     }
     if (action === "audio") {
         if (!args.trim()) {
-            return { shouldContinue: false, reply: ttsUsage() };
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `🎤 Generate audio from text.\n\n` +
+                        `Usage: /tts audio <text>\n` +
+                        `Example: /tts audio Hello, this is a test!`,
+                },
+            };
         }
         const start = Date.now();
         const result = await textToSpeech({
@@ -110,9 +114,6 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
     if (action === "provider") {
         const currentProvider = getTtsProvider(config, prefsPath);
         if (!args.trim()) {
-            const fallback = resolveTtsProviderOrder(currentProvider)
-                .slice(1)
-                .filter((provider) => isTtsProviderConfigured(config, provider));
             const hasOpenAI = Boolean(resolveTtsApiKey(config, "openai"));
             const hasElevenLabs = Boolean(resolveTtsApiKey(config, "elevenlabs"));
             const hasEdge = isTtsProviderConfigured(config, "edge");
@@ -121,7 +122,6 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
                 reply: {
                     text: `🎙️ TTS provider\n` +
                         `Primary: ${currentProvider}\n` +
-                        `Fallbacks: ${fallback.join(", ") || "none"}\n` +
                         `OpenAI key: ${hasOpenAI ? "✅" : "❌"}\n` +
                         `ElevenLabs key: ${hasElevenLabs ? "✅" : "❌"}\n` +
                         `Edge enabled: ${hasEdge ? "✅" : "❌"}\n` +
@@ -134,17 +134,9 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
             return { shouldContinue: false, reply: ttsUsage() };
         }
         setTtsProvider(prefsPath, requested);
-        const fallback = resolveTtsProviderOrder(requested)
-            .slice(1)
-            .filter((provider) => isTtsProviderConfigured(config, provider));
         return {
             shouldContinue: false,
-            reply: {
-                text: `✅ TTS provider set to ${requested} (fallbacks: ${fallback.join(", ") || "none"}).` +
-                    (requested === "edge"
-                        ? "\nEnable Edge TTS in config: messages.tts.edge.enabled = true."
-                        : ""),
-            },
+            reply: { text: `✅ TTS provider set to ${requested}.` },
         };
     }
     if (action === "limit") {
@@ -152,12 +144,21 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
             const currentLimit = getTtsMaxLength(prefsPath);
             return {
                 shouldContinue: false,
-                reply: { text: `📏 TTS limit: ${currentLimit} characters.` },
+                reply: {
+                    text: `📏 TTS limit: ${currentLimit} characters.\n\n` +
+                        `Text longer than this triggers summary (if enabled).\n` +
+                        `Range: 100-4096 chars (Telegram max).\n\n` +
+                        `To change: /tts limit <number>\n` +
+                        `Example: /tts limit 2000`,
+                },
             };
         }
         const next = Number.parseInt(args.trim(), 10);
-        if (!Number.isFinite(next) || next < 100 || next > 10_000) {
-            return { shouldContinue: false, reply: ttsUsage() };
+        if (!Number.isFinite(next) || next < 100 || next > 4096) {
+            return {
+                shouldContinue: false,
+                reply: { text: "❌ Limit must be between 100 and 4096 characters." },
+            };
         }
         setTtsMaxLength(prefsPath, next);
         return {
@@ -168,9 +169,16 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
     if (action === "summary") {
         if (!args.trim()) {
             const enabled = isSummarizationEnabled(prefsPath);
+            const maxLen = getTtsMaxLength(prefsPath);
             return {
                 shouldContinue: false,
-                reply: { text: `📝 TTS auto-summary: ${enabled ? "on" : "off"}.` },
+                reply: {
+                    text: `📝 TTS auto-summary: ${enabled ? "on" : "off"}.\n\n` +
+                        `When text exceeds ${maxLen} chars:\n` +
+                        `• ON: summarizes text, then generates audio\n` +
+                        `• OFF: truncates text, then generates audio\n\n` +
+                        `To change: /tts summary on | off`,
+                },
             };
         }
         const requested = args.trim().toLowerCase();
@@ -186,26 +194,16 @@ export const handleTtsCommands = async (params, allowTextCommands) => {
         };
     }
     if (action === "status") {
-        const sessionAuto = params.sessionEntry?.ttsAuto;
-        const autoMode = resolveTtsAutoMode({ config, prefsPath, sessionAuto });
-        const enabled = autoMode !== "off";
+        const enabled = isTtsEnabled(config, prefsPath);
         const provider = getTtsProvider(config, prefsPath);
         const hasKey = isTtsProviderConfigured(config, provider);
-        const providerStatus = provider === "edge"
-            ? hasKey
-                ? "✅ enabled"
-                : "❌ disabled"
-            : hasKey
-                ? "✅ key"
-                : "❌ no key";
         const maxLength = getTtsMaxLength(prefsPath);
         const summarize = isSummarizationEnabled(prefsPath);
         const last = getLastTtsAttempt();
-        const autoLabel = sessionAuto ? `${autoMode} (session)` : autoMode;
         const lines = [
             "📊 TTS status",
-            `Auto: ${enabled ? autoLabel : "off"}`,
-            `Provider: ${provider} (${providerStatus})`,
+            `State: ${enabled ? "✅ enabled" : "❌ disabled"}`,
+            `Provider: ${provider} (${hasKey ? "✅ configured" : "❌ not configured"})`,
             `Text limit: ${maxLength} chars`,
             `Auto-summary: ${summarize ? "on" : "off"}`,
         ];

package/dist/auto-reply/reply/directive-handling.shared.js

@@ -37,7 +37,7 @@ export function formatElevatedUnavailableText(params) {
         lines.push("Fix-it keys: tools.elevated.enabled, tools.elevated.allowFrom.<provider>, agents.list[].tools.elevated.*");
     }
     if (params.sessionKey) {
-        lines.push(`See: ${formatCliCommand(`pigbot sandbox explain --session ${params.sessionKey}`)}`);
+        lines.push(`See: ${formatCliCommand(`moltbot sandbox explain --session ${params.sessionKey}`)}`);
     }
     return lines.join("\n");
 }

package/dist/auto-reply/reply/directives.js

@@ -1,4 +1,4 @@
-import { normalizeElevatedLevel, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
+import { normalizeElevatedLevel, normalizeNoticeLevel, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
 const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const matchLevelDirective = (body, names) => {
     const namePattern = names.map(escapeRegExp).join("|");
@@ -73,6 +73,17 @@ export function extractVerboseDirective(body) {
         hasDirective: extracted.hasDirective,
     };
 }
+export function extractNoticeDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const extracted = extractLevelDirective(body, ["notice", "notices"], normalizeNoticeLevel);
+    return {
+        cleaned: extracted.cleaned,
+        noticeLevel: extracted.level,
+        rawLevel: extracted.rawLevel,
+        hasDirective: extracted.hasDirective,
+    };
+}
 export function extractElevatedDirective(body) {
     if (!body)
         return { cleaned: "", hasDirective: false };

package/dist/auto-reply/reply/dispatch-from-config.js

@@ -8,7 +8,7 @@ import { getReplyFromConfig } from "../reply.js";
 import { formatAbortReplyText, tryFastAbortFromMessage } from "./abort.js";
 import { shouldSkipDuplicateInbound } from "./inbound-dedupe.js";
 import { isRoutableChannel, routeReply } from "./route-reply.js";
-import { maybeApplyTtsToPayload, normalizeTtsAutoMode } from "../../tts/tts.js";
+import { maybeApplyTtsToPayload, normalizeTtsAutoMode, resolveTtsConfig } from "../../tts/tts.js";
 const AUDIO_PLACEHOLDER_RE = /^<media:audio>(\s*\([^)]*\))?$/i;
 const AUDIO_HEADER_RE = /^\[Audio\b/i;
 const normalizeMediaType = (value) => value.split(";")[0]?.trim().toLowerCase();
@@ -160,7 +160,7 @@ export async function dispatchReplyFromConfig(params) {
      * Note: Only called when shouldRouteToOriginating is true, so
      * originatingChannel and originatingTo are guaranteed to be defined.
      */
-    const sendPayloadAsync = async (payload, abortSignal) => {
+    const sendPayloadAsync = async (payload, abortSignal, mirror) => {
         // TypeScript doesn't narrow these from the shouldRouteToOriginating check,
         // but they're guaranteed non-null when this function is called.
         if (!originatingChannel || !originatingTo)
@@ -176,6 +176,7 @@ export async function dispatchReplyFromConfig(params) {
             threadId: ctx.MessageThreadId,
             cfg,
             abortSignal,
+            mirror,
         });
         if (!result.ok) {
             logVerbose(`dispatch-from-config: route-reply failed: ${result.error ?? "unknown error"}`);
@@ -217,29 +218,23 @@ export async function dispatchReplyFromConfig(params) {
             markIdle("message_completed");
             return { queuedFinal, counts };
         }
+        // Track accumulated block text for TTS generation after streaming completes.
+        // When block streaming succeeds, there's no final reply, so we need to generate
+        // TTS audio separately from the accumulated block content.
+        let accumulatedBlockText = "";
+        let blockCount = 0;
         const replyResult = await (params.replyResolver ?? getReplyFromConfig)(ctx, {
             ...params.replyOptions,
-            onToolResult: (payload) => {
-                const run = async () => {
-                    const ttsPayload = await maybeApplyTtsToPayload({
-                        payload,
-                        cfg,
-                        channel: ttsChannel,
-                        kind: "tool",
-                        inboundAudio,
-                        ttsAuto: sessionTtsAuto,
-                    });
-                    if (shouldRouteToOriginating) {
-                        await sendPayloadAsync(ttsPayload);
-                    }
-                    else {
-                        dispatcher.sendToolResult(ttsPayload);
-                    }
-                };
-                return run();
-            },
             onBlockReply: (payload, context) => {
                 const run = async () => {
+                    // Accumulate block text for TTS generation after streaming
+                    if (payload.text) {
+                        if (accumulatedBlockText.length > 0) {
+                            accumulatedBlockText += "\n";
+                        }
+                        accumulatedBlockText += payload.text;
+                        blockCount++;
+                    }
                     const ttsPayload = await maybeApplyTtsToPayload({
                         payload,
                         cfg,
@@ -249,7 +244,7 @@ export async function dispatchReplyFromConfig(params) {
                         ttsAuto: sessionTtsAuto,
                     });
                     if (shouldRouteToOriginating) {
-                        await sendPayloadAsync(ttsPayload, context?.abortSignal);
+                        await sendPayloadAsync(ttsPayload, context?.abortSignal, false);
                     }
                     else {
                         dispatcher.sendBlockReply(ttsPayload);
@@ -292,6 +287,57 @@ export async function dispatchReplyFromConfig(params) {
                 queuedFinal = dispatcher.sendFinalReply(ttsReply) || queuedFinal;
             }
         }
+        const ttsMode = resolveTtsConfig(cfg).mode ?? "final";
+        // Generate TTS-only reply after block streaming completes (when there's no final reply).
+        // This handles the case where block streaming succeeds and drops final payloads,
+        // but we still want TTS audio to be generated from the accumulated block content.
+        if (ttsMode === "final" &&
+            replies.length === 0 &&
+            blockCount > 0 &&
+            accumulatedBlockText.trim()) {
+            try {
+                const ttsSyntheticReply = await maybeApplyTtsToPayload({
+                    payload: { text: accumulatedBlockText },
+                    cfg,
+                    channel: ttsChannel,
+                    kind: "final",
+                    inboundAudio,
+                    ttsAuto: sessionTtsAuto,
+                });
+                // Only send if TTS was actually applied (mediaUrl exists)
+                if (ttsSyntheticReply.mediaUrl) {
+                    // Send TTS-only payload (no text, just audio) so it doesn't duplicate the block content
+                    const ttsOnlyPayload = {
+                        mediaUrl: ttsSyntheticReply.mediaUrl,
+                        audioAsVoice: ttsSyntheticReply.audioAsVoice,
+                    };
+                    if (shouldRouteToOriginating && originatingChannel && originatingTo) {
+                        const result = await routeReply({
+                            payload: ttsOnlyPayload,
+                            channel: originatingChannel,
+                            to: originatingTo,
+                            sessionKey: ctx.SessionKey,
+                            accountId: ctx.AccountId,
+                            threadId: ctx.MessageThreadId,
+                            cfg,
+                        });
+                        queuedFinal = result.ok || queuedFinal;
+                        if (result.ok)
+                            routedFinalCount += 1;
+                        if (!result.ok) {
+                            logVerbose(`dispatch-from-config: route-reply (tts-only) failed: ${result.error ?? "unknown error"}`);
+                        }
+                    }
+                    else {
+                        const didQueue = dispatcher.sendFinalReply(ttsOnlyPayload);
+                        queuedFinal = didQueue || queuedFinal;
+                    }
+                }
+            }
+            catch (err) {
+                logVerbose(`dispatch-from-config: accumulated block TTS failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         await dispatcher.waitForIdle();
         const counts = dispatcher.getQueuedCounts();
         counts.final += routedFinalCount;

package/dist/auto-reply/reply/followup-runner.js

@@ -93,6 +93,7 @@ export function createFollowupRunner(params) {
                     cfg: queued.run.config,
                     provider: queued.run.provider,
                     model: queued.run.model,
+                    agentDir: queued.run.agentDir,
                     fallbacksOverride: resolveAgentModelFallbacksOverride(queued.run.config, resolveAgentIdFromSessionKey(queued.run.sessionKey)),
                     run: (provider, model) => {
                         const authProfileId = provider === queued.run.provider ? queued.run.authProfileId : undefined;
@@ -106,6 +107,10 @@ export function createFollowupRunner(params) {
                             groupId: queued.run.groupId,
                             groupChannel: queued.run.groupChannel,
                             groupSpace: queued.run.groupSpace,
+                            senderId: queued.run.senderId,
+                            senderName: queued.run.senderName,
+                            senderUsername: queued.run.senderUsername,
+                            senderE164: queued.run.senderE164,
                             sessionFile: queued.run.sessionFile,
                             workspaceDir: queued.run.workspaceDir,
                             config: queued.run.config,

package/dist/auto-reply/reply/get-reply-inline-actions.js

@@ -5,7 +5,7 @@ import { isDirectiveOnly } from "./directive-handling.js";
 import { extractInlineSimpleCommand } from "./reply-inline.js";
 import { listSkillCommandsForWorkspace, resolveSkillCommandInvocation } from "../skill-commands.js";
 import { logVerbose } from "../../globals.js";
-import { createPigbotTools } from "../../agents/pigbot-tools.js";
+import { createMoltbotTools } from "../../agents/moltbot-tools.js";
 import { resolveGatewayMessageChannel } from "../../utils/message-channel.js";
 function extractTextFromToolResult(result) {
     if (!result || typeof result !== "object")
@@ -62,7 +62,7 @@ export async function handleInlineActions(params) {
             const channel = resolveGatewayMessageChannel(ctx.Surface) ??
                 resolveGatewayMessageChannel(ctx.Provider) ??
                 undefined;
-            const tools = createPigbotTools({
+            const tools = createMoltbotTools({
                 agentSessionKey: sessionKey,
                 agentChannel: channel,
                 agentAccountId: ctx.AccountId,

package/dist/auto-reply/reply/get-reply-run.js

@@ -228,6 +228,10 @@ export async function runPreparedReply(params) {
             groupId: resolveGroupSessionKey(sessionCtx)?.id ?? undefined,
             groupChannel: sessionCtx.GroupChannel?.trim() ?? sessionCtx.GroupSubject?.trim(),
             groupSpace: sessionCtx.GroupSpace?.trim() ?? undefined,
+            senderId: sessionCtx.SenderId?.trim() || undefined,
+            senderName: sessionCtx.SenderName?.trim() || undefined,
+            senderUsername: sessionCtx.SenderUsername?.trim() || undefined,
+            senderE164: sessionCtx.SenderE164?.trim() || undefined,
             sessionFile,
             workspaceDir,
             config: cfg,

package/dist/auto-reply/reply/get-reply.js

@@ -18,7 +18,7 @@ import { applyResetModelOverride } from "./session-reset-model.js";
 import { stageSandboxMedia } from "./stage-sandbox-media.js";
 import { createTypingController } from "./typing.js";
 export async function getReplyFromConfig(ctx, opts, configOverride) {
-    const isFastTestEnv = process.env.PIGBOT_TEST_FAST === "1";
+    const isFastTestEnv = process.env.CLAWDBOT_TEST_FAST === "1";
     const cfg = configOverride ?? loadConfig();
     const targetSessionKey = ctx.CommandSource === "native" ? ctx.CommandTargetSessionKey?.trim() : undefined;
     const agentSessionKey = targetSessionKey || ctx.SessionKey;

package/dist/auto-reply/reply/groups.js

@@ -79,7 +79,7 @@ export function buildGroupIntro(params) {
         })
         : undefined;
     const silenceLine = activation === "always"
-        ? `If no response is needed, reply with exactly "${params.silentToken}" (and nothing else) so Pigbot stays silent. Do not add any other words, punctuation, tags, markdown/code blocks, or explanations.`
+        ? `If no response is needed, reply with exactly "${params.silentToken}" (and nothing else) so Moltbot stays silent. Do not add any other words, punctuation, tags, markdown/code blocks, or explanations.`
         : undefined;
     const cautionLine = activation === "always"
         ? "Be extremely selective: reply only when directly addressed or clearly helpful. Otherwise stay silent."

package/dist/auto-reply/reply/history.js

@@ -1,6 +1,23 @@
 import { CURRENT_MESSAGE_MARKER } from "./mentions.js";
 export const HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
 export const DEFAULT_GROUP_HISTORY_LIMIT = 50;
+/** Maximum number of group history keys to retain (LRU eviction when exceeded). */
+export const MAX_HISTORY_KEYS = 1000;
+/**
+ * Evict oldest keys from a history map when it exceeds MAX_HISTORY_KEYS.
+ * Uses Map's insertion order for LRU-like behavior.
+ */
+export function evictOldHistoryKeys(historyMap, maxKeys = MAX_HISTORY_KEYS) {
+    if (historyMap.size <= maxKeys)
+        return;
+    const keysToDelete = historyMap.size - maxKeys;
+    const iterator = historyMap.keys();
+    for (let i = 0; i < keysToDelete; i++) {
+        const key = iterator.next().value;
+        if (key !== undefined)
+            historyMap.delete(key);
+    }
+}
 export function buildHistoryContext(params) {
     const { historyText, currentMessage } = params;
     const lineBreak = params.lineBreak ?? "\n";
@@ -16,7 +33,13 @@ export function appendHistoryEntry(params) {
     history.push(entry);
     while (history.length > params.limit)
         history.shift();
+    if (historyMap.has(historyKey)) {
+        // Refresh insertion order so eviction keeps recently used histories.
+        historyMap.delete(historyKey);
+    }
     historyMap.set(historyKey, history);
+    // Evict oldest keys if map exceeds max size to prevent unbounded memory growth
+    evictOldHistoryKeys(historyMap);
     return history;
 }
 export function recordPendingHistoryEntry(params) {