qlogicagent 2.13.4 → 2.13.5

package/dist/orchestration/tool-loop/tool-choice-policy.js

@@ -0,0 +1,164 @@
+function resolveToolName(tool) {
+    if (tool.function && typeof tool.function === "object" && typeof tool.function.name === "string") {
+        return tool.function.name.trim();
+    }
+    if (typeof tool.name === "string") {
+        return tool.name.trim();
+    }
+    return "";
+}
+function isEligibleStatus(status) {
+    return status === "enabled-eligible" || status === "installed-awaiting-approval";
+}
+function buildEligibilityMap(eligibility) {
+    return new Map((eligibility ?? []).map((entry) => [entry.toolName, entry]));
+}
+export function filterEligibleTools(params) {
+    if (!params.eligibility?.length) {
+        return [...params.tools];
+    }
+    const eligibilityMap = buildEligibilityMap(params.eligibility);
+    return params.tools.filter((tool) => {
+        const name = resolveToolName(tool);
+        if (!name) {
+            return false;
+        }
+        const eligibility = eligibilityMap.get(name);
+        return !eligibility || isEligibleStatus(eligibility.status);
+    });
+}
+export function normalizeAnthropicFunctionToolDefinition(tool) {
+    if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+        return undefined;
+    }
+    const toolRecord = tool;
+    if (toolRecord.function && typeof toolRecord.function === "object") {
+        return toolRecord;
+    }
+    const name = typeof toolRecord.name === "string" ? toolRecord.name.trim() : "";
+    if (!name) {
+        return toolRecord;
+    }
+    const functionSpec = {
+        name,
+        parameters: toolRecord.input_schema && typeof toolRecord.input_schema === "object"
+            ? toolRecord.input_schema
+            : toolRecord.parameters && typeof toolRecord.parameters === "object"
+                ? toolRecord.parameters
+                : { type: "object", properties: {} },
+    };
+    if (typeof toolRecord.description === "string" && toolRecord.description.trim()) {
+        functionSpec.description = toolRecord.description;
+    }
+    if (typeof toolRecord.strict === "boolean") {
+        functionSpec.strict = toolRecord.strict;
+    }
+    return {
+        type: "function",
+        function: functionSpec,
+    };
+}
+export function normalizeAnthropicToolChoice(toolChoice) {
+    if (!toolChoice || typeof toolChoice !== "object" || Array.isArray(toolChoice)) {
+        return toolChoice;
+    }
+    const choice = toolChoice;
+    if (choice.type === "auto") {
+        return "auto";
+    }
+    if (choice.type === "none") {
+        return "none";
+    }
+    if (choice.type === "required" || choice.type === "any") {
+        return "required";
+    }
+    if (choice.type === "tool" && typeof choice.name === "string" && choice.name.trim()) {
+        return {
+            type: "function",
+            function: { name: choice.name.trim() },
+        };
+    }
+    return toolChoice;
+}
+export function applyToolChoiceCompatibility(params) {
+    const warnings = [];
+    const compatibility = params.compatibility ?? {};
+    let normalizedToolChoice = params.toolChoice;
+    if (params.thinkingEnabled && compatibility.requireAutoWhenThinking) {
+        const type = typeof normalizedToolChoice === "object" && normalizedToolChoice && !Array.isArray(normalizedToolChoice)
+            ? String(normalizedToolChoice.type ?? "")
+            : normalizedToolChoice;
+        if (type && type !== "auto" && type !== "none") {
+            warnings.push("tool_choice downgraded to auto because thinking mode requires auto/none compatibility.");
+            normalizedToolChoice = "auto";
+        }
+    }
+    if (normalizedToolChoice === "required" && compatibility.allowRequiredToolChoice === false) {
+        const fallback = compatibility.requiredFallback ?? "auto";
+        warnings.push(`tool_choice=required is not supported by this provider; downgraded to ${fallback}.`);
+        normalizedToolChoice = fallback;
+    }
+    if (normalizedToolChoice
+        && typeof normalizedToolChoice === "object"
+        && !Array.isArray(normalizedToolChoice)
+        && normalizedToolChoice.type === "function"
+        && compatibility.allowNamedToolChoice === false) {
+        const fallback = compatibility.namedFallback ?? "required";
+        warnings.push(`named tool_choice is not supported by this provider; downgraded to ${fallback}.`);
+        normalizedToolChoice = fallback;
+    }
+    return { normalizedToolChoice, warnings };
+}
+export function applyToolChoicePolicy(params) {
+    const compatibilityResult = applyToolChoiceCompatibility({
+        toolChoice: params.toolChoice,
+        thinkingEnabled: params.thinkingEnabled,
+        compatibility: params.compatibility,
+    });
+    const toolChoice = compatibilityResult.normalizedToolChoice;
+    const warnings = [...compatibilityResult.warnings];
+    const tools = filterEligibleTools({
+        tools: params.tools,
+        eligibility: params.eligibility,
+    });
+    if (!toolChoice || toolChoice === "auto") {
+        return { tools, normalizedToolChoice: toolChoice, warnings };
+    }
+    if (toolChoice === "none") {
+        return { tools: [], normalizedToolChoice: "none", warnings };
+    }
+    if (toolChoice === "required") {
+        if (tools.length === 0) {
+            throw new Error("tool_choice=required but no tools were provided");
+        }
+        return {
+            tools,
+            normalizedToolChoice: "required",
+            extraSystemPrompt: "You must call one of the available tools before responding.",
+            warnings,
+        };
+    }
+    if (typeof toolChoice === "object" && !Array.isArray(toolChoice) && toolChoice.type === "function") {
+        const functionChoice = (toolChoice.function ?? undefined);
+        const targetName = typeof functionChoice?.name === "string"
+            ? functionChoice.name.trim()
+            : "";
+        if (!targetName) {
+            throw new Error("tool_choice.function.name is required");
+        }
+        const matchedTools = tools.filter((tool) => resolveToolName(tool) === targetName);
+        if (matchedTools.length === 0) {
+            throw new Error(`tool_choice requested unknown tool: ${targetName}`);
+        }
+        return {
+            tools: matchedTools,
+            normalizedToolChoice: {
+                type: "function",
+                function: { name: targetName },
+            },
+            extraSystemPrompt: `You must call the ${targetName} tool before responding.`,
+            warnings,
+        };
+    }
+    return { tools, normalizedToolChoice: toolChoice, warnings };
+}

