smart-home-engine 1.52.0 → 1.53.0

package/dist/web/assets/{tsMode-CQwwRC_t.js → tsMode-BIGdBOAo.js}

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

package/dist/web/index.html

@@ -175,10 +175,10 @@
                 }
             })();
         </script>
-      <script type="module" crossorigin src="/assets/index-CD6lY3HK.js"></script>
+      <script type="module" crossorigin src="/assets/index-COKTfw7g.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-BswjzIm1.css">
+      <link rel="stylesheet" crossorigin href="/assets/index-x3Sn9IKo.css">
     </head>
     <body>
         <div id="app"></div>

package/package.json

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

package/src/web/ai-api.js

@@ -349,6 +349,23 @@ function answerText(content) {
  * @returns {Promise<{ message: string, usage?: object }>}
  */
 /** run a tool; a result of { text, event } sends the event to the chat and hands the text to the model */
+/**
+ * The tool calls of one round, executed concurrently (roadmap I31): the model is invited to ask for every
+ * independent tool in the same turn, and a slow history query must not delay a topic lookup. The call events go
+ * out first, in the model's order; each result event goes out as its tool finishes; the contents come back in
+ * the model's order, so the tool_result blocks keep their ids.
+ */
+async function runToolCalls(calls, ctx, onEvent) {
+    for (const c of calls) onEvent?.({ type: 'tool_call', name: c.name, args: c.args });
+    return Promise.all(
+        calls.map(async (c) => {
+            const content = await runToolForChat(c.name, c.args, ctx, onEvent);
+            onEvent?.({ type: 'tool_result', name: c.name, content });
+            return content;
+        }),
+    );
+}
+
 async function runToolForChat(name, args, ctx, onEvent) {
     const out = await executeTool(name, args, ctx);
     if (out && typeof out === 'object') {
@@ -420,14 +437,12 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
         if (isAnthropic) {
             // 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 || {};
-                onEvent?.({ type: 'tool_call', name: tc.name, args });
-                const content = await runToolForChat(tc.name, args, toolContext, onEvent);
-                onEvent?.({ type: 'tool_result', name: tc.name, content });
-                toolResultBlocks.push({ type: 'tool_result', tool_use_id: tc.id, content });
-            }
+            const contents = await runToolCalls(
+                result.toolCalls.map((tc) => ({ name: tc.name, args: tc.input || {} })),
+                toolContext,
+                onEvent,
+            );
+            const toolResultBlocks = result.toolCalls.map((tc, i) => ({ type: 'tool_result', tool_use_id: tc.id, content: contents[i] }));
             msgs = [...msgs, { role: 'user', content: toolResultBlocks }];
         } else {
             // Strip any draft content alongside tool_calls — if kept, the model reproduces
@@ -435,19 +450,17 @@ async function resolveAndGetAnswer(ai, messages, toolContext, onEvent) {
             const assistantEntry = { ...result.assistantMsg, role: 'assistant' };
             if (assistantEntry.content && assistantEntry.tool_calls?.length) assistantEntry.content = null;
             msgs = [...msgs, assistantEntry];
-            for (const tc of result.toolCalls) {
-                const name = tc.function.name;
+            const calls = result.toolCalls.map((tc) => {
                 let args;
                 try {
                     args = JSON.parse(tc.function.arguments || '{}');
                 } catch {
                     args = {};
                 }
-                onEvent?.({ type: 'tool_call', name, args });
-                const content = await runToolForChat(name, args, toolContext, onEvent);
-                onEvent?.({ type: 'tool_result', name, content });
-                msgs = [...msgs, { role: 'tool', tool_call_id: tc.id, content }];
-            }
+                return { name: tc.function.name, args };
+            });
+            const contents = await runToolCalls(calls, toolContext, onEvent);
+            msgs = [...msgs, ...result.toolCalls.map((tc, i) => ({ role: 'tool', tool_call_id: tc.id, content: contents[i] }))];
         }
     }
 
@@ -858,13 +871,17 @@ function publishContext(ai, context, send) {
         confirm: (req) =>
             new Promise((resolve) => {
                 const id = 'p' + crypto.randomBytes(4).toString('hex');
+                // the chat learns how the request ended (a click, or the two minutes passing), so the card never
+                // offers a button for a request the daemon has already forgotten
                 const timer = setTimeout(() => {
                     _pendingPublish.delete(id);
+                    send?.({ type: 'publish_decided', id, decided: 'timeout' });
                     resolve('timeout');
                 }, PUBLISH_CONFIRM_MS);
                 _pendingPublish.set(id, (ok) => {
                     clearTimeout(timer);
                     _pendingPublish.delete(id);
+                    send?.({ type: 'publish_decided', id, decided: ok ? 'published' : 'skipped' });
                     resolve(!!ok);
                 });
                 send?.({ type: 'publish_request', id, ...req });
@@ -874,7 +891,7 @@ function publishContext(ai, context, send) {
 
 router.post('/publish/:id', (req, res) => {
     const resolve = _pendingPublish.get(req.params.id);
-    if (!resolve) return res.status(404).json({ error: 'no pending publish with that id (answered or expired)' });
+    if (!resolve) return res.status(410).json({ error: 'this publish request was already answered or expired (two minutes); ask the assistant again' });
     resolve(req.body?.ok === true);
     res.json({ ok: true });
 });

package/src/web/ai-context.js

@@ -23,7 +23,8 @@ const ROLE = read('role.md');
 const CONVENTIONS = read('conventions.md');
 const API_REF = read('api-ref.md');
 const API_REF_COMPACT = read('api-ref-compact.md');
-const FORMATS = read('formats.md');
+const FORMATS = read('formats.md'); // the hand-over through propose_script (I16, I41)
+const FORMATS_NOTOOLS = read('formats-notools.md'); // the fenced block with the @new-file hint, for chats without tools
 const TOOLS = read('tools.md');
 const COMPACT_STEPS = read('compact.md');
 const DB_VIEW_PROMPT = read('db-view.md');
@@ -58,7 +59,7 @@ function houseSection(cfg, entries, instances, notes) {
     const known = (instances || []).filter((i) => i.adapter).map((i) => `\`${i.instance}/\` ${i.adapter}${i.connected === 0 ? ' (offline)' : ''}`);
     if (known.length) lines.push(`- adapter instances: ${known.slice(0, 20).join(', ')}${known.length > 20 ? ` … (${known.length})` : ''}`);
     if (notes && notes.length) {
-        lines.push('- facts the user confirmed earlier (trust them over guesses):');
+        lines.push('- your memory, facts from earlier chats (trust them over guesses; add with remember, drop with forget):');
         for (const n of notes.slice(0, 300)) lines.push(`  - [${n.id}] ${String(n.text).replace(/\s+/g, ' ').slice(0, 200)}`);
     }
     return lines.length > 1 ? lines.join('\n') : '';
@@ -98,7 +99,7 @@ function buildSystemPromptParts(requestCtx, currentScript, currentView, currentD
         staticParts.push(ROLE, CONVENTIONS);
         if (requestCtx.apiref !== false) staticParts.push(profile === 'compact' ? API_REF_COMPACT : API_REF);
         if (toolsOffered) staticParts.push(TOOLS);
-        staticParts.push(FORMATS);
+        staticParts.push(toolsOffered ? FORMATS : FORMATS_NOTOOLS);
         if (profile === 'compact') staticParts.push(COMPACT_STEPS);
     }
 

package/src/web/ai-sandbox-worker.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * The worker side of the AI chat's run_analysis tool (roadmap I42, decision D-9). It runs the model's code as the
+ * body of an async function in a vm context that holds only `data`, `console` and the JavaScript built-ins —
+ * no require, no process, no network. Every `data.*` call is a message to the main thread, which answers from the
+ * daemon's loaders; the main thread kills the worker when the time is up.
+ */
+
+const vm = require('node:vm');
+const { parentPort, workerData } = require('node:worker_threads');
+
+const MAX_LOG_LINES = 50;
+const logs = [];
+let nextId = 1;
+const pending = new Map();
+
+function call(name, args) {
+    return new Promise((resolve, reject) => {
+        const id = nextId++;
+        pending.set(id, { resolve, reject });
+        parentPort.postMessage({ type: 'call', id, name, args });
+    });
+}
+
+parentPort.on('message', (m) => {
+    if (m && m.type === 'reply') {
+        const p = pending.get(m.id);
+        if (!p) return;
+        pending.delete(m.id);
+        if (m.ok) p.resolve(m.value);
+        else p.reject(new Error(m.error));
+    }
+});
+
+const fmt = (args) =>
+    args
+        .map((a) => {
+            if (typeof a === 'string') return a;
+            try {
+                return JSON.stringify(a);
+            } catch {
+                return String(a);
+            }
+        })
+        .join(' ');
+const sandboxConsole = {
+    log: (...a) => logs.length < MAX_LOG_LINES && logs.push(fmt(a)),
+    info: (...a) => logs.length < MAX_LOG_LINES && logs.push(fmt(a)),
+    warn: (...a) => logs.length < MAX_LOG_LINES && logs.push('warn: ' + fmt(a)),
+    error: (...a) => logs.length < MAX_LOG_LINES && logs.push('error: ' + fmt(a)),
+};
+
+const data = Object.freeze({
+    topics: (filter = '') => call('topics', [filter]),
+    history: (topics, from, to) => call('history', [topics, from, to]),
+    messages: (topics, from, to, limit) => call('messages', [topics, from, to, limit]),
+    log: (filter = '', from, to, level, limit) => call('log', [filter, from, to, level, limit]),
+    script: (path) => call('script', [path]),
+    time: (str) => call('time', [str]),
+    from: workerData.from,
+    to: workerData.to,
+});
+
+const context = vm.createContext({ data, console: sandboxConsole });
+
+(async () => {
+    let value;
+    try {
+        const script = new vm.Script('(async () => {\n' + String(workerData.code) + '\n})()', { filename: 'analysis.js' });
+        value = await script.runInContext(context, { timeout: workerData.timeoutMs });
+    } catch (e) {
+        parentPort.postMessage({ type: 'error', message: e && e.message ? e.message : String(e), logs });
+        return;
+    }
+    let json;
+    try {
+        json = JSON.stringify(value === undefined ? null : value);
+    } catch (e) {
+        parentPort.postMessage({ type: 'error', message: 'the result is not JSON-serialisable: ' + e.message, logs });
+        return;
+    }
+    parentPort.postMessage({ type: 'done', json, logs });
+})();

package/src/web/ai-sandbox.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * The main-thread side of the AI chat's run_analysis tool (roadmap I42, decision D-9): starts the worker with the
+ * model's code, answers its data calls from the loaders it is given, and terminates it when the time is up or the
+ * heap limit is hit. Nothing of the daemon is reachable from the worker except through the loaders.
+ */
+
+const path = require('node:path');
+const { Worker } = require('node:worker_threads');
+
+const DEFAULT_TIMEOUT_MS = 10000;
+const DEFAULT_HEAP_MB = 256;
+
+/**
+ * @param {{ code: string, from?: string, to?: string }} job
+ * @param {Record<string, (...args: any[]) => any>} loaders  topics, history, messages, log, script, time
+ * @param {{ timeoutMs?: number, heapMb?: number }} [opts]
+ * @returns {Promise<{ json?: string, error?: string, logs: string[], ms: number, calls: number }>}
+ */
+function runAnalysis(job, loaders, opts = {}) {
+    const timeoutMs = Math.max(1000, Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS);
+    const heapMb = Math.max(32, Number(opts.heapMb) || DEFAULT_HEAP_MB);
+    const started = Date.now();
+    let calls = 0;
+    return new Promise((resolve) => {
+        let settled = false;
+        const worker = new Worker(path.join(__dirname, 'ai-sandbox-worker.js'), {
+            workerData: { code: String(job.code || ''), from: job.from ?? null, to: job.to ?? null, timeoutMs },
+            resourceLimits: { maxOldGenerationSizeMb: heapMb, maxYoungGenerationSizeMb: 32 },
+        });
+        const finish = (result) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            worker.terminate().catch(() => {});
+            resolve({ ...result, ms: Date.now() - started, calls });
+        };
+        const timer = setTimeout(() => finish({ error: `the analysis did not finish within ${timeoutMs / 1000} s and was stopped`, logs: [] }), timeoutMs);
+        worker.on('message', async (m) => {
+            if (!m || typeof m !== 'object') return;
+            if (m.type === 'call') {
+                calls++;
+                const fn = loaders[m.name];
+                try {
+                    if (typeof fn !== 'function') throw new Error(`data.${m.name} is not available`);
+                    const value = await fn(...(Array.isArray(m.args) ? m.args : []));
+                    worker.postMessage({ type: 'reply', id: m.id, ok: true, value });
+                } catch (e) {
+                    worker.postMessage({ type: 'reply', id: m.id, ok: false, error: e && e.message ? e.message : String(e) });
+                }
+            } else if (m.type === 'done') finish({ json: m.json, logs: m.logs || [] });
+            else if (m.type === 'error') finish({ error: m.message, logs: m.logs || [] });
+        });
+        worker.on('error', (e) => finish({ error: e && e.message ? e.message : String(e), logs: [] }));
+        worker.on('exit', (code) => {
+            if (!settled)
+                finish({ error: code === 0 ? 'the analysis ended without a result' : `the analysis was stopped (exit ${code}; the heap limit of ${heapMb} MB?)`, logs: [] });
+        });
+    });
+}
+
+module.exports = { runAnalysis, DEFAULT_TIMEOUT_MS };