maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime/node_modules/undici/lib/web/websocket/receiver.js

@@ -16,6 +16,7 @@ const { failWebsocketConnection } = require('./connection')
 const { WebsocketFrameSend } = require('./frame')
 const { PerMessageDeflate } = require('./permessage-deflate')
 const { MessageSizeExceededError } = require('../../core/errors')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../../core/constants')
 
 // This code was influenced by ws released under the MIT license.
 // Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -48,18 +49,25 @@ class ByteParser extends Writable {
   /**
    * @param {import('./websocket').Handler} handler
    * @param {Map<string, string>|null} extensions
-   * @param {{ maxPayloadSize?: number }} [options]
+   * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+   *   A missing value uses the default limit; `0` disables the limit.
    */
   constructor (handler, extensions, options = {}) {
     super()
 
     this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
-    this.#maxFragments = options.maxFragments ?? 0
-    this.#maxPayloadSize = options.maxPayloadSize ?? 0
+    // Options come from the dispatcher's `webSocketOptions`, which only
+    // DispatcherBase provides. Fall back to the defaults rather than to no
+    // limit, so RetryAgent, MockAgent or a custom dispatcher can't turn off
+    // the payload and decompression limits by accident.
+    this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments
+    this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize
 
     if (this.#extensions.has('permessage-deflate')) {
-      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, {
+        maxPayloadSize: this.#maxPayloadSize
+      }))
     }
   }
 
