@theowlops/boombot 1.1.1 → 1.1.3

package/dist/cli/cli/registry.js

@@ -10,6 +10,7 @@ import { runGateway } from "../commands/gateway.js";
 import { isSupportedMigrateSource, printMigrateReport, runMigrateFromOpenClaw, } from "../commands/migrate.js";
 import { runSetup } from "../commands/setup.js";
 import { runPluginList, runPluginInstall, runPluginUninstall } from "../commands/plugin.js";
+import { runUpdate } from "../commands/update.js";
 import { CliError } from "./cli-error.js";
 async function setupHandler(_ctx) {
     await runSetup();
@@ -182,4 +183,17 @@ export const REGISTRY = [
         },
         handler: pluginUninstallHandler,
     },
+    {
+        spec: {
+            path: ['update'],
+            aliases: [['upgrade']],
+            summary: 'Cập nhật BoomBot lên phiên bản mới nhất từ npm',
+            usage: 'boombot update',
+            acceptsPositionals: false,
+            flags: [],
+            examples: ['boombot update', 'boombot upgrade'],
+            notes: ['Chạy `npm install -g @theowlops/boombot@latest` để kéo code mới.'],
+        },
+        handler: async () => runUpdate(),
+    },
 ];

package/dist/cli/commands/gateway.js

@@ -97,11 +97,11 @@ function gatewayHostPort() {
     try {
         const config = loadConfig(resolveConfigPath());
         const host = process.env['BOOMBOT_HOST']?.trim() || config?.host || '127.0.0.1';
-        const port = Number.parseInt(process.env['BOOMBOT_PORT']?.trim() || String(config?.port ?? 8787), 10);
-        return { host, port: Number.isInteger(port) && port > 0 && port <= 65535 ? port : 8787 };
+        const port = Number.parseInt(process.env['BOOMBOT_PORT']?.trim() || String(config?.port ?? 8788), 10);
+        return { host, port: Number.isInteger(port) && port > 0 && port <= 65535 ? port : 8788 };
     }
     catch {
-        return { host: '127.0.0.1', port: 8787 };
+        return { host: '127.0.0.1', port: 8788 };
     }
 }
 /** Public URL for the browser: 0.0.0.0/:: mean "this machine". Exported for tests. */
@@ -142,7 +142,7 @@ export function initializeGateway(configPath = resolveConfigPath()) {
         ensureMasterKey(masterKeyPath);
     }
     const { apiKeyHash } = ensureApiKey(resolveApiKeyPath(configPath));
-    saveConfig({ host: '127.0.0.1', port: 8787, dataDir, apiKeyHash }, configPath, 'wx');
+    saveConfig({ host: '127.0.0.1', port: 8788, dataDir, apiKeyHash }, configPath, 'wx');
     return true;
 }
 /**

package/dist/cli/commands/update.js

@@ -0,0 +1,21 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export async function runUpdate() {
+    console.log('🔄 Đang kiểm tra và cập nhật @theowlops/boombot từ npm...');
+    try {
+        const { stdout, stderr } = await execAsync('npm install -g @theowlops/boombot@latest');
+        if (stdout.trim()) {
+            console.log(stdout.trim());
+        }
+        if (stderr.trim()) {
+            console.error(stderr.trim());
+        }
+        console.log('✅ Cập nhật thành công! Hãy khởi động lại `boombot gateway start` để áp dụng bản mới.');
+        return 0;
+    }
+    catch (err) {
+        console.error('❌ Lỗi khi cập nhật:', err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}

package/dist/gateway/config.js

@@ -1,8 +1,9 @@
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { hashApiKey } from './auth.js';
 import { coerceChannelSection, defaultConfigDir, defaultConfigPath, readConfigObject, resolveConfigFilePath, } from './config-format.js';
 const DEFAULT_HOST = '127.0.0.1';
-const DEFAULT_PORT = 8787;
+const DEFAULT_PORT = 8788;
 /**
  * Default config path (`~/.boombot/config.yml`). The real definition lives in
  * `config-format.ts`, next to the file probe order; re-exported here so old
@@ -397,8 +398,15 @@ export function loadConfig(env = process.env) {
     const fileHost = typeof file.host === 'string' && file.host.length > 0 ? file.host : undefined;
     const host = get('BOOMBOT_HOST') ?? fileHost ?? DEFAULT_HOST;
     const port = parsePort(get('BOOMBOT_PORT') ?? file.port);
-    const fileDataDir = typeof file.dataDir === 'string' && file.dataDir.length > 0 ? file.dataDir : undefined;
-    const dataDir = get('BOOMBOT_DATA_DIR') ?? fileDataDir ?? defaultDataDir(env);
+    const fileDataDir = typeof file.dataDir === 'string' && file.dataDir.length > 0
+        ? (file.dataDir.startsWith('~/') || file.dataDir.startsWith('~\\')
+            ? join(homedir(), file.dataDir.slice(2))
+            : file.dataDir)
+        : undefined;
+    const rawDataDir = get('BOOMBOT_DATA_DIR') ?? fileDataDir ?? defaultDataDir(env);
+    const dataDir = rawDataDir.startsWith('~/') || rawDataDir.startsWith('~\\')
+        ? join(homedir(), rawDataDir.slice(2))
+        : rawDataDir;
     const apiKeyHash = resolveApiKeyHash(file.apiKeyHash, get('BOOMBOT_API_KEY'));
     const channels = mergeChannelEnv(parseChannels(file.channels, configPath), get);
     const reasoningGuard = {

package/dist/gateway/handlers/system.js

@@ -3,10 +3,64 @@
  *
  * Mirrors `GET /healthz` (which needs no auth): `{ ok, version, wireVersion }`.
  */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { WIRE_VERSION } from '@boombot/protocol';
 import { GATEWAY_VERSION } from '../server.js';
+const execAsync = promisify(exec);
 export function registerSystemHandlers(registry) {
     registry.register('gateway.health', async () => {
         return { ok: true, version: GATEWAY_VERSION, wireVersion: WIRE_VERSION };
     });
+    registry.register('system.version', async () => {
+        let latest;
+        try {
+            const res = await fetch('https://registry.npmjs.org/@theowlops/boombot/latest', {
+                signal: AbortSignal.timeout(4000),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                latest = data.version;
+            }
+        }
+        catch {
+            // offline / timeout
+        }
+        const hasUpdate = Boolean(latest && latest !== GATEWAY_VERSION);
+        return { current: GATEWAY_VERSION, latest, hasUpdate };
+    });
+    registry.register('system.update', async () => {
+        try {
+            const { stdout, stderr } = await execAsync('npm install -g @theowlops/boombot@latest', {
+                timeout: 120_000,
+            });
+            let latest;
+            try {
+                const res = await fetch('https://registry.npmjs.org/@theowlops/boombot/latest', {
+                    signal: AbortSignal.timeout(4000),
+                });
+                if (res.ok) {
+                    const data = (await res.json());
+                    latest = data.version;
+                }
+            }
+            catch {
+                // ignore
+            }
+            return {
+                ok: true,
+                message: latest ? `Đã cập nhật lên v${latest}` : 'Đã kéo bản mới nhất từ npm thành công',
+                current: GATEWAY_VERSION,
+                latest,
+                output: (stdout || stderr || '').trim(),
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: err instanceof Error ? err.message : 'Lỗi cập nhật npm',
+                current: GATEWAY_VERSION,
+            };
+        }
+    });
 }

package/dist/gateway/turns/session-adapter.js

@@ -84,6 +84,7 @@ function toChatMessage(m) {
         ...(metadata?.toolCalls !== undefined ? { toolCalls: metadata.toolCalls } : {}),
         ...(metadata?.toolCallId !== undefined ? { toolCallId: metadata.toolCallId } : {}),
         ...(metadata?.toolName !== undefined ? { name: metadata.toolName } : {}),
+        ...(metadata?.reasoning !== undefined ? { reasoning: metadata.reasoning } : {}),
     };
 }
 /**
@@ -105,6 +106,9 @@ function toSessionMetadata(message) {
     if (message.name !== undefined && message.name !== '') {
         metadata.toolName = message.name;
     }
+    if (message.reasoning !== undefined && message.reasoning !== '') {
+        metadata.reasoning = message.reasoning;
+    }
     return Object.keys(metadata).length > 0 ? metadata : undefined;
 }
 function boundedContext(messages, alreadyOmitted = 0) {

package/dist/node_modules/@boombot/core/agent-core/turn-loop.js

@@ -174,6 +174,7 @@ async function modelRound(deps, messages, tools, emit, signal) {
     checkCancelled(signal);
     let text = '';
     let reasoning = '';
+    let inThinkTag = false;
     const usage = { inputTokens: 0, outputTokens: 0 };
     const accumulators = new Map();
     const order = [];
@@ -188,8 +189,43 @@ async function modelRound(deps, messages, tools, emit, signal) {
             }
         }
         if (chunk.delta) {
-            text += chunk.delta;
-            emit({ type: 'text.delta', text: chunk.delta });
+            let remaining = chunk.delta;
+            while (remaining.length > 0) {
+                if (inThinkTag) {
+                    const closeIdx = remaining.indexOf('</think>');
+                    if (closeIdx !== -1) {
+                        const thinkPart = remaining.slice(0, closeIdx);
+                        remaining = remaining.slice(closeIdx + '</think>'.length);
+                        inThinkTag = false;
+                        if (thinkPart) {
+                            reasoning += thinkPart;
+                            emit({ type: 'reasoning.delta', text: thinkPart });
+                        }
+                    }
+                    else {
+                        reasoning += remaining;
+                        emit({ type: 'reasoning.delta', text: remaining });
+                        remaining = '';
+                    }
+                }
+                else {
+                    const openIdx = remaining.indexOf('<think>');
+                    if (openIdx !== -1) {
+                        const textPart = remaining.slice(0, openIdx);
+                        remaining = remaining.slice(openIdx + '<think>'.length);
+                        inThinkTag = true;
+                        if (textPart) {
+                            text += textPart;
+                            emit({ type: 'text.delta', text: textPart });
+                        }
+                    }
+                    else {
+                        text += remaining;
+                        emit({ type: 'text.delta', text: remaining });
+                        remaining = '';
+                    }
+                }
+            }
         }
         if (chunk.reasoningDelta) {
             reasoning += chunk.reasoningDelta;
@@ -244,15 +280,15 @@ async function modelRound(deps, messages, tools, emit, signal) {
             arguments: parsed,
         });
     }
-    // Fallback: If model emitted thinking/reasoning but no content tokens or tool calls,
-    // salvage reasoning as response text instead of failing with empty response.
-    const finalText = text.trim() ? text : (calls.length ? '' : reasoning.trim());
+    const finalText = text.trim();
+    const trimmedReasoning = reasoning.trim();
     const assistantMessage = {
         role: 'assistant',
         content: finalText,
+        ...(trimmedReasoning ? { reasoning: trimmedReasoning } : {}),
         ...(calls.length > 0 ? { toolCalls: calls } : {}),
     };
-    return { text: finalText, toolCalls: calls, assistantMessage, usage };
+    return { text: finalText, reasoning: trimmedReasoning || undefined, toolCalls: calls, assistantMessage, usage };
 }
 async function executeToolBatch(deps, batch, emit, signal) {
     const results = [];
@@ -431,6 +467,7 @@ export async function runTurn(deps, context, onEvent, signal) {
         let emptyRecoveryPending = false;
         let emptyRecoveryUsed = false;
         let contextRetryUsed = false;
+        let lastRoundReasoning;
         while (rounds < maxRounds) {
             checkCancelled(signal);
             rounds++;
@@ -440,7 +477,10 @@ export async function runTurn(deps, context, onEvent, signal) {
             const requestMessages = () => {
                 const prepared = [...modelMessages];
                 if (recoverEmpty) {
-                    prepared.push({ role: 'user', content: `[Lưu ý hệ thống: ${EMPTY_RESPONSE_NUDGE}]` });
+                    const nudge = lastRoundReasoning
+                        ? 'Bạn đã hoàn thành phần suy luận nhưng chưa sinh nội dung câu trả lời cho người dùng. Hãy đưa ra câu trả lời trực tiếp và chi tiết cho người dùng ngay bây giờ bằng tiếng Việt, không lặp lại phần suy luận và không gọi công cụ.'
+                        : EMPTY_RESPONSE_NUDGE;
+                    prepared.push({ role: 'user', content: `[Lưu ý hệ thống: ${nudge}]` });
                 }
                 if (answerOnly) {
                     prepared.push({
@@ -469,8 +509,36 @@ export async function runTurn(deps, context, onEvent, signal) {
                 if (!emptyRecoveryUsed && rounds < maxRounds) {
                     emptyRecoveryUsed = true;
                     emptyRecoveryPending = true;
+                    lastRoundReasoning = model.reasoning;
                     continue;
                 }
+                // Force one final synthesis round without tools if reasoning exists
+                if (model.reasoning && rounds < maxRounds) {
+                    try {
+                        const forceMessages = [
+                            ...modelMessages,
+                            {
+                                role: 'user',
+                                content: 'Hãy tổng hợp và đưa ra câu trả lời trực tiếp, đầy đủ cho người dùng ngay bây giờ dựa trên các suy luận ở trên bằng tiếng Việt. Không gọi thêm công cụ.',
+                            },
+                        ];
+                        const finalModel = await execPhase('modelRound', () => modelRound(deps, forceMessages, [], emit, signal));
+                        const finalText = finalModel.text.trim();
+                        if (finalText) {
+                            const finalMsg = {
+                                role: 'assistant',
+                                content: finalText,
+                                ...(model.reasoning ? { reasoning: model.reasoning } : {}),
+                            };
+                            messages.push(finalMsg);
+                            modelMessages.push(finalMsg);
+                            break;
+                        }
+                    }
+                    catch {
+                        // fall through to error
+                    }
+                }
                 const result = await finish('error', 'model returned an empty response');
                 emit({ type: 'turn.end', result });
                 return result;

package/dist/node_modules/@boombot/core/agent-core/types.d.ts

@@ -21,6 +21,8 @@ export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
 export interface ChatMessage {
     readonly role: MessageRole;
     readonly content: string;
+    /** Optional reasoning/thinking output from reasoning models or thinking blocks. */
+    readonly reasoning?: string;
     /** Optional image references for multimodal user messages. */
     readonly images?: readonly {
         readonly url: string;
@@ -123,6 +125,7 @@ export type EventHandler = (event: AgentEvent) => void;
 /** Phase payloads consumed by gateway middleware after Python returns them. */
 export interface ModelRoundResult {
     readonly text: string;
+    readonly reasoning?: string;
     readonly toolCalls: readonly ToolCall[];
     readonly assistantMessage: ChatMessage;
 }