@superinterface/server 1.0.0

package/src/app/api/files/route.ts

@@ -0,0 +1,117 @@
+import { isString } from 'radash'
+import type OpenAI from 'openai'
+import { StorageProviderType } from '@prisma/client'
+import { type NextRequest, NextResponse } from 'next/server'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { assistantClientAdapter } from '@/lib/assistants/assistantClientAdapter'
+import { workspaceAccessWhere as getWorkspaceAccessWhere } from '@/lib/apiKeys/workspaceAccessWhere'
+import { prisma } from '@/lib/prisma'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+
+export const POST = async (request: NextRequest) => {
+  const formData = await request.formData()
+  const assistantId = formData.get('assistantId')
+
+  if (!isString(assistantId)) {
+    return NextResponse.json({ error: 'Invalid assistantId' }, { status: 400 })
+  }
+
+  const publicApiKey = formData.get('publicApiKey')
+
+  if (!isString(publicApiKey)) {
+    return NextResponse.json({ error: 'Invalid publicApiKey' }, { status: 400 })
+  }
+
+  const file = formData.get('file')
+
+  const workspaceAccessWhere = await getWorkspaceAccessWhere({ publicApiKey })
+
+  if (!workspaceAccessWhere) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!assistantId) {
+    return NextResponse.json({ error: 'No assistantId found' }, { status: 400 })
+  }
+
+  if (!file) {
+    return NextResponse.json({ error: 'No file found' }, { status: 400 })
+  }
+
+  const assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspace: workspaceAccessWhere,
+    },
+    include: {
+      modelProvider: true,
+      tools: {
+        include: {
+          fileSearchTool: true,
+          webSearchTool: true,
+          imageGenerationTool: true,
+          codeInterpreterTool: true,
+          computerUseTool: true,
+        },
+      },
+      mcpServers: {
+        include: {
+          computerUseTool: true,
+          stdioTransport: true,
+          sseTransport: true,
+          httpTransport: true,
+        },
+      },
+      functions: true,
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  if (
+    isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    }) &&
+    !assistant.openaiAssistantId
+  ) {
+    return NextResponse.json(
+      { error: 'Assistant setup is not done.' },
+      { status: 400 },
+    )
+  }
+
+  const client = assistantClientAdapter({ assistant, prisma })
+  const purpose =
+    (formData.get('purpose') as OpenAI.FilePurpose) ?? 'assistants'
+
+  const createFileResponse = await client.files.create({
+    // @ts-expect-error file is Uploadable
+    file,
+    purpose,
+    ...(assistant.storageProviderType === StorageProviderType.OPENAI
+      ? {
+          expires_after: {
+            anchor: 'created_at',
+            seconds: 2592000, // 30 days
+          },
+        }
+      : {}),
+  })
+
+  return NextResponse.json(
+    {
+      file: createFileResponse,
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/messages/lib/getWorkspaceId.ts

@@ -0,0 +1,12 @@
+import type { Prisma, PrismaClient } from '@prisma/client'
+
+export const getWorkspaceId = async ({
+  workspaceAccessWhere,
+  prisma,
+}: {
+  workspaceAccessWhere: Prisma.WorkspaceWhereInput
+  prisma: PrismaClient
+}) =>
+  (await prisma.workspace.findFirst({
+    where: workspaceAccessWhere,
+  }))!.id

package/src/app/api/messages/lib/initialMessagesResponse.ts

@@ -0,0 +1,90 @@
+import dayjs from 'dayjs'
+import type OpenAI from 'openai'
+import { map } from 'p-iteration'
+import {
+  Prisma,
+  Assistant,
+  StorageProviderType,
+  MessageRole,
+} from '@prisma/client'
+import { optimisticId, serializeMessage } from '@superinterface/react/utils'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+import { isResponsesStorageProvider } from '@/lib/storageProviders/isResponsesStorageProvider'
+
+const assistantId = ({ assistant }: { assistant: Assistant }) => {
+  if (
+    isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    return assistant.openaiAssistantId
+  }
+
+  if (
+    isResponsesStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    return assistant.id
+  }
+
+  if (
+    assistant.storageProviderType === StorageProviderType.SUPERINTERFACE_CLOUD
+  ) {
+    return assistant.id
+  }
+
+  throw new Error('Invalid storage type')
+}
+
+export const initialMessagesResponse = async ({
+  assistant,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      initialMessages: true
+    }
+  }>
+}) => {
+  const threadId = optimisticId()
+  const initialCreatedAt = dayjs().unix()
+
+  return {
+    data: await map(assistant.initialMessages, async (message, index) =>
+      serializeMessage({
+        message: {
+          id: optimisticId(),
+          role: message.role.toLowerCase() as OpenAI.Beta.Threads.Messages.Message['role'],
+          created_at: initialCreatedAt - index - 1,
+          object:
+            'thread.message' as OpenAI.Beta.Threads.Messages.Message['object'],
+          content: [
+            {
+              type: 'text',
+              text: {
+                annotations: [],
+                value: message.content,
+              },
+            } as OpenAI.Beta.Threads.Messages.TextContentBlock,
+          ],
+          run_id: null,
+          assistant_id:
+            message.role === MessageRole.ASSISTANT
+              ? assistantId({ assistant })
+              : null,
+          thread_id: threadId,
+          attachments:
+            message.attachments as OpenAI.Beta.Threads.Messages.Message['attachments'],
+          metadata: message.metadata,
+          completed_at: initialCreatedAt - index - 1,
+          incomplete_at: null,
+          incomplete_details: null,
+          status: 'completed',
+          runSteps: [],
+        },
+      }),
+    ),
+    hasNextPage: false,
+    lastId: null,
+  }
+}

package/src/app/api/messages/lib/serializeThread.ts

@@ -0,0 +1,22 @@
+import { Prisma } from '@prisma/client'
+import dayjs from 'dayjs'
+import { storageThreadId } from '@/lib/threads/storageThreadId'
+
+export const serializeThread = ({
+  thread,
+}: {
+  thread: Prisma.ThreadGetPayload<{
+    include: {
+      assistant: {
+        select: {
+          storageProviderType: true
+        }
+      }
+    }
+  }>
+}) => ({
+  id: storageThreadId({ thread }),
+  object: 'thread',
+  created_at: dayjs(thread.createdAt).unix(),
+  metadata: thread.metadata,
+})