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

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

import {

createDiscordMessageHandler,

preflightDiscordMessageMock,

preflightDiscordMessageMock.mockReset();

processDiscordMessageMock.mockReset();

preflightDiscordMessageMock.mockImplementation(

async (params: { data: { channel_id: string } }) =>

createPreflightContext(params.data.channel_id),

async (params: { data: { channel_id: string } }) => ({

...params,

...createPreflightContext(params.data.channel_id),

}),

);

const handler = createDiscordMessageHandler(createDiscordHandlerParams());

).resolves.toBeUndefined();

await flushAsyncWork();

expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);

expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);

await vi.waitFor(() => {

expect(preflightDiscordMessageMock).toHaveBeenCalledTimes(1);

expect(processDiscordMessageMock).toHaveBeenCalledTimes(1);

});

});

});

},

baseSessionKey: `agent:main:discord:channel:${channelId}`,

messageChannelId: channelId,

messageText: "hello",

isDirectMessage: true,

isGroupDm: false,

isGuildMessage: false,

inboundEventKind: "message",

effectiveWasMentioned: false,

};

}

import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";

import { resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";

import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";

import { stripPlainTextToolCallBlocks } from "openclaw/plugin-sdk/tool-payload";

const DISCORD_INTERNAL_TRACE_LINE_RE =

/^(?:>\s*)?(?:📊|🛠️|📖|📝|🔍|🔎|⚙️)\s*(?:Session Status|Exec|Read|Edit|Write|Patch|Search|Open|Click|Find|Screenshot|Update Plan|Tool Call|Tool Result|Function Call|Shell|Command)\s*:/i;

}

export function sanitizeDiscordFrontChannelText(text: string): string {

const withoutAssistantScaffolding = sanitizeAssistantVisibleText(text);

const withoutTraceLines = stripDiscordInternalTraceLines(withoutAssistantScaffolding);

const withoutToolCallBlocks = stripPlainTextToolCallBlocks(text);

const withoutAssistantScaffolding = sanitizeAssistantVisibleText(withoutToolCallBlocks);

const withoutResidualToolCallBlocks = stripPlainTextToolCallBlocks(withoutAssistantScaffolding);

const withoutTraceLines = stripDiscordInternalTraceLines(withoutResidualToolCallBlocks);

return collapseExcessBlankLines(withoutTraceLines).trim();

}

describePluginRegistrationContract({

pluginId: "ollama",

providerIds: ["ollama"],

providerIds: ["ollama", "ollama-cloud"],

webSearchProviderIds: ["ollama"],

});

describePluginRegistrationContract({

pluginId: "qwen",

providerIds: ["qwen", "qwencloud", "modelstudio", "dashscope"],

providerIds: [

"qwen",

"qwencloud",

"modelstudio",

"dashscope",

"qwen-oauth",

"qwen-portal",

"qwen-cli",

],

mediaUnderstandingProviderIds: ["qwen"],

videoGenerationProviderIds: ["qwen"],

requireDescribeImages: true,

});

try {

await writeSpooledTestUpdates(tempDir, [topicUpdate(42, 10, "wedged topic 10 turn")]);

await writeSpooledTestUpdates(tempDir, [

topicUpdate(42, 10, "wedged topic 10 turn"),

topicUpdate(43, 10, "later blocked topic 10 turn"),

]);

const { runPromise, stopWorker } = startIsolatedIngressSession({

abort,

spoolDir: tempDir,

continue;

}

const ageMs = now - handler.startedAt;

if (ageMs <= this.#spooledUpdateHandlerTimeoutMs) {

if (ageMs < this.#spooledUpdateHandlerTimeoutMs) {

continue;

}

if (!timedOut || ageMs > timedOut.ageMs) {

const listener = await openMonitor(onMessage);

const sock = getSock();

sock.ev.emit("messages.upsert", upsert);

await new Promise((resolve) => setTimeout(resolve, 25));

await vi.waitFor(() => {

expect(

onMessage.mock.calls.length +

sock.readMessages.mock.calls.length +

inboundLoggerInfoMock.mock.calls.length,

).toBeGreaterThan(0);

});

return { onMessage, listener, sock };

}

import type { ProviderAuthContext } from "./types.js";

const OPENAI_CODEX_PROVIDER_ID = "openai";

const OPENAI_CODEX_LEGACY_PROVIDER_ID = "openai-codex";

const OPENAI_CODEX_OAUTH_METHOD_ID = "oauth";

type OpenAICodexOAuthBridgeContext = ProviderAuthContext & {

const record = value as Record<string, unknown>;

return (

record.type === "oauth" &&

record.provider === OPENAI_CODEX_PROVIDER_ID &&

(record.provider === OPENAI_CODEX_PROVIDER_ID ||

record.provider === OPENAI_CODEX_LEGACY_PROVIDER_ID) &&

typeof record.access === "string" &&

typeof record.refresh === "string" &&

typeof record.expires === "number"