smart-home-engine 1.51.2 → 1.51.3

package/dist/web/assets/{tsMode-4A8DZYIU.js → tsMode-sNUSGo5H.js}

@@ -1,4 +1,4 @@
-import{m as O}from"./monaco-langs-DKJI_o9J.js";import{t as I}from"./index-CSKTxEh5.js";/*!-----------------------------------------------------------------------------
+import{m as O}from"./monaco-langs-DKJI_o9J.js";import{t as I}from"./index-D6H4drtd.js";/*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
  * Released under the MIT license

package/dist/web/index.html

@@ -175,7 +175,7 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-CSKTxEh5.js"></script>
+      <script type="module" crossorigin src="/assets/index-D6H4drtd.js"></script>
       <link rel="modulepreload" crossorigin href="/assets/monaco-langs-DKJI_o9J.js">
       <link rel="stylesheet" crossorigin href="/assets/monaco-langs-DyX1CsEw.css">
       <link rel="stylesheet" crossorigin href="/assets/index-DPDW78ru.css">

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "smart-home-engine",
-    "version": "1.51.2",
+    "version": "1.51.3",
     "description": "Node.js based script runner for use in MQTT based Smart Home environments",
     "main": "src/index.js",
     "scripts": {

package/src/index.js

@@ -448,7 +448,7 @@ require('./web/mqtt-api').init(store, () => mqtt);
 require('./web/services-api').init(store, () => mqtt, {
     getMqttConfig: () => ({ url: config.url, username: config.mqttUsername, password: config.mqttPassword }),
 });
-require('./web/ai-api').init(store);
+require('./web/ai-api').init(store, log);
 
 // MQTT message rate counter — reset on each stats poll
 let _mqttMsgCount = 0;

package/src/web/ai-api.js

@@ -30,7 +30,14 @@ let _store = null;
 /**
  * @param {import('../lib/state-store')} store
  */
-function init(store) {
+let _log = console;
+
+/**
+ * @param {object} store
+ * @param {{ error: Function, warn: Function }} [log] — the daemon's logger; console until init
+ */
+function init(store, log) {
+    if (log) _log = log;
     _store = store;
 }
 
@@ -122,7 +129,8 @@ async function callAnthropic(config, messages, tools) {
         model: config.model,
         system: systemMsg?.content || '',
         messages: userMessages,
-        max_tokens: 4096,
+        // thinking tokens count against this on the current models; 4096 cut answers short
+        max_tokens: 16384,
     };
     if (tools?.length) body.tools = tools;
 
@@ -151,8 +159,36 @@ async function callAnthropic(config, messages, tools) {
         return { toolCalls, assistantMsg: json.content, usage };
     }
 
-    const message = json.content?.[0]?.text ?? '';
-    return { message, usage };
+    // an answer without any text block (e.g. only a thinking block) is reported, not shown as nothing:
+    // the caller nudges once and otherwise turns `detail` into the error
+    const message = answerText(json.content);
+    const detail = message ? undefined : `stop_reason ${json.stop_reason}, content blocks: ${(json.content || []).map((b) => b.type).join(',') || 'none'}`;
+    return { message, usage, detail, assistantMsg: json.content };
+}
+
+/**
+ * What a provider may see of a conversation: role and content only. The chat page stores more on its messages
+ * (tool events, timestamps) and Anthropic rejects unknown fields; empty messages are left out too (Anthropic
+ * rejects empty text, and the chat saved empty answers before B-13).
+ * @param {Array<{role:string,content:any}>} messages
+ */
+function providerMessages(messages) {
+    return messages
+        .filter((m) => m && typeof m.role === 'string')
+        .map((m) => ({ role: m.role, content: m.content }))
+        .filter((m) => (typeof m.content === 'string' ? m.content.trim() !== '' : Array.isArray(m.content) ? m.content.length > 0 : m.content != null));
+}
+
+/**
+ * The text of an Anthropic answer: every text block joined, other block types (thinking, tool_use) ignored.
+ * @param {Array<{type:string,text?:string}>|undefined} content
+ */
+function answerText(content) {
+    if (!Array.isArray(content)) return '';
+    return content
+        .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('');
 }
 
 // ---------------------------------------------------------------------------
@@ -176,20 +212,18 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
     const isAnthropic = ai.provider === 'anthropic';
     const tools = isAnthropic ? TOOL_DEFINITIONS_ANTHROPIC : TOOL_DEFINITIONS;
     let msgs = messages;
-    let toolsUsed = false; // once the model has used tools, stop offering them
-
-    for (let round = 0; round < 6; round++) {
-        // After the first round of tool calls, don't offer tools again.
-        // This forces a plain-text response rather than letting the model
-        // keep calling tools indefinitely (and some models return empty
-        // content when given tools but no reason to call them).
-        const roundTools = toolsUsed ? undefined : tools;
+    let toolsUsed = false;
+    // The tools stay on offer in every round (up to MAX_TOOL_ROUNDS): a search that was cut short can be refined,
+    // and a history with tool_use blocks is only valid when the tools are defined. The round cap ends a model that
+    // keeps calling tools; an empty final answer is nudged once below.
+    const MAX_TOOL_ROUNDS = 8;
 
+    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
         let result;
         try {
-            result = isAnthropic ? await callAnthropic(ai, msgs, roundTools) : await callOpenAICompat(ai, msgs, roundTools);
+            result = isAnthropic ? await callAnthropic(ai, msgs, tools) : await callOpenAICompat(ai, msgs, tools);
         } catch (e) {
-            if (round === 0 && roundTools) {
+            if (round === 0) {
                 // Model may not support tool calling — retry without tools
                 result = isAnthropic ? await callAnthropic(ai, msgs) : await callOpenAICompat(ai, msgs);
             } else {
@@ -199,11 +233,21 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
 
         // No tool calls → we have the final answer
         if (!result.toolCalls?.length) {
-            // If the model returned empty content after using tools, nudge it once
-            if (!result.message && toolsUsed) {
-                const nudgeMsgs = [...msgs, { role: 'user', content: 'Based on the information retrieved above, please now provide your complete response.' }];
-                const nudged = isAnthropic ? await callAnthropic(ai, nudgeMsgs) : await callOpenAICompat(ai, nudgeMsgs);
-                return { message: nudged.message ?? '', usage: nudged.usage };
+            if (!result.message) {
+                // An answer without text (a thinking block only, or nothing): ask once for the answer itself.
+                const nudgeMsgs = [
+                    ...msgs,
+                    {
+                        role: 'user',
+                        content: toolsUsed
+                            ? 'Based on the information retrieved above, please now provide your complete response.'
+                            : 'Please provide your complete response as text.',
+                    },
+                ];
+                const nudged = isAnthropic
+                    ? await callAnthropic(ai, nudgeMsgs, toolsUsed ? tools : undefined)
+                    : await callOpenAICompat(ai, nudgeMsgs, toolsUsed ? tools : undefined);
+                return { message: nudged.message ?? '', usage: nudged.usage, detail: nudged.message ? undefined : nudged.detail || result.detail };
             }
             return { message: result.message ?? '', usage: result.usage };
         }
@@ -211,9 +255,8 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
         // Execute tool calls and append results to message history
         toolsUsed = true;
         if (isAnthropic) {
-            // Strip text blocks when tool_use blocks are present (same draft-reproduction issue)
-            const anthropicAssistantContent = result.assistantMsg.some((b) => b.type === 'tool_use') ? result.assistantMsg.filter((b) => b.type !== 'text') : result.assistantMsg;
-            msgs = [...msgs, { role: 'assistant', content: anthropicAssistantContent }];
+            // the assistant turn goes back unchanged: the current models bind their thinking blocks to the turn
+            msgs = [...msgs, { role: 'assistant', content: result.assistantMsg }];
             const toolResultBlocks = [];
             for (const tc of result.toolCalls) {
                 const args = tc.input || {};
@@ -245,9 +288,11 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
         }
     }
 
-    // Fallback (should not normally be reached)
-    const fallback = isAnthropic ? await callAnthropic(ai, msgs) : await callOpenAICompat(ai, msgs);
-    return { message: fallback.message ?? '', usage: fallback.usage };
+    // The round cap was reached: ask for the answer with what was gathered (the tools stay defined - the history
+    // holds tool_use blocks - but the request asks for text).
+    const finalMsgs = [...msgs, { role: 'user', content: 'Please answer now with the information gathered so far; do not call any more tools.' }];
+    const fallback = isAnthropic ? await callAnthropic(ai, finalMsgs, tools) : await callOpenAICompat(ai, finalMsgs, tools);
+    return { message: fallback.message ?? '', usage: fallback.usage, detail: fallback.message ? undefined : fallback.detail };
 }
 
 // ---------------------------------------------------------------------------
@@ -363,6 +408,42 @@ router.get('/config', (req, res) => {
     });
 });
 
+// Shown when the Anthropic models endpoint cannot be reached (no key, offline, 401): the current families.
+const ANTHROPIC_FALLBACK_MODELS = ['claude-opus-5-5', 'claude-sonnet-5-5', 'claude-haiku-5-5', 'claude-haiku-4-5'];
+
+/**
+ * The models the configured Anthropic key may use: GET /v1/models, every page, newest first.
+ * On failure the static fallback list with the error, so the chat still offers a choice.
+ * @param {{ apiKey?: string }} ai
+ * @returns {Promise<{ models: string[], names: Record<string,string>, error?: string }>}
+ */
+async function listAnthropicModels(ai) {
+    const headers = { 'x-api-key': ai.apiKey || '', 'anthropic-version': '2023-06-01' };
+    const all = [];
+    try {
+        let after = null;
+        for (let page = 0; page < 20; page++) {
+            const url = 'https://api.anthropic.com/v1/models?limit=100' + (after ? '&after_id=' + encodeURIComponent(after) : '');
+            const r = await fetch(url, { headers });
+            if (!r.ok) {
+                const text = await r.text().catch(() => '');
+                throw new Error(`Anthropic API error ${r.status}: ${text.slice(0, 200)}`);
+            }
+            const json = await r.json();
+            for (const m of json.data || []) if (m && m.id) all.push(m);
+            if (!json.has_more || !json.last_id) break;
+            after = json.last_id;
+        }
+    } catch (e) {
+        _log.warn('ai models: ' + e.message);
+        return { models: ANTHROPIC_FALLBACK_MODELS.slice(), names: {}, error: e.message };
+    }
+    all.sort((a, b) => String(b.created_at || '').localeCompare(String(a.created_at || '')));
+    const names = {};
+    for (const m of all) if (m.display_name) names[m.id] = m.display_name;
+    return { models: all.map((m) => m.id), names };
+}
+
 // GET /she/ai/models — list available models for the configured provider
 router.get('/models', async (req, res) => {
     const ai = readAiConfig(req.app.locals.configPath);
@@ -381,7 +462,7 @@ router.get('/models', async (req, res) => {
                 .sort();
             return res.json({ models });
         } else if (ai.provider === 'anthropic') {
-            return res.json({ models: [] }); // no public list endpoint
+            return res.json(await listAnthropicModels(ai));
         } else {
             // OpenAI / LM Studio / etc. — try /v1/models
             const h = { 'Content-Type': 'application/json' };
@@ -457,8 +538,9 @@ router.post('/chat', async (req, res) => {
     if (!Array.isArray(messages)) return res.status(400).json({ error: 'messages must be an array' });
 
     const aiWithModel = { ...ai, model: effectiveModel };
+    _log.debug(`ai chat: ${ai.provider} ${effectiveModel}${modelOverride ? ' (chosen in the chat)' : ' (config)'}`);
     const systemPrompt = buildSystemPrompt(context, currentScript ?? null, currentView ?? null, currentDoc ?? null, _store, extraFiles || []);
-    const fullMessages = [{ role: 'system', content: systemPrompt }, ...messages];
+    const fullMessages = [{ role: 'system', content: systemPrompt }, ...providerMessages(messages)];
 
     try {
         let result;
@@ -470,8 +552,10 @@ router.post('/chat', async (req, res) => {
         } else {
             result = await callOpenAICompat(aiWithModel, fullMessages);
         }
-        res.json(result);
+        if (!result.message || !String(result.message).trim()) throw new Error('The model returned an empty answer' + (result.detail ? ` (${result.detail})` : ''));
+        res.json({ message: result.message, usage: result.usage });
     } catch (e) {
+        _log.error('ai chat: ' + e.message);
         res.status(500).json({ error: e.message });
     }
 });
@@ -488,6 +572,7 @@ router.post('/chat/stream', async (req, res) => {
     if (!Array.isArray(messages)) return res.status(400).json({ error: 'messages must be an array' });
 
     const aiWithModel = { ...ai, model: effectiveModel };
+    _log.debug(`ai chat: ${ai.provider} ${effectiveModel}${modelOverride ? ' (chosen in the chat)' : ' (config)'}`);
 
     // Build system prompt BEFORE flushing headers so errors can still return a proper HTTP status
     let systemPrompt;
@@ -506,27 +591,34 @@ router.post('/chat/stream', async (req, res) => {
 
     const send = (data) => res.write(`data: ${JSON.stringify(data)}\n\n`);
 
-    const fullMessages = [{ role: 'system', content: systemPrompt }, ...messages];
+    const fullMessages = [{ role: 'system', content: systemPrompt }, ...providerMessages(messages)];
 
     try {
         if (context.tools) {
             // Tool-calling mode: resolve tools non-streaming (emitting events), then
             // send the final answer as a single token so the client sees it immediately.
             const toolContext = { store: _store, scriptDir: req.app.locals.scriptDir || null };
-            const { message } = await resolveAndGetAnswer(aiWithModel, fullMessages, toolContext, send);
+            const { message, detail } = await resolveAndGetAnswer(aiWithModel, fullMessages, toolContext, send);
+            if (!message || !message.trim()) throw new Error('The model returned an empty answer' + (detail ? ` (${detail})` : ''));
             send({ token: message });
         } else {
-            const onToken = (t) => send({ token: t });
+            let tokens = 0;
+            const onToken = (t) => {
+                tokens++;
+                send({ token: t });
+            };
             if (ai.provider === 'anthropic') {
                 await streamAnthropic(aiWithModel, fullMessages, onToken);
             } else {
                 await streamOpenAICompat(aiWithModel, fullMessages, onToken);
             }
+            if (tokens === 0) throw new Error('The model returned an empty answer');
         }
 
         res.write('data: [DONE]\n\n');
         res.end();
     } catch (e) {
+        _log.error('ai chat: ' + e.message);
         send({ error: e.message });
         res.end();
     }
@@ -607,4 +699,4 @@ router.delete('/conversations/:id', (req, res) => {
     res.json({ ok: true });
 });
 
-module.exports = { router, init };
+module.exports = { router, init, _internal: { callAnthropic, answerText, readAiConfig, listAnthropicModels, ANTHROPIC_FALLBACK_MODELS, providerMessages } };

package/src/web/ai-tools.js

@@ -34,7 +34,12 @@ const TOOL_DEFINITIONS = [
                 properties: {
                     query: {
                         type: 'string',
-                        description: 'Case-insensitive substring to match against topic names. Pass empty string to list all topics (capped at 50).',
+                        description: 'Case-insensitive substring to match against topic names. Pass empty string to list all topics.',
+                    },
+                    limit: {
+                        type: 'integer',
+                        description:
+                            'Maximum number of topics to return (1-500, default 50). The result says how many matched in total; raise the limit or narrow the query to see the rest.',
                     },
                 },
                 required: ['query'],
@@ -217,19 +222,21 @@ async function executeTool(name, args, ctx) {
 // Individual tools
 // ---------------------------------------------------------------------------
 
-function toolSearchMqttTopics({ query = '' }, store) {
+function toolSearchMqttTopics({ query = '', limit = 50 }, store) {
     if (!store) return 'MQTT state store not available.';
-    const q = query.toLowerCase();
+    const q = String(query).toLowerCase();
+    const cap = Math.min(Math.max(1, Number(limit) || 50), 500);
     const results = [];
+    let total = 0;
     for (const [topic, obj] of store.mqttEntries()) {
         if (!q || topic.toLowerCase().includes(q)) {
-            results.push(`${topic}: ${JSON.stringify(obj.val)}`);
-            if (results.length >= 50) {
-                results.push('… (truncated to 50 results, use a more specific query)');
-                break;
-            }
+            total++;
+            if (results.length < cap) results.push(`${topic}: ${JSON.stringify(obj.val)}`);
         }
     }
+    if (total > results.length) {
+        results.push(`… ${results.length} of ${total} matching topics shown; raise the limit (up to 500) or narrow the query for the rest.`);
+    }
     if (results.length === 0) {
         return q ? `No MQTT topics found matching "${query}".` : 'No MQTT topics tracked yet.';
     }