@elizaos/agent 2.0.0-alpha.155 → 2.0.0-alpha.161

package/packages/typescript/src/services/message.js

@@ -1,14 +1,15 @@
 import { v4 } from "uuid";
 import { parseActionParams } from "../actions";
-import { createUniqueUuid } from "../entities";
 import { formatTaskCompletionStatus, getTaskCompletionCacheKey, } from "../features/advanced-capabilities/evaluators/task-completion";
+import { createUniqueUuid } from "../entities";
 import { logger } from "../logger";
 import { imageDescriptionTemplate, messageHandlerTemplate, multiStepDecisionTemplate, multiStepSummaryTemplate, postActionDecisionTemplate, shouldRespondTemplate, } from "../prompts";
 import { isExplicitSelfModificationRequest } from "../should-respond";
-import { runWithStreamingContext } from "../streaming-context";
+import { getModelStreamChunkDeliveryDepth, runWithStreamingContext, } from "../streaming-context";
 import { runWithTrajectoryContext, setTrajectoryPurpose, } from "../trajectory-context";
 import { EventType } from "../types/events";
 import { ModelType } from "../types/model";
+import { incomingPipelineHookContext, modelStreamChunkPipelineHookContext, outgoingPipelineHookContext, parallelWithShouldRespondPipelineHookContext, preShouldRespondPipelineHookContext, } from "../types/pipeline-hooks";
 import { asUUID, ChannelType, ContentType } from "../types/primitives";
 import { composePromptFromState, getLocalServerUrl, parseBooleanFromText, parseKeyValueXml, truncateToCompleteSentence, } from "../utils";
 import { AVAILABLE_CONTEXTS_STATE_KEY, attachAvailableContexts, CONTEXT_ROUTING_STATE_KEY, mergeContextRouting, parseContextRoutingMetadata, setContextRoutingMetadata, } from "../utils/context-routing";
