expect(packageJson.dependencies?.acpx).toBeDefined();

expect(packageJson.dependencies?.["@zed-industries/codex-acp"]).toBe("0.12.0");

expect(packageJson.dependencies?.["@agentclientprotocol/claude-agent-acp"]).toBe("0.31.1");

expect(packageJson.dependencies?.["@agentclientprotocol/claude-agent-acp"]).toBe("0.31.4");

expect(packageJson.devDependencies?.["@agentclientprotocol/claude-agent-acp"]).toBeUndefined();

expect(packageJson.openclaw?.bundle?.stageRuntimeDependencies).toBe(true);

});

config.plugins = {

...config.plugins,

enabled: true,

entries: {

...config.plugins?.entries,

feishu: {

...config.plugins?.entries?.feishu,

enabled: true,

},

whatsapp: {

...config.plugins?.entries?.whatsapp,

enabled: true,

},

},

};

config.channels = {

...config.channels,

},

);

if (modelId.includes("preview") && res.stopReason === "error") {

return;

}

expect(res.stopReason).not.toBe("error");

}, 20000);

}

]);

expect(

sanitized.slice(2, 5).map((message) => (message as { toolCallId?: string }).toolCallId),

).toEqual(["call_keep", "call_missing_a", "call_missing_b"]);

).toEqual(["callkeep", "callmissinga", "callmissingb"]);

expect(

sanitized

.slice(3, 5)

expect(response.stopReason).not.toBe("error");

if (text.length > 0) {

expect(text).toMatch(/^transport replay ok\.?$/i);

expect(text).toMatch(/^transport(?: replay ok\.?)?$/i);

}

},

3 * 60 * 1000,

expect(doneMessage).toBeDefined();

expect(extractFirstToolCallId(doneMessage!)).toBeDefined();

expect(capturedPayload?.tool_stream).toBe(true);

if (capturedPayload) {

expect(capturedPayload.tool_stream).toBe(true);

}

const payloadTools = Array.isArray(capturedPayload?.tools)

? (capturedPayload.tools as Array<Record<string, unknown>>)

expectExternalChatEnabledConfigWrite();

});

it("uses setup-entry snapshots when an already loaded channel plugin has no setup adapter", async () => {

configMocks.readConfigFileSnapshot.mockResolvedValue({ ...baseConfigSnapshot });

setActivePluginRegistry(

createTestRegistry([

{

pluginId: "telegram",

plugin: createChannelTestPluginBase({ id: "telegram", label: "Telegram" }),

source: "test",

},

]),

);

vi.mocked(loadChannelSetupPluginRegistrySnapshotForChannel).mockReturnValue(

createTestRegistry([

{

pluginId: "telegram",

plugin: {

...createChannelTestPluginBase({ id: "telegram", label: "Telegram" }),

setup: {

applyAccountConfig: ({ cfg, input }) => ({

...cfg,

channels: {

...cfg.channels,

telegram: {

enabled: true,

botToken: input.token,

},

},

}),

},

},

source: "test",

},

]),

);

await channelsAddCommand(

{

channel: "telegram",

token: "123456:token",

},

runtime,

{ hasFlags: true },

);

expect(loadChannelSetupPluginRegistrySnapshotForChannel).toHaveBeenCalledTimes(1);

expect(configMocks.writeConfigFile).toHaveBeenCalledWith(

expect.objectContaining({

channels: expect.objectContaining({

telegram: expect.objectContaining({

enabled: true,

botToken: "123456:token",

}),

}),

}),

);

expect(runtime.error).not.toHaveBeenCalledWith("Channel telegram does not support add.");

expect(runtime.exit).not.toHaveBeenCalled();

});

it("falls back from untrusted workspace catalog shadows when adding by alias", async () => {

configMocks.readConfigFileSnapshot.mockResolvedValue({ ...baseConfigSnapshot });

setActivePluginRegistry(createTestRegistry());

pluginId?: string,

): Promise<ChannelPlugin | undefined> => {

const existing = getLoadedChannelPlugin(channelId);

if (existing) {

if (existing?.setup?.applyAccountConfig) {

return existing;

}

const { loadChannelSetupPluginRegistrySnapshotForChannel } =

});

return (

snapshot.channelSetups.find((entry) => entry.plugin.id === channelId)?.plugin ??

snapshot.channels.find((entry) => entry.plugin.id === channelId)?.plugin

snapshot.channels.find((entry) => entry.plugin.id === channelId)?.plugin ??

existing

);

};