- Agents: trim default system prompt guidance and send-only message tool schemas to reduce prompt tokens while preserving GPT-5 personality guidance.

- Context: add `/context map` to send a treemap image of the current session context contributors. (#79867)

- Slack: add `unfurlLinks` and `unfurlMedia` config for bot `chat.postMessage` replies, including per-account overrides, so Slack link and media previews can be suppressed without workspace-wide settings. Fixes #48435. (#80145) Thanks @esegev1 and @HemantSudarshan.

- Slack: add explicit `replyBroadcast` support for text and Block Kit thread replies so agents can opt into Slack's parent-channel `reply_broadcast` behavior. (#64365) Thanks @tony88331.

- Plugin SDK: deprecate public subpaths that existed for at least one month and have no bundled extension production imports, keep legacy barrel/test/zod subpath package exports for backwards compatibility, and track both sets in the SDK surface report.

- Plugin SDK: deprecate public subpaths currently used by only one or two bundled plugin owners, keeping them importable while steering new plugin code to focused shared SDK seams or plugin-owned APIs.

- Plugin SDK: remove the owner-specific `provider-auth-login` public subpath after moving Chutes, GitHub Copilot, and OpenAI Codex auth flows back to provider-owned modules.

- `[[reply_to_current]]`

- `[[reply_to:<id>]]`

For explicit Slack thread replies from the `message` tool, set `replyBroadcast: true` with `action: "send"` and `threadId` or `replyTo` to ask Slack to also broadcast the thread reply to the parent channel. This maps to Slack's `chat.postMessage` `reply_broadcast` flag and is only supported for text or Block Kit sends, not media uploads.

<Note>

`replyToMode="off"` disables **all** reply threading in Slack, including explicit `[[reply_to_*]]` tags. This differs from Telegram, where explicit tags are still honored in `"off"` mode. Slack threads hide messages from the channel while Telegram replies stay visible inline.

</Note>

});

});

it("passes replyBroadcast to sendSlackMessage for thread replies", async () => {

const cfg = slackConfig();

await handleSlackAction(

{

action: "sendMessage",

to: "channel:C123",

content: "Hello thread",

threadTs: "1234567890.123456",

replyBroadcast: true,

},

cfg,

);

expectSlackSendCall(0, "channel:C123", "Hello thread", {

cfg,

mediaUrl: undefined,

threadTs: "1234567890.123456",

replyBroadcast: true,

blocks: undefined,

});

});

it("returns a friendly error when downloadFile cannot fetch the attachment", async () => {

downloadSlackFile.mockResolvedValueOnce(null);

const result = await handleSlackAction(

});

});

it("rejects replyBroadcast for uploadFile", async () => {

await expect(

handleSlackAction(

{

action: "uploadFile",

to: "channel:C123",

filePath: "/tmp/report.txt",

threadTs: "111.222",

replyBroadcast: true,

},

slackConfig(),

),

).rejects.toThrow(/replyBroadcast is only supported for text or block thread replies/i);

});

it("sends media before a separate blocks message", async () => {

sendSlackMessage.mockResolvedValueOnce({ channelId: "C123" });

sendSlackMessage.mockResolvedValueOnce({ channelId: "C123" });

import type { AgentToolResult } from "@mariozechner/pi-agent-core";

import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";

import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";

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

import { parseSlackBlocksInput } from "./blocks-input.js";

});

const mediaUrl = readStringParam(params, "mediaUrl");

const blocks = readSlackBlocksParam(params);

const replyBroadcast = readBooleanParam(params, "replyBroadcast");

if (!content && !mediaUrl && !blocks) {

throw new Error("Slack sendMessage requires content, blocks, or mediaUrl.");

}

if (replyBroadcast && mediaUrl) {

throw new Error(

"Slack replyBroadcast is only supported for text or block thread replies.",

);

}

