@superinterface/server 1.0.25 → 1.0.26

package/dist/app/api/messages/route.js

@@ -1,612 +1,6 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { NextResponse } from 'next/server';
-import { LogRequestMethod, LogRequestRoute, LogLevel, } from '@prisma/client';
-import { messagesResponse, createMessageResponse, } from '@superinterface/react/server';
-import { enqueueJson } from '@superinterface/react/utils';
-import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
-import { z } from 'zod';
-import { storageThreadId as getStorageThreadId } from '../../../lib/threads/storageThreadId';
-import { assistantClientAdapter } from '../../../lib/assistants/assistantClientAdapter';
-import { content as getContent } from '../../../lib/messages/content';
-import { workspaceAccessWhere as getWorkspaceAccessWhere } from '../../../lib/apiKeys/workspaceAccessWhere';
-import { initialMessagesResponse } from './lib/initialMessagesResponse';
-import { createRunOpts } from '../../../lib/runs/createRunOpts';
-import { handleToolCall } from '../../../lib/toolCalls/handleToolCall';
-import { createThread } from '../../../lib/threads/createThread';
-import { managedOpenaiThreadId } from '../../../lib/threads/managedOpenaiThreadId';
-import { resolvePrisma } from '../../../lib/prisma';
-import { createLog } from '../../../lib/logs/createLog';
-import { serializeThread } from './lib/serializeThread';
-import { getWorkspaceId } from './lib/getWorkspaceId';
-import { validThreadId } from '../../../lib/threads/validThreadId';
-import { isOpenaiAssistantsStorageProvider } from '../../../lib/storageProviders/isOpenaiAssistantsStorageProvider';
-import { serializeMetadata } from '../../../lib/metadata/serializeMetadata';
-import { isResponsesStorageProvider } from '../../../lib/storageProviders/isResponsesStorageProvider';
-import { serializeError } from '../../../lib/errors/serializeError';
-export const maxDuration = 800;
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (request) => {
-    var _a;
-    const prisma = resolvePrisma(providedPrisma);
-    const paramsResult = z
-        .object({
-        publicApiKey: z.string().optional(),
-        assistantId: z.string().optional(),
-        threadId: z.string().optional(),
-        pageParam: z.string().optional(),
-    })
-        .parse(Object.fromEntries(request.nextUrl.searchParams.entries()));
-    const workspaceAccessWhere = await getWorkspaceAccessWhere({
-        publicApiKey: (_a = paramsResult.publicApiKey) !== null && _a !== void 0 ? _a : null,
-        prisma,
-    });
-    if (!workspaceAccessWhere) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    const assistantId = paramsResult.assistantId;
-    if (!assistantId) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'No assistantId found.',
-                workspaceId: await getWorkspaceId({ workspaceAccessWhere, prisma }),
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'No assistant id found' }, { status: 400 });
-    }
-    const { threadId, pageParam } = paramsResult;
-    const assistant = await prisma.assistant.findFirst({
-        where: {
-            id: assistantId,
-            workspace: workspaceAccessWhere,
-        },
-        include: {
-            threads: {
-                where: {
-                    id: validThreadId({ threadId: threadId !== null && threadId !== void 0 ? threadId : null }),
-                },
-                take: 1,
-                include: {
-                    assistant: {
-                        select: {
-                            storageProviderType: true,
-                        },
-                    },
-                },
-            },
-            workspace: {
-                include: {
-                    modelProviders: true,
-                },
-            },
-            modelProvider: true,
-            initialMessages: {
-                orderBy: {
-                    orderNumber: 'desc',
-                },
-            },
-            mcpServers: {
-                include: {
-                    computerUseTool: true,
-                    stdioTransport: true,
-                    sseTransport: true,
-                    httpTransport: true,
-                },
-            },
-            tools: {
-                include: {
-                    fileSearchTool: true,
-                    webSearchTool: true,
-                    imageGenerationTool: true,
-                    codeInterpreterTool: true,
-                    computerUseTool: true,
-                },
-            },
-            functions: true,
-        },
-    });
-    if (!assistant) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'No assistant found.',
-                workspaceId: await getWorkspaceId({ workspaceAccessWhere, prisma }),
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'No assistant found' }, { status: 400 });
-    }
-    if (!threadId) {
-        return NextResponse.json(await initialMessagesResponse({ assistant }), {
-            headers: cacheHeaders,
-        });
-    }
-    const thread = assistant.threads[0];
-    if (!thread) {
-        return NextResponse.json(await initialMessagesResponse({ assistant }), {
-            headers: cacheHeaders,
-        });
-    }
-    const assistantClient = assistantClientAdapter({
-        assistant,
-        prisma,
-        thread,
-    });
-    const storageThreadId = getStorageThreadId({
-        thread,
-    });
-    if (!storageThreadId) {
-        return NextResponse.json(await initialMessagesResponse({ assistant }), {
-            headers: cacheHeaders,
-        });
-    }
-    try {
-        return NextResponse.json(await messagesResponse(Object.assign({ threadId: storageThreadId, client: assistantClient }, (pageParam ? { pageParam } : {}))), {
-            headers: cacheHeaders,
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.dir({ error }, { depth: null });
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.GET,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to load messages: ${error.message}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to load messages.' }, { status: 500 });
-    }
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPOST = ({ prisma: providedPrisma, onSuccessCreateThread = () => void 0, } = {}) => async (request) => {
-    var _a;
-    const prisma = resolvePrisma(providedPrisma);
-    const bodyResult = z
-        .object({
-        audioContent: z.any().optional(),
-        content: z.any().optional(),
-        attachments: z.array(z.any()).optional(),
-        assistantId: z.string().optional(),
-        publicApiKey: z.string().optional(),
-        threadId: z.string().optional(),
-    })
-        .passthrough()
-        .parse(await request.json());
-    const { audioContent, content: textContent, attachments, assistantId, publicApiKey } = bodyResult, variables = __rest(bodyResult, ["audioContent", "content", "attachments", "assistantId", "publicApiKey"]);
-    const workspaceAccessWhere = await getWorkspaceAccessWhere({
-        publicApiKey: publicApiKey !== null && publicApiKey !== void 0 ? publicApiKey : null,
-        prisma,
-    });
-    if (!workspaceAccessWhere) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!assistantId) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'No assistantId found.',
-                workspaceId: await getWorkspaceId({ workspaceAccessWhere, prisma }),
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'No assistantId found.' }, { status: 400 });
-    }
-    if (!textContent && !audioContent && !(attachments === null || attachments === void 0 ? void 0 : attachments.length)) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'No content found.',
-                workspaceId: await getWorkspaceId({ workspaceAccessWhere, prisma }),
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'No content found.' }, { status: 400 });
-    }
-    const assistant = await prisma.assistant.findFirst({
-        where: {
-            id: assistantId,
-            workspace: workspaceAccessWhere,
-        },
-        include: {
-            threads: {
-                where: {
-                    id: validThreadId({ threadId: (_a = bodyResult.threadId) !== null && _a !== void 0 ? _a : null }),
-                },
-                include: {
-                    assistant: {
-                        select: {
-                            storageProviderType: true,
-                        },
-                    },
-                },
-                take: 1,
-            },
-            workspace: {
-                include: {
-                    modelProviders: true,
-                },
-            },
-            mcpServers: {
-                include: {
-                    computerUseTool: true,
-                    stdioTransport: true,
-                    sseTransport: true,
-                    httpTransport: true,
-                },
-            },
-            tools: {
-                include: {
-                    fileSearchTool: true,
-                    webSearchTool: true,
-                    imageGenerationTool: true,
-                    codeInterpreterTool: true,
-                    computerUseTool: {
-                        include: {
-                            mcpServer: {
-                                include: {
-                                    stdioTransport: true,
-                                    sseTransport: true,
-                                    httpTransport: true,
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            functions: {
-                include: {
-                    handler: {
-                        include: {
-                            requestHandler: true,
-                            firecrawlHandler: true,
-                            replicateHandler: true,
-                            clientToolHandler: true,
-                            assistantHandler: true,
-                            createTaskHandler: true,
-                            listTasksHandler: true,
-                            updateTaskHandler: true,
-                            deleteTaskHandler: true,
-                        },
-                    },
-                },
-            },
-            modelProvider: true,
-            initialMessages: {
-                orderBy: {
-                    orderNumber: 'asc',
-                },
-            },
-        },
-    });
-    if (!assistant) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'No assistant found.',
-                workspaceId: await getWorkspaceId({ workspaceAccessWhere, prisma }),
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'No assistant found.' }, { status: 400 });
-    }
-    if (isOpenaiAssistantsStorageProvider({
-        storageProviderType: assistant.storageProviderType,
-    }) &&
-        !assistant.openaiAssistantId) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 400,
-                message: 'Assistant setup is not done.',
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Assistant setup is not done.' }, { status: 400 });
-    }
-    let thread = assistant.threads[0];
-    let isThreadCreated = false;
-    if (!thread) {
-        const createThreadClient = assistantClientAdapter({ assistant, prisma });
-        try {
-            thread = await createThread({
-                client: createThreadClient,
-                assistant,
-                prisma,
-                variables: variables,
-            });
-            onSuccessCreateThread({ thread });
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            console.error(error);
-            createLog({
-                log: {
-                    requestMethod: LogRequestMethod.POST,
-                    requestRoute: LogRequestRoute.MESSAGES,
-                    level: LogLevel.ERROR,
-                    status: 500,
-                    message: `Failed to create thread: ${error.message}`,
-                    workspaceId: assistant.workspaceId,
-                    assistantId: assistant.id,
-                },
-                prisma,
-            });
-            return NextResponse.json({ error: 'Failed to create thread.' }, { status: 500 });
-        }
-        isThreadCreated = true;
-    }
-    let storageThreadId;
-    try {
-        storageThreadId = getStorageThreadId({
-            thread,
-        });
-    }
-    catch (error) {
-        console.error(error);
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: 'Failed to get storage thread id.',
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to get storage thread id.' }, { status: 500 });
-    }
-    if (!storageThreadId &&
-        (isOpenaiAssistantsStorageProvider({
-            storageProviderType: assistant.storageProviderType,
-        }) ||
-            isResponsesStorageProvider({
-                storageProviderType: assistant.storageProviderType,
-            }))) {
-        try {
-            storageThreadId = await managedOpenaiThreadId({
-                assistant,
-                threadId: thread.id,
-                prisma,
-            });
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (error) {
-            createLog({
-                log: {
-                    requestMethod: LogRequestMethod.POST,
-                    requestRoute: LogRequestRoute.MESSAGES,
-                    level: LogLevel.ERROR,
-                    status: 500,
-                    message: `Failed to get managed openai thread id: ${error.message}`,
-                    workspaceId: assistant.workspaceId,
-                    assistantId: assistant.id,
-                    threadId: thread.id,
-                },
-                prisma,
-            });
-            return NextResponse.json({ error: 'Failed to get managed openai thread id.' }, { status: 500 });
-        }
-    }
-    if (!storageThreadId) {
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: 'Invalid thread configuration.',
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Invalid thread configuration.' }, { status: 500 });
-    }
-    let content;
-    try {
-        content = await getContent({
-            audioContent,
-            textContent,
-            assistant,
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.error(error);
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to get content: ${error.message}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to get content.' }, { status: 500 });
-    }
-    const assistantClient = assistantClientAdapter({
-        assistant,
-        prisma,
-        thread,
-    });
-    try {
-        await assistantClient.beta.threads.messages.create(storageThreadId, Object.assign(Object.assign({ role: 'user', content }, ((attachments === null || attachments === void 0 ? void 0 : attachments.length) ? { attachments } : {})), { metadata: serializeMetadata({
-                variables,
-                workspaceId: assistant.workspaceId,
-                prisma,
-            }) }));
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.log({ error });
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to create message: ${error.message}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to create message.' }, { status: 500 });
-    }
-    let createRunStream;
-    try {
-        createRunStream = await assistantClient.beta.threads.runs.create(storageThreadId, await createRunOpts({ assistant, thread, prisma }));
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }
-    catch (error) {
-        console.error(error);
-        createLog({
-            log: {
-                requestMethod: LogRequestMethod.POST,
-                requestRoute: LogRequestRoute.MESSAGES,
-                level: LogLevel.ERROR,
-                status: 500,
-                message: `Failed to create run stream: ${serializeError({ error })}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-            prisma,
-        });
-        return NextResponse.json({ error: 'Failed to create run stream.' }, { status: 500 });
-    }
-    let latestInProgressRunData = null;
-    let latestCompletedRunData = null;
-    return new Response(createMessageResponse({
-        client: assistantClient,
-        createRunStream,
-        handleToolCall: handleToolCall({ assistant, thread, prisma }),
-        onStart: ({ controller, }) => {
-            if (!isThreadCreated)
-                return;
-            return enqueueJson({
-                controller,
-                value: {
-                    event: 'thread.created',
-                    data: serializeThread({
-                        thread,
-                    }),
-                },
-            });
-        },
-        onError: async ({ error }) => {
-            if (request.signal.aborted)
-                return;
-            createLog({
-                log: {
-                    requestMethod: LogRequestMethod.POST,
-                    requestRoute: LogRequestRoute.MESSAGES,
-                    level: LogLevel.ERROR,
-                    status: 500,
-                    message: `Thread Run failed: ${error.message}`,
-                    workspaceId: assistant.workspaceId,
-                    assistantId: assistant.id,
-                    threadId: thread.id,
-                },
-                prisma,
-            });
-            // if (latestInProgressRunData) {
-            //   await assistantClient.beta.threads.runs.cancel(
-            //     latestInProgressRunData.thread_id,
-            //     latestInProgressRunData.id,
-            //   )
-            // }
-        },
-        onEvent: ({ event, data }) => {
-            var _a;
-            if (event === 'thread.run.failed') {
-                createLog({
-                    log: {
-                        requestMethod: LogRequestMethod.POST,
-                        requestRoute: LogRequestRoute.MESSAGES,
-                        level: LogLevel.ERROR,
-                        status: 500,
-                        message: `Thread Run failed: ${(_a = data.last_error) === null || _a === void 0 ? void 0 : _a.message}`,
-                        workspaceId: assistant.workspaceId,
-                        assistantId: assistant.id,
-                        threadId: thread.id,
-                    },
-                    prisma,
-                });
-            }
-            else if (event === 'thread.run.in_progress') {
-                latestInProgressRunData = data;
-            }
-            else if (event === 'thread.run.completed') {
-                latestCompletedRunData = data;
-            }
-        },
-        onClose: async () => {
-            if (latestCompletedRunData)
-                return;
-            if (!isOpenaiAssistantsStorageProvider({
-                storageProviderType: assistant.storageProviderType,
-            }))
-                return;
-            if (latestInProgressRunData) {
-                await assistantClient.beta.threads.runs.cancel(latestInProgressRunData.id, {
-                    thread_id: latestInProgressRunData.thread_id,
-                });
-            }
-        },
-    }), {
-        status: 200,
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8',
-        },
-    });
-};
-export const POST = ((...args) => buildPOST({})(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../lib/prisma';
+import { buildGET, buildOPTIONS, buildPOST, maxDuration, } from './buildRoute';
+export { maxDuration };
+export const GET = buildGET({ prisma });
+export const POST = buildPOST({ prisma });
+export const OPTIONS = buildOPTIONS();

package/dist/app/api/providers/[modelProviderId]/assistants/buildRoute.d.ts

@@ -0,0 +1,24 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse, type NextRequest } from 'next/server';
+type RouteProps = {
+    params: Promise<{
+        modelProviderId: string;
+    }>;
+};
+export declare const buildGET: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (_request: NextRequest, props: RouteProps) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    storageProviderAssistants: {
+        id: string;
+        model: string;
+        name: string | null;
+        description: string | null;
+        instructions: string | null;
+        tools: import("openai/resources/beta/assistants.mjs").AssistantTool[];
+    }[];
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+export {};
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/providers/[modelProviderId]/assistants/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../../../src/app/api/providers/[modelProviderId]/assistants/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAA;AAM5D,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,QAAQ,GAClB,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MAC9B,UAAU,WAAW,EAAE,OAAO,UAAU;;;;;;;;;;;GAgD9C,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}

package/dist/app/api/providers/[modelProviderId]/assistants/buildRoute.js

@@ -0,0 +1,43 @@
+import { headers } from 'next/headers';
+import { ApiKeyType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { cacheHeaders } from '../../../../../lib/cache/cacheHeaders';
+import { getApiKey } from '../../../../../lib/apiKeys/getApiKey';
+import { getStorageProviderAssistants } from '../../../../../lib/storageProviders/getStorageProviderAssistants';
+import { serializeApiStorageProviderAssistant } from '../../../../../lib/storageProviders/serializeApiStorageProviderAssistant';
+export const buildGET = ({ prisma }) => async (_request, props) => {
+    const { modelProviderId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const provider = await prisma.modelProvider.findUnique({
+        where: {
+            id: modelProviderId,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!provider) {
+        return NextResponse.json({ error: 'No provider found' }, { status: 400 });
+    }
+    const storageProviderAssistants = await getStorageProviderAssistants({
+        modelProvider: provider,
+    });
+    return NextResponse.json({
+        storageProviderAssistants: storageProviderAssistants.map((storageProviderAssistant) => serializeApiStorageProviderAssistant({
+            storageProviderAssistant,
+        })),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});