@superinterface/server 1.0.0

package/src/app/api/api-keys/route.ts

@@ -0,0 +1,147 @@
+import { headers } from 'next/headers'
+import { ApiKeyType } from '@prisma/client'
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeApiKey } from '@/lib/apiKeys/serializeApiKey'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { getOrganizationApiKey } from '@/lib/organizationApiKeys/getOrganizationApiKey'
+
+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 apiKeys = await prisma.apiKey.findMany({
+    where: {
+      type: ApiKeyType.PUBLIC,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  return NextResponse.json(
+    {
+      apiKeys: apiKeys.map((apiKey) => serializeApiKey({ apiKey })),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+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 body = await request.json().catch(() => null)
+
+  const organizationApiKey = await getOrganizationApiKey({
+    authorization,
+  })
+
+  if (organizationApiKey) {
+    const createSchemaOrganizationApiKey = z.object({
+      name: z.string().min(1).optional(),
+      type: z.nativeEnum(ApiKeyType),
+      workspaceId: z.string().min(1).optional(),
+    })
+
+    const parsedOrganizationApiKey =
+      createSchemaOrganizationApiKey.safeParse(body)
+
+    if (!parsedOrganizationApiKey.success) {
+      return NextResponse.json({ error: 'Invalid body' }, { status: 400 })
+    }
+
+    const workspace = await prisma.workspace.findUnique({
+      where: {
+        id: parsedOrganizationApiKey.data.workspaceId,
+        organizationId: organizationApiKey.organizationId,
+      },
+    })
+
+    if (!workspace) {
+      return NextResponse.json({ error: 'Invalid workspace' }, { status: 400 })
+    }
+
+    const apiKey = await prisma.apiKey.create({
+      data: {
+        type: parsedOrganizationApiKey.data.type,
+        name: parsedOrganizationApiKey.data.name,
+        workspaceId: workspace.id,
+      },
+    })
+
+    return NextResponse.json(
+      {
+        apiKey: serializeApiKey({ apiKey }),
+      },
+      { headers: cacheHeaders },
+    )
+  }
+
+  const privateApiKey = await getApiKey({
+    type: ApiKeyType.PRIVATE,
+    authorization,
+  })
+
+  if (!privateApiKey) {
+    return NextResponse.json({ error: 'Invalid api key' }, { status: 400 })
+  }
+
+  const createSchema = z.object({
+    name: z.string().min(1).optional(),
+  })
+
+  const parsed = createSchema.safeParse(body)
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid body' }, { status: 400 })
+  }
+
+  const { name } = parsed.data
+
+  const workspaceId = privateApiKey.workspaceId
+
+  const apiKey = await prisma.apiKey.create({
+    data: {
+      type: ApiKeyType.PUBLIC,
+      name,
+      workspaceId,
+    },
+  })
+
+  return NextResponse.json(
+    {
+      apiKey: serializeApiKey({ apiKey }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

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

@@ -0,0 +1,245 @@
+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 { validate } from 'uuid'
+import { serializeApiFunction } from '@/lib/functions/serializeApiFunction'
+import { functionSchema } from '@/lib/functions/functionSchema'
+import { updateFunction } from '@/lib/functions/updateFunction'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ assistantId: string; functionId: string }> },
+) => {
+  const { assistantId, functionId } = 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(assistantId)) {
+    return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 })
+  }
+
+  if (!validate(functionId)) {
+    return NextResponse.json({ error: 'Invalid function id' }, { status: 400 })
+  }
+
+  const fn = await prisma.function.findFirst({
+    where: {
+      id: functionId,
+      assistant: {
+        id: assistantId,
+        workspaceId: privateApiKey.workspaceId,
+      },
+    },
+    include: {
+      handler: {
+        include: {
+          requestHandler: true,
+          firecrawlHandler: true,
+          replicateHandler: true,
+          clientToolHandler: true,
+          assistantHandler: true,
+          createTaskHandler: true,
+          listTasksHandler: true,
+          updateTaskHandler: true,
+          deleteTaskHandler: true,
+        },
+      },
+    },
+  })
+
+  if (!fn) {
+    return NextResponse.json({ error: 'No function found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      function: serializeApiFunction({ fn }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PATCH = async (
+  request: NextRequest,
+  props: { params: Promise<{ assistantId: string; functionId: string }> },
+) => {
+  const { assistantId, functionId } = 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(assistantId)) {
+    return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 })
+  }
+
+  if (!validate(functionId)) {
+    return NextResponse.json({ error: 'Invalid function id' }, { status: 400 })
+  }
+
+  const body = await request.json()
+
+  const parsed = functionSchema.safeParse(body)
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const fn = await prisma.function.findFirst({
+    where: {
+      id: functionId,
+      assistant: {
+        id: assistantId,
+        workspaceId: privateApiKey.workspaceId,
+      },
+    },
+    include: {
+      assistant: true,
+    },
+  })
+
+  if (!fn) {
+    return NextResponse.json({ error: 'No function found' }, { status: 400 })
+  }
+
+  const updatedFunction = await updateFunction({
+    fn,
+    parsedInput: parsed.data,
+    include: {
+      handler: {
+        include: {
+          requestHandler: true,
+          firecrawlHandler: true,
+          replicateHandler: true,
+          clientToolHandler: true,
+          assistantHandler: true,
+          createTaskHandler: true,
+          listTasksHandler: true,
+          updateTaskHandler: true,
+          deleteTaskHandler: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      function: serializeApiFunction({ fn: updatedFunction }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const DELETE = async (
+  _request: NextRequest,
+  props: { params: Promise<{ assistantId: string; functionId: string }> },
+) => {
+  const { assistantId, functionId } = 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(assistantId)) {
+    return NextResponse.json({ error: 'Invalid assistant id' }, { status: 400 })
+  }
+
+  if (!validate(functionId)) {
+    return NextResponse.json({ error: 'Invalid function id' }, { status: 400 })
+  }
+
+  const fn = await prisma.function.findFirst({
+    where: {
+      id: functionId,
+      assistant: {
+        id: assistantId,
+        workspaceId: privateApiKey.workspaceId,
+      },
+    },
+  })
+
+  if (!fn) {
+    return NextResponse.json({ error: 'No function found' }, { status: 400 })
+  }
+
+  const deletedFunction = await prisma.function.delete({
+    where: { id: fn.id },
+    include: {
+      handler: {
+        include: {
+          requestHandler: true,
+          firecrawlHandler: true,
+          replicateHandler: true,
+          clientToolHandler: true,
+          assistantHandler: true,
+          createTaskHandler: true,
+          listTasksHandler: true,
+          updateTaskHandler: true,
+          deleteTaskHandler: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      mcpServer: serializeApiFunction({ fn: deletedFunction }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

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

@@ -0,0 +1,157 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { ApiKeyType } from '@prisma/client'
+import { headers } from 'next/headers'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+import { serializeApiFunction } from '@/lib/functions/serializeApiFunction'
+import { functionSchema } from '@/lib/functions/functionSchema'
+import { createFunction } from '@/lib/functions/createFunction'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ assistantId: string }> },
+) => {
+  const { assistantId } = 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 assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+    include: {
+      functions: {
+        include: {
+          handler: {
+            include: {
+              requestHandler: true,
+              firecrawlHandler: true,
+              replicateHandler: true,
+              clientToolHandler: true,
+              assistantHandler: true,
+              createTaskHandler: true,
+              listTasksHandler: true,
+              updateTaskHandler: true,
+              deleteTaskHandler: true,
+            },
+          },
+        },
+        orderBy: {
+          createdAt: 'desc',
+        },
+      },
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      functions: assistant.functions.map((fn) =>
+        serializeApiFunction({
+          fn,
+        }),
+      ),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const POST = async (
+  request: NextRequest,
+  props: { params: Promise<{ assistantId: string }> },
+) => {
+  const { assistantId } = 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 })
+  }
+
+  const assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  const body = await request.json()
+  const parsed = functionSchema.safeParse(body)
+
+  if (!parsed.success) {
+    console.error('Function creation error:', parsed.error)
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const fn = await createFunction({
+    parsedInput: parsed.data,
+    assistant,
+    include: {
+      handler: {
+        include: {
+          requestHandler: true,
+          firecrawlHandler: true,
+          replicateHandler: true,
+          clientToolHandler: true,
+          assistantHandler: true,
+          createTaskHandler: true,
+          listTasksHandler: true,
+          updateTaskHandler: true,
+          deleteTaskHandler: true,
+        },
+      },
+    },
+  })
+
+  return NextResponse.json(
+    {
+      function: serializeApiFunction({ fn }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

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

@@ -0,0 +1,127 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { ApiKeyType, InitialMessage } from '@prisma/client'
+import { headers } from 'next/headers'
+import { cacheHeaders } from '@/lib/cache/cacheHeaders'
+import { prisma } from '@/lib/prisma'
+import { serializeApiInitialMessage } from '@/lib/initialMessages/serializeApiInitialMessage'
+import { initialMessagesSchema } from '@/lib/initialMessages/schema'
+import { updateInitialMessages } from '@/lib/initialMessages/updateInitialMessages'
+import { getApiKey } from '@/lib/apiKeys/getApiKey'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ assistantId: string }> },
+) => {
+  const { assistantId } = 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 assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+    include: {
+      initialMessages: {
+        orderBy: {
+          orderNumber: 'asc',
+        },
+      },
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      initialMessages: assistant.initialMessages.map((m) =>
+        serializeApiInitialMessage({ initialMessage: m }),
+      ),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PUT = async (
+  request: NextRequest,
+  props: { params: Promise<{ assistantId: string }> },
+) => {
+  const { assistantId } = 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 })
+  }
+
+  const body = await request.json()
+  const bodyParse = initialMessagesSchema.safeParse(body)
+
+  if (!bodyParse.success) {
+    return NextResponse.json({ error: 'Invalid body' }, { status: 400 })
+  }
+  const { initialMessages } = bodyParse.data
+
+  const assistant = await prisma.assistant.findFirst({
+    where: {
+      id: assistantId,
+      workspaceId: privateApiKey.workspaceId,
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  const messages = await updateInitialMessages({
+    assistantId: assistant.id,
+    initialMessages,
+  })
+
+  return NextResponse.json(
+    {
+      initialMessages: messages.map((m: InitialMessage) =>
+        serializeApiInitialMessage({ initialMessage: m }),
+      ),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )