@iletai/nzb 1.6.0 → 1.6.2

package/dist/config.js

@@ -63,6 +63,14 @@ export const config = {
     set showReasoning(value) {
         process.env.SHOW_REASONING = value ? "true" : "false";
     },
+    /** Usage display mode: off | tokens | full */
+    usageMode: (process.env.USAGE_MODE || "off"),
+    /** Verbose mode: when on, instructs the AI to be more detailed */
+    verboseMode: process.env.VERBOSE_MODE === "true",
+    /** Thinking level: off | low | medium | high */
+    thinkingLevel: (process.env.THINKING_LEVEL || "off"),
+    /** Group chat: when true, bot only responds when mentioned in groups */
+    groupMentionOnly: process.env.GROUP_MENTION_ONLY !== "false",
 };
 /** Persist an env variable to ~/.nzb/.env */
 export function persistEnvVar(key, value) {

package/dist/copilot/orchestrator.js

@@ -31,6 +31,8 @@ let healthCheckTimer;
 let orchestratorSession;
 // Coalesces concurrent ensureOrchestratorSession calls
 let sessionCreatePromise;
+// Tracks in-flight context recovery injection so we don't race with real messages
+let recoveryInjectionPromise;
 const messageQueue = [];
 let processing = false;
 let currentCallback;
@@ -244,16 +246,22 @@ async function createOrResumeSession() {
     setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
     console.log(`[nzb] Created orchestrator session ${session.sessionId.slice(0, 8)}…`);
     // Recover conversation context if available (session was lost, not first run)
-    // Fire-and-forget: don't block the first real message behind recovery injection
+    // Runs concurrently but is awaited before any real message is sent on the session
     const recentHistory = getRecentConversation(10);
     if (recentHistory) {
-        console.log(`[nzb] Injecting recent conversation context into new session (non-blocking)`);
-        session
+        console.log(`[nzb] Injecting recent conversation context into new session`);
+        recoveryInjectionPromise = session
             .sendAndWait({
             prompt: `[System: Session recovered] Your previous session was lost. Here's the recent conversation for context — do NOT respond to these messages, just absorb the context silently:\n\n${recentHistory}\n\n(End of recovery context. Wait for the next real message.)`,
         }, 20_000)
+            .then(() => {
+            console.log(`[nzb] Context recovery injection completed`);
+        })
             .catch((err) => {
             console.log(`[nzb] Context recovery injection failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+        })
+            .finally(() => {
+            recoveryInjectionPromise = undefined;
         });
     }
     return session;
@@ -291,6 +299,11 @@ export async function initOrchestrator(client) {
 /** Send a prompt on the persistent session, return the response. */
 async function executeOnSession(prompt, callback, onToolEvent, onUsage) {
     const session = await ensureOrchestratorSession();
+    // Wait for any in-flight context recovery injection to finish before sending
+    if (recoveryInjectionPromise) {
+        console.log(`[nzb] Waiting for context recovery injection to complete before sending…`);
+        await recoveryInjectionPromise;
+    }
     currentCallback = callback;
     let accumulated = "";
     let toolCallExecuted = false;
@@ -408,6 +421,17 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
         if (freshMemory) {
             taggedPrompt = `<reminder>\n${freshMemory}\n</reminder>\n\n${taggedPrompt}`;
         }
+        // Inject thinking level and verbose mode hints
+        const hints = [];
+        if (config.thinkingLevel !== "off") {
+            hints.push(`[Thinking level: ${config.thinkingLevel} — reason through this at ${config.thinkingLevel} depth]`);
+        }
+        if (config.verboseMode) {
+            hints.push("[Verbose mode: ON — provide detailed, thorough explanations with examples]");
+        }
+        if (hints.length > 0) {
+            taggedPrompt = `${hints.join("\n")}\n\n${taggedPrompt}`;
+        }
     }
     // Log role: background events are "system", user messages are "user"
     const logRole = source.type === "background" ? "system" : "user";
@@ -468,8 +492,7 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                 await callback(finalContent, true, { assistantLogId });
                 // Auto-continue: if the response was cut short by timeout, automatically
                 // send a follow-up "Continue" message so the user doesn't have to
-                if (finalContent.includes("⏱ Response was cut short (timeout)") &&
-                    _autoContinueCount < MAX_AUTO_CONTINUE) {
+                if (finalContent.includes("⏱ Response was cut short (timeout)") && _autoContinueCount < MAX_AUTO_CONTINUE) {
                     console.log(`[nzb] Auto-continuing after timeout (${_autoContinueCount + 1}/${MAX_AUTO_CONTINUE})…`);
                     await sleep(1000);
                     void sendToOrchestrator("Continue from where you left off. Do not repeat what was already said.", source, callback, onToolEvent, onUsage, _autoContinueCount + 1);
@@ -532,4 +555,45 @@ export function getWorkers() {
 export function getQueueSize() {
     return messageQueue.length;
 }
+/** Reset the orchestrator session — destroys current session and creates a fresh one. */
+export async function resetSession() {
+    // Drain any queued messages first
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        item.reject(new Error("Session reset"));
+    }
+    // Abort in-flight request
+    if (orchestratorSession && currentCallback) {
+        try {
+            await orchestratorSession.abort();
+        }
+        catch { }
+    }
+    // Destroy the existing session
+    if (orchestratorSession) {
+        try {
+            await orchestratorSession.destroy();
+        }
+        catch { }
+        orchestratorSession = undefined;
+    }
+    // Clear persisted session ID so a fresh session is created
+    deleteState(ORCHESTRATOR_SESSION_KEY);
+    console.log("[nzb] Session reset — will create fresh session on next message");
+}
+/** Compact the session by sending a compaction prompt (summarize context). */
+export async function compactSession() {
+    const session = await ensureOrchestratorSession();
+    try {
+        const result = await session.sendAndWait({
+            prompt: "[System: Context compaction requested] Summarize everything important from our conversation so far into a concise internal note. " +
+                "Include: key decisions, pending tasks, user preferences, and any context you'd need to continue helping. " +
+                "This summary will be used to maintain continuity. Be thorough but concise.",
+        }, 30_000);
+        return result?.data?.content || "(Compaction completed)";
+    }
+    catch (err) {
+        return `Compaction failed: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
 //# sourceMappingURL=orchestrator.js.map

package/dist/telegram/bot.js

@@ -133,8 +133,13 @@ export async function startBot() {
         await bot.api.setMyCommands([
             { command: "start", description: "Start the bot" },
             { command: "help", description: "Show help text" },
+            { command: "new", description: "Reset session (fresh context)" },
+            { command: "compact", description: "Compact session context" },
             { command: "cancel", description: "Cancel current message" },
             { command: "model", description: "Show/switch AI model" },
+            { command: "think", description: "Set thinking level (off/low/medium/high)" },
+            { command: "verbose", description: "Toggle verbose responses" },
+            { command: "usage", description: "Set usage display (off/tokens/full)" },
             { command: "status", description: "Show system status" },
             { command: "workers", description: "List active workers" },
             { command: "skills", description: "List installed skills" },

package/dist/telegram/handlers/commands.js

@@ -1,10 +1,10 @@
-import { config, persistModel } from "../../config.js";
-import { cancelCurrentMessage, getQueueSize, getWorkers } from "../../copilot/orchestrator.js";
+import { config, persistEnvVar, persistModel } from "../../config.js";
+import { cancelCurrentMessage, compactSession, getQueueSize, getWorkers, resetSession } from "../../copilot/orchestrator.js";
 import { listSkills } from "../../copilot/skills.js";
 import { restartDaemon } from "../../daemon.js";
 import { searchMemories } from "../../store/db.js";
-import { getReactionHelpText } from "./reactions.js";
 import { buildSettingsText, formatMemoryList } from "../menus.js";
+import { getReactionHelpText } from "./reactions.js";
 export function registerCommandHandlers(bot, deps) {
     const { replyKeyboard, mainMenu, settingsMenu, getUptimeStr } = deps;
     // /start and /help — with inline menu + reply keyboard
@@ -14,27 +14,89 @@ export function registerCommandHandlers(bot, deps) {
     });
     bot.command("help", (ctx) => ctx.reply("I'm NZB, your AI daemon.\n\n" +
         "Just send me a message and I'll handle it.\n\n" +
-        "Commands:\n" +
-        "/cancel — Cancel the current message\n" +
-        "/model — Show current model\n" +
-        "/model <name> — Switch model\n" +
-        "/memory — Show stored memories\n" +
-        "/skills — List installed skills\n" +
-        "/workers — List active worker sessions\n" +
-        "/status — Show system status\n" +
-        "/settings — Bot settings\n" +
-        "/restart — Restart NZB\n" +
-        "/help — Show this help\n\n" +
+        "Session:\n" +
+        "/new — Reset session (fresh context)\n" +
+        "/compact — Compact session context\n" +
+        "/cancel — Cancel the current message\n\n" +
+        "Config:\n" +
+        "/model — Show/switch AI model\n" +
+        "/think <level> — off|low|medium|high\n" +
+        "/verbose — Toggle verbose responses\n" +
+        "/usage — off|tokens|full\n" +
+        "/settings — Bot settings\n\n" +
+        "Info:\n" +
+        "/status — System status\n" +
+        "/memory — Stored memories\n" +
+        "/skills — Installed skills\n" +
+        "/workers — Active worker sessions\n" +
+        "/restart — Restart NZB\n\n" +
         "⚡ Breakthrough Features:\n" +
         "• @bot query — Use me inline in any chat!\n" +
         "• React to any message to trigger AI:\n" +
         getReactionHelpText() +
         "\n" +
-        "• Smart suggestions appear after each response", { reply_markup: mainMenu }));
+        "• Smart suggestions appear after each response\n" +
+        "• Works in groups — mention me to activate!", { reply_markup: mainMenu }));
     bot.command("cancel", async (ctx) => {
         const cancelled = await cancelCurrentMessage();
         await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
     });
+    bot.command("new", async (ctx) => {
+        await ctx.reply("🔄 Resetting session…");
+        try {
+            await resetSession();
+            await ctx.reply("✅ Session reset. Fresh context — send me a message to start.");
+        }
+        catch (err) {
+            await ctx.reply(`❌ Reset failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    bot.command("compact", async (ctx) => {
+        await ctx.reply("📦 Compacting session context…");
+        try {
+            const summary = await compactSession();
+            const preview = summary.length > 500 ? summary.slice(0, 500) + "…" : summary;
+            await ctx.reply(`✅ Context compacted.\n\n${preview}`);
+        }
+        catch (err) {
+            await ctx.reply(`❌ Compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    bot.command("think", async (ctx) => {
+        const THINK_LEVELS = ["off", "low", "medium", "high"];
+        const arg = ctx.match?.trim().toLowerCase();
+        if (arg && THINK_LEVELS.includes(arg)) {
+            config.thinkingLevel = arg;
+            persistEnvVar("THINKING_LEVEL", arg);
+            await ctx.reply(`🧠 Thinking level → ${arg}`);
+        }
+        else if (arg) {
+            await ctx.reply(`Invalid level: ${arg}\nValid: ${THINK_LEVELS.join(", ")}`);
+        }
+        else {
+            await ctx.reply(`🧠 Thinking level: ${config.thinkingLevel}\nSet with: /think off|low|medium|high`);
+        }
+    });
+    bot.command("usage", async (ctx) => {
+        const USAGE_MODES = ["off", "tokens", "full"];
+        const arg = ctx.match?.trim().toLowerCase();
+        if (arg && USAGE_MODES.includes(arg)) {
+            config.usageMode = arg;
+            persistEnvVar("USAGE_MODE", arg);
+            await ctx.reply(`📊 Usage display → ${arg}`);
+        }
+        else if (arg) {
+            await ctx.reply(`Invalid mode: ${arg}\nValid: ${USAGE_MODES.join(", ")}`);
+        }
+        else {
+            await ctx.reply(`📊 Usage display: ${config.usageMode}\nSet with: /usage off|tokens|full`);
+        }
+    });
+    bot.command("verbose", async (ctx) => {
+        config.verboseMode = !config.verboseMode;
+        persistEnvVar("VERBOSE_MODE", config.verboseMode ? "true" : "false");
+        await ctx.reply(`📝 Verbose mode ${config.verboseMode ? "ON — detailed responses" : "OFF — concise responses"}`);
+    });
     bot.command("model", async (ctx) => {
         const arg = ctx.match?.trim();
         if (arg) {
@@ -99,6 +161,9 @@ export function registerCommandHandlers(bot, deps) {
         const lines = [
             "📊 NZB Status",
             `Model: ${config.copilotModel}`,
+            `Thinking: ${config.thinkingLevel}`,
+            `Verbose: ${config.verboseMode ? "on" : "off"}`,
+            `Usage: ${config.usageMode}`,
             `Uptime: ${getUptimeStr()}`,
             `Workers: ${workers.length} active`,
             `Queue: ${getQueueSize()} pending`,
@@ -122,6 +187,9 @@ export function registerCommandHandlers(bot, deps) {
         const lines = [
             "📊 NZB Status",
             `Model: ${config.copilotModel}`,
+            `Thinking: ${config.thinkingLevel}`,
+            `Verbose: ${config.verboseMode ? "on" : "off"}`,
+            `Usage: ${config.usageMode}`,
             `Uptime: ${getUptimeStr()}`,
             `Workers: ${workers.length} active`,
             `Queue: ${getQueueSize()} pending`,

package/dist/telegram/handlers/streaming.js

@@ -11,8 +11,17 @@ export function registerMessageHandler(bot, getBot) {
         const chatId = ctx.chat.id;
         const userMessageId = ctx.message.message_id;
         const replyParams = { message_id: userMessageId };
+        // Group chat support — only respond when mentioned or replied to
+        const isGroup = ctx.chat.type === "group" || ctx.chat.type === "supergroup";
+        if (isGroup && config.groupMentionOnly) {
+            const botUsername = ctx.me.username;
+            const isMentioned = botUsername && ctx.message.text.includes(`@${botUsername}`);
+            const isReplyToBot = ctx.message.reply_to_message?.from?.id === ctx.me.id;
+            if (!isMentioned && !isReplyToBot)
+                return;
+        }
         const msgPreview = ctx.message.text.length > 80 ? ctx.message.text.slice(0, 80) + "…" : ctx.message.text;
-        void logInfo(`📩 Message: ${msgPreview}`);
+        void logInfo(`📩 Message${isGroup ? " (group)" : ""}: ${msgPreview}`);
         // React with 👀 to acknowledge message received
         try {
             await ctx.react("👀");
@@ -163,6 +172,10 @@ export function registerMessageHandler(bot, getBot) {
         };
         // If user replies to a message, include surrounding conversation context
         let userPrompt = ctx.message.text;
+        // Strip bot mention from the prompt in group chats
+        if (isGroup && ctx.me.username) {
+            userPrompt = userPrompt.replace(new RegExp(`@${ctx.me.username}\\b`, "gi"), "").trim();
+        }
         const replyMsg = ctx.message.reply_to_message;
         if (replyMsg && "text" in replyMsg && replyMsg.text) {
             // Try to find full conversation context around the replied message
@@ -209,15 +222,15 @@ export function registerMessageHandler(bot, getBot) {
                         return;
                     }
                     let textWithMeta = text;
-                    if (usageInfo) {
+                    if (usageInfo && config.usageMode !== "off") {
                         const fmtTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n));
                         const parts = [];
-                        if (usageInfo.model)
+                        if (config.usageMode === "full" && usageInfo.model)
                             parts.push(usageInfo.model);
                         parts.push(`⬆${fmtTokens(usageInfo.inputTokens)} ⬇${fmtTokens(usageInfo.outputTokens)}`);
                         const totalTokens = usageInfo.inputTokens + usageInfo.outputTokens;
                         parts.push(`Σ${fmtTokens(totalTokens)}`);
-                        if (usageInfo.duration)
+                        if (config.usageMode === "full" && usageInfo.duration)
                             parts.push(`${(usageInfo.duration / 1000).toFixed(1)}s`);
                         textWithMeta += `\n\n📊 ${parts.join(" · ")}`;
                     }

package/dist/telegram/menus.js

@@ -43,6 +43,9 @@ export function buildSettingsText(getUptimeStr) {
     return ("⚙️ Settings\n\n" +
         `⏱ Worker Timeout: ${getTimeoutLabel()}\n` +
         `🤖 Model: ${config.copilotModel}\n` +
+        `🧠 Thinking: ${config.thinkingLevel}\n` +
+        `📝 Verbose: ${config.verboseMode ? "✅ ON" : "❌ OFF"}\n` +
+        `📊 Usage: ${config.usageMode}\n` +
         `🔧 Show Reasoning: ${config.showReasoning ? "✅ ON" : "❌ OFF"}\n\n` +
         `📌 v${process.env.npm_package_version || "?"} · uptime ${getUptimeStr()}`);
 }
@@ -103,6 +106,35 @@ export function createMenus(getUptimeStr) {
         ctx.menu.update();
         await ctx.editMessageText(buildSettingsText(getUptimeStr));
         await ctx.answerCallbackQuery(`Reasoning ${config.showReasoning ? "ON" : "OFF"}`);
+    })
+        .row()
+        .text(() => `🧠 Think: ${config.thinkingLevel}`, async (ctx) => {
+        const levels = ["off", "low", "medium", "high"];
+        const idx = levels.indexOf(config.thinkingLevel);
+        const next = levels[(idx + 1) % levels.length];
+        config.thinkingLevel = next;
+        persistEnvVar("THINKING_LEVEL", next);
+        ctx.menu.update();
+        await ctx.editMessageText(buildSettingsText(getUptimeStr));
+        await ctx.answerCallbackQuery(`Thinking → ${next}`);
+    })
+        .text(() => `📝 ${config.verboseMode ? "Verbose" : "Concise"}`, async (ctx) => {
+        config.verboseMode = !config.verboseMode;
+        persistEnvVar("VERBOSE_MODE", config.verboseMode ? "true" : "false");
+        ctx.menu.update();
+        await ctx.editMessageText(buildSettingsText(getUptimeStr));
+        await ctx.answerCallbackQuery(`Verbose ${config.verboseMode ? "ON" : "OFF"}`);
+    })
+        .row()
+        .text(() => `📊 Usage: ${config.usageMode}`, async (ctx) => {
+        const modes = ["off", "tokens", "full"];
+        const idx = modes.indexOf(config.usageMode);
+        const next = modes[(idx + 1) % modes.length];
+        config.usageMode = next;
+        persistEnvVar("USAGE_MODE", next);
+        ctx.menu.update();
+        await ctx.editMessageText(buildSettingsText(getUptimeStr));
+        await ctx.answerCallbackQuery(`Usage → ${next}`);
     })
         .row()
         .text(() => `📌 v${process.env.npm_package_version || "?"} · uptime ${getUptimeStr()}`, async (ctx) => {
@@ -119,6 +151,9 @@ export function createMenus(getUptimeStr) {
         const lines = [
             "📊 NZB Status",
             `Model: ${config.copilotModel}`,
+            `Thinking: ${config.thinkingLevel}`,
+            `Verbose: ${config.verboseMode ? "on" : "off"}`,
+            `Usage: ${config.usageMode}`,
             `Uptime: ${getUptimeStr()}`,
             `Workers: ${workers.length} active`,
             `Queue: ${getQueueSize()} pending`,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iletai/nzb",
-    "version": "1.6.0",
+    "version": "1.6.2",
     "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
     "bin": {
         "nzb": "dist/cli.js"
@@ -69,4 +69,4 @@
         "typescript": "^5.9.3",
         "vitest": "^4.1.0"
     }
-}
+}