@superinterface/server 1.0.0

package/src/app/api/assistants/[assistantId]/route.ts

@@ -0,0 +1,336 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  StorageProviderType,
+  Prisma,
+  ApiKeyType,
+  ToolType,
+} from '@prisma/client'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { workspaceAccessWhere as getWorkspaceAccessWhere } from '@/lib/apiKeys/workspaceAccessWhere'
+import { prisma } from '@/lib/prisma'
+import { serializeAssistant } from '@/lib/assistants/serializeAssistant'
+import { serializeApiAssistant } from '@/lib/assistants/serializeApiAssistant'
+import { headers } from 'next/headers'
+import { z } from 'zod'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+
+export const GET = async (
+  request: NextRequest,
+  props: {
+    params: Promise<{
+      assistantId: string
+    }>
+  },
+) => {
+  const params = await props.params
+
+  const { assistantId } = params
+
+  const headersList = await headers()
+  const authorization = headersList.get('authorization')
+
+  if (authorization) {
+    const privateApiKey = await getApiKey({
+      authorization,
+      type: ApiKeyType.PRIVATE,
+    })
+
+    if (!privateApiKey) {
+      return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+    }
+
+    const assistant = await prisma.assistant.findUnique({
+      where: {
+        id: assistantId,
+        workspaceId: privateApiKey.workspaceId,
+      },
+      include: {
+        tools: true,
+        avatar: {
+          include: {
+            imageAvatar: true,
+            iconAvatar: true,
+          },
+        },
+      },
+    })
+
+    if (!assistant) {
+      return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+    }
+
+    return NextResponse.json(
+      {
+        assistant: serializeApiAssistant({ assistant }),
+      },
+      { headers: cacheHeaders },
+    )
+  }
+
+  const workspaceAccessWhere = await getWorkspaceAccessWhere({
+    publicApiKey: request.nextUrl.searchParams.get('publicApiKey'),
+  })
+
+  if (!workspaceAccessWhere) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!assistantId) {
+    return NextResponse.json(
+      { error: 'No assistant id found' },
+      { status: 400 },
+    )
+  }
+
+  const assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspace: workspaceAccessWhere,
+    },
+    include: {
+      avatar: {
+        include: {
+          imageAvatar: true,
+          iconAvatar: true,
+        },
+      },
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      assistant: serializeAssistant({ assistant }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PATCH = async (
+  request: NextRequest,
+  props: {
+    params: Promise<{
+      assistantId: string
+    }>
+  },
+) => {
+  const params = await props.params
+
+  const { assistantId } = 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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  const updateSchema = z
+    .object({
+      storageProviderType: z.nativeEnum(StorageProviderType).optional(),
+      storageProviderAssistantId: z.string().nullable().optional(),
+      modelProviderId: z.string().optional(),
+      model: z.string().optional(),
+      name: z.string().optional(),
+      description: z.string().optional(),
+      instructions: z.string().optional(),
+      codeInterpreterEnabled: z.boolean().optional(),
+      fileSearchEnabled: z.boolean().optional(),
+    })
+    .superRefine((data, ctx) => {
+      if (!data.storageProviderType) return
+
+      if (
+        data.storageProviderType === StorageProviderType.SUPERINTERFACE_CLOUD &&
+        data.storageProviderAssistantId
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message:
+            'storageProviderAssistantId should not be provided for SUPERINTERFACE_CLOUD',
+          path: ['storageProviderAssistantId'],
+        })
+      }
+
+      if (
+        data.storageProviderType !== StorageProviderType.SUPERINTERFACE_CLOUD &&
+        !data.storageProviderAssistantId
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message:
+            'storageProviderAssistantId is required for this storage provider',
+          path: ['storageProviderAssistantId'],
+        })
+      }
+    })
+
+  const parseResult = updateSchema.safeParse(await request.json())
+
+  if (!parseResult.success) {
+    return NextResponse.json(
+      {
+        error: 'Invalid body: ' + parseResult.error.message,
+      },
+      { status: 400 },
+    )
+  }
+
+  const {
+    storageProviderType,
+    storageProviderAssistantId,
+    modelProviderId,
+    model,
+    name,
+    description,
+    instructions,
+    codeInterpreterEnabled,
+    fileSearchEnabled,
+  } = parseResult.data
+
+  const data: Prisma.AssistantUpdateInput = {
+    ...(storageProviderType !== undefined && { storageProviderType }),
+    ...(storageProviderAssistantId !== undefined && {
+      openaiAssistantId: storageProviderAssistantId,
+    }),
+    ...(modelProviderId !== undefined && {
+      modelProvider: { connect: { id: modelProviderId } },
+    }),
+    ...(model !== undefined && { modelSlug: model }),
+    ...(name !== undefined && { name }),
+    ...(description !== undefined && { description }),
+    ...(instructions !== undefined && { instructions }),
+    tools: {
+      create: [
+        ...(codeInterpreterEnabled === true
+          ? [
+              {
+                type: ToolType.CODE_INTERPRETER,
+                codeInterpreterTool: { create: {} },
+              },
+            ]
+          : []),
+        ...(fileSearchEnabled === true
+          ? [{ type: ToolType.FILE_SEARCH, fileSearchTool: { create: {} } }]
+          : []),
+      ],
+      deleteMany: [
+        ...(codeInterpreterEnabled === false
+          ? [{ assistantId, type: ToolType.CODE_INTERPRETER }]
+          : []),
+        ...(fileSearchEnabled === false
+          ? [{ assistantId, type: ToolType.FILE_SEARCH }]
+          : []),
+      ],
+    },
+  }
+
+  const assistant = await prisma.assistant.update({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+    data,
+    include: {
+      tools: true,
+      avatar: {
+        include: {
+          imageAvatar: true,
+          iconAvatar: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      assistant: serializeApiAssistant({ assistant }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const DELETE = async (
+  request: NextRequest,
+  props: {
+    params: Promise<{
+      assistantId: string
+    }>
+  },
+) => {
+  const params = await props.params
+
+  const { assistantId } = 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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+  const assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+    include: {
+      tools: true,
+      avatar: {
+        include: {
+          imageAvatar: true,
+          iconAvatar: true,
+        },
+      },
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  await prisma.assistant.delete({
+    where: {
+      id: assistant.id,
+    },
+  })
+
+  return NextResponse.json(
+    {
+      assistant: serializeApiAssistant({ assistant }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

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

@@ -0,0 +1,196 @@
+import { headers } from 'next/headers'
+import { ApiKeyType, StorageProviderType, ToolType } from '@prisma/client'
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeApiAssistant } from '@/lib/assistants/serializeApiAssistant'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+
+export const GET = async () => {
+  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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  const assistants = await prisma.assistant.findMany({
+    where: {
+      workspaceId: privateApiKey.workspaceId,
+    },
+    include: {
+      tools: true,
+      avatar: {
+        include: {
+          imageAvatar: true,
+          iconAvatar: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      assistants: assistants.map((a) =>
+        serializeApiAssistant({ assistant: a }),
+      ),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+const createAssistantSchema = z
+  .object({
+    storageProviderType: z.nativeEnum(StorageProviderType),
+    storageProviderAssistantId: z.string().nullable().optional(),
+    modelProviderId: z.string(),
+    model: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional().default(''),
+    instructions: z.string().optional().default(''),
+    codeInterpreterEnabled: z.boolean().optional().default(false),
+    fileSearchEnabled: z.boolean().optional().default(false),
+  })
+  .superRefine((data, ctx) => {
+    if (
+      data.storageProviderType === StorageProviderType.SUPERINTERFACE_CLOUD &&
+      data.storageProviderAssistantId
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          'storageProviderAssistantId should not be provided for SUPERINTERFACE_CLOUD',
+        path: ['storageProviderAssistantId'],
+      })
+    }
+
+    if (
+      data.storageProviderType !== StorageProviderType.SUPERINTERFACE_CLOUD &&
+      !data.storageProviderAssistantId
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          'storageProviderAssistantId is required for this storage provider',
+        path: ['storageProviderAssistantId'],
+      })
+    }
+  })
+
+export const POST = async (request: Request) => {
+  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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  const parseResult = createAssistantSchema.safeParse(await request.json())
+
+  if (!parseResult.success) {
+    return NextResponse.json(
+      {
+        error: `Missing required fields. ${JSON.stringify(parseResult.error.format())}`,
+      },
+      { status: 400 },
+    )
+  }
+
+  const {
+    storageProviderType,
+    storageProviderAssistantId,
+    modelProviderId,
+    model,
+    name,
+    description,
+    instructions,
+    codeInterpreterEnabled,
+    fileSearchEnabled,
+  } = parseResult.data
+
+  const workspaceId = privateApiKey.workspaceId
+
+  const assistant = await prisma.assistant.create({
+    data: {
+      workspace: { connect: { id: workspaceId } },
+      modelProvider: { connect: { id: modelProviderId } },
+      modelSlug: model,
+      name,
+      description,
+      instructions,
+      storageProviderType,
+      openaiAssistantId: storageProviderAssistantId ?? null,
+      tools: {
+        create: [
+          ...(fileSearchEnabled
+            ? [
+                {
+                  type: ToolType.FILE_SEARCH,
+                  fileSearchTool: {
+                    create: {},
+                  },
+                },
+              ]
+            : []),
+          ...(codeInterpreterEnabled
+            ? [
+                {
+                  type: ToolType.CODE_INTERPRETER,
+                  codeInterpreterTool: {
+                    create: {},
+                  },
+                },
+              ]
+            : []),
+        ],
+      },
+    },
+    include: {
+      tools: true,
+      avatar: {
+        include: {
+          imageAvatar: true,
+          iconAvatar: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      assistant: serializeApiAssistant({ assistant }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/files/[fileId]/contents/route.ts

@@ -0,0 +1,145 @@
+import type { OpenAI } from 'openai'
+import { isString } from 'radash'
+import type { Prisma } 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 buildGET =
+  ({
+    purposeAssistantsResponse = () =>
+      NextResponse.json({ error: 'No file source found' }, { status: 404 }),
+  }: {
+    purposeAssistantsResponse?: ({
+      file,
+    }: {
+      file: OpenAI.Files.FileObject
+      workspaceAccessWhere: Prisma.WorkspaceWhereInput
+    }) => Promise<NextResponse> | NextResponse
+  }) =>
+  async (
+    request: NextRequest,
+    props: {
+      params: Promise<{
+        fileId: string
+      }>
+    },
+  ) => {
+    const params = await props.params
+
+    const { fileId } = params
+
+    const assistantId = request.nextUrl.searchParams.get('assistantId')
+
+    if (!isString(assistantId)) {
+      return NextResponse.json(
+        { error: 'Invalid assistantId' },
+        { status: 400 },
+      )
+    }
+
+    const publicApiKey = request.nextUrl.searchParams.get('publicApiKey')
+
+    if (!isString(publicApiKey)) {
+      return NextResponse.json(
+        { error: 'Invalid publicApiKey' },
+        { status: 400 },
+      )
+    }
+
+    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 },
+      )
+    }
+
+    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 file = await client.files.retrieve(fileId)
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file found' }, { status: 404 })
+    }
+
+    if (file.purpose === 'assistants') {
+      return purposeAssistantsResponse({ file, workspaceAccessWhere })
+    }
+
+    const fileContentResponse = await client.files.content(fileId)
+    const fileData = await fileContentResponse.arrayBuffer()
+
+    return new NextResponse(fileData, {
+      headers: {
+        ...cacheHeaders,
+        'Content-Type':
+          fileContentResponse.headers.get('Content-Type') ??
+          'application/octet-stream',
+        'Content-Disposition':
+          fileContentResponse.headers.get('Content-Disposition') ?? 'inline',
+      },
+    })
+  }
+
+export const GET = buildGET({})
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )