@superinterface/server 1.0.0

package/src/lib/tasks/parseTaskToolArgs.ts

@@ -0,0 +1,101 @@
+import OpenAI from 'openai'
+import {
+  Assistant,
+  Thread,
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+} from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+import { scheduleSchema } from './scheduleSchema'
+import { getNextOccurrence } from './getNextOccurrence'
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc'
+import timezone from 'dayjs/plugin/timezone'
+
+dayjs.extend(utc)
+dayjs.extend(timezone)
+
+const formatCurrentTime = ({
+  schedule,
+}: {
+  schedule: PrismaJson.TaskSchedule
+}) => {
+  if (schedule.timeZone) {
+    return `${dayjs().tz(schedule.timeZone).format()} in timezone ${schedule.timeZone}`
+  }
+
+  return `${dayjs().toISOString()} in UTC`
+}
+
+export const parseTaskToolArgs = ({
+  toolCall,
+  assistant,
+  thread,
+}: {
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  assistant: Assistant
+  thread: Thread
+}) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let args: any = {}
+  try {
+    args = JSON.parse(toolCall.function.arguments || '{}')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (e: any) {
+    createLog({
+      log: {
+        requestMethod: LogRequestMethod.POST,
+        requestRoute: LogRequestRoute.MESSAGES,
+        level: LogLevel.ERROR,
+        status: 400,
+        message: `Failed parsing task function arguments: ${e.message}`,
+        workspaceId: assistant.workspaceId,
+        assistantId: assistant.id,
+        threadId: thread.id,
+      },
+    })
+    return { ok: false as const, error: 'Invalid arguments.' }
+  }
+
+  if (args && typeof args === 'object' && args.schedule !== undefined) {
+    const parsed = scheduleSchema.safeParse(args.schedule)
+    if (!parsed.success) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 400,
+          message: 'Invalid schedule provided.',
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+      return { ok: false as const, error: parsed.error.toString() }
+    }
+
+    const next = getNextOccurrence({ schedule: args.schedule })
+    if (!next) {
+      const message = `Schedule must be in the future. Current time: ${formatCurrentTime({ schedule: args.schedule })}`
+
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 400,
+          message,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return { ok: false as const, error: message }
+    }
+  }
+
+  return { ok: true as const, args }
+}

package/src/lib/tasks/scheduleSchema.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod'
+
+const isoLoose =
+  /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})?$/
+
+export const recurrenceRuleSchema = z
+  .object({
+    frequency: z.enum([
+      'yearly',
+      'monthly',
+      'weekly',
+      'daily',
+      'hourly',
+      'minutely',
+      'secondly',
+    ]),
+    interval: z.number().int().min(1).optional(),
+    byDay: z.array(z.string()).optional(),
+    byMonth: z.array(z.number()).optional(),
+    byHour: z.array(z.number()).optional(),
+    byMinute: z.array(z.number()).optional(),
+    bySecond: z.array(z.number()).optional(),
+    until: z.string().regex(isoLoose).optional(),
+    count: z.number().int().optional(),
+  })
+  .passthrough()
+
+export const scheduleSchema = z
+  .object({
+    start: z.string().regex(isoLoose),
+    due: z.string().regex(isoLoose).optional(),
+    recurrenceRules: z.array(recurrenceRuleSchema).optional(),
+  })
+  .passthrough()

package/src/lib/tasks/scheduleTask.ts

@@ -0,0 +1,37 @@
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc'
+import timezone from 'dayjs/plugin/timezone'
+
+import { qstash } from '@/lib/upstash/qstash'
+import { prisma } from '@/lib/prisma'
+import { type Task } from '@prisma/client'
+import { getNextOccurrence } from './getNextOccurrence'
+
+dayjs.extend(utc)
+dayjs.extend(timezone)
+
+export const scheduleTask = async ({ task }: { task: Task }) => {
+  if (!task.schedule || typeof task.schedule !== 'object') return
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const nextIso = getNextOccurrence({ schedule: task.schedule as any })
+  if (!nextIso) return
+
+  const next = dayjs.utc(nextIso)
+  if (!next.isValid()) return
+
+  const delay = Math.max(0, next.diff(dayjs.utc(), 'second'))
+
+  const { messageId } = await qstash.publishJSON({
+    url: `${process.env.NEXT_PUBLIC_SUPERINTERFACE_BASE_URL}/api/cloud/tasks/callback`,
+    body: { taskId: task.id },
+    delay,
+  })
+
+  if (!messageId) throw new Error('Failed to schedule task: missing QStash ID')
+
+  await prisma.task.update({
+    where: { id: task.id },
+    data: { qstashMessageId: messageId },
+  })
+}

