onPartialReply?: (payload: { text?: string }) => Promise<void> | void;

onAssistantMessageStart?: () => Promise<void> | void;

allowProgressCallbacksWhenSourceDeliverySuppressed?: boolean;

allowToolLifecycleWhenProgressHidden?: boolean;

onTypingCleanup?: () => Promise<void> | void;

};

};

await runProcessDiscordMessage(ctx);

expect(getLastDispatchReplyOptions()?.allowToolLifecycleWhenProgressHidden).toBe(true);

const emojis = getReactionEmojis();

expect(emojis).toContain("👀");

expect(emojis).toContain(DEFAULT_EMOJIS.done);

await runProcessDiscordMessage(ctx);

expect(getLastDispatchReplyOptions()?.allowToolLifecycleWhenProgressHidden).toBeUndefined();

expect(getReactionEmojis()).toEqual(["👀"]);

});

draftPreview.suppressDefaultToolProgressMessages

? true

: undefined,

allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : undefined,

commentaryProgressEnabled: draftPreview.isProgressMode

? draftPreview.commentaryProgressEnabled

: undefined,

| {

disableBlockStreaming?: boolean;

suppressDefaultToolProgressMessages?: boolean;

allowProgressCallbacksWhenSourceDeliverySuppressed?: boolean;

allowToolLifecycleWhenProgressHidden?: boolean;

onAssistantMessageStart?: () => Promise<void> | void;

onReasoningEnd?: () => Promise<void> | void;

onReasoningStream?: (payload?: {

);

expect(capturedReplyOptions?.disableBlockStreaming).toBe(true);

expect(capturedReplyOptions?.allowProgressCallbacksWhenSourceDeliverySuppressed).toBe(true);

expect(capturedReplyOptions?.allowToolLifecycleWhenProgressHidden).toBe(true);

expectRecordFields(requireRecord(capturedStatusReactionOptions, "status reaction options"), {

enabled: true,

initialEmoji: "eyes",

disableBlockStreaming,

onModelSelected,

suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : undefined,

allowProgressCallbacksWhenSourceDeliverySuppressed:

sourceReplyDeliveryMode === "message_tool_only" && statusReactionsEnabled

? true

: undefined,

allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : undefined,

onPartialReply: useStreaming

? undefined

: !previewStreamingEnabled

* channel to surface progress via its own streaming/edit UX.

*/

suppressDefaultToolProgressMessages?: boolean;

/** Allow channel-owned tool lifecycle feedback while text progress remains hidden. */

allowToolLifecycleWhenProgressHidden?: boolean;

/**

* Called before dispatch with a live getter for whether verbose standalone

* progress messages are active for this run. Channels that render tool or

expect(dispatcher.sendFinalReply).toHaveBeenCalledTimes(1);

});

it("forwards only opted-in tool lifecycle feedback while verbose is off", async () => {

setNoAbort();

sessionStoreMocks.currentEntry = {

verboseLevel: "off",

};

const dispatcher = createDispatcher();

const ctx = buildTestCtx({

Provider: "discord",

Surface: "discord",

ChatType: "group",

});

const onToolStart = vi.fn();

const onItemEvent = vi.fn();

const onCommandOutput = vi.fn();

const replyResolver = async (

_ctx: MsgContext,

opts?: GetReplyOptions,

_cfg?: OpenClawConfig,

) => {

await opts?.onToolStart?.({ name: "exec", phase: "start" });

await opts?.onItemEvent?.({ itemId: "1", kind: "tool", progressText: "running exec" });

await opts?.onCommandOutput?.({ phase: "end", name: "exec", status: "ok", exitCode: 0 });

return { text: "done" } satisfies ReplyPayload;

};

await dispatchReplyFromConfig({

ctx,

cfg: automaticGroupReplyConfig,

dispatcher,

replyResolver,

replyOptions: {

allowToolLifecycleWhenProgressHidden: true,

onToolStart,

onItemEvent,

onCommandOutput,

},

});

expect(onToolStart).toHaveBeenCalledWith({ name: "exec", phase: "start" });

expect(onItemEvent).not.toHaveBeenCalled();

expect(onCommandOutput).not.toHaveBeenCalled();

expect(dispatcher.sendFinalReply).toHaveBeenCalledTimes(1);

});

it("delivers verbose inter-tool commentary as standalone progress messages before the tool summary", async () => {

setNoAbort();

sessionStoreMocks.currentEntry = {

const allowSuppressedSourceProgressCallbacks =

params.replyOptions?.allowProgressCallbacksWhenSourceDeliverySuppressed === true;

const shouldAllowQuietChannelOwnedProgressCallbacks = (options?: {

allowWhenToolSummariesHidden?: boolean;

requiresToolSummaryVisibility?: boolean;

}) =>

options?.requiresToolSummaryVisibility === true &&

params.replyOptions?.suppressDefaultToolProgressMessages === true;

(params.replyOptions?.suppressDefaultToolProgressMessages === true ||

options.allowWhenToolSummariesHidden === true);

let hasPendingDirectBlockReplyDelivery = false;

const waitForPendingDirectBlockReplyDelivery = async (abortSignal?: AbortSignal) => {

if (!hasPendingDirectBlockReplyDelivery) {

await waitForReplyDispatcherIdle(dispatcher, abortSignal);

};

const shouldForwardProgressCallback = (options?: {

allowWhenToolSummariesHidden?: boolean;

forwardWhenSourceDeliverySuppressed?: boolean;

requiresToolSummaryVisibility?: boolean;

}) => {

const wrapProgressCallback = <Args extends unknown[]>(

callback: ((...args: Args) => Promise<void> | void) | undefined,

options?: {

allowWhenToolSummariesHidden?: boolean;

forwardWhenSourceDeliverySuppressed?: boolean;

requiresToolSummaryVisibility?: boolean;

onForward?: (...args: Args) => Promise<void> | void;

),

onBlockReplyQueued: wrapProgressCallback(params.replyOptions?.onBlockReplyQueued),

onToolStart: wrapProgressCallback(params.replyOptions?.onToolStart, {

allowWhenToolSummariesHidden:

params.replyOptions?.allowToolLifecycleWhenProgressHidden === true,

forwardWhenSourceDeliverySuppressed: true,

requiresToolSummaryVisibility: true,

waitForDirectBlockReplyDelivery: true,

expect(sessionStore.main.compactionCount).toBe(1);

});

it("forwards opted-in queued tool lifecycle feedback while verbose progress is disabled", async () => {

const onToolStart = vi.fn(async () => {});

const onItemEvent = vi.fn(async () => {});

const onCommandOutput = vi.fn(async () => {});

runEmbeddedAgentMock.mockImplementationOnce(

async (args: {

onAgentEvent?: (evt: { stream: string; data: Record<string, unknown> }) => Promise<void>;

}) => {

await args.onAgentEvent?.({

stream: "tool",

data: { phase: "start", name: "exec", args: { command: "echo hidden" } },

});

await args.onAgentEvent?.({

stream: "item",

data: { phase: "start", itemId: "item-1", title: "hidden item" },

});

await args.onAgentEvent?.({

stream: "command_output",

data: { phase: "chunk", output: "hidden output" },

});

return { payloads: [{ text: "final" }], meta: { agentMeta: {} } };

},

);

const runner = createFollowupRunner({

opts: {

allowToolLifecycleWhenProgressHidden: true,

onToolStart,

onItemEvent,

onCommandOutput,

},

typing: createMockTypingController(),

typingMode: "instant",

defaultModel: "claude",

});

await runner(

createQueuedRun({

run: {

messageProvider: "discord",

sourceReplyDeliveryMode: "message_tool_only",

verboseLevel: "off",

},

}),

);

expect(onToolStart).toHaveBeenCalledWith({

name: "exec",

phase: "start",

args: { command: "echo hidden" },

detailMode: undefined,

});

expect(onItemEvent).not.toHaveBeenCalled();

expect(onCommandOutput).not.toHaveBeenCalled();

});

it("keeps queued follow-up progress quiet when verbose state is missing", async () => {

const onToolStart = vi.fn(async () => {});

const onCommandOutput = vi.fn(async () => {});

}) {

const { evt, opts } = params;

const emitChannelProgress = params.emitChannelProgress !== false;

if (!emitChannelProgress && evt.stream !== "compaction") {

const allowQuietToolLifecycle =

evt.stream === "tool" && opts?.allowToolLifecycleWhenProgressHidden === true;

if (!emitChannelProgress && evt.stream !== "compaction" && !allowQuietToolLifecycle) {

return;

}