@langchain/openai 0.5.6 → 0.5.8

package/dist/chat_models.js

@@ -1,5 +1,5 @@
 import { OpenAI as OpenAIClient } from "openai";
-import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, isAIMessage, } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessageChunk, HumanMessageChunk, SystemMessageChunk, ToolMessageChunk, isAIMessage, parseBase64DataUrl, parseMimeType, convertToProviderContentBlock, isDataContentBlock, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
@@ -46,6 +46,132 @@ export function messageToOpenAIRole(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
+const completionsApiContentBlockConverter = {
+    providerName: "ChatOpenAI",
+    fromStandardTextBlock(block) {
+        return { type: "text", text: block.text };
+    },
+    fromStandardImageBlock(block) {
+        if (block.source_type === "url") {
+            return {
+                type: "image_url",
+                image_url: {
+                    url: block.url,
+                    ...(block.metadata?.detail
+                        ? { detail: block.metadata.detail }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            const url = `data:${block.mime_type ?? ""};base64,${block.data}`;
+            return {
+                type: "image_url",
+                image_url: {
+                    url,
+                    ...(block.metadata?.detail
+                        ? { detail: block.metadata.detail }
+                        : {}),
+                },
+            };
+        }
+        throw new Error(`Image content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+    fromStandardAudioBlock(block) {
+        if (block.source_type === "url") {
+            const data = parseBase64DataUrl({ dataUrl: block.url });
+            if (!data) {
+                throw new Error(`URL audio blocks with source_type ${block.source_type} must be formatted as a data URL for ChatOpenAI`);
+            }
+            const rawMimeType = data.mime_type || block.mime_type || "";
+            let mimeType;
+            try {
+                mimeType = parseMimeType(rawMimeType);
+            }
+            catch {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            if (mimeType.type !== "audio" ||
+                (mimeType.subtype !== "wav" && mimeType.subtype !== "mp3")) {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            return {
+                type: "input_audio",
+                input_audio: {
+                    format: mimeType.subtype,
+                    data: data.data,
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            let mimeType;
+            try {
+                mimeType = parseMimeType(block.mime_type ?? "");
+            }
+            catch {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            if (mimeType.type !== "audio" ||
+                (mimeType.subtype !== "wav" && mimeType.subtype !== "mp3")) {
+                throw new Error(`Audio blocks with source_type ${block.source_type} must have mime type of audio/wav or audio/mp3`);
+            }
+            return {
+                type: "input_audio",
+                input_audio: {
+                    format: mimeType.subtype,
+                    data: block.data,
+                },
+            };
+        }
+        throw new Error(`Audio content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+    fromStandardFileBlock(block) {
+        if (block.source_type === "url") {
+            const data = parseBase64DataUrl({ dataUrl: block.url });
+            if (!data) {
+                throw new Error(`URL file blocks with source_type ${block.source_type} must be formatted as a data URL for ChatOpenAI`);
+            }
+            return {
+                type: "file",
+                file: {
+                    file_data: block.url,
+                    ...(block.metadata?.filename || block.metadata?.name
+                        ? {
+                            filename: (block.metadata?.filename ||
+                                block.metadata?.name),
+                        }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "base64") {
+            return {
+                type: "file",
+                file: {
+                    file_data: `data:${block.mime_type ?? ""};base64,${block.data}`,
+                    ...(block.metadata?.filename ||
+                        block.metadata?.name ||
+                        block.metadata?.title
+                        ? {
+                            filename: (block.metadata?.filename ||
+                                block.metadata?.name ||
+                                block.metadata?.title),
+                        }
+                        : {}),
+                },
+            };
+        }
+        if (block.source_type === "id") {
+            return {
+                type: "file",
+                file: {
+                    file_id: block.id,
+                },
+            };
+        }
+        throw new Error(`File content blocks with source_type ${block.source_type} are not supported for ChatOpenAI`);
+    },
+};
 // Used in LangSmith, export is important here
 export function _convertMessagesToOpenAIParams(messages, model) {
     // TODO: Function messages do not support array content, fix cast
@@ -54,10 +180,18 @@ export function _convertMessagesToOpenAIParams(messages, model) {
         if (role === "system" && isReasoningModel(model)) {
             role = "developer";
         }
+        const content = typeof message.content === "string"
+            ? message.content
+            : message.content.map((m) => {
+                if (isDataContentBlock(m)) {
+                    return convertToProviderContentBlock(m, completionsApiContentBlockConverter);
+                }
+                return m;
+            });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const completionParam = {
             role,
-            content: message.content,
+            content,
         };
         if (message.name != null) {
             completionParam.name = message.name;
@@ -93,8 +227,32 @@ export function _convertMessagesToOpenAIParams(messages, model) {
     });
 }
 const _FUNCTION_CALL_IDS_MAP_KEY = "__openai_function_call_ids__";
-function _convertMessagesToOpenAIResponsesParams(messages, model) {
-    return messages.flatMap((lcMsg) => {
+function _convertReasoningSummaryToOpenAIResponsesParams(reasoning) {
+    // combine summary parts that have the the same index and then remove the indexes
+    const summary = (reasoning.summary.length > 1
+        ? reasoning.summary.reduce((acc, curr) => {
+            const last = acc.at(-1);
+            if (last.index === curr.index) {
+                last.text += curr.text;
+            }
+            else {
+                acc.push(curr);
+            }
+            return acc;
+        }, [{ ...reasoning.summary[0] }])
+        : reasoning.summary).map((s) => Object.fromEntries(Object.entries(s).filter(([k]) => k !== "index")));
+    return {
+        ...reasoning,
+        summary,
+    };
+}
+function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
+    const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
+    const lastAIMessageId = lastAIMessage?.response_metadata?.id;
+    const newMessages = lastAIMessageId && lastAIMessageId.startsWith("resp_") && !zdrEnabled
+        ? messages.slice(messages.indexOf(lastAIMessage) + 1)
+        : messages;
+    return newMessages.flatMap((lcMsg) => {
         let role = messageToOpenAIRole(lcMsg);
         if (role === "system" && isReasoningModel(model))
             role = "developer";
@@ -144,15 +302,25 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
             };
         }
         if (role === "assistant") {
+            // if we have the original response items, just reuse them
+            if (!zdrEnabled &&
+                lcMsg.response_metadata.output != null &&
+                Array.isArray(lcMsg.response_metadata.output) &&
+                lcMsg.response_metadata.output.length > 0 &&
+                lcMsg.response_metadata.output.every((item) => "type" in item)) {
+                return lcMsg.response_metadata.output;
+            }
+            // otherwise, try to reconstruct the response from what we have
             const input = [];
             // reasoning items
-            if (lcMsg.additional_kwargs.reasoning != null) {
+            if (!zdrEnabled && lcMsg.additional_kwargs.reasoning != null) {
                 const isReasoningItem = (item) => typeof item === "object" &&
                     item != null &&
                     "type" in item &&
                     item.type === "reasoning";
                 if (isReasoningItem(lcMsg.additional_kwargs.reasoning)) {
-                    input.push(lcMsg.additional_kwargs.reasoning);
+                    const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(lcMsg.additional_kwargs.reasoning);
+                    input.push(reasoningItem);
                 }
             }
             // ai content
@@ -169,6 +337,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
             input.push({
                 type: "message",
                 role: "assistant",
+                ...(lcMsg.id && !zdrEnabled ? { id: lcMsg.id } : {}),
                 content: typeof content === "string"
                     ? content
                     : content.flatMap((item) => {
@@ -196,7 +365,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
                     name: toolCall.name,
                     arguments: JSON.stringify(toolCall.args),
                     call_id: toolCall.id,
-                    id: functionCallIds?.[toolCall.id],
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
             else if (lcMsg.additional_kwargs.tool_calls != null) {
@@ -204,21 +373,17 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
                     type: "function_call",
                     name: toolCall.function.name,
                     call_id: toolCall.id,
-                    id: functionCallIds?.[toolCall.id],
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                     arguments: toolCall.function.arguments,
                 })));
             }
             const toolOutputs = lcMsg.response_metadata.output?.length
                 ? lcMsg.response_metadata.output
                 : lcMsg.additional_kwargs.tool_outputs;
+            let computerCalls = [];
             if (toolOutputs != null) {
                 const castToolOutputs = toolOutputs;
-                const reasoningCalls = castToolOutputs?.filter((item) => item.type === "reasoning");
-                const computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
-                // NOTE: Reasoning outputs must be passed to the model BEFORE computer calls.
-                if (reasoningCalls.length > 0 && computerCalls.length > 0) {
-                    input.push(...reasoningCalls);
-                }
+                computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
                 if (computerCalls.length > 0)
                     input.push(...computerCalls);
             }
@@ -227,6 +392,9 @@ function _convertMessagesToOpenAIResponsesParams(messages, model) {
         const content = typeof lcMsg.content === "string"
             ? lcMsg.content
             : lcMsg.content.flatMap((item) => {
+                if (isDataContentBlock(item)) {
+                    return convertToProviderContentBlock(item, completionsApiContentBlockConverter);
+                }
                 if (item.type === "text") {
                     return { type: "input_text", text: item.text };
                 }
@@ -419,6 +587,39 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
     else if (chunk.type === "response.refusal.done") {
         additional_kwargs.refusal = chunk.refusal;
     }
+    else if (chunk.type === "response.output_item.added" &&
+        "item" in chunk &&
+        chunk.item.type === "reasoning") {
+        const summary = chunk
+            .item.summary
+            ? chunk.item.summary.map((s, index) => ({
+                ...s,
+                index,
+            }))
+            : undefined;
+        additional_kwargs.reasoning = {
+            // We only capture ID in the first chunk or else the concatenated result of all chunks will
+            // have an ID field that is repeated once per chunk. There is special handling for the `type`
+            // field that prevents this, however.
+            id: chunk.item.id,
+            type: chunk.item.type,
+            ...(summary ? { summary } : {}),
+        };
+    }
+    else if (chunk.type === "response.reasoning_summary_part.added") {
+        additional_kwargs.reasoning = {
+            type: "reasoning",
+            summary: [{ ...chunk.part, index: chunk.summary_index }],
+        };
+    }
+    else if (chunk.type === "response.reasoning_summary_text.delta") {
+        additional_kwargs.reasoning = {
+            type: "reasoning",
+            summary: [
+                { text: chunk.delta, type: "summary_text", index: chunk.summary_index },
+            ],
+        };
+    }
     else {
         return null;
     }
@@ -461,9 +662,7 @@ function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
     return _convertToOpenAITool(tool, fields);
 }
 function isReasoningModel(model) {
-    return (model?.startsWith("o1") ||
-        model?.startsWith("o3") ||
-        model?.startsWith("o4"));
+    return model && /^o\d/.test(model);
 }
 /**
  * OpenAI chat model integration.
@@ -1071,6 +1270,9 @@ export class ChatOpenAI extends BaseChatModel {
             "tags",
             "metadata",
             "disableStreaming",
+            "useResponsesApi",
+            "zdrEnabled",
+            "reasoning",
         ];
     }
     constructor(fields) {
@@ -1248,18 +1450,51 @@ export class ChatOpenAI extends BaseChatModel {
             writable: true,
             value: void 0
         });
+        /**
+         * @deprecated Use {@link reasoning} object instead.
+         */
         Object.defineProperty(this, "reasoningEffort", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Options for reasoning models.
+         */
+        Object.defineProperty(this, "reasoning", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether to use the responses API for all requests. If `false` the responses API will be used
+         * only when required in order to fulfill the request.
+         */
         Object.defineProperty(this, "useResponsesApi", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: false
         });
+        /**
+         * Must be set to `true` in tenancies with Zero Data Retention. Setting to `true` will disable
+         * output storage in the Responses API, but this DOES NOT enable Zero Data Retention in your
+         * OpenAI organization or project. This must be configured directly with OpenAI.
+         *
+         * See:
+         * https://help.openai.com/en/articles/10503543-data-residency-for-the-openai-api
+         * https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
+         *
+         * @default false
+         */
+        Object.defineProperty(this, "zdrEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.openAIApiKey =
             fields?.apiKey ??
                 fields?.openAIApiKey ??
@@ -1287,7 +1522,12 @@ export class ChatOpenAI extends BaseChatModel {
         this.__includeRawResponse = fields?.__includeRawResponse;
         this.audio = fields?.audio;
         this.modalities = fields?.modalities;
-        this.reasoningEffort = fields?.reasoningEffort;
+        this.reasoningEffort = fields?.reasoningEffort ?? fields?.reasoning?.effort;
+        this.reasoning =
+            fields?.reasoning ??
+                (fields?.reasoningEffort
+                    ? { effort: fields.reasoningEffort }
+                    : undefined);
         this.maxTokens = fields?.maxCompletionTokens ?? fields?.maxTokens;
         this.useResponsesApi = fields?.useResponsesApi ?? this.useResponsesApi;
         this.disableStreaming = fields?.disableStreaming ?? this.disableStreaming;
@@ -1310,6 +1550,7 @@ export class ChatOpenAI extends BaseChatModel {
         if (fields?.supportsStrictToolCalling !== undefined) {
             this.supportsStrictToolCalling = fields.supportsStrictToolCalling;
         }
+        this.zdrEnabled = fields?.zdrEnabled ?? false;
     }
     getLsParams(options) {
         const params = this.invocationParams(options);
@@ -1348,6 +1589,35 @@ export class ChatOpenAI extends BaseChatModel {
         }
         return resFormat;
     }
+    getReasoningParams(options) {
+        if (!isReasoningModel(this.model)) {
+            return;
+        }
+        let reasoning;
+        // apply reasoning options in reverse order of priority without else blocks so that highest priority overrides lowest priority
+        if (this.reasoningEffort !== undefined) {
+            reasoning = { effort: this.reasoningEffort };
+        }
+        if (this.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...this.reasoning,
+            };
+        }
+        if (options?.reasoning_effort !== undefined) {
+            reasoning = {
+                ...reasoning,
+                effort: options.reasoning_effort,
+            };
+        }
+        if (options?.reasoning !== undefined) {
+            reasoning = {
+                ...reasoning,
+                ...options.reasoning,
+            };
+        }
+        return reasoning;
+    }
     /**
      * Get the parameters used to invoke the model
      */
@@ -1424,11 +1694,12 @@ export class ChatOpenAI extends BaseChatModel {
                 })(),
                 parallel_tool_calls: options?.parallel_tool_calls,
                 max_output_tokens: this.maxTokens === -1 ? undefined : this.maxTokens,
+                ...(this.zdrEnabled ? { store: false } : {}),
                 ...this.modelKwargs,
             };
-            const reasoningEffort = options?.reasoning_effort ?? this.reasoningEffort;
-            if (reasoningEffort !== undefined) {
-                params.reasoning = { effort: reasoningEffort };
+            const reasoning = this.getReasoningParams(options);
+            if (reasoning !== undefined) {
+                params.reasoning = reasoning;
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return params;
@@ -1475,9 +1746,9 @@ export class ChatOpenAI extends BaseChatModel {
         if (options?.prediction !== undefined) {
             params.prediction = options.prediction;
         }
-        const reasoningEffort = options?.reasoning_effort ?? this.reasoningEffort;
-        if (reasoningEffort !== undefined) {
-            params.reasoning_effort = reasoningEffort;
+        const reasoning = this.getReasoningParams(options);
+        if (reasoning !== undefined && reasoning.effort !== undefined) {
+            params.reasoning_effort = reasoning.effort;
         }
         if (isReasoningModel(params.model)) {
             params.max_completion_tokens =
@@ -1631,10 +1902,17 @@ export class ChatOpenAI extends BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponseApi(options)) {
+            const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
+            const lastAIMessageId = lastAIMessage?.response_metadata?.id;
             const streamIterable = await this.responseApiWithRetry({
                 ...this.invocationParams(options, { streaming: true }),
-                input: _convertMessagesToOpenAIResponsesParams(messages, this.model),
+                input: _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
                 stream: true,
+                ...(lastAIMessageId &&
+                    lastAIMessageId.startsWith("resp_") &&
+                    !this.zdrEnabled
+                    ? { previous_response_id: lastAIMessageId }
+                    : {}),
             }, options);
             for await (const data of streamIterable) {
                 const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk(data);
@@ -1768,8 +2046,18 @@ export class ChatOpenAI extends BaseChatModel {
                 },
             };
         }
-        const input = _convertMessagesToOpenAIResponsesParams(messages, this.model);
-        const data = await this.responseApiWithRetry({ input, ...invocationParams }, { signal: options?.signal, ...options?.options });
+        const lastAIMessage = messages.filter((m) => isAIMessage(m)).pop();
+        const lastAIMessageId = lastAIMessage?.response_metadata?.id;
+        const input = _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled);
+        const data = await this.responseApiWithRetry({
+            input,
+            ...invocationParams,
+            ...(lastAIMessageId &&
+                lastAIMessageId.startsWith("resp_") &&
+                !this.zdrEnabled
+                ? { previous_response_id: lastAIMessageId }
+                : {}),
+        }, { signal: options?.signal, ...options?.options });
         return {
             generations: [
                 {
@@ -1789,12 +2077,23 @@ export class ChatOpenAI extends BaseChatModel {
             },
         };
     }
+    /**
+     * Determines whether the responses API should be used for the given request.
+     *
+     * @internal
+     *
+     * @param options The parsed call options for the request.
+     * @returns `true` if the responses API should be used, either because it is explicitly enabled,
+     * or because the request requires it.
+     */
     _useResponseApi(options) {
         const usesBuiltInTools = options?.tools?.some(isBuiltInTool);
         const hasResponsesOnlyKwargs = options?.previous_response_id != null ||
             options?.text != null ||
             options?.truncation != null ||
-            options?.include != null;
+            options?.include != null ||
+            options?.reasoning?.summary != null ||
+            this.reasoning?.summary != null;
         return this.useResponsesApi || usesBuiltInTools || hasResponsesOnlyKwargs;
     }
     /** @ignore */

package/dist/tools/dalle.cjs

@@ -115,7 +115,7 @@ class DallEAPIWrapper extends tools_1.Tool {
         if (this.dallEResponseFormat === "url") {
             return response.flatMap((res) => {
                 const imageUrlContent = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.url)
                         return [];
                     return {
@@ -126,14 +126,14 @@ class DallEAPIWrapper extends tools_1.Tool {
                     .filter((item) => item !== undefined &&
                     item.type === "image_url" &&
                     typeof item.image_url === "string" &&
-                    item.image_url !== undefined);
+                    item.image_url !== undefined) ?? [];
                 return imageUrlContent;
             });
         }
         else {
             return response.flatMap((res) => {
                 const b64Content = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.b64_json)
                         return [];
                     return {
@@ -148,7 +148,7 @@ class DallEAPIWrapper extends tools_1.Tool {
                     typeof item.image_url === "object" &&
                     "url" in item.image_url &&
                     typeof item.image_url.url === "string" &&
-                    item.image_url.url !== undefined);
+                    item.image_url.url !== undefined) ?? [];
                 return b64Content;
             });
         }
@@ -172,14 +172,17 @@ class DallEAPIWrapper extends tools_1.Tool {
         const response = await this.client.images.generate(generateImageFields);
         let data = "";
         if (this.dallEResponseFormat === "url") {
-            [data] = response.data
-                .map((item) => item.url)
-                .filter((url) => url !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.url)
+                    .filter((url) => url !== "undefined") ?? [];
         }
         else {
-            [data] = response.data
-                .map((item) => item.b64_json)
-                .filter((b64_json) => b64_json !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.b64_json)
+                    .filter((b64_json) => b64_json !== "undefined") ??
+                    [];
         }
         return data;
     }

package/dist/tools/dalle.js

@@ -112,7 +112,7 @@ export class DallEAPIWrapper extends Tool {
         if (this.dallEResponseFormat === "url") {
             return response.flatMap((res) => {
                 const imageUrlContent = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.url)
                         return [];
                     return {
@@ -123,14 +123,14 @@ export class DallEAPIWrapper extends Tool {
                     .filter((item) => item !== undefined &&
                     item.type === "image_url" &&
                     typeof item.image_url === "string" &&
-                    item.image_url !== undefined);
+                    item.image_url !== undefined) ?? [];
                 return imageUrlContent;
             });
         }
         else {
             return response.flatMap((res) => {
                 const b64Content = res.data
-                    .flatMap((item) => {
+                    ?.flatMap((item) => {
                     if (!item.b64_json)
                         return [];
                     return {
@@ -145,7 +145,7 @@ export class DallEAPIWrapper extends Tool {
                     typeof item.image_url === "object" &&
                     "url" in item.image_url &&
                     typeof item.image_url.url === "string" &&
-                    item.image_url.url !== undefined);
+                    item.image_url.url !== undefined) ?? [];
                 return b64Content;
             });
         }
@@ -169,14 +169,17 @@ export class DallEAPIWrapper extends Tool {
         const response = await this.client.images.generate(generateImageFields);
         let data = "";
         if (this.dallEResponseFormat === "url") {
-            [data] = response.data
-                .map((item) => item.url)
-                .filter((url) => url !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.url)
+                    .filter((url) => url !== "undefined") ?? [];
         }
         else {
-            [data] = response.data
-                .map((item) => item.b64_json)
-                .filter((b64_json) => b64_json !== "undefined");
+            [data] =
+                response.data
+                    ?.map((item) => item.b64_json)
+                    .filter((b64_json) => b64_json !== "undefined") ??
+                    [];
         }
         return data;
     }