maka-agent 0.2.1-dev.89.20261016 → 0.2.1-dev.91.20261018

package/node_modules/@maka/core/dist/event-wait.js

@@ -29,7 +29,12 @@ export const EVENT_WAIT_LIMITS = Object.freeze({
     evidenceRefs: 8,
     evidenceRefBytes: 1024,
     reasonBytes: 1024,
-    recordBytes: 32768,
+    cursorBytes: 2048,
+    observationAttempts: 1_000_000,
+    // Every combination of bounded fields, including observation and a cancelled
+    // priorResolution, fits below 42 KiB even with JSON escaping. Leave room for
+    // the full lifecycle so an accepted result can always retain its facts on cancel.
+    recordBytes: 48 * 1024,
 });
 const encoder = new TextEncoder();
 const invalidIdCharacterPattern = /[^A-Za-z0-9_-]/u;
@@ -187,7 +192,7 @@ export function decodeEventWaitRecord(value) {
         'deadlineAt',
         'status',
         ...lifecycleKeys,
-    ], root.status === 'cancelled' ? ['priorResolution'] : []);
+    ], root.status === 'cancelled' ? ['priorResolution', 'observation'] : ['observation']);
     if (r.schemaVersion !== EVENT_WAIT_SCHEMA_VERSION)
         invalid('schemaVersion');
     const lease = shape(r.goalControlLease, ['goalId', 'generation']);
@@ -230,6 +235,62 @@ export function decodeEventWaitRecord(value) {
             invalid('lifecycle time');
         return result;
     };
+    if (Object.hasOwn(r, 'observation')) {
+        const x = shape(r.observation, [
+            'schemaVersion',
+            'attempts',
+            'lastAttemptAt',
+            'lastObservedAt',
+            'nextObserveAt',
+            'nextPollAt',
+            'consecutiveErrors',
+            'outcome',
+            'cursor',
+            'eventKey',
+            'reason',
+        ]);
+        const attempts = integer(x.attempts, 'observation attempts', 1);
+        const consecutiveErrors = integer(x.consecutiveErrors, 'consecutive errors');
+        const lastAttemptAt = time(x.lastAttemptAt);
+        const nextObserveAt = integer(x.nextObserveAt, 'next observation');
+        const nextPollAt = integer(x.nextPollAt, 'next poll');
+        const lastObservedAt = x.lastObservedAt === null ? null : time(x.lastObservedAt);
+        if (x.schemaVersion !== 1 ||
+            attempts > EVENT_WAIT_LIMITS.observationAttempts ||
+            consecutiveErrors > attempts ||
+            nextObserveAt < lastAttemptAt ||
+            nextPollAt < nextObserveAt ||
+            (x.outcome !== 'checking' && (lastObservedAt === null || lastObservedAt < lastAttemptAt)) ||
+            typeof x.outcome !== 'string' ||
+            ![
+                'checking',
+                'pending',
+                'unknown',
+                'satisfied',
+                'invalidated',
+                'source_unavailable',
+            ].includes(x.outcome))
+            invalid('observation');
+        Object.assign(base, {
+            observation: {
+                schemaVersion: 1,
+                attempts,
+                lastAttemptAt,
+                lastObservedAt,
+                nextObserveAt,
+                nextPollAt,
+                consecutiveErrors,
+                outcome: x.outcome,
+                cursor: x.cursor === null ? null : text(x.cursor, 'cursor', EVENT_WAIT_LIMITS.cursorBytes),
+                eventKey: x.eventKey === null
+                    ? null
+                    : text(x.eventKey, 'event key', EVENT_WAIT_LIMITS.receiptKeyBytes),
+                reason: x.reason === null
+                    ? null
+                    : text(x.reason, 'observation reason', EVENT_WAIT_LIMITS.reasonBytes),
+            },
+        });
+    }
     const resolution = (v, resolvedAt) => {
         const x = shape(v, ['outcome', 'receiptKey', 'observedAt', 'evidenceRefs']);
         if (x.outcome !== 'satisfied' &&
@@ -306,7 +367,41 @@ export function assertEventWaitTransition(previous, next) {
     }
     if (b.updatedAt < a.updatedAt)
         invalid('time regression');
+    if (a.observation) {
+        if (!b.observation ||
+            b.observation.attempts < a.observation.attempts ||
+            b.observation.attempts > a.observation.attempts + 1 ||
+            b.observation.lastAttemptAt < a.observation.lastAttemptAt ||
+            (a.observation.lastObservedAt !== null &&
+                (b.observation.lastObservedAt === null ||
+                    b.observation.lastObservedAt < a.observation.lastObservedAt)))
+            invalid('observation regression');
+        if (b.observation.attempts === a.observation.attempts &&
+            b.observation.lastAttemptAt !== a.observation.lastAttemptAt)
+            invalid('attempt time without reservation');
+        if (b.observation.attempts > a.observation.attempts &&
+            (b.status !== 'waiting' ||
+                b.observation.outcome !== 'checking' ||
+                b.observation.lastObservedAt !== a.observation.lastObservedAt ||
+                b.observation.cursor !== a.observation.cursor ||
+                b.observation.eventKey !== a.observation.eventKey ||
+                b.observation.consecutiveErrors !== a.observation.consecutiveErrors))
+            invalid('attempt reservation');
+    }
+    else if (b.observation && b.observation.attempts !== 1)
+        invalid('initial observation budget');
     if (a.status === 'waiting') {
+        if (b.status === 'waiting' && b.observation && !same(a.observation, b.observation)) {
+            if (b.observation.attempts > (a.observation?.attempts ?? 0) &&
+                b.observation.outcome === 'checking')
+                return;
+            if (a.observation?.outcome === 'checking' &&
+                (b.observation.outcome === 'pending' || b.observation.outcome === 'unknown'))
+                return;
+            invalid('observation update without reservation');
+        }
+        if (b.status === 'resolved' && b.resolvedAt >= b.deadlineAt)
+            invalid('resolution after deadline');
         if (b.status === 'resolved' ||
             b.status === 'expired' ||
             (b.status === 'cancelled' && !b.priorResolution))
@@ -314,6 +409,7 @@ export function assertEventWaitTransition(previous, next) {
     }
     else if (a.status === 'resolved' &&
         b.status === 'cancelled' &&
+        same(a.observation, b.observation) &&
         same(b.priorResolution, { resolvedAt: a.resolvedAt, resolution: a.resolution }))
         return;
     invalid('state transition');

package/node_modules/@maka/core/dist/runtime-event.js

@@ -173,6 +173,7 @@ export function runtimeEventEnvelopeValueDomains() {
 }
 const RUNTIME_EVENT_SHAPE = defineObjectShape()(['id', 'invocationId', 'runId', 'sessionId', 'turnId', 'ts', 'partial', 'role', 'author'], ['branch', 'origin', 'modelVisibility', 'status', 'content', 'actions', 'refs']);
 const TEXT_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], [
+    'summary',
     'displayText',
     'interrupted',
     'origin',
@@ -377,6 +378,7 @@ export function decodeRuntimeEvent(value) {
             content: {
                 kind: 'text',
                 ...normalizeMessageContent(value.content),
+                ...(value.content.summary !== undefined ? { summary: value.content.summary } : {}),
                 ...(value.content.origin !== undefined
                     ? { origin: decodeTurnOrigin(value.content.origin) }
                     : {}),
@@ -403,6 +405,7 @@ function isRuntimeEventContent(value) {
     switch (value.kind) {
         case 'text':
             if (!hasExactShape(value, TEXT_CONTENT_SHAPE) ||
+                (value.summary !== undefined && typeof value.summary !== 'string') ||
                 (value.origin !== undefined && !isTurnOrigin(value.origin)) ||
                 (value.steering !== undefined && value.steering !== true) ||
                 (value.interrupted !== undefined && value.interrupted !== true) ||

package/node_modules/@maka/core/dist/session.js

@@ -393,7 +393,7 @@ const USER_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 't
     'coordinationActionId',
     'origin',
 ]);
-const ASSISTANT_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'text', 'modelId'], ['thinking', 'contentOrder', 'providerOptions', 'interrupted']);
+const ASSISTANT_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'text', 'modelId'], ['thinking', 'contentOrder', 'providerOptions', 'interrupted', 'summary']);
 const TOOL_CALL_MESSAGE_SHAPE = defineObjectShape()(['type', 'id', 'turnId', 'ts', 'toolName', 'args'], [
     'activityKind',
     'displayName',
@@ -610,6 +610,7 @@ function decodeMessage(value, decodeToolResultContent) {
                 hasMessageEnvelope(message, true) &&
                 typeof message.text === 'string' &&
                 typeof message.modelId === 'string' &&
+                (message.summary === undefined || typeof message.summary === 'string') &&
                 (message.interrupted === undefined || message.interrupted === true) &&
                 (message.providerOptions === undefined || isRecord(message.providerOptions)) &&
                 (message.thinking === undefined || isAssistantThinking(message.thinking)) &&

package/node_modules/@maka/core/dist/turn-origin.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
+const EXTERNAL_CONNECTOR_ORIGIN_SHAPE = defineObjectShape()(['kind', 'connectorId'], ['senderId']);
 const SCHEDULED_TASK_ORIGIN_SHAPE = defineObjectShape()(['kind', 'scheduledTaskId'], []);
 const CLOUD_ACTIVATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'activationId'], []);
 const LEGACY_AUTOMATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'automationId'], []);
@@ -26,6 +27,19 @@ const AGENT_GRAPH_ORIGIN_SHAPE = defineObjectShape()(['kind', 'graphId', 'wakeId
 export function decodeTurnOrigin(value) {
     if (!isRecord(value))
         return undefined;
+    if (value.kind === 'external_connector') {
+        if (!hasExactShape(value, EXTERNAL_CONNECTOR_ORIGIN_SHAPE) ||
+            typeof value.connectorId !== 'string' ||
+            !value.connectorId.length ||
+            (value.senderId !== undefined &&
+                (typeof value.senderId !== 'string' || !value.senderId.length)))
+            return undefined;
+        return {
+            kind: 'external_connector',
+            connectorId: value.connectorId,
+            ...(value.senderId !== undefined ? { senderId: value.senderId } : {}),
+        };
+    }
     if (value.kind === 'workhub_result') {
         const keys = ['kind', 'eventId', 'actionId', 'delegationId', 'targetSessionId', 'targetTurnId'];
         if (Object.keys(value).length !== keys.length ||

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -1748,6 +1748,7 @@ export class AiSdkTurn {
                         throw providerOutcome.failure;
                     finishReason = providerOutcome.finishReason;
                     await queue.waitUntilConsumedThroughCurrent();
+                    let toolRequestedFinish = false;
                     if (returnedToolCalls.length > 0) {
                         const continuationBudgetRemains = maxSteps === undefined || runtimeSteps < maxSteps;
                         if (continuationBudgetRemains && !this.deps.backend.loadTurnRuntimeEvents) {
@@ -1819,6 +1820,12 @@ export class AiSdkTurn {
                                 throw outcome.reason;
                             const settlement = outcome.value;
                             const toolCall = returnedToolCalls[index];
+                            const definition = toolCall && toolsByName.get(toolCall.toolName);
+                            if (returnedToolCalls.length === 1 &&
+                                definition?.executionSemantics === 'exclusive_step' &&
+                                definition.finishTurnOnSuccess &&
+                                !settlement.providerError)
+                                toolRequestedFinish = true;
                             if (isPlanToolResult(settlement.result)) {
                                 this.handlePlanToolResult(settlement.result, queue);
                             }
@@ -1851,6 +1858,21 @@ export class AiSdkTurn {
                         ...(providerStepUsage ? { usage: providerStepUsage } : {}),
                     });
                     lastCompletedStepHadToolResult = returnedToolCalls.length > 0;
+                    // Finish only after the tool result is durably consumed. The Host can
+                    // veto completion (for example, new Inbox input raced with Sleep).
+                    if (toolRequestedFinish && !this.aborted && !this.loopStopRequested) {
+                        const decision = await this.deps.backend.beforeTurnFinish?.({
+                            sessionId: this.deps.backend.sessionId,
+                            turnId,
+                            signal: turnAbortController.signal,
+                        });
+                        if (!decision || decision.allow) {
+                            finishReason = 'stop';
+                            this.deps.modelAdapter.clearContinuation(this.turnId);
+                            break agentLoop;
+                        }
+                        finishFeedback = decision.feedback;
+                    }
                     const stepLimitReached = maxSteps !== undefined && runtimeSteps >= maxSteps;
                     if (sandboxBoundaryFinalizationStep ||
                         (stepLimitReached &&

package/node_modules/@maka/runtime/dist/plugin-agent-service.js

@@ -100,7 +100,13 @@ export class PluginAgentService extends Service {
         return Object.freeze({
             ...descriptor,
             id,
-            followup: (message) => service.runtime().followup(id, message, invocation),
+            followup: (message, options) => service.runtime().followup(id, message, invocation, options),
+            messageExecution: async (messageId) => {
+                const runtime = service.runtime();
+                if (!runtime.messageExecution)
+                    throw new Error('Runtime message execution query unavailable');
+                return runtime.messageExecution(id, messageId, invocation);
+            },
             steer: (message) => service.runtime().steer(id, message, invocation),
             inject: (message) => service.runtime().inject(id, message, invocation),
             cancel: () => service.runtime().cancel(id, invocation),

package/node_modules/@maka/runtime/dist/plugin-executor-backend.js

@@ -59,8 +59,8 @@ export class PluginExecutorBackend {
                 yield event;
                 queue.ackConsumed();
             }
-            const returnedResult = await producer;
-            if (returnedResult) {
+            const settlement = await producer;
+            if (settlement === 'published') {
                 // The Runtime Kernel requests the next item only after onSessionEvent
                 // resolves. Reaching this point means its terminal event was accepted.
                 // The Plugin decides whether its external execution actually settled;
@@ -78,8 +78,11 @@ export class PluginExecutorBackend {
         finally {
             queue.noteConsumerDetached();
             abort.abort(new Error('Plugin executor event consumer detached'));
-            const returnedResult = await producer.catch(() => false);
-            if (returnedResult &&
+            // A settled result that was not acknowledged is abandoned, including one
+            // the Runtime rejected before publishing it. A provider failure before
+            // settlement is neither acknowledged nor abandoned.
+            const settlement = await producer.catch(() => 'unsettled');
+            if (settlement !== 'unsettled' &&
                 this.#binding.acknowledgeExecution &&
                 !acknowledged &&
                 this.#binding.abandonExecution)
@@ -113,6 +116,7 @@ export class PluginExecutorBackend {
         let result;
         let failure;
         let failed = false;
+        let settled = false;
         try {
             result = await this.#binding.execute({
                 sessionId: this.sessionId,
@@ -130,6 +134,9 @@ export class PluginExecutorBackend {
                 ...(input.quotes ? { quotes: input.quotes } : {}),
             }, {
                 signal,
+                onSettled: () => {
+                    settled = true;
+                },
                 onEvent: (event) => {
                     if (event.type === 'thinking_delta')
                         thinkingText += event.text;
@@ -148,14 +155,14 @@ export class PluginExecutorBackend {
                 this.#publishCancellation(turnId, { status: 'cancelled', source: 'caller' }, queue);
             else
                 this.#publishFailure(turnId, failure instanceof Error ? failure.message : 'External executor failed', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         if (result === undefined) {
             this.#publishFailure(turnId, 'External executor returned no terminal result', undefined, false, queue);
-            return false;
+            return settled ? 'rejected' : 'unsettled';
         }
         this.#publishResult(turnId, messageId, result, queue);
-        return true;
+        return 'published';
     }
     async #requestPermission(input, request, signal, toolUseIds, queue) {
         const hosted = input.hostedInteraction;

package/node_modules/@maka/runtime/dist/plugin-executor-service.js

@@ -280,6 +280,12 @@ export class PluginExecutorService extends Service {
                         return normalizePermissionResult(result, normalized);
                     },
                 });
+                try {
+                    options.onSettled?.();
+                }
+                catch {
+                    // A settlement observer must not change external execution.
+                }
                 if (signal.aborted) {
                     const cancelled = cancelledResult(signal.reason);
                     const normalized = normalizeResult(result);

package/node_modules/@maka/runtime/dist/runtime-event-backfill.js

@@ -90,6 +90,7 @@ export function backfillRuntimeEventsFromStoredMessages(input) {
                         content: {
                             kind: 'text',
                             text: message.text,
+                            ...(message.summary !== undefined ? { summary: message.summary } : {}),
                             ...(message.interrupted ? { interrupted: true } : {}),
                         },
                         actions: { stateDelta: recoveryState(now, message) },

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -659,6 +659,7 @@ function projectText(event, state, messages) {
             turnId: event.turnId,
             ts: event.ts,
             text: event.content.text,
+            ...(event.content.summary !== undefined ? { summary: event.content.summary } : {}),
             ...(event.content.interrupted ? { interrupted: true } : {}),
             ...(event.content.providerOptions !== undefined
                 ? { providerOptions: structuredClone(event.content.providerOptions) }

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

@@ -0,0 +1,89 @@
+/*
+ * 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';
+import { z } from 'zod';
+import { validateImageBytes } from '@maka/runtime/image-file';
+import { assistantAvatarSchema, assistantEmojiSchema, DEFAULT_ASSISTANT_AVATAR, } from '../../protocol/personal-assistant.js';
+export function initializeAvatar(ctx, store, bot, register) {
+    const current = () => store.get('avatar');
+    const avatar = () => {
+        const { imageData: _, ...metadata } = current() ?? {};
+        return assistantAvatarSchema.safeParse(metadata).data ?? DEFAULT_ASSISTANT_AVATAR;
+    };
+    ctx.api.register('assistant.avatar', () => ({ avatar: avatar() }));
+    // Bounded transfers keep large images out of the normal status polling and model transcript.
+    ctx.api.register('assistant.avatar-image', (raw) => {
+        const { id, offset } = z
+            .object({ id: z.string(), offset: z.number().int().nonnegative().default(0) })
+            .parse(raw);
+        const saved = current();
+        if (avatar().image?.id !== id || !saved?.imageData)
+            throw Error('Avatar changed; refresh its metadata');
+        if (offset >= saved.imageData.length)
+            throw Error('Invalid avatar offset');
+        const data = saved.imageData.slice(offset, offset + 192 * 1024);
+        return {
+            id,
+            offset,
+            data,
+            nextOffset: offset + data.length < saved.imageData.length ? offset + data.length : null,
+        };
+    });
+    register('AssistantSetAvatar', '更换你自己的头像，入口和聊天消息同步显示，重启后保留。image 填生成或找到的图片的当前工具会话工作目录内的本地路径或公网 HTTP(S) 图片网址（PNG/JPEG/WebP/GIF，最多 2 MiB），不要传 base64。也可用 emoji 填一个 emoji；两者选一。background 可填 #RRGGBB。图片会保存副本；此工具只设置头像，生成或找图使用已有工具，必要时委派任务。不会发送消息。', z
+        .object({
+        emoji: assistantEmojiSchema.optional(),
+        image: z.string().trim().min(1).max(8192).optional(),
+        background: z
+            .string()
+            .regex(/^#[0-9a-fA-F]{6}$/)
+            .default('#E5EDFF'),
+    })
+        .strict()
+        .refine((value) => Boolean(value.emoji) !== Boolean(value.image), 'Provide exactly one of emoji or image'), async (input, call) => {
+        let saved;
+        if (input.image) {
+            if (!ctx.readAvatarImage)
+                throw Error('Image loading is unavailable on this Host');
+            const worker = bot.worker();
+            const owner = bot.owner();
+            const result = await ctx.readAvatarImage(call.sessionId, input.image, call.abortSignal);
+            call.abortSignal.throwIfAborted();
+            bot.ready();
+            if (bot.worker() !== worker || bot.owner() !== owner)
+                throw Error('Assistant binding changed');
+            const image = validateImageBytes(result.bytes, 'chat');
+            const bytes = Buffer.from(image.bytes);
+            const imageData = bytes.toString('base64');
+            saved = {
+                background: input.background,
+                image: {
+                    id: createHash('sha256').update(bytes).digest('hex'),
+                    mimeType: image.mimeType,
+                    length: imageData.length,
+                },
+                imageData,
+            };
+        }
+        else
+            saved = { emoji: input.emoji, background: input.background };
+        // One SQLite value makes image content and metadata an atomic replacement.
+        store.set('avatar', saved);
+        return { updated: true, avatar: avatar() };
+    });
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+/** In-process routing only; durable mailbox and wake state belong to the Bot. */
+export class AssistantBotBridge {
+    endpoint;
+    register(endpoint) {
+        this.endpoint = endpoint;
+    }
+    status() {
+        return this.endpoint?.status() ?? null;
+    }
+    isConversation(id) {
+        return this.endpoint?.owner() === id;
+    }
+    hasUserMessage(sessionId, id) {
+        return this.isConversation(sessionId) && this.endpoint.hasUserMessage(id);
+    }
+    isWorker(id) {
+        return this.endpoint?.worker() === id;
+    }
+    ownerFor(id) {
+        return this.isWorker(id) ? this.endpoint?.owner() : undefined;
+    }
+    async receive(sessionId, id, content, origin) {
+        if (!this.isConversation(sessionId))
+            return false;
+        await this.endpoint.receive(id, content, origin);
+        return true;
+    }
+    post(owner, input) {
+        if (!this.isConversation(owner))
+            return false;
+        this.endpoint.post(input);
+        return true;
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+export const BOT_TOOLS = new Set([
+    'InboxList',
+    'InboxRead',
+    'InboxCheck',
+    'SendUser',
+    'AssistantSetAvatar',
+    'Sleep',
+    'AssistantConversation',
+    'MatterDelegate',
+    'MatterTasks',
+    'MatterTaskMessage',
+    'MatterReply',
+    'MatterTaskControl',
+    'MatterDelegationRecover',
+    'MatterFeedbackRetry',
+    'InitiativeEnable',
+    'InitiativeConfigure',
+    'InitiativeControl',
+    'InitiativeStatus',
+    'MemoryIndexCreate',
+    'MemoryIndexCreateGroup',
+    'MemoryIndexMaintain',
+    'MemoryIndexControl',
+    'MemoryIndexAddSources',
+    'MemoryIndexList',
+    'MemoryIndexRead',
+    'MemoryIndexContent',
+    'MemoryIndexLinks',
+    'MemoryOriginal',
+    'MemoryHistory',
+    'MemorySources',
+    'MemoryRange',
+]);
+export const BOT_DELEGATION_TOOLS = new Set([...BOT_TOOLS].filter((name) => name.startsWith('Matter') || name.startsWith('Initiative') || name.startsWith('Memory')));