maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

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

@@ -16,6 +16,12 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/**
+ * One AI SDK turn: request projection, provider steps, retries, tool
+ * settlement, steering, terminal events, and per-turn cleanup. Session-level
+ * construction and cross-turn routing remain in AiSdkBackend.
+ */
+import { EVENT_WAIT_TOOL_NAME, isEventWaitYieldReceipt } from './event-wait-tool.js';
 import { DEFAULT_TOOL_MODE, isToolMode } from '@maka/core/tool-mode';
 import { resolveEffectiveOrchestration, } from '@maka/core/orchestration';
 import { stripUndefinedDeep } from '@maka/core/tool-args-identity';
@@ -39,6 +45,7 @@ import { portableApplyPatchTool } from './apply-patch-profile.js';
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, requiredSandboxBoundaryToolNames, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, appendPriorUnknownToolResponses, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, inspectPriorUnknownToolOutcomes, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
+import { changedRuntimeContexts } from './runtime-context.js';
 import { toolSchemaCharsForDiagnostics, requestCompositionToolSchemas, stableHash, toolCatalogHash, } from './request-shape.js';
 import { toolAvailabilityHash } from './tool-availability.js';
 import { hasFinalizedReasoning } from './ai-sdk-message-projection.js';
@@ -383,8 +390,8 @@ export class AiSdkTurn {
     abortController = new AbortController();
     activeTools;
     aborted = false;
-    loopStopRequested = false;
-    loopStopReason;
+    stopRequested = false;
+    turnYield;
     handoffPaused = false;
     watchdog = null;
     runTrace = null;
@@ -424,8 +431,8 @@ export class AiSdkTurn {
         await this.toolRuntime.endTurn(this.aborted ? 'aborted' : 'completed');
     }
     requestStop(reason, mode) {
+        this.stopRequested = true;
         if (mode === 'after_step') {
-            this.loopStopRequested = true;
             this.runTrace?.abortRequested(reason);
             return;
         }
@@ -433,6 +440,9 @@ export class AiSdkTurn {
         this.abortController.abort();
         this.runTrace?.abortRequested(reason);
     }
+    get loopStopReason() {
+        return this.stopRequested ? 'user_stop' : this.turnYield;
+    }
     async endAbortedTools() {
         await this.toolRuntime.endTurn('aborted');
     }
@@ -1086,6 +1096,24 @@ export class AiSdkTurn {
                         ? currentTurnMessages
                         : [...priorReplay.messages, ...currentTurnMessages];
                 };
+                const appendRuntimeContexts = async (history, contexts) => {
+                    const additions = changedRuntimeContexts(contexts, history).map((context) => ({
+                        context,
+                        id: this.deps.newId(),
+                    }));
+                    for (const { context, id } of additions) {
+                        queue.push({ type: 'runtime_context', id, turnId, ts: this.deps.now(), ...context });
+                    }
+                    if (additions.length === 0)
+                        return history;
+                    // Persist before dispatch; retries reuse the same snapshot. Context
+                    // removed by compaction is refreshed after that fold, not lost in it.
+                    await queue.waitUntilConsumedThroughCurrent();
+                    return [
+                        ...history,
+                        ...additions.map(({ context, id }) => this.deps.messageProjection.materializeRuntimeContext(context, id)),
+                    ];
+                };
                 // Tool Availability describes the provider-visible (active) subset. A
                 // group loaded this turn expands that subset on later requests, so the
                 // terminal trace is refined against the final active set below.
@@ -1120,7 +1148,7 @@ export class AiSdkTurn {
                 let finishFeedback;
                 let result;
                 let providerOutcome;
-                let finishReason = 'stop';
+                let terminalStopReason;
                 let terminalProviderError;
                 agentLoop: for (;;) {
                     ({ plan, providerTools, modelTools, nestedTools } = snapshotStepTools());
@@ -1182,7 +1210,6 @@ export class AiSdkTurn {
                             activeTools,
                         };
                     };
-                    const dynamicContextMessages = (resolvedSystemPrompt.contexts ?? []).map(({ text }) => ({ role: 'user', content: text }));
                     const shaped = requestProjection
                         ? await requestProjection({
                             completedSteps: completedProviderSteps,
@@ -1214,9 +1241,10 @@ export class AiSdkTurn {
                         })
                         : undefined;
                     providerRequestTracker?.setStep(runtimeSteps, requestCompositionId);
-                    let attemptMessages = projectedMessages;
+                    let attemptMessages = await appendRuntimeContexts(projectedMessages, resolvedSystemPrompt.contexts ?? []);
                     let overflowRecoveryMaxOutputTokens;
                     let providerAttempt = 0;
+                    let pendingRetryReason;
                     const returnedToolCalls = [];
                     const providerToolInputs = new Map();
                     let providerStepUsage;
@@ -1237,8 +1265,7 @@ export class AiSdkTurn {
                         let attemptSawReplayBarrier = false;
                         const attemptHasNoObservableOutput = () => !attemptSawVisibleContent && !attemptSawToolActivity && !attemptSawReplayBarrier;
                         const attemptCanReplay = () => !attemptSawToolActivity && !attemptSawReplayBarrier;
-                        // Request-only facts must survive history replacement and overflow recovery.
-                        const dispatchMessages = [...attemptMessages, ...dynamicContextMessages];
+                        const dispatchMessages = attemptMessages;
                         this.memorySourceMessages = dispatchMessages;
                         this.memorySourceEventMessagePositions =
                             this.deps.messageProjection.memoryEventMessagePositions(dispatchMessages);
@@ -1261,6 +1288,24 @@ export class AiSdkTurn {
                         // rebuilt in place by overflow recovery, and the boundary it folded
                         // under must travel with that rebuild, not with the step.
                         const historyCompactBoundary = requestHistoryCompactBoundary();
+                        // Stop can arrive during handoff, retry backoff, or overflow recovery.
+                        if (this.loopStopReason) {
+                            terminalStopReason = this.loopStopReason;
+                            break agentLoop;
+                        }
+                        if (pendingRetryReason) {
+                            queue.push({
+                                type: 'provider_retry',
+                                id: this.deps.newId(),
+                                turnId,
+                                ts: this.deps.now(),
+                                phase: 'started',
+                                attempt: providerAttempt,
+                                maxAttempts: MAX_PROVIDER_ATTEMPTS_PER_STEP,
+                                reason: pendingRetryReason,
+                            });
+                            pendingRetryReason = undefined;
+                        }
                         result = await this.deps.modelAdapter.startStream({
                             model,
                             messages: dispatchMessages,
@@ -1590,7 +1635,7 @@ export class AiSdkTurn {
                                     !attemptSawToolInput &&
                                     returnedToolCalls.length === 0))
                                 sawUnusableStepUsage = true;
-                            if (this.loopStopRequested) {
+                            if (this.loopStopReason) {
                                 terminalProviderError = failure;
                                 terminalProviderErrorReason =
                                     lastCompletedStepHadToolResult && failure.kind === 'timeout'
@@ -1627,7 +1672,7 @@ export class AiSdkTurn {
                                 })
                                 : undefined;
                             if (recovered) {
-                                attemptMessages = recovered.messages;
+                                attemptMessages = await appendRuntimeContexts(recovered.messages, resolvedSystemPrompt.contexts ?? []);
                                 overflowRecoveryMaxOutputTokens = Math.min(this.deps.modelAdapter.maxOutputTokens() ?? CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS, CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS);
                                 continue;
                             }
@@ -1710,16 +1755,7 @@ export class AiSdkTurn {
                                     reason,
                                 });
                                 await this.deps.providerRetrySleep(delayMs, turnAbortController.signal);
-                                queue.push({
-                                    type: 'provider_retry',
-                                    id: this.deps.newId(),
-                                    turnId,
-                                    ts: this.deps.now(),
-                                    phase: 'started',
-                                    attempt: nextAttempt,
-                                    maxAttempts,
-                                    reason,
-                                });
+                                pendingRetryReason = reason;
                                 continue;
                             }
                             // Unrecoverable (not context-length, this step's attempt spent,
@@ -1746,7 +1782,7 @@ export class AiSdkTurn {
                     const providerStepId = currentStepMessageId;
                     if (providerOutcome.kind !== 'completed')
                         throw providerOutcome.failure;
-                    finishReason = providerOutcome.finishReason;
+                    const finishReason = providerOutcome.finishReason;
                     await queue.waitUntilConsumedThroughCurrent();
                     let toolRequestedFinish = false;
                     if (returnedToolCalls.length > 0) {
@@ -1761,6 +1797,12 @@ export class AiSdkTurn {
                             await loadDurableTurnEvents();
                         }
                         const toolsByName = new Map(providerTools.map((tool) => [tool.name, tool]));
+                        // A wait controls the lifetime of the whole Turn. Refuse the entire
+                        // mixed step before dispatch, rather than letting the first call win
+                        // the ordinary exclusive-step gate and leaving a registered orphan.
+                        const mixedEventWait = returnedToolCalls.length > 1 &&
+                            toolsByName.has(EVENT_WAIT_TOOL_NAME) &&
+                            returnedToolCalls.some((call) => call.toolName === EVENT_WAIT_TOOL_NAME);
                         const settlementOutcomes = await Promise.allSettled(returnedToolCalls.map(async (toolCall) => {
                             if (toolCall.providerExecuted) {
                                 throw new Error(`Provider-executed tool call "${toolCall.toolName}" is outside the main-agent tool loop`);
@@ -1771,18 +1813,20 @@ export class AiSdkTurn {
                             if (deniedBoundaryRequest) {
                                 toolRuntime.forceSandboxBoundaryFinalization();
                             }
-                            const blockedToolCall = sandboxBoundaryFinalizationStep || deniedBoundaryRequest;
+                            const blockedToolCall = mixedEventWait || sandboxBoundaryFinalizationStep || deniedBoundaryRequest;
                             const requestedTool = blockedToolCall
                                 ? undefined
                                 : toolsByName.get(toolCall.toolName);
                             const tool = requestedTool ?? toolsByName.get(INVALID_TOOL_NAME);
                             if (!tool)
                                 throw new Error('Runtime invalid-tool fallback is unavailable');
-                            const unavailableError = sandboxBoundaryFinalizationStep
-                                ? 'Sandbox boundary finalization does not permit tool execution.'
-                                : deniedBoundaryRequest
-                                    ? SANDBOX_BOUNDARY_DENIED_FOR_TURN
-                                    : 'returned tool is unavailable';
+                            const unavailableError = mixedEventWait
+                                ? 'WaitForEvent requires a step containing exactly one tool call. No tools in this mixed step ran.'
+                                : sandboxBoundaryFinalizationStep
+                                    ? 'Sandbox boundary finalization does not permit tool execution.'
+                                    : deniedBoundaryRequest
+                                        ? SANDBOX_BOUNDARY_DENIED_FOR_TURN
+                                        : 'returned tool is unavailable';
                             return await toolRuntime.settleToolCall({
                                 tool,
                                 turnId,
@@ -1826,6 +1870,11 @@ export class AiSdkTurn {
                                 definition.finishTurnOnSuccess &&
                                 !settlement.providerError)
                                 toolRequestedFinish = true;
+                            if (returnedToolCalls.length === 1 &&
+                                !settlement.providerError &&
+                                isEventWaitYieldReceipt(settlement.result)) {
+                                this.turnYield = 'event_wait';
+                            }
                             if (isPlanToolResult(settlement.result)) {
                                 this.handlePlanToolResult(settlement.result, queue);
                             }
@@ -1839,9 +1888,7 @@ export class AiSdkTurn {
                         // an entire completed batch across the next provider request.
                         settlementOutcomes.length = 0;
                         await queue.waitUntilConsumedThroughCurrent();
-                        const continuationWillRun = (maxSteps === undefined || runtimeSteps < maxSteps) &&
-                            !this.loopStopRequested &&
-                            !this.aborted;
+                        const continuationWillRun = (maxSteps === undefined || runtimeSteps < maxSteps) && !this.loopStopReason;
                         if (continuationWillRun && providerOutcome.continuation === 'pending') {
                             const persistedProjection = await loadDurableTurnProjection();
                             const responseMessages = persistedOpenAiResponsesStepMessages(attemptMessages, persistedProjection, returnedToolCalls.map((toolCall) => toolCall.toolCallId));
@@ -1858,119 +1905,72 @@ 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 &&
                             (toolRuntime.shouldFinalizeSandboxBoundary() ||
                                 toolRuntime.hasSandboxBoundaryDenial()))) {
-                        this.loopStopReason = 'permission_handoff';
-                        this.loopStopRequested = true;
-                    }
-                    const mayTakeAnotherStep = !stepLimitReached && !this.loopStopRequested && !this.aborted;
-                    if (returnedToolCalls.length > 0 && mayTakeAnotherStep) {
-                        if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                            this.handoffPaused = true;
-                            break agentLoop;
-                        }
-                        if (this.aborted || this.loopStopRequested)
-                            break agentLoop;
-                        currentStepMessageId = this.deps.newId();
-                        continue agentLoop;
+                        this.turnYield = 'permission_handoff';
                     }
+                    let finishCandidateReason = returnedToolCalls.length > 0 && !toolRequestedFinish
+                        ? undefined
+                        : toolRequestedFinish
+                            ? 'end_turn'
+                            : this.deps.modelAdapter.mapFinishReason(finishReason);
                     // Enforce Host prerequisites locally: some providers reject required
                     // tool_choice in thinking mode. Never silently complete without the
                     // receipt; replay the draft and per-step reminder for bounded repair.
                     if (returnedToolCalls.length === 0 &&
                         resolvedSystemPrompt.requireToolCall &&
-                        !this.loopStopRequested &&
-                        !this.aborted) {
-                        if (!mayTakeAnotherStep ||
+                        !this.loopStopReason) {
+                        if (stepLimitReached ||
                             !this.deps.backend.loadTurnRuntimeEvents ||
                             ++missingPrerequisiteAttempts > 2) {
                             throw new Error('Required turn prerequisite was not recorded; cannot complete this response.');
                         }
-                        await queue.waitUntilConsumedThroughCurrent();
-                        if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                            this.handoffPaused = true;
-                            break agentLoop;
-                        }
-                        if (this.aborted || this.loopStopRequested)
-                            break agentLoop;
-                        currentStepMessageId = this.deps.newId();
-                        continue agentLoop;
+                        finishCandidateReason = undefined;
                     }
-                    // Continuing the turn needs the durable current-run reader, for the
-                    // same reason the tool-call edge above demands it: the next request
-                    // has to carry the assistant output this step just produced, and only
-                    // the ledger projection has it. The no-reader fallback at the top of
-                    // the loop appends steering alone, which would ask the model to
-                    // redirect work it cannot see. Without a reader this edge is skipped
-                    // rather than throwing — the turn still completes and the Host folds
-                    // the message into the next Turn, which is today's behaviour.
-                    if (mayTakeAnotherStep && this.deps.backend.loadTurnRuntimeEvents) {
-                        // Last chance for a steer that landed after this turn's final
-                        // tool-call boundary — including the only boundary a tool-free
-                        // turn has, which precedes the model's first token. Without it the
-                        // message is never pulled at all, and whether Steer works would
-                        // depend on the model happening to call a tool afterwards (#3529).
-                        // A step-limited turn deliberately skips this: its budget is spent,
-                        // and the Host folds the message into the next Turn instead.
+                    // The Host carries steering left unconsumed here into the next Turn.
+                    if (finishCandidateReason !== undefined &&
+                        !toolRequestedFinish &&
+                        !stepLimitReached &&
+                        !this.loopStopReason &&
+                        this.deps.backend.loadTurnRuntimeEvents) {
                         const injectedBefore = this.injectedSteeringMessages.length;
                         await this.drainSteeringInto(input, queue);
-                        // Re-read the stop flags: the drain awaits a durable push, so an
-                        // `after_step` stop or an abort can land while it is in flight, and
-                        // `mayTakeAnotherStep` is stale by now. Stop wins — the message is
-                        // already durable, so the Host folds it into the next Turn.
-                        if (this.injectedSteeringMessages.length > injectedBefore &&
-                            !this.loopStopRequested &&
-                            !this.aborted) {
-                            await queue.waitUntilConsumedThroughCurrent();
-                            if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                                this.handoffPaused = true;
-                                break agentLoop;
-                            }
-                            if (this.aborted || this.loopStopRequested)
-                                break agentLoop;
-                            currentStepMessageId = this.deps.newId();
-                            continue agentLoop;
-                        }
+                        if (this.injectedSteeringMessages.length > injectedBefore)
+                            finishCandidateReason = undefined;
                     }
-                    if (mayTakeAnotherStep &&
-                        returnedToolCalls.length === 0 &&
-                        this.deps.backend.beforeTurnFinish &&
-                        this.deps.backend.loadTurnRuntimeEvents &&
-                        this.deps.modelAdapter.mapFinishReason(finishReason) === 'end_turn') {
-                        const decision = await this.deps.backend.beforeTurnFinish({
+                    // Finishing needs Host approval even when no continuation is possible.
+                    if (finishCandidateReason === 'end_turn' && !this.loopStopReason) {
+                        const finishDecision = await this.deps.backend.beforeTurnFinish?.({
                             sessionId: this.deps.backend.sessionId,
                             turnId,
                             signal: turnAbortController.signal,
                         });
-                        if (!decision.allow && !this.aborted && !this.loopStopRequested) {
-                            if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                                this.handoffPaused = true;
-                                break agentLoop;
-                            }
-                            finishFeedback = decision.feedback;
-                            currentStepMessageId = this.deps.newId();
-                            continue agentLoop;
+                        if (finishDecision && !finishDecision.allow) {
+                            finishFeedback = finishDecision.feedback;
+                            finishCandidateReason = undefined;
                         }
+                        else if (toolRequestedFinish) {
+                            this.deps.modelAdapter.clearContinuation(this.turnId);
+                        }
+                    }
+                    terminalStopReason =
+                        this.loopStopReason ??
+                            finishCandidateReason ??
+                            (stepLimitReached ? 'step_limit' : undefined);
+                    if (terminalStopReason)
+                        break agentLoop;
+                    if (!this.deps.backend.loadTurnRuntimeEvents) {
+                        throw new Error('durable current-run reader is required for turn continuation');
                     }
-                    break agentLoop;
+                    await queue.waitUntilConsumedThroughCurrent();
+                    if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
+                        this.handoffPaused = true;
+                        break agentLoop;
+                    }
+                    currentStepMessageId = this.deps.newId();
                 }
                 // Refine Tool Availability against the final active set. Deferred
                 // loading may add tools, while boundary convergence may remove them;
@@ -1986,7 +1986,7 @@ export class AiSdkTurn {
                 // silently drop prior requests. An unusable sample in ANY request fails
                 // the whole record closed (#972).
                 try {
-                    const attemptTotalUsage = providerOutcome.usage;
+                    const attemptTotalUsage = providerOutcome?.usage;
                     tokenUsage = sawUnusableStepUsage ? undefined : (completedStepUsage ?? attemptTotalUsage);
                     if (tokenUsage) {
                         tokenUsageCostUsd = this.deps.providerTelemetry.normalizedUsageCostUsd(tokenUsage);
@@ -2090,10 +2090,9 @@ export class AiSdkTurn {
                 // seals the drained stream; no complete/abort event ends the logical Turn.
                 if (this.handoffPaused)
                     return;
-                const stopReason = this.loopStopReason ??
-                    (maxSteps !== undefined && finishReason === 'tool-calls'
-                        ? 'step_limit'
-                        : this.mapFinishReason(finishReason));
+                const stopReason = this.loopStopReason ?? terminalStopReason;
+                if (!stopReason)
+                    throw new Error('Turn ended without a terminal decision');
                 trace.modelStreamCompleted(stopReason);
                 const completeEvent = {
                     type: 'complete',
@@ -2261,7 +2260,7 @@ export class AiSdkTurn {
                 })),
                 isFatalToolError: isRuntimeCommitBoundaryError,
                 callTool: async (name, input, signal) => {
-                    if (this.loopStopRequested)
+                    if (this.loopStopReason)
                         throw new Error('The turn has yielded; no further tools may run.');
                     const tool = snapshot.get(name);
                     if (!tool)
@@ -2323,8 +2322,7 @@ export class AiSdkTurn {
                 revision: proposal.revision,
                 storeVersion: result.storeVersion,
             });
-            this.loopStopReason = 'plan_handoff';
-            this.loopStopRequested = true;
+            this.turnYield = 'plan_handoff';
             return;
         }
         const traceType = result.kind;
@@ -2345,11 +2343,7 @@ export class AiSdkTurn {
             liveOperatorCount: result.liveOperatorCount,
             reason: result.reason,
         });
-        this.loopStopReason = 'graph_yield';
-        this.loopStopRequested = true;
-    }
-    mapFinishReason(reason) {
-        return this.deps.modelAdapter.mapFinishReason(reason);
+        this.turnYield = 'graph_yield';
     }
     makeErrorEvent(turnId, err, reasonOverride) {
         return this.deps.modelAdapter.makeErrorEvent(turnId, err, reasonOverride);

package/node_modules/@maka/runtime/dist/bots/bot-registry.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { resolveBotMessageHandling, } from '@maka/core/bot-chat-settings';
 import { generalizedErrorMessage } from '@maka/core/redaction';
 import { BOT_PROVIDERS } from '@maka/core/settings';
 import { DingTalkBotBridge } from './dingtalk-bridge.js';
@@ -69,7 +70,19 @@ export class BotRegistry {
         const bridge = this.bridges.get(platform);
         if (!bridge || typeof bridge.sendTypingIndicator !== 'function')
             return false;
-        return bridge.sendTypingIndicator(chatId);
+        return bridge.sendTypingIndicator(chatId).catch(() => false);
+    }
+    async cancelTypingIndicator(platform, chatId) {
+        const bridge = this.bridges.get(platform);
+        if (!bridge?.cancelTypingIndicator)
+            return false;
+        return bridge.cancelTypingIndicator(chatId).catch(() => false);
+    }
+    async getMessageReadStatus(platform, messageId, userId) {
+        const bridge = this.bridges.get(platform);
+        return ((await bridge
+            ?.getMessageReadStatus?.(messageId, userId)
+            .catch(() => ({ state: 'unknown' }))) ?? { state: 'unknown' });
     }
     async stopAll() {
         const next = this.applyQueue.then(() => this.stopAllNow(), () => this.stopAllNow());
@@ -77,7 +90,10 @@ export class BotRegistry {
         return next;
     }
     async applySettingsNow(settings) {
-        await Promise.all(BOT_PROVIDERS.map((provider) => this.reconcileOne(provider, settings.channels[provider])));
+        await Promise.all(BOT_PROVIDERS.map((provider) => this.reconcileOne(provider, {
+            ...settings.channels[provider],
+            messageHandling: resolveBotMessageHandling(settings, provider),
+        })));
     }
     async stopAllNow() {
         await Promise.all([...this.bridges.values()].map((bridge) => bridge.stop().catch(() => { })));
@@ -116,7 +132,7 @@ export class BotRegistry {
         }
         this.statuses.delete(platform);
         const bridge = platform === 'wechat'
-            ? new WechatBridge(settings)
+            ? new WechatBridge(settings, this.deps.wechatContextDirectory)
             : platform === 'wecom'
                 ? new WeComBotBridge(settings)
                 : platform === 'feishu'