expect(payload.output?.[0]?.content?.[0]?.text).toBe("fresh-marker-ok");

});

it("keeps stale consecutive image prompts from overriding later marker turns", async () => {

const server = await startMockServer();

const response = await fetch(`${server.baseUrl}/v1/responses`, {

method: "POST",

headers: { "content-type": "application/json" },

body: JSON.stringify({

stream: false,

model: "mock-openai/gpt-5.5",

input: [

{

role: "user",

content: [

{

type: "input_text",

text: "Image understanding check: describe the top and bottom colors.",

},

{

type: "input_image",

source: {

type: "base64",

mime_type: "image/png",

data: QA_IMAGE_PNG_BASE64,

},

},

],

},

makeUserInput("Marker exact marker: `fresh-consecutive-marker-ok`"),

],

}),

});

expect(response.status).toBe(200);

const payload = (await response.json()) as {

output?: Array<{ content?: Array<{ text?: string }> }>;

};

expect(payload.output?.[0]?.content?.[0]?.text).toBe("fresh-consecutive-marker-ok");

});

it("handles deeply nested image input shapes without recursive traversal failure", async () => {

const server = await startQaMockOpenAiServer({

host: "127.0.0.1",

return { text: "", imageInputCount: 0 };

}

let startIndex = latestUserIndex;

while (

startIndex > 0 &&

input[startIndex - 1]?.role === "user" &&

Array.isArray(input[startIndex - 1]?.content)

) {

startIndex -= 1;

const latestUserItem = input[latestUserIndex];

if (!latestUserItem) {

return { text: "", imageInputCount: 0 };

}

const imageTurnItems = input.slice(startIndex, latestUserIndex + 1);

const imageTurnItems = [latestUserItem];

const imageInputCount = countImageInputs(imageTurnItems.map((item) => item.content));

if (imageInputCount === 0) {

return { text: "", imageInputCount: 0 };

);

});

it("does not raw-send channel completions just because the requester key is direct", async () => {

const callGateway = createGatewayMock({

result: {

payloads: [],

},

});

const sendMessage = createSendMessageMock();

const result = await deliverSlackChannelAnnouncement({

callGateway,

sendMessage,

sessionId: "requester-session-channel",

isActive: false,

expectsCompletionMessage: true,

directIdempotencyKey: "announce-channel-direct-key-empty",

requesterSessionKey: "agent:main:discord:dm:U123",

internalEvents: [

{

type: "task_completion",

source: "subagent",

childSessionKey: "agent:worker:subagent:child",

childSessionId: "child-session-id",

announceType: "subagent task",

taskLabel: "channel completion smoke",

status: "ok",

statusLabel: "completed successfully",

result: "child completion output",

replyInstruction: "Summarize the result.",

},

],

});

expectRecordFields(result, {

delivered: true,

path: "direct",

});

expectGatewayAgentParams(callGateway, {

deliver: true,

channel: "slack",

accountId: "acct-1",

to: "channel:C123",

});

expect(sendMessage).not.toHaveBeenCalled();

});

it("directly delivers direct-message subagent text when the announce agent returns incomplete", async () => {

const callGateway = vi.fn(async () => {

throw new Error(

if (target.threadId) {

return false;

}

if (deriveSessionChatTypeFromKey(requesterSessionKey) === "direct") {

return true;

const targetChatType = inferDeliveryTargetChatType(target);

if (targetChatType) {

return targetChatType === "direct";

}

return inferDeliveryTargetChatType(target) === "direct";

return deriveSessionChatTypeFromKey(requesterSessionKey) === "direct";

}

function resolveTextCompletionDirectFallback(events: readonly AgentInternalEvent[] | undefined) {