@superinterface/server 1.0.0

package/src/app/api/providers/[modelProviderId]/assistants/route.ts

@@ -0,0 +1,68 @@
+import { headers } from 'next/headers'
+import { ApiKeyType } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { getStorageProviderAssistants } from '@/lib/storageProviders/getStorageProviderAssistants'
+import { serializeApiStorageProviderAssistant } from '@/lib/storageProviders/serializeApiStorageProviderAssistant'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ modelProviderId: string }> },
+) => {
+  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,
+  })
+
+  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 OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/providers/[modelProviderId]/models/route.ts

@@ -0,0 +1,68 @@
+import { headers } from 'next/headers'
+import { ApiKeyType } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { getModels } from '@/lib/models/getModels'
+import { serializeApiModel } from '@/lib/models/serializeApiModel'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ modelProviderId: string }> },
+) => {
+  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,
+  })
+
+  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 models = await getModels({
+    modelProvider: provider,
+  })
+
+  return NextResponse.json(
+    {
+      models: models.map((model) =>
+        serializeApiModel({
+          model,
+        }),
+      ),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/providers/[modelProviderId]/route.ts

@@ -0,0 +1,202 @@
+import { headers } from 'next/headers'
+import { ApiKeyType, ModelProviderType, Prisma } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeModelProvider } from '@/lib/modelProviders/serializeModelProvider'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { validate } from 'uuid'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ modelProviderId: string }> },
+) => {
+  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,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!validate(modelProviderId)) {
+    return NextResponse.json({ error: 'Invalid provider id' }, { status: 400 })
+  }
+
+  const provider = await prisma.modelProvider.findFirst({
+    where: {
+      id: modelProviderId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (!provider) {
+    return NextResponse.json({ error: 'No provider found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      provider: serializeModelProvider({ provider }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PATCH = async (
+  request: NextRequest,
+  props: { params: Promise<{ modelProviderId: string }> },
+) => {
+  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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!validate(modelProviderId)) {
+    return NextResponse.json({ error: 'Invalid provider id' }, { status: 400 })
+  }
+
+  const body = await request.json()
+  const schema = z.object({
+    type: z.nativeEnum(ModelProviderType).optional(),
+    name: z.string().optional(),
+    apiKey: z.string().optional(),
+    endpoint: z.string().optional().nullable(),
+    apiVersion: z.string().optional().nullable(),
+  })
+
+  const parsed = schema.safeParse(body)
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const { type, apiKey: providerKey, endpoint, apiVersion, name } = parsed.data
+  const updateData: Prisma.ModelProviderUpdateInput = {
+    ...(type ? { type } : {}),
+    ...(name !== undefined ? { name } : {}),
+    ...(providerKey !== undefined ? { apiKey: providerKey } : {}),
+    ...(endpoint !== undefined ? { endpoint } : {}),
+    ...(apiVersion !== undefined ? { apiVersion } : {}),
+  }
+
+  const existingProvider = await prisma.modelProvider.findFirst({
+    where: {
+      id: modelProviderId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (!existingProvider) {
+    return NextResponse.json({ error: 'No provider found' }, { status: 400 })
+  }
+
+  const provider = await prisma.modelProvider.update({
+    where: { id: modelProviderId },
+    data: updateData,
+  })
+
+  return NextResponse.json(
+    {
+      provider: serializeModelProvider({ provider }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const DELETE = async (
+  _request: NextRequest,
+  props: { params: Promise<{ modelProviderId: string }> },
+) => {
+  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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!validate(modelProviderId)) {
+    return NextResponse.json({ error: 'Invalid provider id' }, { status: 400 })
+  }
+
+  const assistantsUsingProvider = await prisma.assistant.count({
+    where: {
+      modelProviderId: modelProviderId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (assistantsUsingProvider > 0) {
+    return NextResponse.json({ error: 'Provider in use' }, { status: 400 })
+  }
+
+  const existingProvider = await prisma.modelProvider.findFirst({
+    where: {
+      id: modelProviderId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (!existingProvider) {
+    return NextResponse.json({ error: 'No provider found' }, { status: 400 })
+  }
+
+  const provider = await prisma.modelProvider.delete({
+    where: { id: modelProviderId },
+  })
+
+  return NextResponse.json(
+    {
+      provider: serializeModelProvider({ provider }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

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

@@ -0,0 +1,105 @@
+import { headers } from 'next/headers'
+import { ApiKeyType, ModelProviderType } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeModelProvider } from '@/lib/modelProviders/serializeModelProvider'
+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({
+    type: ApiKeyType.PRIVATE,
+    authorization,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  const providers = await prisma.modelProvider.findMany({
+    where: {
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  return NextResponse.json(
+    {
+      providers: providers.map((p) => serializeModelProvider({ provider: p })),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const POST = async (request: NextRequest) => {
+  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 body = await request.json()
+  const schema = z.object({
+    type: z.nativeEnum(ModelProviderType),
+    name: z.string().optional(),
+    apiKey: z.string().optional(),
+    endpoint: z.string().optional().nullable(),
+    apiVersion: z.string().optional().nullable(),
+  })
+
+  const parsed = schema.safeParse(body)
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const { type, name, apiKey: providerKey, endpoint, apiVersion } = parsed.data
+  const workspaceId = privateApiKey.workspaceId
+
+  const provider = await prisma.modelProvider.create({
+    data: {
+      type: type as ModelProviderType,
+      name: name ?? '',
+      apiKey: providerKey ?? '',
+      endpoint: endpoint ?? null,
+      apiVersion: apiVersion ?? null,
+      workspaceId,
+    },
+  })
+
+  return NextResponse.json(
+    {
+      provider: serializeModelProvider({ provider }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/tasks/[taskId]/route.ts

@@ -0,0 +1,213 @@
+import { headers } from 'next/headers'
+import { ApiKeyType } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { z } from 'zod'
+import { validate } from 'uuid'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeTask } from '@/lib/tasks/serializeTask'
+import { validateSchedule } from '@/lib/tasks/validateSchedule'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { scheduleTask } from '@/lib/tasks/scheduleTask'
+import { cancelScheduledTask } from '@/lib/tasks/cancelScheduledTask'
+
+const updateTaskSchema = z.object({
+  title: z.string().optional(),
+  message: z.string().optional(),
+  schedule: z.any().optional(),
+  key: z.string().optional(),
+})
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ taskId: string }> },
+) => {
+  const { taskId } = 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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!taskId) {
+    return NextResponse.json({ error: 'No task id found' }, { status: 400 })
+  }
+
+  if (!validate(taskId)) {
+    return NextResponse.json({ error: 'Invalid task id' }, { status: 400 })
+  }
+
+  const task = await prisma.task.findFirst({
+    where: {
+      id: taskId,
+      thread: { assistant: { workspaceId: privateApiKey.workspaceId } },
+    },
+  })
+
+  if (!task) {
+    return NextResponse.json({ error: 'No task found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    { task: serializeTask({ task }) },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PATCH = async (
+  request: NextRequest,
+  props: { params: Promise<{ taskId: string }> },
+) => {
+  const { taskId } = 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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!taskId) {
+    return NextResponse.json({ error: 'No task id found' }, { status: 400 })
+  }
+
+  if (!validate(taskId)) {
+    return NextResponse.json({ error: 'Invalid task id' }, { status: 400 })
+  }
+
+  const parsed = updateTaskSchema.safeParse(await request.json())
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const updateData = {
+    ...(parsed.data.title !== undefined ? { title: parsed.data.title } : {}),
+    ...(parsed.data.message !== undefined
+      ? { message: parsed.data.message }
+      : {}),
+    ...(parsed.data.schedule !== undefined
+      ? {
+          ...(validateSchedule(parsed.data.schedule)
+            ? { schedule: parsed.data.schedule }
+            : {}),
+        }
+      : {}),
+    ...(parsed.data.key !== undefined ? { key: parsed.data.key } : {}),
+  }
+
+  if (
+    parsed.data.schedule !== undefined &&
+    !validateSchedule(parsed.data.schedule)
+  ) {
+    return NextResponse.json({ error: 'Invalid schedule' }, { status: 400 })
+  }
+
+  const existingTask = await prisma.task.findFirst({
+    where: {
+      id: taskId,
+      thread: { assistant: { workspaceId: privateApiKey.workspaceId } },
+    },
+  })
+
+  if (!existingTask) {
+    return NextResponse.json({ error: 'No task found' }, { status: 400 })
+  }
+
+  const task = await prisma.task.update({
+    where: { id: existingTask.id },
+    data: updateData,
+  })
+
+  await scheduleTask({ task })
+
+  return NextResponse.json(
+    { task: serializeTask({ task }) },
+    { headers: cacheHeaders },
+  )
+}
+
+export const DELETE = async (
+  _request: NextRequest,
+  props: { params: Promise<{ taskId: string }> },
+) => {
+  const { taskId } = 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({
+    authorization,
+    type: ApiKeyType.PRIVATE,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  if (!taskId) {
+    return NextResponse.json({ error: 'No task id found' }, { status: 400 })
+  }
+
+  if (!validate(taskId)) {
+    return NextResponse.json({ error: 'Invalid task id' }, { status: 400 })
+  }
+
+  const existingTask = await prisma.task.findFirst({
+    where: {
+      id: taskId,
+      thread: { assistant: { workspaceId: privateApiKey.workspaceId } },
+    },
+  })
+
+  if (!existingTask) {
+    return NextResponse.json({ error: 'No task found' }, { status: 400 })
+  }
+
+  await cancelScheduledTask({ task: existingTask })
+
+  const task = await prisma.task.delete({ where: { id: existingTask.id } })
+
+  return NextResponse.json(
+    { task: serializeTask({ task }) },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )