@superinterface/server 1.0.23 → 1.0.25

package/dist/app/messages/route.js

@@ -1,585 +0,0 @@
-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 { prisma } 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 GET = 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,
-    });
-    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 }),
-            },
-        });
-        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 }),
-            },
-        });
-        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 client = 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 }, (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,
-            },
-        });
-        return NextResponse.json({ error: 'Failed to load messages.' }, { status: 500 });
-    }
-};
-export const buildPOST = ({ 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,
-    });
-    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 }),
-            },
-        });
-        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 }),
-            },
-        });
-        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 }),
-            },
-        });
-        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,
-            },
-        });
-        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,
-                },
-            });
-            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,
-            },
-        });
-        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,
-            });
-            // 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,
-                },
-            });
-            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,
-            },
-        });
-        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,
-            },
-        });
-        return NextResponse.json({ error: 'Failed to get content.' }, { status: 500 });
-    }
-    const client = assistantClientAdapter({
-        assistant,
-        prisma,
-        thread,
-    });
-    try {
-        await client.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,
-            }) }));
-        // 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,
-            },
-        });
-        return NextResponse.json({ error: 'Failed to create message.' }, { status: 500 });
-    }
-    let createRunStream;
-    try {
-        createRunStream = await client.beta.threads.runs.create(storageThreadId, await createRunOpts({ assistant, 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 run stream: ${serializeError({ error })}`,
-                workspaceId: assistant.workspaceId,
-                assistantId: assistant.id,
-                threadId: thread.id,
-            },
-        });
-        return NextResponse.json({ error: 'Failed to create run stream.' }, { status: 500 });
-    }
-    let latestInProgressRunData = null;
-    let latestCompletedRunData = null;
-    return new Response(createMessageResponse({
-        client,
-        createRunStream,
-        handleToolCall: handleToolCall({ assistant, thread }),
-        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,
-                },
-            });
-            // if (latestInProgressRunData) {
-            //   await client.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,
-                    },
-                });
-            }
-            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 client.beta.threads.runs.cancel(latestInProgressRunData.id, {
-                    thread_id: latestInProgressRunData.thread_id,
-                });
-            }
-        },
-    }), {
-        status: 200,
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8',
-        },
-    });
-};
-export const POST = buildPOST({});
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});

package/dist/lib/prismaClient.d.ts

@@ -1,5 +0,0 @@
-import { PrismaClient } from '../../generated/prisma/index';
-export * from '../../generated/prisma/index';
-export { PrismaClient };
-export default PrismaClient;
-//# sourceMappingURL=prismaClient.d.ts.map

package/dist/lib/prismaClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prismaClient.d.ts","sourceRoot":"","sources":["../../src/lib/prismaClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAE3D,cAAc,8BAA8B,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,CAAA;AACvB,eAAe,YAAY,CAAA"}

package/dist/lib/prismaClient.js

@@ -1,4 +0,0 @@
-import { PrismaClient } from '../../generated/prisma/index';
-export * from '../../generated/prisma/index';
-export { PrismaClient };
-export default PrismaClient;