const threadTs = resolveThreadTsFromContext(

readStringParam(params, "threadTs"),

to,

mediaLocalRoots: context?.mediaLocalRoots,

mediaReadFile: context?.mediaReadFile,

threadTs: threadTs ?? undefined,

...(replyBroadcast ? { replyBroadcast } : {}),

};

const result =

mediaUrl && blocks

});

const filename = readStringParam(params, "filename");

const title = readStringParam(params, "title");

const replyBroadcast = readBooleanParam(params, "replyBroadcast");

if (replyBroadcast) {

throw new Error(

"Slack replyBroadcast is only supported for text or block thread replies.",

);

}

const threadTs = resolveThreadTsFromContext(

readStringParam(params, "threadTs"),

to,

mediaLocalRoots?: readonly string[];

mediaReadFile?: (filePath: string) => Promise<Buffer>;

threadTs?: string;

replyBroadcast?: boolean;

uploadFileName?: string;

uploadTitle?: string;

blocks?: (Block | KnownBlock)[];

mediaReadFile: opts.mediaReadFile,

client: opts.client,

threadTs: opts.threadTs,

replyBroadcast: opts.replyBroadcast,

...(opts.uploadFileName ? { uploadFileName: opts.uploadFileName } : {}),

...(opts.uploadTitle ? { uploadTitle: opts.uploadTitle } : {}),

blocks: opts.blocks,

expectForwardedCfg(invoke, cfg);

});

it("passes replyBroadcast through for Slack thread sends", async () => {

const invoke = createInvokeSpy();

const cfg = slackConfig();

await handleSlackMessageAction({

providerId: "slack",

ctx: {

action: "send",

cfg,

params: {

to: "channel:C1",

message: "Visible from the channel",

threadId: "111.222",

replyBroadcast: true,

},

} as never,

invoke: invoke as never,

});

expect(invoke).toHaveBeenCalledWith(

expect.objectContaining({

action: "sendMessage",

to: "channel:C1",

content: "Visible from the channel",

threadTs: "111.222",

replyBroadcast: true,

}),

cfg,

undefined,

);

});

it("maps upload-file to the internal uploadFile action", async () => {

const invoke = createInvokeSpy();

const cfg = slackConfig();

expectForwardedCfg(invoke, cfg);

});

it("rejects replyBroadcast for upload-file", async () => {

await expect(

handleSlackMessageAction({

providerId: "slack",

ctx: {

action: "upload-file",

cfg: {},

params: {

to: "channel:C1",

filePath: "/tmp/report.png",

threadId: "111.222",

replyBroadcast: true,

},

} as never,

invoke: createInvokeSpy() as never,

}),

).rejects.toThrow(/replyBroadcast is only supported for text or block thread replies/i);

});

it("maps upload-file aliases to upload params", async () => {

const invoke = createInvokeSpy();

const cfg = slackConfig();

import type { AgentToolResult } from "@mariozechner/pi-agent-core";

import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";

import type { ChannelMessageActionContext } from "openclaw/plugin-sdk/channel-contract";

import {

normalizeInteractiveReply,

if (!content && !mediaUrl && !blocks) {

throw new Error("Slack send requires message, blocks, or media.");

}

const replyBroadcast = readBooleanParam(actionParams, "replyBroadcast");

if (replyBroadcast && mediaUrl) {

throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");

}

const threadId = readStringParam(actionParams, "threadId");

const replyTo = readStringParam(actionParams, "replyTo");

return await invoke(

mediaUrl: mediaUrl ?? undefined,

accountId,

threadTs: threadId ?? replyTo ?? undefined,

...(replyBroadcast ? { replyBroadcast } : {}),

...(blocks ? { blocks } : {}),

},

cfg,

}

if (action === "upload-file") {

const replyBroadcast = readBooleanParam(actionParams, "replyBroadcast");

if (replyBroadcast) {

throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");

}

const to = readStringParam(actionParams, "to") ?? resolveChannelId();

const filePath =

readStringParam(actionParams, "filePath", { trim: false }) ??

};

}

function createSlackSendActionSchema(): Record<string, TSchema> {

return {

replyBroadcast: Type.Optional(

Type.Boolean({

description:

'Slack-only opt-in for action="send" thread replies. Set true with threadId or replyTo on text/block sends to also broadcast the reply to the parent channel. Not supported for media or upload-file.',

}),

),

};

}

export function describeSlackMessageTool({

cfg,

accountId,

actions: ["download-file"],

});

}

if (actions.includes("send")) {

schema.push({

properties: createSlackSendActionSchema(),

actions: ["send"],

});

}

const messageIdActions: ChannelMessageActionName[] = [];

for (const action of SLACK_MESSAGE_ID_ACTIONS) {

if (actions.includes(action)) {

expect(alias.description).toMatch(/Alias for messageId/i);

});

it("describes Slack reply broadcasts as send-only thread hints", () => {

const discovery = describeSlackMessageTool({

cfg: {

channels: {

slack: {

botToken: "xoxb-test",

},

},

},

});

const { schema, property } = requireSchemaProperty(discovery, "replyBroadcast");

expect(schema.actions).toEqual(["send"]);

expect(property.description).toContain('action="send"');

expect(property.description).toContain("threadId");

expect(property.description).toContain("Not supported for media or upload-file");

});

it("omits Slack file and message id schemas when those actions are disabled", () => {

const discovery = describeSlackMessageTool({

cfg: {

});

expect(discovery.actions).toEqual(["send"]);

expect(discovery.schema).toBeNull();

const schemas = Array.isArray(discovery.schema)

? discovery.schema

: discovery.schema

? [discovery.schema]

: [];

expect(schemas.some((entry) => "fileId" in entry.properties)).toBe(false);

expect(schemas.some((entry) => "messageId" in entry.properties)).toBe(false);

expect(schemas.some((entry) => "replyBroadcast" in entry.properties)).toBe(true);

});

});

expect(result.receipt.threadId).toBe("171234.100");

});

it("passes reply_broadcast for threaded text sends only on the first chunk", async () => {

const client = createSlackSendTestClient();

await sendMessageSlack("channel:C123", "a".repeat(8500), {

token: "xoxb-test",

cfg: SLACK_TEST_CFG,

client,

threadTs: "171234.100",

replyBroadcast: true,

});

expect(client.chat.postMessage).toHaveBeenCalledTimes(2);

expect(client.chat.postMessage.mock.calls[0]?.[0]).toEqual(

expect.objectContaining({

thread_ts: "171234.100",

reply_broadcast: true,

}),

);

expect(client.chat.postMessage.mock.calls[1]?.[0]).not.toHaveProperty("reply_broadcast");

});

it("does not pass reply_broadcast when no thread is selected", async () => {

const client = createSlackSendTestClient();

await sendMessageSlack("channel:C123", "hello", {

token: "xoxb-test",

cfg: SLACK_TEST_CFG,

client,

replyBroadcast: true,

});

expect(client.chat.postMessage).toHaveBeenCalledWith(

expect.not.objectContaining({

reply_broadcast: true,

}),

);

});

it("does not retry Slack platform errors", async () => {

const client = createSlackSendTestClient();

const platformError = Object.assign(

expect(client.chat.postMessage).not.toHaveBeenCalled();

});

it("rejects replyBroadcast combined with mediaUrl", async () => {

const client = createSlackSendTestClient();

await expect(

sendMessageSlack("channel:C123", "hi", {

token: "xoxb-test",

cfg: SLACK_TEST_CFG,

client,

mediaUrl: "https://example.com/image.png",

threadTs: "171234.100",

replyBroadcast: true,

}),

).rejects.toThrow(/replyBroadcast is only supported for text or block thread replies/i);

expect(client.chat.postMessage).not.toHaveBeenCalled();

});

it("rejects empty blocks arrays from runtime callers", async () => {

const client = createSlackSendTestClient();

await expect(