@superinterface/server 1.0.25 → 1.0.26

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

@@ -0,0 +1,607 @@
+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 { 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 }) => async (request) => {
+    var _a;
+    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 buildPOST = ({ prisma, onSuccessCreateThread = () => void 0, }) => async (request) => {
+    var _a;
+    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 buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/messages/lib/initialMessagesResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialMessagesResponse.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/messages/lib/initialMessagesResponse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,EACL,MAAM,EAIP,MAAM,gBAAgB,CAAA;AA+BvB,eAAO,MAAM,uBAAuB,GAAU,gBAE3C;IACD,SAAS,EAAE,MAAM,CAAC,mBAAmB,CAAC;QACpC,OAAO,EAAE;YACP,eAAe,EAAE,IAAI,CAAA;SACtB,CAAA;KACF,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;EA4CA,CAAA"}
+{"version":3,"file":"initialMessagesResponse.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/messages/lib/initialMessagesResponse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,EACL,MAAM,EAIP,MAAM,gBAAgB,CAAA;AA+BvB,eAAO,MAAM,uBAAuB,GAAU,gBAE3C;IACD,SAAS,EAAE,MAAM,CAAC,mBAAmB,CAAC;QACpC,OAAO,EAAE;YACP,eAAe,EAAE,IAAI,CAAA;SACtB,CAAA;KACF,CAAC,CAAA;CACH;;;;;;;;;;;;;;;;EAgDA,CAAA"}

package/dist/app/api/messages/lib/initialMessagesResponse.js

@@ -23,7 +23,7 @@ export const initialMessagesResponse = async ({ assistant, }) => {
     const threadId = optimisticId();
     const initialCreatedAt = dayjs().unix();
     return {
-        data: await Promise.all(assistant.initialMessages.map((message, index) => serializeMessage({
+        data: await Promise.all(assistant.initialMessages.map(async (message, index) => serializeMessage({
             message: {
                 id: optimisticId(),
                 role: message.role.toLowerCase(),

package/dist/app/api/messages/route.d.ts

@@ -1,36 +1,24 @@
-import { type NextRequest, NextResponse } from 'next/server';
-import OpenAI from 'openai';
-import { type PrismaClient } from '@prisma/client';
-import type { Thread } from '@prisma/client';
-export declare const maxDuration = 800;
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest) => Promise<NextResponse<{
+import { maxDuration } from './buildRoute';
+export { maxDuration };
+export declare const GET: (request: import("next/server").NextRequest) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     data: {
         id: string;
         role: "user" | "assistant";
         created_at: number;
-        content: OpenAI.Beta.Threads.Messages.MessageContent[];
+        content: import("openai/resources/beta/threads/messages.mjs").MessageContent[];
         run_id: string;
         assistant_id: string;
         thread_id: string;
-        attachments: OpenAI.Beta.Threads.Messages.Message.Attachment[];
+        attachments: import("openai/resources/beta/threads/messages.mjs").Message.Attachment[];
         metadata: import("openai/resources/shared.mjs").Metadata;
-        runSteps: Pick<OpenAI.Beta.Threads.Runs.Steps.RunStep, "id" | "run_id" | "step_details" | "completed_at" | "cancelled_at" | "failed_at" | "status">[];
+        runSteps: Pick<import("openai/resources/beta/threads/runs/steps.mjs").RunStep, "id" | "run_id" | "step_details" | "completed_at" | "cancelled_at" | "failed_at" | "status">[];
         status: "in_progress" | "incomplete" | "completed";
     }[];
     hasNextPage: boolean;
     lastId: null;
-}> | NextResponse<import("@superinterface/react/types/index").MessagesPage>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPOST: ({ prisma: providedPrisma, onSuccessCreateThread, }?: {
-    prisma?: PrismaClient;
-    onSuccessCreateThread?: ({ thread, }: {
-        thread: Thread;
-    }) => void | Promise<void>;
-}) => (request: NextRequest) => Promise<Response>;
-export declare const POST: ReturnType<typeof buildPOST>;
-export declare const OPTIONS: () => NextResponse<{}>;
+}> | import("next/server").NextResponse<import("@superinterface/react/types/index").MessagesPage>>;
+export declare const POST: (request: import("next/server").NextRequest) => Promise<Response>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/messages/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/messages/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,MAAM,MAAM,QAAQ,CAAA;AAC3B,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AA2B5C,eAAO,MAAM,WAAW,MAAM,CAAA;AAE9B,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MACpD,SAAS,WAAW;;;;;;;;;;;;;;;;;;4EA4K1B,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,SAAS,GACnB,qDAGE;IACD,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,qBAAqB,CAAC,EAAE,CAAC,EACvB,MAAM,GACP,EAAE;QACD,MAAM,EAAE,MAAM,CAAA;KACf,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB,MACC,SAAS,WAAW,sBAggB1B,CAAA;AAEH,eAAO,MAAM,IAAI,EACY,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA;AAEzD,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/messages/route.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,WAAW,EACZ,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,WAAW,EAAE,CAAA;AAEtB,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;kGAAuB,CAAA;AAEvC,eAAO,MAAM,IAAI,mEAAwB,CAAA;AAEzC,eAAO,MAAM,OAAO,8CAAiB,CAAA"}