### Changes

- Telegram: treat successful same-chat `message` tool outbound sends during an inbound telegram turn as delivered when deciding whether to emit the rewritten silent reply fallback (#78685). Thanks @neeravmakwana.

- Docs/iMessage: deprecate BlueBubbles for new OpenClaw setups, document the upstream server-release rationale, and point new iMessage deployments toward the native `imsg` path while keeping BlueBubbles as a supported legacy fallback.

- Discord/streaming: default Discord replies to progress draft previews so tool/work activity appears in one edited Discord message unless `channels.discord.streaming.mode` is set to `off`.

- Plugins/install: add `npm-pack:<path.tgz>` installs so local npm pack artifacts run through the same managed npm-root install, lockfile verification, dependency scan, and install-record path as registry npm plugins.

import { captureEnv } from "openclaw/plugin-sdk/test-env";

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

import { handleTelegramAction, telegramActionRuntime } from "./action-runtime.js";

import { beginTelegramInboundTurnDeliveryCorrelation } from "./inbound-turn-delivery.js";

const originalTelegramActionRuntime = { ...telegramActionRuntime };

const reactMessageTelegram = vi.fn(async () => ({ ok: true }));

});

});

it("marks the matching inbound turn delivered after a successful send", async () => {

let count = 0;

const end = beginTelegramInboundTurnDeliveryCorrelation("telegram-session", {

outboundTo: "@testchannel",

markInboundTurnDelivered: () => {

count += 1;

},

});

await handleTelegramAction(

{

action: "sendMessage",

to: "@testchannel",

content: "Hello, Telegram!",

},

telegramConfig(),

{ sessionKey: "telegram-session" },

);

expect(count).toBe(1);

end();

});

it("accepts shared send action aliases", async () => {

await handleTelegramAction(

{

import type { MessagePresentation } from "openclaw/plugin-sdk/interactive-runtime";

import { createTelegramActionGate, resolveTelegramPollActionGateState } from "./accounts.js";

import { resolveTelegramInlineButtons } from "./button-types.js";

import { notifyTelegramInboundTurnOutboundSuccess } from "./inbound-turn-delivery.js";

import {

resolveTelegramInlineButtonsScope,

resolveTelegramTargetChatType,

options?: {

mediaLocalRoots?: readonly string[];

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

sessionKey?: string | null;

},

): Promise<AgentToolResult<unknown>> {

const { action, accountId } = {

readBooleanParam(params, "asDocument") ??

false,

});

notifyTelegramInboundTurnOutboundSuccess({

sessionKey: options?.sessionKey ?? undefined,

to,

accountId,

});

await maybePinTelegramActionSend({

args: params,

cfg,

} from "./error-policy.js";

import { shouldSuppressLocalTelegramExecApprovalPrompt } from "./exec-approvals.js";

import { markdownToTelegramChunks, renderTelegramHtmlText } from "./format.js";

import { beginTelegramInboundTurnDeliveryCorrelation } from "./inbound-turn-delivery.js";

import {

createLaneDeliveryStateTracker,

createLaneTextDeliverer,

? ctxPayload.ReplyToQuoteEntities

: undefined;

const deliveryState = createLaneDeliveryStateTracker();

const endTelegramInboundTurnDeliveryCorrelation = beginTelegramInboundTurnDeliveryCorrelation(

ctxPayload.SessionKey,

{

outboundTo: String(chatId),

outboundAccountId: route.accountId,

markInboundTurnDelivered: () => deliveryState.markDelivered(),

},

);

const clearGroupHistory = () => {

if (isGroup && historyKey) {

clearHistoryEntriesIfEnabled({

} finally {

dispatchWasSuperseded = isDispatchSuperseded();

releaseReplyFence();

endTelegramInboundTurnDeliveryCorrelation();

}

if (dispatchWasSuperseded) {

if (statusReactionController) {

cfg: {} as never,

accountId: "default",

mediaLocalRoots: [],

sessionKey: "telegram-session",

} as never);

expect(handleTelegramActionMock).toHaveBeenCalledWith(

expect.anything(),

expect.objectContaining({

mediaLocalRoots: [],

sessionKey: "telegram-session",

}),

);

});

extractToolSend: ({ args }) => {

return extractToolSend(args, "sendMessage");

},

handleAction: async ({ action, params, cfg, accountId, mediaLocalRoots, toolContext }) => {

handleAction: async ({

action,

params,

cfg,

accountId,

mediaLocalRoots,

sessionKey,

toolContext,

}) => {

const telegramAction = resolveTelegramMessageActionName(action);

if (!telegramAction) {

throw new Error(`Unsupported Telegram action: ${action}`);

: {}),

},

cfg,

{ mediaLocalRoots },

{ mediaLocalRoots, sessionKey },

);

},

};

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

import {

beginTelegramInboundTurnDeliveryCorrelation,

notifyTelegramInboundTurnOutboundSuccess,

} from "./inbound-turn-delivery.js";

describe("telegram inbound turn delivery", () => {

it("marks delivered once for a matching outbound send then clears correlation", () => {

let count = 0;

const end = beginTelegramInboundTurnDeliveryCorrelation("sess:z", {

outboundTo: "999",

outboundAccountId: "a1",

markInboundTurnDelivered: () => {

count += 1;

},

});

notifyTelegramInboundTurnOutboundSuccess({

sessionKey: "sess:z",

to: "999",

accountId: "a1",

});

expect(count).toBe(1);

end();

notifyTelegramInboundTurnOutboundSuccess({

sessionKey: "sess:z",

to: "999",

accountId: "a1",

});

expect(count).toBe(1);

});

it("ignores outbound sends to another destination", () => {

let count = 0;

const end = beginTelegramInboundTurnDeliveryCorrelation("sess:y", {

outboundTo: "1",

markInboundTurnDelivered: () => {

count += 1;

},

});

notifyTelegramInboundTurnOutboundSuccess({

sessionKey: "sess:y",

to: "2",

accountId: undefined,

});

expect(count).toBe(0);

end();

});

});

export type TelegramInboundTurnDeliveryEnd = () => void;

type ActiveTurn = {

outboundTo: string;

outboundAccountId?: string;

markInboundTurnDelivered: () => void;

};

const registry = new Map<string, ActiveTurn>();

export function beginTelegramInboundTurnDeliveryCorrelation(

sessionKey: string | undefined,

turn: ActiveTurn,

): TelegramInboundTurnDeliveryEnd {

const key = sessionKey?.trim();

if (!key) {

return () => {};

}

registry.set(key, turn);

return () => {

registry.delete(key);

};

}

export function notifyTelegramInboundTurnOutboundSuccess(params: {

sessionKey: string | undefined;

to: string;

accountId?: string | null;

}): void {

const key = params.sessionKey?.trim();

if (!key) {

return;

}

const turn = registry.get(key);

if (!turn || turn.outboundTo !== params.to) {

return;

}

if (turn.outboundAccountId && params.accountId && params.accountId !== turn.outboundAccountId) {

return;

}

turn.markInboundTurnDelivered();

}