sendPolicy: "deny",

};

const dispatcher = createDispatcher();

const replyResolver = vi.fn(async () => ({ text: "agent reply" }) satisfies ReplyPayload);

const replyResolver = vi.fn(async (_ctx: MsgContext, opts?: GetReplyOptions) => {

expect(opts?.suppressTyping).toBe(true);

return { text: "agent reply" } satisfies ReplyPayload;

});

const ctx = buildTestCtx({ SessionKey: "test:session" });

await dispatchReplyFromConfig({

itemEvent: vi.fn(),

planUpdate: vi.fn(),

toolResult: vi.fn(),

typingStart: vi.fn(async () => {}),

};

const replyResolver = vi.fn(async (_ctx: MsgContext, opts?: GetReplyOptions) => {

expect(opts?.suppressTyping).toBe(false);

await opts?.onReplyStart?.();

await opts?.onPartialReply?.({ text: "draft leak" });

await opts?.onReasoningStream?.({ text: "reasoning leak" });

await opts?.onAssistantMessageStart?.();

onPartialReply: callbacks.partial,

onReasoningStream: callbacks.reasoning,

onAssistantMessageStart: callbacks.assistantStart,

onReplyStart: callbacks.typingStart,

onBlockReplyQueued: callbacks.blockQueued,

onToolStart: callbacks.toolStart,

onItemEvent: callbacks.itemEvent,

expect(dispatcher.sendFinalReply).not.toHaveBeenCalled();

expect(dispatcher.sendBlockReply).not.toHaveBeenCalled();

expect(dispatcher.sendToolResult).not.toHaveBeenCalled();

for (const callback of Object.values(callbacks)) {

expect(callbacks.typingStart).toHaveBeenCalledTimes(1);

for (const [name, callback] of Object.entries(callbacks)) {

if (name === "typingStart") {

continue;

}

expect(callback).not.toHaveBeenCalled();

}

expect(hookMocks.runner.runReplyDispatch).toHaveBeenCalledWith(

const dispatcher = createDispatcher();

const replyResolver = vi.fn(async (_ctx: MsgContext, opts?: GetReplyOptions) => {

expect(opts?.sourceReplyDeliveryMode).toBe("message_tool_only");

expect(opts?.suppressTyping).toBe(false);

return { text: "final reply" } satisfies ReplyPayload;

});