@@ -244,6 +252,19 @@ class ByteParser extends Writable {
         if (isControlFrame(this.#info.opcode)) {
           this.#loop = this.parseControlFrame(body)
           this.#state = parserStates.INFO
+
+          // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+          // stop parsing and resume on drain so a PING flood cannot grow the
+          // outbound queue without bound.
+          if (this.#loop && this.#handler.socket.writableNeedDrain) {
+            this.#loop = false
+            this.#handler.socket.once('drain', () => {
+              if (this.destroyed) return
+              this.#loop = true
+              this.run(callback)
+            })
+            return
+          }
         } else {
           if (!this.#info.compressed) {
             if (!this.writeFragments(body)) {

package/node_modules/@maka/runtime/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.11.2",
+  "version": "8.12.3",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -63,13 +63,15 @@
   "types": "index.d.ts",
   "scripts": {
     "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
-    "build:wasm": "node build/wasm.js --docker",
+    "build:milo": "node build/milo.js",
+    "build:llhttp": "node build/llhttp.js --docker",
+    "build:wasm": "node build/llhttp.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
     "lint": "eslint --cache",
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
     "test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
@@ -97,7 +99,7 @@
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
-    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
+    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource /service-workers",
     "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -109,7 +111,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.2.2",
+    "@fastify/busboy": "3.2.3",
     "@matteo.collina/tspl": "^0.2.0",
     "@metcoder95/https-pem": "^1.0.0",
     "@sinonjs/fake-timers": "^12.0.0",
@@ -120,12 +122,12 @@
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
+    "eslint": "^10.12.0",
     "fast-check": "^4.1.1",
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "neostandard": "^0.14.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",

package/node_modules/@maka/runtime/package.json

@@ -5,6 +5,7 @@
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
+    "./code-mode": "./dist/code-mode.js",
     "./admission-limiter": "./dist/admission-limiter.js",
     "./ask-user-question-tool": "./dist/ask-user-question-tool.js",
     "./ai-sdk-backend": "./dist/ai-sdk-backend.js",
@@ -115,6 +116,7 @@
     "./runtime-read-model": "./dist/runtime-read-model.js",
     "./sandbox-boundary-tool": "./dist/sandbox-boundary-tool.js",
     "./scheduled-task-tools": "./dist/scheduled-task-tools.js",
+    "./session-checkin": "./dist/session-checkin.js",
     "./session-recap": "./dist/session-recap.js",
     "./session-export": "./dist/session-export.js",
     "./session-trace-projection": "./dist/session-trace-projection.js",

package/node_modules/@maka/runtime-host/dist/assistant/bot/bridge.js

@@ -43,6 +43,14 @@ export class AssistantBotBridge {
         await this.endpoint.receive(id, content, origin);
         return true;
     }
+    discoveryContext(owner) {
+        if (!this.isConversation(owner))
+            throw Error('Assistant conversation unavailable');
+        return {
+            deliveries: this.endpoint.discoveryDeliveries?.() ?? [],
+            feedback: this.endpoint.discoveryFeedback?.() ?? [],
+        };
+    }
     post(owner, input) {
         if (!this.isConversation(owner))
             return false;

package/node_modules/@maka/runtime-host/dist/assistant/bot/capabilities.js

@@ -21,6 +21,7 @@ export const BOT_TOOLS = new Set([
     'InboxRead',
     'InboxCheck',
     'SendUser',
+    'DiscoveryFeedback',
     'AssistantSetAvatar',
     'Sleep',
     'AssistantConversation',

package/node_modules/@maka/runtime-host/dist/assistant/bot/controller.js

@@ -19,6 +19,8 @@
 import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { ASSISTANT_BACKGROUND_SESSION_LABEL } from '@maka/core/session';
+import { executionFailure } from '../execution-outcome.js';
+import { assistantErrorOutputTurnId, assistantInputTurnId } from './turn-ids.js';
 const UNREAD_SLEEP_FEEDBACK = '本次未能休眠：你读取 Inbox 后又收到新消息，或上一批还有未投递消息。请调用 InboxCheck 接收正文，再自行决定如何处理；不要求回复或完成每件事，之后可再次调用 Sleep。';
 export class BotController {
     ctx;
@@ -96,7 +98,7 @@ export class BotController {
             type: 'user',
             ...(origin ? { origin } : {}),
             id,
-            turnId: `assistant-input:${id}`,
+            turnId: assistantInputTurnId(id),
             ts: Date.now(),
         });
         await this.flush();
@@ -153,14 +155,26 @@ export class BotController {
         }
         const attemptedThrough = this.store.head();
         this.running = this.run()
-            .catch((error) => {
+            .catch(async (error) => {
             if (!this.abort.signal.aborted) {
                 this.store.transaction(() => {
                     this.store.set('error', String(error));
                     // Mail arriving during a failed execution must still trigger a new
                     // attempt. Do not latch the failure against that newer input.
                     this.store.set('errorThrough', attemptedThrough);
+                    const id = randomUUID();
+                    this.store.queueVisible({
+                        type: 'assistant',
+                        id: `bot-error:${id}`,
+                        turnId: assistantErrorOutputTurnId(id),
+                        ts: Date.now(),
+                        text: '助手消息处理暂时停止。消息已保留；请检查当前模型和连接，发送新消息可重试。',
+                        modelId: 'assistant-bot',
+                    });
                 });
+                // A publication may have committed before its response was lost.
+                // Keep the outbox entry for the next tick without replacing the failure.
+                await this.flush().catch(() => { });
             }
         })
             .finally(() => {
@@ -168,7 +182,17 @@ export class BotController {
         });
     }
     async run() {
-        await this.flush();
+        try {
+            await this.flush();
+        }
+        catch (error) {
+            // Pending publication is retried independently of model execution. A
+            // delivery failure cannot consume the retry triggered by fresh Inbox mail.
+            if (!this.abort.signal.aborted)
+                this.store.set('wakeError', String(error));
+            return;
+        }
+        this.store.set('wakeError', null);
         if (this.store.get('error')) {
             const errorThrough = this.store.get('errorThrough');
             if (errorThrough !== undefined && this.store.head() <= errorThrough)
@@ -211,7 +235,19 @@ export class BotController {
                     let resolution;
                     try {
                         resolution = await agent.messageExecution(wake.messageId);
-                        if (resolution?.state === 'not_admitted') {
+                    }
+                    catch (error) {
+                        this.store.set('wakeError', String(error));
+                        return;
+                    }
+                    if (resolution?.state === 'not_admitted') {
+                        // Only a new admission may change the execution model. Recovering
+                        // an owned or pending wake must keep observing that execution.
+                        const prepared = await this.ctx.prepareBotWake(this.owner(), this.worker());
+                        if (prepared === 'deferred')
+                            return;
+                        this.ready();
+                        try {
                             const admitted = await agent.followup(wake.text, { messageId: wake.messageId });
                             if (!['turn_started', 'followup'].includes(admitted?.disposition))
                                 throw Error('Bot wake was not admitted');
@@ -220,11 +256,11 @@ export class BotController {
                                 break;
                             }
                         }
-                    }
-                    catch (error) {
-                        // Retry reconciliation on the next scheduler tick, keeping the submission identity.
-                        this.store.set('wakeError', String(error));
-                        return;
+                        catch (error) {
+                            // Retry reconciliation on the next scheduler tick, keeping the submission identity.
+                            this.store.set('wakeError', String(error));
+                            return;
+                        }
                     }
                     this.store.set('wakeError', null);
                     if (resolution?.state === 'owned') {
@@ -270,10 +306,25 @@ export class BotController {
             }
             const finalStatus = (await agent.snapshot())?.agent?.status;
             this.store.set('wake', null);
-            if (['aborted', 'blocked', 'waiting_for_user'].includes(finalStatus))
-                throw Error('Bot stopped: ' + finalStatus);
-            if (!this.store.get('sleepTurn'))
-                throw Error('Bot ended without Sleep; send a new message to retry');
+            if (['aborted', 'blocked', 'waiting_for_user'].includes(finalStatus) ||
+                !this.store.get('sleepTurn')) {
+                let message = ['aborted', 'blocked', 'waiting_for_user'].includes(finalStatus)
+                    ? 'Bot stopped: ' + finalStatus
+                    : 'Bot ended without Sleep; send a new message to retry';
+                // A contained provider failure can settle whenIdle normally. Resolve
+                // this wake's latest execution rather than reporting a stale turn error.
+                if (wake) {
+                    const execution = await agent
+                        .messageExecution(wake.messageId)
+                        .catch(() => undefined);
+                    if (execution?.state === 'owned' && execution.turnId) {
+                        const failure = await executionFailure(agent, execution.turnId).catch(() => undefined);
+                        if (failure)
+                            message = failure.message;
+                    }
+                }
+                throw Error(message);
+            }
         }
         finally {
             this.activeAgent = undefined;

package/node_modules/@maka/runtime-host/dist/assistant/bot/host.js

@@ -26,7 +26,7 @@ Inbox 中 source=external_connector 的文本来自外部连接器，不是主
 
 用户消息、主动发现、任务和索引的后台反馈通过 Inbox 送达。你需要将每一条消息都处理，按你的判断选择合适的方式处理，
 
-你需要向用户传达重要发现和进展。后台的失败、阻塞和澄清请求也由你接住，处理或向用户寻求帮助。
+你需要向用户传达重要发现和进展。后台的失败、阻塞和澄清请求也由你接住，处理或向用户寻求帮助。用户回应已发送的主动发现时，用 DiscoveryFeedback 关联这条回复与对应消息；普通聊天不是主动发现反馈。
 
 你负责索引的创建、来源和维护配置，以及主动发现的启停和周期。委派的工作由执行者推进和等待，结果返回给你，由你与用户交流。
 
@@ -49,6 +49,8 @@ export function initializeBot(ctx, directory, binding) {
         }),
         receive: (id, content, origin) => bot.receive(id, content, origin),
         post: (input) => bot.post(input),
+        discoveryDeliveries: () => store.discoveryDeliveries(),
+        discoveryFeedback: () => store.discoveryFeedback(),
     });
     ctx.backgroundSessions.register(() => (bot.worker() ? [bot.worker()] : []));
     ctx.onClose(() => store.close());
@@ -84,12 +86,13 @@ export function initializeBot(ctx, directory, binding) {
         offset: z.number().int().nonnegative().default(0),
         limit: z.number().int().min(1).max(48000).default(24000),
     }), (input) => store.read(input.id, input.offset, input.limit), true);
-    register('SendUser', '向用户发送一批聊天消息，messages 按顺序显示为独立气泡。每项填写 text（完整正文）；summary（简短摘要）可选。短消息直接发正文，不必写摘要。较长消息需要填写独立摘要，用户默认看到摘要，点击展开正文；摘要由你概括，不是截断正文。需要你从用户的观看体验来看需不需要摘要。messageId 标识这批发送，重试时复用。发送后循环继续。', z
+    register('SendUser', '向用户发送一批聊天消息，messages 按顺序显示为独立气泡。每项填写 text（完整正文）；summary（简短摘要）可选。短消息直接发正文，不必写摘要。较长消息需要填写独立摘要，用户默认看到摘要，点击展开正文；摘要由你概括，不是截断正文。需要你从用户的观看体验来看需不需要摘要。转达主动发现时，在该项 discoveryIds 填对应的 discovery 类型 Inbox 消息 ID，记录实际送达关系；普通聊天留空。messageId 标识这批发送，重试时复用。发送后循环继续。', z
         .object({
         messageId: z.string().min(1).max(200),
         messages: z
             .array(z
             .object({
+            discoveryIds: z.array(z.string().min(1)).min(1).max(100).optional(),
             summary: z.string().trim().min(1).max(2000).optional(),
             text: z.string().trim().min(1).max(48000),
         })
@@ -103,6 +106,12 @@ export function initializeBot(ctx, directory, binding) {
         await bot.flush();
         return { sent: true, messageIds };
     });
+    register('DiscoveryFeedback', '仅当用户在回应已发送的主动发现时，关联用户的 Inbox 消息 ID 和 SendUser 返回的实际消息 ID。根据交流内容判断关联，不把普通聊天或新任务当反馈；无需改写用户原话。可以回查 Inbox 和 AssistantConversation。', z
+        .object({
+        userMessageId: z.string().min(1),
+        messageId: z.string().min(1),
+    })
+        .strict(), (input) => store.linkDiscoveryFeedback(input.userMessageId, input.messageId));
     register('Sleep', '结束本轮并休眠，新 Inbox 消息自动唤醒，不支持设置唤醒时间。还有未投递消息时返回 sleeping=false 和原因，循环继续；成功休眠不要求先发送消息，也不代表后台任务已完成。', z.object({}), (_, call) => bot.sleep(call.turnId), false, true);
     register('AssistantConversation', '读取用户可见的助手交流历史，理解既有约定、避免重复。内部工具执行不等于用户已经收到消息。', z.object({
         offset: z.number().int().nonnegative().default(0),

package/node_modules/@maka/runtime-host/dist/assistant/bot/store.js

@@ -19,6 +19,7 @@
 import { DatabaseSync } from 'node:sqlite';
 import { mkdirSync, chmodSync } from 'node:fs';
 import { join } from 'node:path';
+import { assistantBatchOutputTurnId, assistantOutputTurnId } from './turn-ids.js';
 /** Durable incoming messages; delivery cursors are not task completion state. */
 export class BotStore {
     db;
@@ -32,6 +33,9 @@ export class BotStore {
         type TEXT NOT NULL, source TEXT NOT NULL, at INTEGER NOT NULL, task TEXT,
         content TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS metadata(key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS discovery_messages(message_id TEXT PRIMARY KEY, discovery_ids TEXT NOT NULL, delivered_at INTEGER);
+      CREATE TABLE IF NOT EXISTS discovery_feedback(user_id TEXT NOT NULL, message_id TEXT NOT NULL,
+        PRIMARY KEY(user_id,message_id));
       CREATE TABLE IF NOT EXISTS outbox_batches(id TEXT PRIMARY KEY, payload TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS outbox(id TEXT PRIMARY KEY, payload TEXT NOT NULL, delivered INTEGER NOT NULL DEFAULT 0);`);
     }
@@ -175,7 +179,14 @@ export class BotStore {
             const serialize = (items) => JSON.stringify(items.map((entry) => ({
                 text: entry.text,
                 ...(entry.summary !== undefined ? { summary: entry.summary } : {}),
+                ...(entry.discoveryIds?.length
+                    ? { discoveryIds: [...new Set(entry.discoveryIds)].sort() }
+                    : {}),
             })));
+            for (const entry of texts)
+                for (const id of entry.discoveryIds ?? [])
+                    if (!this.db.prepare("SELECT 1 FROM inbox WHERE id=? AND type='discovery'").get(id))
+                        throw Error('discoveryIds must reference discovery messages in Inbox');
             const payload = serialize(texts);
             const old = this.db.prepare('SELECT payload FROM outbox_batches WHERE id=?').get(batchId);
             if (old && serialize(JSON.parse(String(old.payload))) !== payload)
@@ -195,12 +206,18 @@ export class BotStore {
                 this.queueVisible({
                     type: 'assistant',
                     id,
-                    turnId: texts.length === 1 ? `assistant-output:${suffix}` : `assistant-output:batch:${suffix}`,
+                    turnId: texts.length === 1
+                        ? assistantOutputTurnId(batchId)
+                        : assistantBatchOutputTurnId(batchId, index),
                     ts: timestamp,
                     text,
                     ...(summary !== undefined ? { summary } : {}),
                     modelId: 'assistant-bot',
                 });
+                if (entry.discoveryIds?.length)
+                    this.db
+                        .prepare('INSERT OR IGNORE INTO discovery_messages(message_id,discovery_ids) VALUES(?,?)')
+                        .run(id, JSON.stringify([...new Set(entry.discoveryIds)].sort()));
                 return id;
             });
             if (!old)
@@ -208,6 +225,53 @@ export class BotStore {
             return ids;
         });
     }
+    discoveryDeliveries() {
+        return this.db
+            .prepare(`SELECT o.id,o.payload,d.discovery_ids,d.delivered_at FROM outbox o
+      JOIN discovery_messages d ON d.message_id=o.id WHERE o.delivered=1 ORDER BY o.rowid`)
+            .all()
+            .map((row) => {
+            const m = JSON.parse(String(row.payload));
+            return {
+                messageId: String(row.id),
+                discoveryIds: JSON.parse(String(row.discovery_ids)),
+                text: m.text,
+                at: new Date(Number(row.delivered_at)).toISOString(),
+            };
+        });
+    }
+    linkDiscoveryFeedback(userMessageId, messageId) {
+        // Both sides must be real messages. The Bot supplies the semantic relationship,
+        // never replacement user text or an inferred reply based on adjacency.
+        const user = this.db
+            .prepare("SELECT * FROM inbox WHERE id=? AND type='user_message' AND source='user'")
+            .get(userMessageId);
+        const visible = this.db.prepare('SELECT payload FROM outbox WHERE id=?').get(userMessageId);
+        const delivery = this.discoveryDeliveries().find((d) => d.messageId === messageId);
+        if (!user || !visible || JSON.parse(String(visible.payload)).origin || !delivery)
+            throw Error('Feedback requires an owner user message and a delivered discovery message');
+        if (Number(user.at) < Date.parse(delivery.at))
+            throw Error('Feedback must follow the delivered discovery message');
+        this.db
+            .prepare('INSERT OR IGNORE INTO discovery_feedback VALUES(?,?)')
+            .run(userMessageId, messageId);
+        return { recorded: true, userMessageId, messageId };
+    }
+    discoveryFeedback() {
+        return this.db
+            .prepare(`SELECT f.user_id,f.message_id,o.payload,i.at FROM discovery_feedback f
+      JOIN outbox o ON o.id=f.user_id JOIN inbox i ON i.id=f.user_id ORDER BY f.rowid`)
+            .all()
+            .map((row) => {
+            const m = JSON.parse(String(row.payload));
+            return {
+                id: String(row.user_id),
+                messageId: String(row.message_id),
+                text: m.displayText ?? m.text,
+                at: new Date(Number(row.at)).toISOString(),
+            };
+        });
+    }
     pendingVisible() {
         return this.db
             .prepare('SELECT payload FROM outbox WHERE delivered=0 ORDER BY rowid')
@@ -215,7 +279,12 @@ export class BotStore {
             .map((row) => JSON.parse(String(row.payload)));
     }
     delivered(id) {
-        this.db.prepare('UPDATE outbox SET delivered=1 WHERE id=?').run(id);
+        this.transaction(() => {
+            this.db.prepare('UPDATE outbox SET delivered=1 WHERE id=?').run(id);
+            this.db
+                .prepare('UPDATE discovery_messages SET delivered_at=COALESCE(delivered_at,?) WHERE message_id=?')
+                .run(Date.now(), id);
+        });
     }
     close() {
         this.db.close();

package/node_modules/@maka/runtime-host/dist/assistant/bot/turn-ids.js

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Turn ids for the assistant conversation's bot-delivered messages.
+ *
+ * The Runtime Host admits a turn id only when it matches
+ * `^[A-Za-z0-9_-]{1,128}$` (`requireEntityId`), and the desktop can branch
+ * from any turn whose id it can read. The ids below therefore use dashes, and
+ * the caller-supplied parts (an external connector message id, or the model's
+ * batch `messageId`) are hashed rather than embedded as text.
+ *
+ * Legacy transcript rows were written with colon separators. Readers must
+ * accept both forms.
+ */
+const digest = (value) => createHash('sha256').update(value).digest('hex').slice(0, 48);
+export const assistantInputTurnId = (messageId) => `assistant-input-${digest(messageId)}`;
+export const legacyAssistantInputTurnId = (messageId) => `assistant-input:${messageId}`;
+export const assistantOutputTurnId = (batchId) => `assistant-output-${digest(batchId)}`;
+export const assistantBatchOutputTurnId = (batchId, index) => `assistant-output-batch-${digest(batchId)}-${index}`;
+// The id is a fresh UUID minted by the bot, so it needs no hashing.
+export const assistantErrorOutputTurnId = (id) => `assistant-output-error-${id}`;

package/node_modules/@maka/runtime-host/dist/assistant/index-initiative/assistant.js

@@ -184,6 +184,13 @@ export function registerAssistant(ctx, store, controller) {
             totalCharacters: text.length,
         };
     });
+    ctx.api.register('assistant.allocate-workspace', async (input) => {
+        z.object({}).strict().parse(input);
+        controller.ready();
+        if (!ctx.allocateWorkspace)
+            throw Error('Assistant workspace allocation is unavailable');
+        return ctx.allocateWorkspace();
+    });
     ctx.api.register('assistant.binding', () => ({ state: store.get(), bot: ctx.bot.status() }));
     ctx.api.register('assistant.status', summary);
     ctx.api.register('assistant.bind', async (input) => {