internalStreamError?: boolean;

};

// Placeholder user text for an image-only turn. The agent command requires a

// non-empty message even when the real payload is the attached image, so both

// the /v1/chat/completions and /v1/responses prompt builders substitute this

// for the active user turn. Keep it shared so the two endpoints stay in sync.

export const IMAGE_ONLY_USER_MESSAGE = "User sent image(s) with no text.";

/**

* Coerce body to string. Handles cases where body is a content array

* (e.g. [{type:"text", text:"hello"}]) that would serialize as

import {

buildAgentMessageFromConversationEntries,

type ConversationEntry,

IMAGE_ONLY_USER_MESSAGE,

} from "./agent-prompt.js";

import type { AuthRateLimiter } from "./auth-rate-limit.js";

import type { ResolvedGatewayAuth } from "./auth.js";

};

const DEFAULT_OPENAI_CHAT_COMPLETIONS_BODY_BYTES = 20 * 1024 * 1024;

const IMAGE_ONLY_USER_MESSAGE = "User sent image(s) with no text.";

const DEFAULT_OPENAI_MAX_IMAGE_PARTS = 8;

const DEFAULT_OPENAI_MAX_TOTAL_IMAGE_BYTES = 20 * 1024 * 1024;

const DEFAULT_OPENAI_IMAGE_LIMITS: InputImageLimits = {

import { CURRENT_MESSAGE_MARKER } from "../auto-reply/reply/mentions.js";

import { resetConfigRuntimeState } from "../config/config.js";

import { emitAgentEvent } from "../infra/agent-events.js";

import { IMAGE_ONLY_USER_MESSAGE } from "./agent-prompt.js";

import { buildAssistantDeltaResult } from "./test-helpers.agent-results.js";

import {

agentCommand,

expect(agentCommand).not.toHaveBeenCalled();

});

it("accepts image-only input without text, matching /v1/chat/completions", async () => {

const port = enabledPort;

// 1x1 PNG; same fixture used by the parity schema tests.

const pngBase64 =

"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";

agentCommand.mockClear();

agentCommand.mockResolvedValueOnce({ payloads: [{ text: "ok" }] } as never);

const res = await postResponses(port, {

model: "openclaw",

input: [

{

type: "message",

role: "user",

content: [

{

type: "input_image",

source: { type: "base64", media_type: "image/png", data: pngBase64 },

},

],

},

],

});

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

expect(agentCommand).toHaveBeenCalledTimes(1);

const opts = firstAgentOpts();

// Image-only turn carries a non-empty placeholder so the agent command runs,

// with the real image attached via `images` (parity with /v1/chat/completions).

expect((opts as { message?: string }).message ?? "").toBe(IMAGE_ONLY_USER_MESSAGE);

expect((opts as { images?: unknown[] }).images?.length).toBe(1);

await ensureResponseConsumed(res);

});

it("still rejects input with neither text nor image", async () => {

const port = enabledPort;

agentCommand.mockClear();

const res = await postResponses(port, {

model: "openclaw",

input: [{ type: "message", role: "user", content: [] }],

});

await expectInvalidRequest(res, /Missing user message/i);

expect(agentCommand).not.toHaveBeenCalled();

});

it("enforces URL allowlist and URL part cap for responses inputs", async () => {

const allowlistConfig = buildResponsesUrlPolicyConfig(1);

await writeGatewayConfig(allowlistConfig);

*/

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

import { IMAGE_ONLY_USER_MESSAGE } from "./agent-prompt.js";

import { wrapUntrustedFileContent } from "./openresponses-file-content.js";

let InputImageContentPartSchema: typeof import("./open-responses.schema.js").InputImageContentPartSchema;

expect(result.message).toContain("72°F");

expect(result.message).toContain("Thanks");

});

it("substitutes a placeholder for an image-only active user turn", () => {

const result = buildAgentPrompt([

{

type: "message" as const,

role: "user" as const,

content: [

{

type: "input_image" as const,

source: { type: "url" as const, url: "https://example.com/cat.png" },

},

],

},

]);

expect(result.message).toBe(IMAGE_ONLY_USER_MESSAGE);

});

it("keeps an empty message when the active turn has neither text nor image", () => {

const result = buildAgentPrompt([

{ type: "message" as const, role: "user" as const, content: [] },

]);

expect(result.message).toBe("");

});

});

describe("input_file hardening", () => {

import {

buildAgentMessageFromConversationEntries,

type ConversationEntry,

IMAGE_ONLY_USER_MESSAGE,

} from "./agent-prompt.js";

import type { ContentPart, ItemParam } from "./open-responses.schema.js";

.join("\n");

}

function hasImageContent(content: string | ContentPart[]): boolean {

return typeof content !== "string" && content.some((part) => part.type === "input_image");

}

/** Index of the last user message item, or -1 when there is none. */

function findActiveUserMessageIndex(input: ItemParam[]): number {

for (let i = input.length - 1; i >= 0; i -= 1) {

const item = input[i];

if (item?.type === "message" && item.role === "user") {

return i;

}

}

return -1;

}

/** Build the user message and optional system prompt from Responses API input. */

export function buildAgentPrompt(input: string | ItemParam[]): {

message: string;

const systemParts: string[] = [];

const conversationEntries: ConversationEntry[] = [];

const activeUserMessageIndex = findActiveUserMessageIndex(input);

for (const item of input) {

for (const [i, item] of input.entries()) {

if (item.type === "message") {

const content = extractTextContent(item.content).trim();

if (!content) {

// Substitute a placeholder for an image-only active user turn so the turn

// is not dropped and the downstream agent command (which requires non-empty

// message text) still runs with the attached image, matching /v1/chat/completions.

// Historical image-only turns stay skipped because their bytes are not replayed.

const body =

content ||

(item.role === "user" && i === activeUserMessageIndex && hasImageContent(item.content)

? IMAGE_ONLY_USER_MESSAGE

: "");

if (!body) {

continue;

}

if (item.role === "system" || item.role === "developer") {

systemParts.push(content);

systemParts.push(body);

continue;

}

conversationEntries.push({

role: normalizedRole,

entry: { sender, body: content },

entry: { sender, body },

});

} else if (item.type === "function_call_output") {

conversationEntries.push({