}

return results;

}

export function resolveAcpInlineImageAttachments(

images: Array<{ data: string; mimeType: string }> | undefined,

): AcpTurnAttachment[] {

if (!Array.isArray(images)) {

return [];

}

return images

.map((image) => ({

mediaType: image.mimeType,

data: image.data,

}))

.filter((image) => image.mediaType.startsWith("image/") && image.data.trim().length > 0);

}

);

});

it("mirrors routed ACP replies into the target ACP session", async () => {

const coordinator = createAcpDispatchDeliveryCoordinator({

cfg: createAcpTestConfig(),

ctx: buildTestCtx({

Provider: "visiblechat",

Surface: "visiblechat",

SessionKey: "agent:main:main",

}),

dispatcher: createDispatcher(),

inboundAudio: false,

sessionKey: "agent:claude:acp:spawned",

shouldRouteToOriginating: true,

originatingChannel: "visiblechat",

originatingTo: "channel:thread-1",

});

await coordinator.deliver("block", { text: "hello" }, { skipTts: true });

expect(deliveryMocks.routeReply).toHaveBeenCalledWith(

expect.objectContaining({

sessionKey: "agent:claude:acp:spawned",

policySessionKey: "agent:main:main",

}),

);

});

it("routes ACP replies when cfg.channels is missing", async () => {

await expectVisibleChatBlockRoutesToAccount({} as OpenClawConfig, undefined);

});

ctx: FinalizedMsgContext;

dispatcher: ReplyDispatcher;

inboundAudio: boolean;

sessionKey?: string;

sessionTtsAuto?: TtsAutoMode;

ttsChannel?: string;

suppressUserDelivery?: boolean;

};

const directChannel = normalizeOptionalLowercaseString(params.ctx.Provider ?? params.ctx.Surface);

const routedChannel = normalizeOptionalLowercaseString(params.originatingChannel);

const deliverySessionKey = normalizeOptionalString(params.sessionKey) ?? params.ctx.SessionKey;

const explicitAccountId = normalizeOptionalString(params.ctx.AccountId);

const resolvedAccountId =

explicitAccountId ??

payload: ttsPayload,

channel: params.originatingChannel,

to: params.originatingTo,

sessionKey: params.ctx.SessionKey,

sessionKey: deliverySessionKey,

...(deliverySessionKey !== params.ctx.SessionKey

? { policySessionKey: params.ctx.SessionKey }

: {}),

accountId: resolvedAccountId,

requesterSenderId: params.ctx.SenderId,

requesterSenderName: params.ctx.SenderName,

import type { SessionBindingRecord } from "../../infra/outbound/session-binding-service.js";

import type { MediaUnderstandingSkipError } from "../../media-understanding/errors.js";

import { withFetchPreconnect } from "../../test-utils/fetch-mock.js";

import { resolveAcpAttachments } from "./dispatch-acp-attachments.js";

import {

resolveAcpAttachments,

resolveAcpInlineImageAttachments,

} from "./dispatch-acp-attachments.js";

import { tryDispatchAcpReply } from "./dispatch-acp.js";

import type { ReplyDispatcher } from "./reply-dispatcher.js";

import { buildTestCtx } from "./test-ctx.js";

originatingChannel?: string;

originatingTo?: string;

onReplyStart?: () => void;

images?: Array<{ data: string; mimeType: string }>;

ctxOverrides?: Record<string, unknown>;

sessionKeyOverride?: string;

}) {

cfg: params.cfg ?? createAcpTestConfig(),

dispatcher: params.dispatcher ?? createDispatcher().dispatcher,

sessionKey: targetSessionKey,

images: params.images,

inboundAudio: false,

shouldRouteToOriginating: params.shouldRouteToOriginating ?? false,

...(params.shouldRouteToOriginating

}

});

it("forwards chat.send inline image attachments into ACP turns", async () => {

setReadyAcpResolution();

const image = {

mimeType: "image/png",

data: Buffer.from("image-bytes").toString("base64"),

};

expect(resolveAcpInlineImageAttachments([image])).toEqual([

{

mediaType: "image/png",

data: image.data,

},

]);

await runDispatch({

bodyForAgent: "describe image",

images: [image],

});

expect(managerMocks.runTurn).toHaveBeenCalledWith(

expect.objectContaining({

text: "describe image",

attachments: [

{

mediaType: "image/png",

data: image.data,

},

],

}),

);

});

it("skips ACP attachments outside allowed inbound roots", async () => {

setReadyAcpResolution();

const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dispatch-acp-"));

import { resolveConfiguredTtsMode } from "../../tts/tts-config.js";

import type { FinalizedMsgContext } from "../templating.js";

import { createAcpReplyProjector } from "./acp-projector.js";

import { loadDispatchAcpMediaRuntime, resolveAcpAttachments } from "./dispatch-acp-attachments.js";

import {

loadDispatchAcpMediaRuntime,

resolveAcpAttachments,

resolveAcpInlineImageAttachments,

} from "./dispatch-acp-attachments.js";

import {

createAcpDispatchDeliveryCoordinator,

type AcpDispatchDeliveryCoordinator,

dispatcher: ReplyDispatcher;

runId?: string;

sessionKey?: string;

images?: Array<{ data: string; mimeType: string }>;

abortSignal?: AbortSignal;

inboundAudio: boolean;

sessionTtsAuto?: TtsAutoMode;

ctx: params.ctx,

dispatcher: params.dispatcher,

inboundAudio: params.inboundAudio,

sessionKey: canonicalSessionKey,

sessionTtsAuto: params.sessionTtsAuto,

ttsChannel: params.ttsChannel,

suppressUserDelivery: params.suppressUserDelivery,

}

const promptText = resolveAcpPromptText(params.ctx);

const attachments = hasInboundMedia(params.ctx)

const mediaAttachments = hasInboundMedia(params.ctx)

? await resolveAcpAttachments({ ctx: params.ctx, cfg: params.cfg })

: [];

const attachments =

mediaAttachments.length > 0

? mediaAttachments

: resolveAcpInlineImageAttachments(params.images);

if (!promptText && attachments.length === 0) {

const counts = params.dispatcher.getQueuedCounts();

delivery.applyRoutedCounts(counts);

ctx,

runId: params.replyOptions?.runId,

sessionKey: acpDispatchSessionKey,

images: params.replyOptions?.images,

inboundAudio,

sessionTtsAuto,

ttsChannel,

ctx,

runId: params.replyOptions?.runId,

sessionKey: acpDispatchSessionKey,

images: params.replyOptions?.images,

inboundAudio,

sessionTtsAuto,

ttsChannel,

agentAccountId: "bot-account",

});

});

it("passes queued images into queued embedded followup runs", async () => {

runEmbeddedPiAgentMock.mockResolvedValueOnce({

payloads: [],

meta: {},

});

const images = [{ type: "image" as const, data: "base64-cat", mimeType: "image/png" }];

const imageOrder = ["inline" as const];

const runner = createFollowupRunner({

typing: createMockTypingController(),

typingMode: "instant",

defaultModel: "openai/gpt-5.4",

opts: {

images: [{ type: "image", data: "fallback", mimeType: "image/png" }],

imageOrder: ["inline"],

},

});

await runner(

createQueuedRun({

images,

imageOrder,

}),

);

const call = runEmbeddedPiAgentMock.mock.calls.at(-1)?.[0] as

| {

images?: unknown;

imageOrder?: unknown;

}

| undefined;

expect(call?.images).toBe(images);

expect(call?.imageOrder).toBe(imageOrder);

});

});

describe("createFollowupRunner compaction", () => {

};

return async (queued: FollowupRun) => {

const queuedImages = queued.images ?? opts?.images;

const queuedImageOrder = queued.imageOrder ?? opts?.imageOrder;

queued.run.config = await resolveQueuedReplyExecutionConfig(queued.run.config, {

originatingChannel: queued.originatingChannel,

messageProvider: queued.run.messageProvider,

bashElevated: run.bashElevated,

timeoutMs: run.timeoutMs,

runId,

images: queuedImages,

imageOrder: queuedImageOrder,

allowTransientCooldownProbe: runOptions?.allowTransientCooldownProbe,

blockReplyBreak: run.blockReplyBreak,

bootstrapPromptWarningSignaturesSeen,

messageId: sessionCtx.MessageSidFull ?? sessionCtx.MessageSid,

summaryLine: baseBodyTrimmedRaw,

enqueuedAt: Date.now(),

images: opts?.images,

imageOrder: opts?.imageOrder,

// Originating channel for reply routing.

originatingChannel: ctx.OriginatingChannel,

originatingTo: ctx.OriginatingTo,

expect(calls[0]?.originatingTo).toBe("channel:A");

});

it("carries image payloads across collected batches", async () => {

const key = `test-collect-images-${Date.now()}`;

const calls: FollowupRun[] = [];

const done = createDeferred<void>();

const runFollowup = async (run: FollowupRun) => {

calls.push(run);

done.resolve();

};

const settings: QueueSettings = {

mode: "collect",

debounceMs: 0,

cap: 50,

dropPolicy: "summarize",

};

const firstImage = { type: "image" as const, data: "first", mimeType: "image/png" };

const secondImage = { type: "image" as const, data: "second", mimeType: "image/png" };

enqueueFollowupRun(

key,

{

...createRun({

prompt: "one",

originatingChannel: "slack",

originatingTo: "channel:A",

}),

images: [firstImage],

imageOrder: ["inline"],

},

settings,

);

enqueueFollowupRun(

key,

{

...createRun({

prompt: "two",

originatingChannel: "slack",

originatingTo: "channel:A",

}),

images: [secondImage],

imageOrder: ["inline"],

},

settings,

);

scheduleFollowupDrain(key, runFollowup);

await done.promise;

expect(calls[0]?.images).toEqual([firstImage, secondImage]);

expect(calls[0]?.imageOrder).toEqual(["inline", "inline"]);

});

it("splits collect batches when sender authorization changes", async () => {

const key = `test-collect-auth-split-${Date.now()}`;

const calls: FollowupRun[] = [];