@superinterface/server 1.0.0

package/src/app/api/tasks/callback/route.ts

@@ -0,0 +1,280 @@
+import { NextResponse } from 'next/server'
+import { verifySignatureAppRouter } from '@upstash/qstash/nextjs'
+import { createMessageResponse } from '@superinterface/react/server'
+import { LogRequestMethod, LogRequestRoute, LogLevel } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+import { assistantClientAdapter } from '@/lib/assistants/assistantClientAdapter'
+import { createRunOpts } from '@/lib/runs/createRunOpts'
+import { scheduleTask } from '@/lib/tasks/scheduleTask'
+import { handleToolCall } from '@/lib/toolCalls/handleToolCall'
+import { createLog } from '@/lib/logs/createLog'
+import { map } from 'p-iteration'
+import { storageThreadId as getStorageThreadId } from '@/lib/threads/storageThreadId'
+import { redis } from '@/lib/redis'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+import { managedOpenaiThreadId } from '@/lib/threads/managedOpenaiThreadId'
+import { serializeMetadata } from '@/lib/metadata/serializeMetadata'
+
+export const maxDuration = 800
+
+const postHandler = async (request: Request) => {
+  const { taskId } = await request.json()
+  const task = await prisma.task.findUnique({
+    where: { id: taskId },
+    include: {
+      thread: {
+        include: {
+          assistant: {
+            include: {
+              modelProvider: 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,
+                    },
+                  },
+                },
+              },
+              mcpServers: {
+                include: {
+                  computerUseTool: true,
+                  stdioTransport: true,
+                  sseTransport: true,
+                  httpTransport: true,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  })
+
+  if (!task) {
+    return NextResponse.json({ error: 'Task not found' }, { status: 400 })
+  }
+
+  const assistant = task.thread.assistant
+  const thread = task.thread
+  const client = assistantClientAdapter({ assistant, prisma })
+
+  let storageThreadId
+
+  try {
+    storageThreadId = getStorageThreadId({
+      thread,
+    })
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (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,
+    })
+  ) {
+    try {
+      storageThreadId = await managedOpenaiThreadId({
+        assistant,
+        threadId: thread.id,
+      })
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      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 },
+    )
+  }
+
+  try {
+    await client.beta.threads.messages.create(storageThreadId, {
+      role: 'user',
+      content: task.message,
+      metadata: serializeMetadata({
+        variables: {
+          superinterfaceCreatedByType: 'TASK',
+          superinterfaceCreatedById: task.id,
+        },
+        workspaceId: assistant.workspaceId,
+      }),
+    })
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
+    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: any) {
+    console.log({ error })
+    createLog({
+      log: {
+        requestMethod: LogRequestMethod.POST,
+        requestRoute: LogRequestRoute.MESSAGES,
+        level: LogLevel.ERROR,
+        status: 500,
+        message: `Failed to create run stream: ${error.message}`,
+        workspaceId: assistant.workspaceId,
+        assistantId: assistant.id,
+        threadId: thread.id,
+      },
+    })
+    return NextResponse.json(
+      { error: 'Failed to create run stream' },
+      { status: 500 },
+    )
+  }
+
+  const messageResponse = createMessageResponse({
+    client,
+    createRunStream,
+    handleToolCall: handleToolCall({ assistant, thread }),
+  })
+
+  const decoder = new TextDecoder()
+
+  const reader = messageResponse.getReader()
+  while (true) {
+    const { value, done } = await reader.read()
+    if (done) break
+
+    if (!value) continue
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let event: any
+
+    try {
+      event = JSON.parse(decoder.decode(value))
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (e) {
+      continue
+    }
+
+    if (
+      event.event === 'thread.run.requires_action' &&
+      event.data?.required_action?.type === 'submit_client_tool_outputs'
+    ) {
+      await map(
+        event.data.required_action.submit_client_tool_outputs.tool_calls,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (toolCall: any) => {
+          await redis.set(
+            `submit-client-tool-outputs:output:${toolCall.id}`,
+            'Client tools cannot be used during tasks',
+            { ex: 60 * 60 * 24 * 7 },
+          )
+        },
+      )
+    }
+  }
+
+  await scheduleTask({ task })
+
+  return NextResponse.json({ ok: true })
+}
+
+export const POST =
+  process.env.NODE_ENV === 'test' || !process.env.QSTASH_CURRENT_SIGNING_KEY
+    ? postHandler
+    : verifySignatureAppRouter(postHandler)

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

@@ -0,0 +1,121 @@
+import { headers } from 'next/headers'
+import { ApiKeyType } from '@prisma/client'
+import { NextResponse, type NextRequest } from 'next/server'
+import { createTaskSchema } from '@/lib/tasks/schemas'
+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'
+
+export const GET = 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 key = request.nextUrl.searchParams.get('key')
+
+  const tasks = await prisma.task.findMany({
+    where: {
+      ...(key ? { key } : {}),
+      thread: { assistant: { workspaceId: privateApiKey.workspaceId } },
+    },
+    orderBy: { createdAt: 'desc' },
+  })
+
+  return NextResponse.json(
+    {
+      tasks: tasks.map((t) => serializeTask({ task: t })),
+    },
+    { 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 parsed = createTaskSchema.safeParse(await request.json())
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const { title, message, schedule, threadId } = parsed.data
+
+  if (!validateSchedule(schedule)) {
+    return NextResponse.json({ error: 'Invalid schedule' }, { status: 400 })
+  }
+
+  const thread = await prisma.thread.findFirst({
+    where: {
+      id: threadId,
+      assistant: {
+        workspaceId: privateApiKey.workspaceId,
+      },
+    },
+  })
+
+  if (!thread) {
+    return NextResponse.json({ error: 'Thread not found' }, { status: 400 })
+  }
+
+  const task = await prisma.task.create({
+    data: {
+      title,
+      message,
+      schedule,
+      thread: {
+        connect: { id: thread.id },
+      },
+      key: parsed.data.key ?? '',
+    },
+  })
+
+  await scheduleTask({ task })
+
+  return NextResponse.json(
+    {
+      task: serializeTask({ task }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )

package/src/app/api/threads/runs/submit-client-tool-outputs/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { map } from 'p-iteration'
+import { redis } from '@/lib/redis'
+import { prisma } from '@/lib/prisma'
+import { workspaceAccessWhere as getWorkspaceAccessWhere } from '@/lib/apiKeys/workspaceAccessWhere'
+
+export async function POST(request: NextRequest) {
+  const body = await request.json()
+
+  const { assistantId, publicApiKey, toolOutputs } = body
+
+  const workspaceAccessWhere = await getWorkspaceAccessWhere({
+    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,
+    },
+  })
+
+  if (!assistant) {
+    return NextResponse.json({ error: 'No assistant found' }, { status: 400 })
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  await map(toolOutputs, async (toolOutput: any) => {
+    const isPending = await redis.get(
+      `submit-client-tool-outputs:pending:${toolOutput.toolCallId}`,
+    )
+
+    if (isPending) {
+      await redis.set(
+        `submit-client-tool-outputs:output:${toolOutput.toolCallId}`,
+        JSON.stringify(toolOutput.output),
+        { ex: 60 * 60 * 24 * 7 },
+      )
+    }
+  })
+
+  return NextResponse.json({ status: 'success' })
+}

package/src/app/api/workspaces/[workspaceId]/route.ts

@@ -0,0 +1,137 @@
+import { headers } from 'next/headers'
+import { 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 { validate } from 'uuid'
+import { getOrganizationApiKey } from '@/lib/organizationApiKeys/getOrganizationApiKey'
+import { serializeApiWorkspace } from '@/lib/workspaces/serializeApiWorkspace'
+
+export const GET = async (
+  _request: NextRequest,
+  props: { params: Promise<{ workspaceId: string }> },
+) => {
+  const { workspaceId } = 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 organizationApiKey = await getOrganizationApiKey({
+    authorization,
+  })
+
+  if (!organizationApiKey) {
+    return NextResponse.json(
+      { error: 'Invalid organization api key' },
+      { status: 400 },
+    )
+  }
+
+  if (!validate(workspaceId)) {
+    return NextResponse.json({ error: 'Invalid workspace id' }, { status: 400 })
+  }
+
+  const workspace = await prisma.workspace.findFirst({
+    where: {
+      id: workspaceId,
+      organizationId: organizationApiKey.organizationId,
+    },
+  })
+
+  if (!workspace) {
+    return NextResponse.json({ error: 'No workspace found' }, { status: 400 })
+  }
+
+  return NextResponse.json(
+    {
+      workspace: serializeApiWorkspace({ workspace }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const PATCH = async (
+  request: NextRequest,
+  props: { params: Promise<{ workspaceId: string }> },
+) => {
+  const { workspaceId } = 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 organizationApiKey = await getOrganizationApiKey({
+    authorization,
+  })
+
+  if (!organizationApiKey) {
+    return NextResponse.json(
+      { error: 'Invalid organization api key' },
+      { status: 400 },
+    )
+  }
+
+  if (!validate(workspaceId)) {
+    return NextResponse.json({ error: 'Invalid workspace id' }, { status: 400 })
+  }
+
+  const body = await request.json()
+  const schema = z.object({
+    name: z.string().optional(),
+  })
+
+  const parsed = schema.safeParse(body)
+
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid payload' }, { status: 400 })
+  }
+
+  const { name } = parsed.data
+  const updateData: Prisma.WorkspaceUpdateInput = {
+    ...(name !== undefined ? { name } : {}),
+  }
+
+  const existingWorkspace = await prisma.workspace.findFirst({
+    where: {
+      id: workspaceId,
+      organizationId: organizationApiKey.organizationId,
+    },
+  })
+
+  if (!existingWorkspace) {
+    return NextResponse.json({ error: 'No workspace found' }, { status: 400 })
+  }
+
+  const workspace = await prisma.workspace.update({
+    where: { id: workspaceId },
+    data: updateData,
+  })
+
+  return NextResponse.json(
+    {
+      workspace: serializeApiWorkspace({ workspace }),
+    },
+    { headers: cacheHeaders },
+  )
+}
+
+export const OPTIONS = () =>
+  NextResponse.json(
+    {},
+    {
+      headers: cacheHeaders,
+    },
+  )