qlogicagent 2.13.5 → 2.13.6

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

@@ -1,164 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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 } : {}),
-    };
-}