@@ -775,11 +776,18 @@ export class DefaultMessageService {
                     : undefined;
         }
         return await runWithTrajectoryContext(typeof trajectoryStepId === "string" && trajectoryStepId.trim() !== ""
-            ? { trajectoryStepId: trajectoryStepId.trim() }
+            ? {
+                trajectoryStepId: trajectoryStepId.trim(),
+                runId: runtime.getCurrentRunId?.(),
+                roomId: message.roomId,
+                messageId: message.id,
+            }
             : undefined, async () => {
             // Determine shouldRespondModel from options or runtime settings
             const shouldRespondModelSetting = runtime.getSetting("SHOULD_RESPOND_MODEL");
             const resolvedShouldRespondModel = normalizeShouldRespondModelType(options?.shouldRespondModel ?? shouldRespondModelSetting);
+            // Single ID used for tracking, streaming, and the final message (before opts / chunk wrapper).
+            const responseId = asUUID(v4());
             // WHY voice detection wraps onStreamChunk here instead of using a
             // separate ResponseStreamExtractor + AsyncLocalStorage context:
             //
@@ -815,6 +823,19 @@ export class DefaultMessageService {
                         streamTextFallback += chunk;
                         streamText = streamTextFallback;
                     }
+                    // Skip when this callback is invoked from `useModel`'s stream loop:
+                    // `source: "use_model"` already ran for the same raw chunk (Node ALS).
+                    if (getModelStreamChunkDeliveryDepth() === 0) {
+                        await runtime.applyPipelineHooks("model_stream_chunk", modelStreamChunkPipelineHookContext({
+                            source: "message_service",
+                            chunk,
+                            messageId,
+                            roomId: message.roomId,
+                            runId: runtime.getCurrentRunId(),
+                            responseId,
+                            accumulated,
+                        }));
+                    }
                     // Only run first-sentence TTS detection when `accumulated` is present.
                     // Raw-token streams (no accumulated) may contain XML markup or partial
                     // structured output that would garble hasFirstSentence() and TTS.
@@ -956,8 +977,6 @@ export class DefaultMessageService {
                 : undefined;
             // Set up timeout monitoring
             let timeoutId;
-            // Single ID used for tracking, streaming, and the final message
-            const responseId = asUUID(v4());
             try {
                 runtime.logger.info({
                     src: "service:message",
@@ -1266,12 +1285,10 @@ export class DefaultMessageService {
                 mode: "none",
             };
         }
-        // Compose initial state
-        let state = await runtime.composeState(message, ["ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"], true, false);
-        state = attachAvailableContexts(state, runtime);
-        // Get room and mention context
+        // Room context for shouldRespond (fetch before compose so providers see
+        // post-attachment and post-incoming-hook message state).
         const room = await runtime.getRoom(message.roomId);
-        // Process attachments before deciding to respond
+        // Process attachments before state composition / incoming hooks
         if (message.content.attachments && message.content.attachments.length > 0) {
             message.content.attachments = await this.processAttachments(runtime, message.content.attachments);
             if (message.id) {
@@ -1284,169 +1301,94 @@ export class DefaultMessageService {
                 });
             }
         }
+        const preIncomingHookText = typeof message.content?.text === "string" ? message.content.text : "";
+        await runtime.applyPipelineHooks("incoming_before_compose", incomingPipelineHookContext(message, {
+            roomId: message.roomId,
+            responseId,
+            runId,
+        }));
+        const postIncomingHookText = typeof message.content?.text === "string" ? message.content.text : "";
+        if (message.id && postIncomingHookText !== preIncomingHookText) {
+            await runtime.updateMemory({
+                id: message.id,
+                content: message.content,
+            });
+            await runtime.queueEmbeddingGeneration({ ...message, id: message.id }, "normal");
+        }
         const promptAttachments = resolvePromptAttachments(message.content.attachments);
-        let shouldRespondToMessage = true;
-        let terminalDecision = null;
-        let routedDecision = null;
-        let dualPressureLog = null;
-        let shouldRespondClassifierAction = null;
+        // Compose initial state (after incoming hooks so providers/actions text matches this turn)
+        let state = await runtime.composeState(message, ["ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"], true, false);
+        state = attachAvailableContexts(state, runtime);
         const metadata = typeof message.content.metadata === "object" &&
             message.content.metadata !== null
             ? message.content.metadata
             : null;
         const isAutonomous = metadata?.isAutonomous === true;
         const autonomyMode = typeof metadata?.autonomyMode === "string" ? metadata.autonomyMode : null;
+        await runtime.applyPipelineHooks("pre_should_respond", preShouldRespondPipelineHookContext(message, {
+            roomId: message.roomId,
+            responseId,
+            runId,
+            state,
+            isAutonomous,
+        }));
+        let shouldRespondToMessage = true;
+        let terminalDecision = null;
+        let routedDecision = null;
+        let dualPressureLog = null;
+        let shouldRespondClassifierAction = null;
+        const parallelJoin = {};
+        const setTranslatedUserText = (text) => {
+            parallelJoin.translatedUserText = text;
+        };
+        const parallelHookCtx = parallelWithShouldRespondPipelineHookContext({
+            roomId: message.roomId,
+            responseId,
+            runId,
+            message,
+            state,
+            room: room ?? undefined,
+            mentionContext,
+            isAutonomous,
+            setTranslatedUserText,
+        });
         if (isAutonomous) {
             runtime.logger.debug({ src: "service:message", autonomyMode }, "Autonomy message bypassing shouldRespond checks");
             shouldRespondToMessage = true;
+            await runtime.applyPipelineHooks("parallel_with_should_respond", parallelHookCtx);
         }
         else {
-            // Check if shouldRespond evaluation is enabled
-            const checkShouldRespondEnabled = runtime.isCheckShouldRespondEnabled();
-            // Determine if we should respond
-            const responseDecision = this.shouldRespond(runtime, message, room ?? undefined, mentionContext);
-            runtime.logger.debug({ src: "service:message", responseDecision, checkShouldRespondEnabled }, "Response decision");
-            // If checkShouldRespond is disabled, always respond (ChatGPT mode)
-            if (!checkShouldRespondEnabled) {
-                runtime.logger.debug({ src: "service:message" }, "checkShouldRespond disabled, always responding (ChatGPT mode)");
-                shouldRespondToMessage = true;
-            }
-            else if (responseDecision.skipEvaluation) {
-                // If we can skip the evaluation, use the decision directly
-                runtime.logger.debug({
-                    src: "service:message",
-                    agentName: runtime.character.name ?? "Agent",
-                    reason: responseDecision.reason,
-                }, "Skipping LLM evaluation");
-                routedDecision = parseContextRoutingMetadata(responseDecision);
-                setContextRoutingMetadata(message, routedDecision);
-                shouldRespondToMessage = responseDecision.shouldRespond;
-            }
-            else {
-                state = {
-                    ...state,
-                    values: {
-                        ...state.values,
-                        dualPressureThreshold: resolveDualPressureThreshold(runtime),
-                    },
-                };
-                const shouldRespondState = prepareShouldRespondState(state);
-                // Need LLM evaluation for ambiguous case
-                const _shouldRespondPrompt = composePromptFromState({
-                    state: shouldRespondState,
-                    template: runtime.character.templates?.shouldRespondTemplate ||
-                        shouldRespondTemplate,
-                });
-                runtime.logger.debug({
-                    src: "service:message",
-                    agentName: runtime.character.name ?? "Agent",
-                    reason: responseDecision.reason,
-                    model: opts.shouldRespondModel,
-                }, "Using LLM evaluation");
-                // Use dynamicPromptExecFromState for structured output with validation
-                setTrajectoryPurpose("should_respond");
-                const responseObject = await runtime.dynamicPromptExecFromState({
-                    state: shouldRespondState,
-                    params: {
-                        prompt: runtime.character.templates?.shouldRespondTemplate ||
-                            shouldRespondTemplate,
-                        ...(promptAttachments ? { attachments: promptAttachments } : {}),
-                    },
-                    schema: [
-                        // Decision schema - no streaming, no per-field validation needed
-                        // WHY: This is internal decision-making, not user-facing output
-                        {
-                            field: "name",
-                            description: "The name of the agent responding",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "reasoning",
-                            description: "Your reasoning for this decision",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "speak_up",
-                            description: "Integer 0-100 pressure TO engage",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "hold_back",
-                            description: "Integer 0-100 pressure to STAY QUIET",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "action",
-                            description: "REPLY | RESPOND | IGNORE | STOP (REPLY and RESPOND both mean engage)",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "primaryContext",
-                            description: "Primary domain context from available_contexts (e.g., wallet, knowledge)",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "secondaryContexts",
-                            description: "Optional comma-separated additional domain contexts",
-                            validateField: false,
-                            streamField: false,
-                        },
-                        {
-                            field: "evidenceTurnIds",
-                            description: "Optional comma-separated message IDs that influenced this decision",
-                            validateField: false,
-                            streamField: false,
-                        },
-                    ],
-                    options: {
-                        contextCheckLevel: 0, // Set to 0 for now
-                        // Classifier failures are usually transient provider hiccups;
-                        // give this internal decision one short retry window.
-                        maxRetries: Math.max(1, Math.min(opts.maxRetries, 2)),
-                        retryBackoff: {
-                            initialMs: 500,
-                            multiplier: 2,
-                            maxMs: 2000,
-                        },
-                        modelType: resolveShouldRespondModelType(opts.shouldRespondModel),
-                        preferredEncapsulation: "toon",
-                    },
+            const [classifyOutcome] = await Promise.all([
+                this.runNonAutonomousShouldRespondClassify(runtime, message, state, room ?? undefined, mentionContext, opts, promptAttachments),
+                runtime.applyPipelineHooks("parallel_with_should_respond", parallelHookCtx),
+            ]);
+            shouldRespondToMessage = classifyOutcome.shouldRespondToMessage;
+            terminalDecision = classifyOutcome.terminalDecision;
+            routedDecision = classifyOutcome.routedDecision;
+            dualPressureLog = classifyOutcome.dualPressureLog;
+            shouldRespondClassifierAction =
+                classifyOutcome.shouldRespondClassifierAction;
+            state = classifyOutcome.state;
+        }
+        const joinedTranslation = typeof parallelJoin.translatedUserText === "string"
+            ? parallelJoin.translatedUserText
+            : undefined;
+        if (joinedTranslation !== undefined &&
+            joinedTranslation !== message.content.text) {
+            message.content.text = joinedTranslation;
+            if (message.id) {
+                await runtime.updateMemory({
+                    id: message.id,
+                    content: message.content,
                 });
-                runtime.logger.debug({ src: "service:message", responseObject }, "Parsed evaluation result");
-                const rawAction = typeof responseObject?.action === "string"
-                    ? responseObject.action
-                    : "";
-                const actionUpper = rawAction.trim().toUpperCase();
-                const hasValidClassifierAction = actionUpper.length > 0 && ALLOWED_CLASSIFIER_ACTIONS.has(actionUpper);
-                routedDecision = parseContextRoutingMetadata(responseObject);
-                setContextRoutingMetadata(message, routedDecision);
-                if (!hasValidClassifierAction) {
-                    runtime.logger.warn({
-                        src: "service:message",
-                        action: responseObject?.action,
-                    }, "Classifier response missing valid action; treating as IGNORE");
-                    terminalDecision = "IGNORE";
-                    shouldRespondToMessage = false;
-                }
-                else {
-                    const dual = applyDualPressureToClassifierAction(runtime, responseObject, rawAction);
-                    dualPressureLog = dual.pressure;
-                    shouldRespondClassifierAction = dual.finalActionUpper;
-                    if (dual.finalActionUpper === "IGNORE" ||
-                        dual.finalActionUpper === "STOP") {
-                        terminalDecision = dual.finalActionUpper;
-                    }
-                    shouldRespondToMessage =
-                        dual.finalActionUpper === "REPLY" ||
-                            dual.finalActionUpper === "RESPOND";
-                }
+                await runtime.queueEmbeddingGeneration({ ...message, id: message.id }, "normal");
+            }
+            if (message.id) {
+                runtime.stateCache.delete(message.id);
+                runtime.stateCache.delete(`${message.id}_action_results`);
             }
+            state = await runtime.composeState(message, ["ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"], true, false);
+            state = attachAvailableContexts(state, runtime);
         }
         let responseContent = null;
         let responseMessages = [];
@@ -1501,8 +1443,8 @@ export class DefaultMessageService {
             if (responseContent?.providers && responseContent.providers.length > 0) {
                 state = await runtime.composeState(message, responseContent.providers, false, false);
             }
-            // Save response memory to database
-            if (responseMessages.length > 0) {
+            // Save response memory to database (simple mode persists after hooks; see below)
+            if (responseMessages.length > 0 && mode !== "simple") {
                 for (const responseMemory of responseMessages) {
                     // Update the content in case inReplyTo was added
                     if (responseContent) {
@@ -1511,11 +1453,6 @@ export class DefaultMessageService {
                     runtime.logger.debug({ src: "service:message", memoryId: responseMemory.id }, "Saving response to memory");
                     await runtime.createMemory(responseMemory, "messages");
                     await this.emitMessageSent(runtime, responseMemory, message.content.source ?? "messageHandler");
-                    // Track IDs for simple-mode so we can delete orphaned
-                    // memories if reflection overrides the deferred emit.
-                    if (mode === "simple" && responseMemory.id) {
-                        pendingSimpleMemoryIds.push(responseMemory.id);
-                    }
                 }
             }
             if (responseContent) {
@@ -1528,11 +1465,25 @@ export class DefaultMessageService {
                             providers: responseContent.providers,
                         }, "Simple response used providers");
                     }
-                    // Defer the callback until after reflection has had a
-                    // chance to override. Redact secrets now so the content
-                    // is ready to flush at the bottom of handleMessage.
-                    if (responseContent.text) {
-                        responseContent.text = runtime.redactSecrets(responseContent.text);
+                    // WHY order: hooks → createMemory → deferred callback matches wire + DB.
+                    await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(responseContent, {
+                        source: "simple",
+                        roomId: message.roomId,
+                        message,
+                        responseId: responseContent.responseId ?? responseMessages[0]?.id,
+                    }));
+                    if (responseMessages.length > 0) {
+                        for (const responseMemory of responseMessages) {
+                            if (responseContent) {
+                                responseMemory.content = responseContent;
+                            }
+                            runtime.logger.debug({ src: "service:message", memoryId: responseMemory.id }, "Saving response to memory");
+                            await runtime.createMemory(responseMemory, "messages");
+                            await this.emitMessageSent(runtime, responseMemory, message.content.source ?? "messageHandler");
+                            if (responseMemory.id) {
+                                pendingSimpleMemoryIds.push(responseMemory.id);
+                            }
+                        }
                     }
                     pendingSimpleEmit = responseContent;
                 }
@@ -1609,11 +1560,11 @@ export class DefaultMessageService {
                 simple: true,
                 inReplyTo: createUniqueUuid(runtime, message.id),
             };
-            // Call the callback with the terminal content
-            if (callback) {
-                await callback(terminalContent);
-            }
-            // Save this terminal action/thought to memory
+            await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(terminalContent, {
+                source: "excluded",
+                roomId: message.roomId,
+                message,
+            }));
             const terminalMemory = {
                 id: asUUID(v4()),
                 entityId: runtime.agentId,
@@ -1625,6 +1576,9 @@ export class DefaultMessageService {
             await runtime.createMemory(terminalMemory, "messages");
             await this.emitMessageSent(runtime, terminalMemory, message.content.source ?? "messageHandler");
             runtime.logger.debug({ src: "service:message", memoryId: terminalMemory.id }, "Saved terminal response to memory");
+            if (callback) {
+                await callback(terminalContent);
+            }
         }
         // Clean up the response ID
         clearLatestResponseId(runtime.agentId, message.roomId, responseId);
@@ -1636,9 +1590,12 @@ export class DefaultMessageService {
                 responseContent.evalCallbacks = content;
             }
             if (callback) {
-                if (content.text) {
-                    content.text = runtime.redactSecrets(content.text);
-                }
+                await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(content, {
+                    source: "evaluate",
+                    roomId: message.roomId,
+                    message,
+                    responseId: content.responseId,
+                }));
                 return callback(content);
             }
             return [];
@@ -1794,6 +1751,156 @@ export class DefaultMessageService {
                 : {}),
         };
     }
+    async runNonAutonomousShouldRespondClassify(runtime, message, state, room, mentionContext, opts, promptAttachments) {
+        let shouldRespondToMessage = true;
+        let terminalDecision = null;
+        let routedDecision = null;
+        let dualPressureLog = null;
+        let shouldRespondClassifierAction = null;
+        let workingState = state;
+        const checkShouldRespondEnabled = runtime.isCheckShouldRespondEnabled();
+        const responseDecision = this.shouldRespond(runtime, message, room, mentionContext);
+        runtime.logger.debug({ src: "service:message", responseDecision, checkShouldRespondEnabled }, "Response decision");
+        if (!checkShouldRespondEnabled) {
+            runtime.logger.debug({ src: "service:message" }, "checkShouldRespond disabled, always responding (ChatGPT mode)");
+            shouldRespondToMessage = true;
+        }
+        else if (responseDecision.skipEvaluation) {
+            runtime.logger.debug({
+                src: "service:message",
+                agentName: runtime.character.name ?? "Agent",
+                reason: responseDecision.reason,
+            }, "Skipping LLM evaluation");
+            routedDecision = parseContextRoutingMetadata(responseDecision);
+            setContextRoutingMetadata(message, routedDecision);
+            shouldRespondToMessage = responseDecision.shouldRespond;
+        }
+        else {
+            workingState = {
+                ...workingState,
+                values: {
+                    ...workingState.values,
+                    dualPressureThreshold: resolveDualPressureThreshold(runtime),
+                },
+            };
+            const shouldRespondState = prepareShouldRespondState(workingState);
+            const _shouldRespondPrompt = composePromptFromState({
+                state: shouldRespondState,
+                template: runtime.character.templates?.shouldRespondTemplate ||
+                    shouldRespondTemplate,
+            });
+            runtime.logger.debug({
+                src: "service:message",
+                agentName: runtime.character.name ?? "Agent",
+                reason: responseDecision.reason,
+                model: opts.shouldRespondModel,
+            }, "Using LLM evaluation");
+            setTrajectoryPurpose("should_respond");
+            const responseObject = await runtime.dynamicPromptExecFromState({
+                state: shouldRespondState,
+                params: {
+                    prompt: runtime.character.templates?.shouldRespondTemplate ||
+                        shouldRespondTemplate,
+                    ...(promptAttachments ? { attachments: promptAttachments } : {}),
+                },
+                schema: [
+                    {
+                        field: "name",
+                        description: "The name of the agent responding",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "reasoning",
+                        description: "Your reasoning for this decision",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "speak_up",
+                        description: "Integer 0-100 pressure TO engage",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "hold_back",
+                        description: "Integer 0-100 pressure to STAY QUIET",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "action",
+                        description: "REPLY | RESPOND | IGNORE | STOP (REPLY and RESPOND both mean engage)",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "primaryContext",
+                        description: "Primary domain context from available_contexts (e.g., wallet, knowledge)",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "secondaryContexts",
+                        description: "Optional comma-separated additional domain contexts",
+                        validateField: false,
+                        streamField: false,
+                    },
+                    {
+                        field: "evidenceTurnIds",
+                        description: "Optional comma-separated message IDs that influenced this decision",
+                        validateField: false,
+                        streamField: false,
+                    },
+                ],
+                options: {
+                    contextCheckLevel: 0,
+                    maxRetries: Math.max(1, Math.min(opts.maxRetries, 2)),
+                    retryBackoff: {
+                        initialMs: 500,
+                        multiplier: 2,
+                        maxMs: 2000,
+                    },
+                    modelType: resolveShouldRespondModelType(opts.shouldRespondModel),
+                    preferredEncapsulation: "toon",
+                },
+            });
+            runtime.logger.debug({ src: "service:message", responseObject }, "Parsed evaluation result");
+            const rawAction = typeof responseObject?.action === "string" ? responseObject.action : "";
+            const actionUpper = rawAction.trim().toUpperCase();
+            const hasValidClassifierAction = actionUpper.length > 0 && ALLOWED_CLASSIFIER_ACTIONS.has(actionUpper);
+            routedDecision = parseContextRoutingMetadata(responseObject);
+            setContextRoutingMetadata(message, routedDecision);
+            if (!hasValidClassifierAction) {
+                runtime.logger.warn({
+                    src: "service:message",
+                    action: responseObject?.action,
+                }, "Classifier response missing valid action; treating as IGNORE");
+                terminalDecision = "IGNORE";
+                shouldRespondToMessage = false;
+            }
+            else {
+                const dual = applyDualPressureToClassifierAction(runtime, responseObject, rawAction);
+                dualPressureLog = dual.pressure;
+                shouldRespondClassifierAction = dual.finalActionUpper;
+                if (dual.finalActionUpper === "IGNORE" ||
+                    dual.finalActionUpper === "STOP") {
+                    terminalDecision = dual.finalActionUpper;
+                }
+                shouldRespondToMessage =
+                    dual.finalActionUpper === "REPLY" ||
+                        dual.finalActionUpper === "RESPOND";
+            }
+        }
+        return {
+            shouldRespondToMessage,
+            terminalDecision,
+            routedDecision,
+            dualPressureLog,
+            shouldRespondClassifierAction,
+            state: workingState,
+        };
+    }
     /**
      * Determines whether the agent should respond to a message.
      * Uses simple rules for obvious cases (DM, mentions) and defers to LLM for ambiguous cases.
@@ -2135,7 +2242,8 @@ export class DefaultMessageService {
                 accumulatedState = withActionResults(continuation.state, traceActionResults);
             }
             accumulatedState = withTaskCompletion(accumulatedState, taskCompletion);
-            if (continuation.responseMessages.length > 0) {
+            if (continuation.responseMessages.length > 0 &&
+                continuation.mode !== "simple") {
                 for (const responseMemory of continuation.responseMessages) {
                     responseMemory.content = responseContent;
                     await runtime.createMemory(responseMemory, "messages");
@@ -2144,10 +2252,22 @@ export class DefaultMessageService {
                 responseMessages.push(...continuation.responseMessages);
             }
             if (continuation.mode === "simple") {
-                if (callback) {
-                    if (responseContent.text) {
-                        responseContent.text = runtime.redactSecrets(responseContent.text);
+                await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(responseContent, {
+                    source: "continuation_simple",
+                    roomId: message.roomId,
+                    message,
+                    responseId: responseContent.responseId ??
+                        continuation.responseMessages[0]?.id,
+                }));
+                if (continuation.responseMessages.length > 0) {
+                    for (const responseMemory of continuation.responseMessages) {
+                        responseMemory.content = responseContent;
+                        await runtime.createMemory(responseMemory, "messages");
+                        await this.emitMessageSent(runtime, responseMemory, message.content.source ?? "messageHandler");
                     }
+                    responseMessages.push(...continuation.responseMessages);
+                }
+                if (callback) {
                     await callback(responseContent);
                 }
                 break;
@@ -2218,7 +2338,8 @@ export class DefaultMessageService {
         else {
             accumulatedState = withTaskCompletion(withActionResults(continuation.state, initialActionResults), taskCompletion);
         }
-        if (continuation.responseMessages.length > 0) {
+        if (continuation.responseMessages.length > 0 &&
+            continuation.mode !== "simple") {
             for (const responseMemory of continuation.responseMessages) {
                 responseMemory.content = responseContent;
                 await runtime.createMemory(responseMemory, "messages");
@@ -2227,10 +2348,21 @@ export class DefaultMessageService {
             responseMessages.push(...continuation.responseMessages);
         }
         if (continuation.mode === "simple") {
-            if (callback) {
-                if (responseContent.text) {
-                    responseContent.text = runtime.redactSecrets(responseContent.text);
+            await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(responseContent, {
+                source: "continuation_simple",
+                roomId: message.roomId,
+                message,
+                responseId: responseContent.responseId ?? continuation.responseMessages[0]?.id,
+            }));
+            if (continuation.responseMessages.length > 0) {
+                for (const responseMemory of continuation.responseMessages) {
+                    responseMemory.content = responseContent;
+                    await runtime.createMemory(responseMemory, "messages");
+                    await this.emitMessageSent(runtime, responseMemory, message.content.source ?? "messageHandler");
                 }
+                responseMessages.push(...continuation.responseMessages);
+            }
+            if (callback) {
                 await callback(responseContent);
             }
             return {
@@ -2285,38 +2417,6 @@ export class DefaultMessageService {
         if (!state.values?.actionNames) {
             runtime.logger.warn({ src: "service:message" }, "actionNames data missing from state");
         }
-        // Self-modification requests already have a deterministic action path.
-        // Skip the planner so group-chat style updates reliably hit MODIFY_CHARACTER.
-        if (isExplicitSelfModificationRequest(message.content.text || "")) {
-            const modifyCharacterAction = runtime.actions.find((action) => action.name === "MODIFY_CHARACTER");
-            const canHandleSelfModification = await modifyCharacterAction?.validate?.(runtime, message, state);
-            if (canHandleSelfModification) {
-                const responseContent = {
-                    thought: "Directly route explicit self-modification request to MODIFY_CHARACTER.",
-                    actions: ["MODIFY_CHARACTER"],
-                    providers: [],
-                    text: "",
-                    simple: false,
-                    responseId,
-                };
-                const responseMessages = [
-                    {
-                        id: responseId,
-                        entityId: runtime.agentId,
-                        agentId: runtime.agentId,
-                        content: responseContent,
-                        roomId: message.roomId,
-                        createdAt: Date.now(),
-                    },
-                ];
-                return {
-                    responseContent,
-                    responseMessages,
-                    state,
-                    mode: "actions",
-                };
-            }
-        }
         let responseContent = null;
         // Create streaming context for retry state tracking
         const streamingExtractor = opts.onStreamChunk
@@ -2701,7 +2801,7 @@ Output ONLY the continuation, starting immediately after the last character abov
                 .filter(Boolean)
                 .join(" ");
         }
-        replyText = runtime.redactSecrets(truncateToCompleteSentence(replyText.trim(), 2000));
+        replyText = truncateToCompleteSentence(replyText.trim(), 2000);
         const responseContent = {
             thought: `Explain the structured-output failure during ${stage}.`,
             actions: ["REPLY"],
@@ -2915,11 +3015,17 @@ Output ONLY the continuation, starting immediately after the last character abov
                     completedProviders: Array.from(completedProviders),
                 }, `Providers took too long (>${PROVIDERS_TOTAL_TIMEOUT_MS}ms) - slow providers: ${pendingProviders.join(", ")}`);
                 if (callback) {
-                    await callback({
+                    const timeoutContent = {
                         text: "Providers took too long to respond. Please optimize your providers or use caching.",
                         actions: [],
                         thought: "Provider timeout - pipeline aborted",
-                    });
+                    };
+                    await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(timeoutContent, {
+                        source: "simple",
+                        roomId: message.roomId,
+                        message,
+                    }));
+                    await callback(timeoutContent);
                 }
                 return {
                     responseContent: null,