package/src/lib/tasks/schemas.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod'
+
+export const createTaskSchema = z.object({
+  title: z.string(),
+  message: z.string(),
+  schedule: z.any(),
+  threadId: z.string(),
+  key: z.string().optional(),
+})
+
+export const createTaskToolSchema = createTaskSchema.omit({ threadId: true })
+
+export const updateTaskSchema = z.object({
+  taskId: z.string(),
+  title: z.string().optional(),
+  message: z.string().optional(),
+  schedule: z.any().optional(),
+  key: z.string().optional(),
+})
+
+export const deleteTaskSchema = z.object({
+  taskId: z.string(),
+})
+
+export const listTasksSchema = z.object({})

package/src/lib/tasks/serializeTask.ts

@@ -0,0 +1,14 @@
+import type { Task } from '@prisma/client'
+
+export const serializeTask = ({ task }: { task: Task }) => ({
+  id: task.id,
+  title: task.title,
+  message: task.message,
+  schedule: task.schedule,
+  threadId: task.threadId,
+  key: task.key,
+  createdAt: task.createdAt.toISOString(),
+  updatedAt: task.updatedAt.toISOString(),
+})
+
+export type SerializedTask = ReturnType<typeof serializeTask>

package/src/lib/tasks/validateSchedule.ts

@@ -0,0 +1,23 @@
+import { scheduleSchema } from './scheduleSchema'
+import { getNextOccurrence } from './getNextOccurrence'
+
+export const validateSchedule = (
+  schedule: PrismaJson.TaskSchedule,
+): boolean => {
+  const parsed = scheduleSchema.safeParse(schedule)
+  if (!parsed.success) return false
+  try {
+    const next = getNextOccurrence({ schedule })
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      Array.isArray((schedule as any).recurrenceRules) &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (schedule as any).recurrenceRules.length
+    ) {
+      return next !== null
+    }
+    return true
+  } catch {
+    return false
+  }
+}

package/src/lib/themes/defaultTheme.ts

@@ -0,0 +1,7 @@
+export const defaultTheme = {
+  accentColor: 'BLUE',
+  grayColor: 'GRAY',
+  appearance: 'LIGHT',
+  radius: 'MEDIUM',
+  scaling: 'SCALING_100',
+}

package/src/lib/themes/serializeAccentColor.ts

@@ -0,0 +1,9 @@
+import type { themePropDefs } from '@radix-ui/themes/props'
+
+export const serializeAccentColor = ({
+  accentColor,
+}: {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  accentColor: any
+}) =>
+  accentColor.toLowerCase() as (typeof themePropDefs.accentColor.values)[number]

package/src/lib/themes/serializeTheme/index.ts

@@ -0,0 +1,25 @@
+import { themePropDefs } from '@radix-ui/themes/props'
+import { serializeAccentColor } from '@/lib/themes/serializeAccentColor'
+import { serializeScaling } from './serializeScaling'
+
+type Args = {
+  theme: {
+    accentColor: string
+    grayColor: string
+    appearance: string
+    radius: string
+    scaling: string
+  }
+}
+
+export const serializeTheme = ({ theme }: Args) => ({
+  accentColor: serializeAccentColor({ accentColor: theme.accentColor }),
+  grayColor:
+    theme.grayColor.toLowerCase() as (typeof themePropDefs.grayColor.values)[number],
+  appearance:
+    theme.appearance.toLowerCase() as (typeof themePropDefs.appearance.values)[number],
+  radius:
+    theme.radius.toLowerCase() as (typeof themePropDefs.radius.values)[number],
+  scaling: serializeScaling({ scaling: theme.scaling }),
+  panelBackground: 'solid' as const,
+})

package/src/lib/themes/serializeTheme/serializeScaling.ts

@@ -0,0 +1,14 @@
+import type { themePropDefs } from '@radix-ui/themes/props'
+
+const scalingMap = {
+  SCALING_90: '90%',
+  SCALING_95: '95%',
+  SCALING_100: '100%',
+  SCALING_105: '105%',
+  SCALING_110: '110%',
+} as const
+
+export const serializeScaling = ({ scaling }: { scaling: string }) =>
+  scalingMap[
+    scaling as keyof typeof scalingMap
+  ] as (typeof themePropDefs.scaling.values)[number]

