markSubagentRunTerminated: () => 0,

}));

// #85714: keep the real private-final decision but spy the WARN emitter so we

// can assert it fires only through the substantive text suppression branch.

const warnPrivateFinalSpy = vi.hoisted(() => vi.fn());

vi.mock("./private-message-tool-final.js", async (importOriginal) => {

const actual = await importOriginal<typeof import("./private-message-tool-final.js")>();

return { ...actual, warnPrivateMessageToolFinal: warnPrivateFinalSpy };

});

import { runReplyAgent } from "./agent-runner.js";

type RunWithModelFallbackParams = {

embeddedRunTesting.resetActiveEmbeddedRuns();

replyRunRegistryTesting.resetReplyRunRegistry();

runEmbeddedAgentMock.mockClear();

warnPrivateFinalSpy.mockClear();

runCliAgentMock.mockClear();

runWithModelFallbackMock.mockClear();

runtimeErrorMock.mockClear();

expect(payload?.text).toBeUndefined();

});

});

describe("runReplyAgent private message_tool_only final warning (#85714)", () => {

async function runPrivateFinalCase(params: {

messagingToolSentTargets?: unknown[];

finalAssistantText?: string;

payloadText?: string;

successfulCronAdds?: number;

}) {

const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-stranded-"));

const storePath = path.join(tmp, "sessions.json");

const sessionKey = "stranded";

const sessionEntry = { sessionId: "session", updatedAt: Date.now(), totalTokens: 1_000 };

await fs.writeFile(storePath, JSON.stringify({ [sessionKey]: sessionEntry }, null, 2), "utf-8");

const finalAssistantText =

params.finalAssistantText ??

"Here is the answer the user asked for. It includes enough detail to read like a user-facing response rather than a short private note. This should have been sent with the message tool if the channel expected a visible reply.";

runEmbeddedAgentMock.mockResolvedValue({

// payloadText can differ from the assistant text to simulate metadata-only

// payloads (verbose notices, usage line) that must NOT trigger the warn —

// detection keys off the assistant final text, not the payload bundle.

payloads: [{ text: params.payloadText ?? finalAssistantText }],

meta: { agentMeta: {}, finalAssistantVisibleText: finalAssistantText },

...(params.messagingToolSentTargets

? { messagingToolSentTargets: params.messagingToolSentTargets }

: {}),

...(params.successfulCronAdds === undefined

? {}

: { successfulCronAdds: params.successfulCronAdds }),

});

const sessionCtx = {

Provider: "whatsapp",

OriginatingTo: "+15550001111",

AccountId: "primary",

MessageSid: "msg",

ChatType: "direct",

} as unknown as TemplateContext;

const followupRun = {

prompt: "hello",

summaryLine: "hello",

enqueuedAt: Date.now(),

run: {

agentId: "main",

agentDir: "/tmp/agent",

sessionId: "session",

sessionKey,

messageProvider: "whatsapp",

sessionFile: "/tmp/session.jsonl",

workspaceDir: tmp,

// Direct chat + visibleReplies=message_tool resolves to message_tool_only,

// so the final text is kept private (no automatic delivery).

config: { messages: { visibleReplies: "message_tool" } },

skillsSnapshot: {},

provider: "anthropic",

model: "claude",

thinkLevel: "low",

reasoningLevel: "on",

verboseLevel: "off",

elevatedLevel: "off",

bashElevated: { enabled: false, allowed: false, defaultLevel: "off" },

timeoutMs: 1_000,

blockReplyBreak: "message_end",

},

} as unknown as FollowupRun;

await runReplyAgent({

commandBody: "hello",

followupRun,

queueKey: sessionKey,

resolvedQueue: { mode: "interrupt" } as unknown as QueueSettings,

shouldSteer: false,

shouldFollowup: false,

isActive: false,

isStreaming: false,

typing: createMockTypingController(),

sessionCtx,

sessionEntry,

sessionStore: { [sessionKey]: sessionEntry },

sessionKey,

storePath,

defaultModel: "anthropic/claude-opus-4-6",

agentCfgContextTokens: 200_000,

resolvedVerboseLevel: "off",

isNewSession: false,

blockStreamingEnabled: false,

resolvedBlockStreamingBreak: "message_end",

shouldInjectGroupIntro: false,

typingMode: "instant",

});

}

it("warns when a substantive private final reply never used the message tool", async () => {

await runPrivateFinalCase({});

expect(warnPrivateFinalSpy).toHaveBeenCalledTimes(1);

expect(warnPrivateFinalSpy.mock.calls[0]?.[0]).toMatchObject({ sessionKey: "stranded" });

});

it("does not warn for a short private final reply", async () => {

await runPrivateFinalCase({ finalAssistantText: "Nothing to send here." });

expect(warnPrivateFinalSpy).not.toHaveBeenCalled();

});

it("does not warn when the message tool delivered this turn", async () => {

await runPrivateFinalCase({

messagingToolSentTargets: [{ tool: "message", provider: "whatsapp", to: "+15550001111" }],

});

expect(warnPrivateFinalSpy).not.toHaveBeenCalled();

});

it("still warns when only an unrelated cron side effect succeeded", async () => {

await runPrivateFinalCase({ successfulCronAdds: 1 });

expect(warnPrivateFinalSpy).toHaveBeenCalledTimes(1);

});

it("does not warn on an intentional NO_REPLY turn even when metadata payloads remain", async () => {

// Assistant went silent (NO_REPLY), but a verbose/usage metadata payload

// survives in finalPayloads. The warn must key off the assistant text, not

// the payload bundle, so no private-final warning should fire.

await runPrivateFinalCase({

finalAssistantText: "no_reply",

payloadText: "Auto-compaction complete (count 1).",

});

expect(warnPrivateFinalSpy).not.toHaveBeenCalled();

});

});