rendered: incoming,

source: incoming,

}),

buildStatusFinalPreviewText: () => "status",

resolveSlackStreamingConfig: () => ({

mode: mockedSlackStreamingMode,

nativeStreaming: mockedNativeStreaming,

// Slack tests cover stream mode plugin behavior.

import { describe, expect, it } from "vitest";

import {

applyAppendOnlyStreamUpdate,

buildStatusFinalPreviewText,

resolveSlackStreamingConfig,

resolveSlackStreamMode,

} from "./stream-mode.js";

describe("resolveSlackStreamMode", () => {

it("defaults to replace", () => {

expect(resolveSlackStreamMode(undefined)).toBe("replace");

expect(resolveSlackStreamMode("")).toBe("replace");

expect(resolveSlackStreamMode("unknown")).toBe("replace");

});

it("accepts valid modes", () => {

expect(resolveSlackStreamMode("replace")).toBe("replace");

expect(resolveSlackStreamMode("status_final")).toBe("status_final");

expect(resolveSlackStreamMode("append")).toBe("append");

});

});

import { applyAppendOnlyStreamUpdate, resolveSlackStreamingConfig } from "./stream-mode.js";

describe("resolveSlackStreamingConfig", () => {

it("defaults to partial mode with native streaming enabled", () => {

});

});

});

describe("buildStatusFinalPreviewText", () => {

it("cycles status dots", () => {

expect(buildStatusFinalPreviewText(1)).toBe("Status: thinking..");

expect(buildStatusFinalPreviewText(2)).toBe("Status: thinking...");

expect(buildStatusFinalPreviewText(3)).toBe("Status: thinking.");

});

});

// Slack plugin module implements stream mode behavior.

import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";

import {

mapStreamingModeToSlackLegacyDraftStreamMode,

resolveSlackNativeStreaming,

type StreamingMode,

} from "./streaming-compat.js";

type SlackStreamMode = SlackLegacyDraftStreamMode;

type SlackStreamingMode = StreamingMode;

const DEFAULT_STREAM_MODE: SlackStreamMode = "replace";

export function resolveSlackStreamMode(raw: unknown): SlackStreamMode {

if (typeof raw !== "string") {

return DEFAULT_STREAM_MODE;

}

const normalized = normalizeLowercaseStringOrEmpty(raw);

if (normalized === "replace" || normalized === "status_final" || normalized === "append") {

return normalized;

}

return DEFAULT_STREAM_MODE;

}

export function resolveSlackStreamingConfig(params: {

streaming?: unknown;

streamMode?: unknown;

nativeStreaming?: unknown;

}): { mode: SlackStreamingMode; nativeStreaming: boolean; draftMode: SlackStreamMode } {

}): {

mode: SlackStreamingMode;

nativeStreaming: boolean;

draftMode: SlackLegacyDraftStreamMode;

} {

const mode = resolveSlackStreamingMode(params);

const nativeStreaming = resolveSlackNativeStreaming(params);

return {

changed: true,

};

}

export function buildStatusFinalPreviewText(updateCount: number): string {

const dots = ".".repeat((Math.max(1, updateCount) % 3) + 1);

return `Status: thinking${dots}`;

}

warningNotes: await collectWarnings(params),

};

}),

collectDoctorPreviewWarnings: vi.fn(collectWarnings),

};

});

import {

collectDoctorPreviewNotes,

collectChannelBoundMessageToolPolicyWarnings,

collectDoctorPreviewWarnings,

collectProfileConfiguredToolSectionWarnings,

collectVisibleReplyToolPolicyWarnings,

} from "./preview-warnings.js";

async function collectDoctorPreviewWarnings(

params: Parameters<typeof collectDoctorPreviewNotes>[0],

): Promise<string[]> {

return (await collectDoctorPreviewNotes(params)).warningNotes;

}

type TestManifestRecord = {

id: string;

channels: string[];

return { infoNotes, warningNotes: warnings };

}

/** Collect warning notes only for callers that do not display info notes. */

export async function collectDoctorPreviewWarnings(params: {

cfg: OpenClawConfig;

doctorFixCommand: string;

env?: NodeJS.ProcessEnv;

allowExec?: boolean;

}): Promise<string[]> {

return (await collectDoctorPreviewNotes(params)).warningNotes;

}