package/src/lib/threads/createThread/index.ts

@@ -0,0 +1,185 @@
+import OpenAI from 'openai'
+import { StorageProviderType } from '@prisma/client'
+import { PrismaClient, Prisma } from '@prisma/client'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+import { initialMessages } from './initialMessages'
+import { serializeMetadata } from '@/lib/metadata/serializeMetadata'
+
+export const createThread = async ({
+  client,
+  assistant,
+  prisma,
+  variables = {},
+}: {
+  client: OpenAI
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      initialMessages: true
+      modelProvider: true
+    }
+  }>
+  prisma: PrismaClient
+  variables?: Record<string, string>
+}) => {
+  const serializedMetadata = serializeMetadata({
+    variables,
+    workspaceId: assistant.workspaceId,
+  })
+
+  let thread
+
+  if (
+    isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    const newThread = await prisma.thread.create({
+      data: {
+        assistantId: assistant.id,
+        metadata: serializedMetadata,
+      },
+    })
+
+    const storageProviderThread = await client.beta.threads.create({
+      messages: initialMessages({ assistant }),
+      metadata: {
+        assistantId: assistant.id,
+        threadId: newThread.id,
+        ...serializedMetadata,
+      },
+    })
+
+    thread = await prisma.thread.update({
+      where: {
+        id: newThread.id,
+      },
+      include: {
+        assistant: {
+          select: {
+            storageProviderType: true,
+          },
+        },
+      },
+      data: {
+        openaiThreadId: storageProviderThread.id,
+        metadata: {
+          assistantId: assistant.id,
+          threadId: newThread.id,
+          ...serializedMetadata,
+        },
+      },
+    })
+  } else if (
+    assistant.storageProviderType === StorageProviderType.OPENAI_RESPONSES
+  ) {
+    const newThread = await prisma.thread.create({
+      data: {
+        assistantId: assistant.id,
+        metadata: serializedMetadata,
+      },
+    })
+
+    const storageProviderThread = await client.beta.threads.create({
+      messages: initialMessages({ assistant }),
+      metadata: {
+        assistantId: assistant.id,
+        threadId: newThread.id,
+        ...serializedMetadata,
+      },
+    })
+
+    thread = await prisma.thread.update({
+      where: {
+        id: newThread.id,
+      },
+      include: {
+        assistant: {
+          select: {
+            storageProviderType: true,
+          },
+        },
+      },
+      data: {
+        openaiConversationId: storageProviderThread.id,
+        metadata: {
+          assistantId: assistant.id,
+          threadId: newThread.id,
+          ...serializedMetadata,
+        },
+      },
+    })
+  } else if (
+    assistant.storageProviderType === StorageProviderType.AZURE_OPENAI_RESPONSES
+  ) {
+    const newThread = await prisma.thread.create({
+      data: {
+        assistantId: assistant.id,
+        metadata: serializedMetadata,
+      },
+    })
+
+    const storageProviderThread = await client.beta.threads.create({
+      messages: initialMessages({ assistant }),
+      metadata: {
+        assistantId: assistant.id,
+        threadId: newThread.id,
+        ...serializedMetadata,
+      },
+    })
+
+    thread = await prisma.thread.update({
+      where: {
+        id: newThread.id,
+      },
+      include: {
+        assistant: {
+          select: {
+            storageProviderType: true,
+          },
+        },
+      },
+      data: {
+        azureOpenaiConversationId: storageProviderThread.id,
+        metadata: {
+          assistantId: assistant.id,
+          threadId: newThread.id,
+          ...serializedMetadata,
+        },
+      },
+    })
+  } else {
+    const storageProviderThread = await client.beta.threads.create({
+      messages: initialMessages({ assistant }),
+      metadata: {
+        assistantId: assistant.id,
+        ...serializedMetadata,
+      },
+    })
+
+    thread = await prisma.thread.update({
+      where: {
+        id: storageProviderThread.id,
+      },
+      include: {
+        assistant: {
+          select: {
+            storageProviderType: true,
+          },
+        },
+      },
+      data: {
+        metadata: {
+          assistantId: assistant.id,
+          threadId: storageProviderThread.id,
+          ...serializedMetadata,
+        },
+      },
+    })
+  }
+
+  if (!thread) {
+    throw new Error('Failed to create thread')
+  }
+
+  return thread
+}