package/dist/orchestration/tool-loop/tool-loop-state.d.ts

@@ -0,0 +1,50 @@
+import { type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiResponsesItemLike } from "./conversation-repair.js";
+export interface ToolLoopState<TMessage = unknown> {
+    round: number;
+    maxRounds: number;
+    pendingToolCallIds: string[];
+    completedToolCallIds: string[];
+    lastStopReason?: string;
+    replayMessages: TMessage[];
+}
+export interface ToolLoopRepairAction {
+    kind: "strip-forced-stop-tool-metadata" | "inject-placeholder-tool-result" | "drop-orphan-tool-result" | "rewrite-openai-function-call-pair" | "drop-trailing-reasoning";
+    detail?: string;
+}
+export interface RepairToolLoopStateResult<TMessage> {
+    state: ToolLoopState<TMessage>;
+    recoveryActions: ToolLoopRepairAction[];
+}
+export declare function createToolLoopState<TMessage>(params: {
+    maxRounds: number;
+    replayMessages?: readonly TMessage[];
+    round?: number;
+    pendingToolCallIds?: readonly string[];
+    completedToolCallIds?: readonly string[];
+    lastStopReason?: string;
+}): ToolLoopState<TMessage>;
+export declare function advanceToolLoopState<TMessage>(state: ToolLoopState<TMessage>, params: {
+    replayMessages?: readonly TMessage[];
+    pendingToolCallIds?: readonly string[];
+    completedToolCallIds?: readonly string[];
+    lastStopReason?: string;
+}): ToolLoopState<TMessage>;
+export declare function settleToolLoopState<TMessage>(state: ToolLoopState<TMessage>, params: {
+    replayMessages?: readonly TMessage[];
+    completedToolCallIds?: readonly string[];
+    lastStopReason?: string;
+}): ToolLoopState<TMessage>;
+export declare function recoverToolLoopStateFromChatConversation<TMessage extends OpenAiChatMessageLike>(params: {
+    maxRounds: number;
+    replayMessages: readonly TMessage[];
+    round?: number;
+    lastStopReason?: string;
+    options?: ConversationRepairOptions;
+}): RepairToolLoopStateResult<TMessage>;
+export declare function recoverToolLoopStateFromResponsesItems<TItem extends OpenAiResponsesItemLike>(params: {
+    maxRounds: number;
+    replayItems: readonly TItem[];
+    round?: number;
+    lastStopReason?: string;
+    options?: ConversationRepairOptions;
+}): RepairToolLoopStateResult<TItem>;

package/dist/orchestration/tool-loop/tool-loop-state.js

@@ -0,0 +1,133 @@
+import { injectDanglingToolCallPlaceholders, repairOpenAiResponsesItems, stripForcedStopAssistantToolMetadata, sanitizeOpenAiChatMessages, } from "./conversation-repair.js";
+function collectChatPendingToolCallIds(messages) {
+    const called = new Set();
+    const completed = new Set();
+    for (const message of messages) {
+        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+            for (const toolCall of message.tool_calls) {
+                if (typeof toolCall.id === "string" && toolCall.id) {
+                    called.add(toolCall.id);
+                }
+            }
+        }
+        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
+            completed.add(message.tool_call_id);
+        }
+    }
+    return [...called].filter((callId) => !completed.has(callId));
+}
+function collectChatCompletedToolCallIds(messages) {
+    const completed = new Set();
+    for (const message of messages) {
+        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
+            completed.add(message.tool_call_id);
+        }
+    }
+    return [...completed];
+}
+function collectResponsesPendingToolCallIds(items) {
+    const called = new Set();
+    const completed = new Set();
+    for (const item of items) {
+        if (item.type === "function_call") {
+            const callId = typeof item.call_id === "string" && item.call_id
+                ? item.call_id
+                : typeof item.id === "string"
+                    ? item.id
+                    : "";
+            if (callId) {
+                called.add(callId);
+            }
+        }
+        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
+            completed.add(item.call_id);
+        }
+    }
+    return [...called].filter((callId) => !completed.has(callId));
+}
+function collectResponsesCompletedToolCallIds(items) {
+    const completed = new Set();
+    for (const item of items) {
+        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
+            completed.add(item.call_id);
+        }
+    }
+    return [...completed];
+}
+export function createToolLoopState(params) {
+    return {
+        round: params.round ?? 0,
+        maxRounds: params.maxRounds,
+        pendingToolCallIds: [...(params.pendingToolCallIds ?? [])],
+        completedToolCallIds: [...(params.completedToolCallIds ?? [])],
+        lastStopReason: params.lastStopReason,
+        replayMessages: [...(params.replayMessages ?? [])],
+    };
+}
+export function advanceToolLoopState(state, params) {
+    return {
+        round: state.round + 1,
+        maxRounds: state.maxRounds,
+        pendingToolCallIds: [...(params.pendingToolCallIds ?? state.pendingToolCallIds)],
+        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
+        lastStopReason: params.lastStopReason ?? state.lastStopReason,
+        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
+    };
+}
+export function settleToolLoopState(state, params) {
+    return {
+        round: state.round,
+        maxRounds: state.maxRounds,
+        pendingToolCallIds: [],
+        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
+        lastStopReason: params.lastStopReason ?? state.lastStopReason,
+        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
+    };
+}
+export function recoverToolLoopStateFromChatConversation(params) {
+    const recoveryActions = [];
+    const sanitizedMessages = sanitizeOpenAiChatMessages(params.replayMessages);
+    if (sanitizedMessages.length !== params.replayMessages.length) {
+        recoveryActions.push({ kind: "drop-orphan-tool-result", detail: "Removed orphan tool results or invalid assistant tool calls." });
+    }
+    const strippedMessages = stripForcedStopAssistantToolMetadata(sanitizedMessages, params.options);
+    if (strippedMessages.some((message, index) => message !== sanitizedMessages[index])) {
+        recoveryActions.push({ kind: "strip-forced-stop-tool-metadata", detail: "Removed assistant tool-call metadata after forced stop." });
+    }
+    const repairedMessages = injectDanglingToolCallPlaceholders(strippedMessages, params.options);
+    if (repairedMessages.length > strippedMessages.length) {
+        recoveryActions.push({ kind: "inject-placeholder-tool-result", detail: "Injected placeholder tool result for pending tool calls." });
+    }
+    return {
+        state: createToolLoopState({
+            maxRounds: params.maxRounds,
+            round: params.round,
+            lastStopReason: params.lastStopReason,
+            replayMessages: repairedMessages,
+            pendingToolCallIds: collectChatPendingToolCallIds(repairedMessages),
+            completedToolCallIds: collectChatCompletedToolCallIds(repairedMessages),
+        }),
+        recoveryActions,
+    };
+}
+export function recoverToolLoopStateFromResponsesItems(params) {
+    const repairedItems = repairOpenAiResponsesItems(params.replayItems, params.options);
+    const recoveryActions = [];
+    if (repairedItems.length !== params.replayItems.length) {
+        recoveryActions.push({ kind: "drop-trailing-reasoning", detail: "Dropped dangling reasoning blocks or injected missing function_call_output items." });
+    }
+    if (repairedItems.some((item, index) => item !== params.replayItems[index] && item.type === "function_call")) {
+        recoveryActions.push({ kind: "rewrite-openai-function-call-pair", detail: "Rewrote OpenAI function_call pairing ids for replay compatibility." });
+    }
+    return {
+        state: createToolLoopState({
+            maxRounds: params.maxRounds,
+            round: params.round,
+            lastStopReason: params.lastStopReason,
+            replayMessages: repairedItems,
+            pendingToolCallIds: collectResponsesPendingToolCallIds(repairedItems),
+            completedToolCallIds: collectResponsesCompletedToolCallIds(repairedItems),
+        }),
+        recoveryActions,
+    };
+}

package/dist/orchestration/tool-loop/tool-schema.d.ts

@@ -0,0 +1,46 @@
+import type { OpenAiToolCall } from "./conversation-repair.js";
+export type ToolSchemaProvider = {
+    modelProvider?: string;
+    modelId?: string;
+    cleanSchema?: (schema: Record<string, unknown>, context: {
+        modelProvider?: string;
+        modelId?: string;
+    }) => Record<string, unknown>;
+};
+export interface FunctionToolSource {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+}
+export interface FunctionToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface CapabilityToolManifestLike {
+    name: string;
+    description?: string;
+    requiredParameters?: string[];
+}
+export declare function normalizeFunctionToolParameters(parameters: Record<string, unknown> | undefined, options?: ToolSchemaProvider): Record<string, unknown>;
+export declare function convertFunctionTools(tools: readonly FunctionToolSource[], options?: ToolSchemaProvider): FunctionToolDefinition[];
+export declare function convertCapabilityToolManifestsToFunctionTools(tools: readonly CapabilityToolManifestLike[]): FunctionToolDefinition[];
+export declare function normalizeMessageTextContent(content: unknown): string;
+export declare function parseOpenAiToolCallsFromChatResponse(responseBody: string): {
+    toolCalls: OpenAiToolCall[];
+    responseText: string;
+};
+export declare function buildAssistantToolCallMessage(toolCalls: OpenAiToolCall[], text?: string, thinkingBlocks?: Array<{
+    thinking: string;
+    signature: string;
+}>, reasoningContent?: string): Record<string, unknown>;
+export declare function buildToolResultMessage(callId: string, result: {
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+    toolReferences?: string[];
+    imageUrls?: string[];
+}): Record<string, unknown>;

package/dist/orchestration/tool-loop/tool-schema.js

@@ -0,0 +1,208 @@
+function extractEnumValues(schema) {
+    if (!schema || typeof schema !== "object") {
+        return undefined;
+    }
+    const record = schema;
+    if (Array.isArray(record.enum)) {
+        return record.enum;
+    }
+    if ("const" in record) {
+        return [record.const];
+    }
+    const variants = Array.isArray(record.anyOf)
+        ? record.anyOf
+        : Array.isArray(record.oneOf)
+            ? record.oneOf
+            : null;
+    if (!variants) {
+        return undefined;
+    }
+    const values = variants.flatMap((variant) => extractEnumValues(variant) ?? []);
+    return values.length > 0 ? values : undefined;
+}
+function mergePropertySchemas(existing, incoming) {
+    if (!existing)
+        return incoming;
+    if (!incoming)
+        return existing;
+    const existingEnum = extractEnumValues(existing);
+    const incomingEnum = extractEnumValues(incoming);
+    if (!existingEnum && !incomingEnum) {
+        return existing;
+    }
+    const values = Array.from(new Set([...(existingEnum ?? []), ...(incomingEnum ?? [])]));
+    const merged = {};
+    for (const source of [existing, incoming]) {
+        if (!source || typeof source !== "object") {
+            continue;
+        }
+        const record = source;
+        for (const key of ["title", "description", "default"]) {
+            if (!(key in merged) && key in record) {
+                merged[key] = record[key];
+            }
+        }
+    }
+    const types = new Set(values.map((value) => typeof value));
+    if (types.size === 1) {
+        merged.type = Array.from(types)[0];
+    }
+    merged.enum = values;
+    return merged;
+}
+export function normalizeFunctionToolParameters(parameters, options) {
+    const schema = parameters && typeof parameters === "object" ? parameters : { type: "object", properties: {}, additionalProperties: true };
+    const applyProviderCleaning = (nextSchema) => {
+        return options?.cleanSchema?.(nextSchema, {
+            modelProvider: options.modelProvider,
+            modelId: options.modelId,
+        }) ?? nextSchema;
+    };
+    if ("type" in schema && "properties" in schema && !Array.isArray(schema.anyOf)) {
+        return applyProviderCleaning(schema);
+    }
+    if (!("type" in schema)
+        && (typeof schema.properties === "object" || Array.isArray(schema.required))
+        && !Array.isArray(schema.anyOf)
+        && !Array.isArray(schema.oneOf)) {
+        return applyProviderCleaning({ ...schema, type: "object" });
+    }
+    const variantKey = Array.isArray(schema.anyOf)
+        ? "anyOf"
+        : Array.isArray(schema.oneOf)
+            ? "oneOf"
+            : null;
+    if (!variantKey) {
+        return applyProviderCleaning(schema);
+    }
+    const variants = schema[variantKey];
+    const mergedProperties = {};
+    const requiredCounts = new Map();
+    let objectVariants = 0;
+    for (const entry of variants) {
+        if (!entry || typeof entry !== "object") {
+            continue;
+        }
+        const props = entry.properties;
+        if (!props || typeof props !== "object") {
+            continue;
+        }
+        objectVariants += 1;
+        for (const [key, value] of Object.entries(props)) {
+            mergedProperties[key] = key in mergedProperties ? mergePropertySchemas(mergedProperties[key], value) : value;
+        }
+        const required = Array.isArray(entry.required)
+            ? entry.required
+            : [];
+        for (const key of required) {
+            if (typeof key === "string") {
+                requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    const baseRequired = Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : undefined;
+    const mergedRequired = baseRequired && baseRequired.length > 0
+        ? baseRequired
+        : objectVariants > 0
+            ? Array.from(requiredCounts.entries()).filter(([, count]) => count === objectVariants).map(([key]) => key)
+            : undefined;
+    return applyProviderCleaning({
+        type: "object",
+        ...(typeof schema.title === "string" ? { title: schema.title } : {}),
+        ...(typeof schema.description === "string" ? { description: schema.description } : {}),
+        properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : (schema.properties ?? {}),
+        ...(mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {}),
+        additionalProperties: "additionalProperties" in schema ? schema.additionalProperties : true,
+    });
+}
+export function convertFunctionTools(tools, options) {
+    return tools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+            parameters: normalizeFunctionToolParameters(tool.parameters, options),
+        },
+    }));
+}
+export function convertCapabilityToolManifestsToFunctionTools(tools) {
+    return convertFunctionTools(tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+            type: "object",
+            properties: Object.fromEntries((tool.requiredParameters ?? []).map((name) => [name, { type: "string" }])),
+            additionalProperties: true,
+            ...((tool.requiredParameters?.length ?? 0) > 0 ? { required: tool.requiredParameters } : {}),
+        },
+    })));
+}
+export function normalizeMessageTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content.map((entry) => {
+        if (typeof entry === "string") {
+            return entry;
+        }
+        if (entry && typeof entry === "object" && "text" in entry && typeof entry.text === "string") {
+            return entry.text;
+        }
+        return "";
+    }).filter(Boolean).join("\n");
+}
+export function parseOpenAiToolCallsFromChatResponse(responseBody) {
+    try {
+        const parsed = JSON.parse(responseBody);
+        const firstChoice = parsed.choices?.[0]?.message;
+        const toolCalls = Array.isArray(firstChoice?.tool_calls)
+            ? firstChoice.tool_calls.filter((entry) => entry?.type === "function" && typeof entry.function?.name === "string")
+            : [];
+        return {
+            toolCalls,
+            responseText: normalizeMessageTextContent(firstChoice?.content),
+        };
+    }
+    catch {
+        return { toolCalls: [], responseText: "" };
+    }
+}
+export function buildAssistantToolCallMessage(toolCalls, text, thinkingBlocks, reasoningContent) {
+    return {
+        role: "assistant",
+        // CC parity: preserve text alongside tool_use (Anthropic format allows coexistence)
+        content: text || null,
+        tool_calls: toolCalls,
+        // Anthropic thinking blocks must be passed back to API (DeepSeek/Claude requirement)
+        ...(thinkingBlocks && thinkingBlocks.length > 0 ? { thinkingBlocks } : {}),
+        // OpenAI-chat reasoning (GLM/DeepSeek): reasoning_content field on assistant message
+        // so the API can see the model's reasoning chain across tool-call rounds
+        ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
+    };
+}
+export function buildToolResultMessage(callId, result) {
+    // CC parity: plain text content, no JSON wrapping.
+    // LLM sees raw output directly — reduces token noise and parsing confusion.
+    const content = result.ok
+        ? (typeof result.payload === "string" ? result.payload : JSON.stringify(result.payload ?? ""))
+        : `Error: ${result.error ?? "Tool execution failed"}`;
+    return {
+        role: "tool",
+        tool_call_id: callId,
+        content,
+        // AP2: explicit is_error flag so all transports (not just Anthropic) can
+        // signal tool failure to the model without relying on content prefix parsing.
+        // CC uses is_error on Anthropic tool_result blocks — we propagate it through
+        // the message so OpenAI/Gemini transports can also leverage it if supported.
+        ...(!result.ok && { is_error: true }),
+        // CC parity: tool_reference metadata for Anthropic API tool_result blocks.
+        // When present, the transport can emit tool_reference blocks instead of plain text.
+        ...(result.toolReferences?.length ? { toolReferences: result.toolReferences } : {}),
+        // Image URLs from tool results (e.g. read tool reading an image file).
+        // Transport layer resolves these via FileUploadAdapter before sending to LLM.
+        ...(result.imageUrls?.length ? { imageUrls: result.imageUrls } : {}),
+    };
+}