package/src/lib/threads/createThread/initialMessages.ts

@@ -0,0 +1,36 @@
+import { Prisma, InitialMessage, Assistant } from '@prisma/client'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+
+const role = ({
+  message,
+  assistant,
+}: {
+  message: InitialMessage
+  assistant: Assistant
+}) => {
+  if (
+    isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    return message.role.toLowerCase() as 'user' | 'assistant'
+  }
+
+  return message.role as 'user' | 'assistant'
+}
+
+export const initialMessages = ({
+  assistant,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      initialMessages: true
+    }
+  }>
+}) =>
+  assistant.initialMessages.map((message) => ({
+    role: role({ message, assistant }),
+    content: message.content,
+    attachments: message.attachments,
+    metadata: message.metadata,
+  }))

package/src/lib/threads/managedOpenaiThreadId.ts

@@ -0,0 +1,72 @@
+import { Prisma, StorageProviderType } from '@prisma/client'
+import { assistantClientAdapter } from '@/lib/assistants/assistantClientAdapter'
+import { prisma } from '@/lib/prisma'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+
+export const managedOpenaiThreadId = async ({
+  assistant,
+  threadId,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      tools: {
+        include: {
+          fileSearchTool: true
+          webSearchTool: true
+          imageGenerationTool: true
+          codeInterpreterTool: true
+          computerUseTool: true
+        }
+      }
+      mcpServers: {
+        include: {
+          computerUseTool: true
+          stdioTransport: true
+          sseTransport: true
+          httpTransport: true
+        }
+      }
+      functions: true
+      modelProvider: true
+    }
+  }>
+  threadId: string
+}) => {
+  const newStorageThread = await assistantClientAdapter({
+    assistant,
+    prisma,
+  }).beta.threads.create({
+    metadata: {
+      assistantId: assistant.id,
+      threadId,
+    },
+  })
+
+  await prisma.thread.update({
+    where: {
+      id: threadId,
+    },
+    data: {
+      ...(isOpenaiAssistantsStorageProvider({
+        storageProviderType: assistant.storageProviderType,
+      })
+        ? {
+            openaiThreadId: newStorageThread.id,
+          }
+        : {}),
+      ...(assistant.storageProviderType === StorageProviderType.OPENAI_RESPONSES
+        ? {
+            openaiConversationId: newStorageThread.id,
+          }
+        : {}),
+      ...(assistant.storageProviderType ===
+      StorageProviderType.AZURE_OPENAI_RESPONSES
+        ? {
+            azureOpenaiConversationId: newStorageThread.id,
+          }
+        : {}),
+    },
+  })
+
+  return newStorageThread.id
+}

package/src/lib/threads/storageThreadId.ts

@@ -0,0 +1,49 @@
+import { Prisma, StorageProviderType } from '@prisma/client'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+
+export const storageThreadId = ({
+  thread,
+}: {
+  thread: Prisma.ThreadGetPayload<{
+    include: {
+      assistant: {
+        select: {
+          storageProviderType: true
+        }
+      }
+    }
+  }>
+}) => {
+  if (
+    isOpenaiAssistantsStorageProvider({
+      storageProviderType: thread.assistant.storageProviderType,
+    })
+  ) {
+    return thread.openaiThreadId
+  }
+
+  if (
+    thread.assistant.storageProviderType ===
+    StorageProviderType.OPENAI_RESPONSES
+  ) {
+    return thread.openaiConversationId
+  }
+
+  if (
+    thread.assistant.storageProviderType ===
+    StorageProviderType.AZURE_OPENAI_RESPONSES
+  ) {
+    return thread.azureOpenaiConversationId
+  }
+
+  if (
+    thread.assistant.storageProviderType ===
+    StorageProviderType.SUPERINTERFACE_CLOUD
+  ) {
+    return thread.id
+  }
+
+  throw new Error(
+    `Invalid storage type: ${thread.assistant.storageProviderType}`,
+  )
+}

package/src/lib/threads/validThreadId.ts

@@ -0,0 +1,10 @@
+import { validate } from 'uuid'
+
+const fallbackUuid = '00000000-0000-0000-0000-000000000000'
+
+export const validThreadId = ({ threadId }: { threadId: string | null }) => {
+  if (!threadId) return fallbackUuid
+  if (!validate(threadId)) return fallbackUuid
+
+  return threadId
+}