@superinterface/server 1.0.0

package/src/lib/modelProviders/modelProviderConfigs.ts

@@ -0,0 +1,221 @@
+import { StorageProviderType, ModelProviderType } from '@prisma/client'
+import { ModelProviderConfig } from '@/types'
+
+export const modelProviderConfigs: ModelProviderConfig[] = [
+  {
+    slug: 'openai',
+    type: ModelProviderType.OPENAI,
+    name: 'OpenAI',
+    description: 'Assistants API, Completions API, Function calling',
+    iconUrl: '/images/openai-logo-square-light.svg',
+    logoUrl: '/images/openai-logo-light.png',
+    dashboardUrl: 'https://platform.openai.com/api-keys',
+    modelSlugs: [
+      'gpt-4o-mini',
+      'gpt-4o-mini-2024-07-18',
+      'gpt-4o',
+      'gpt-4o-2024-11-20',
+      'gpt-4o-2024-05-13',
+      'chatgpt-4o-latest',
+      'o1-preview',
+      'o1-preview-2024-09-12',
+      'o1-mini',
+      'o1-mini-2024-09-12',
+    ],
+    storageProviderTypes: [
+      StorageProviderType.SUPERINTERFACE_CLOUD,
+      StorageProviderType.OPENAI,
+      StorageProviderType.OPENAI_RESPONSES,
+    ],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'azure-openai',
+    type: ModelProviderType.AZURE_OPENAI,
+    name: 'Azure OpenAI',
+    description: 'Assistants API, Completions API, Function calling',
+    iconUrl: '/images/microsoft-azure-logo-square.svg',
+    logoUrl: '/images/microsoft-azure-logo-square.svg',
+    dashboardUrl: 'https://ai.azure.com/playground/assistants',
+    modelSlugs: [
+      'gpt-4o-mini',
+      'gpt-4o-mini-2024-07-18',
+      'gpt-4o',
+      'gpt-4o-2024-11-20',
+      'gpt-4o-2024-05-13',
+      'chatgpt-4o-latest',
+      'o1-preview',
+      'o1-preview-2024-09-12',
+      'o1-mini',
+      'o1-mini-2024-09-12',
+    ],
+    storageProviderTypes: [
+      StorageProviderType.AZURE_OPENAI,
+      StorageProviderType.SUPERINTERFACE_CLOUD,
+      // StorageProviderType.AZURE_OPENAI_RESPONSES,
+    ],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'anthropic',
+    type: ModelProviderType.ANTHROPIC,
+    name: 'Anthropic',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/anthropic-logo-square.png',
+    logoUrl: '/images/anthropic-logo-light.png',
+    dashboardUrl: 'https://console.anthropic.com/settings/keys',
+    modelSlugs: [
+      'claude-3-5-sonnet-20241022',
+      'claude-3-5-sonnet-20240620',
+      'claude-3-opus-20240229',
+      'claude-3-sonnet-20240229',
+      'claude-3-5-haiku-20241022',
+      'claude-3-haiku-20240307',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'ollama',
+    type: ModelProviderType.OLLAMA,
+    name: 'Ollama',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/ollama-logo-square.jpg',
+    logoUrl: '/images/ollama-logo-light.png',
+    dashboardUrl: 'https://ollama.com',
+    modelSlugs: [
+      'qwq',
+      'qwen2.5-coder:32b',
+      'qwen2.5-coder:14b',
+      'qwen2.5-coder:7b',
+      'qwen2.5-coder:3b',
+      'qwen2.5-coder:1.5b',
+      'qwen2.5-coder:0.5b',
+      'llama3.2',
+      'llama3.2:1b',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'google',
+    type: ModelProviderType.GOOGLE,
+    name: 'Google',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/google-gemini-logo-square.svg',
+    logoUrl: '/images/google-gemini-logo-square.svg',
+    dashboardUrl: 'https://aistudio.google.com/apikey',
+    modelSlugs: ['gemini-2.0-flash-exp'],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'mistral',
+    type: ModelProviderType.MISTRAL,
+    name: 'Mistral',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/mistral-logo-square.png',
+    logoUrl: '/images/mistral-logo-light.svg',
+    dashboardUrl: 'https://console.mistral.ai/api-keys/',
+    modelSlugs: [
+      'mistral-large-latest',
+      'mistral-large-2407',
+      'open-mistral-nemo',
+      'open-mistral-nemo-2407',
+      'open-mixtral-8x22b',
+      'open-mixtral-8x7b',
+      'open-mistral-7b',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'groq',
+    type: ModelProviderType.GROQ,
+    name: 'Groq',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/groq-logo-square.png',
+    logoUrl: '/images/groq-logo-light2.png',
+    dashboardUrl: 'https://console.groq.com/keys',
+    modelSlugs: [
+      // 'llama-3.1-405b-reasoning',
+      'meta-llama/llama-4-scout-17b-16e-instruct',
+      'llama-3.1-8b-instant',
+      'llama3-groq-70b-8192-tool-use-preview',
+      'llama3-8b-8192',
+      'llama3-70b-8192',
+      'deepseek-r1-distill-llama-70b',
+      // 'mixtral-8x7b-32768',
+      'gemma-7b-it',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'humiris',
+    type: ModelProviderType.HUMIRIS,
+    name: 'Humiris',
+    description: 'Completions API',
+    iconUrl: '/images/humiris-logo-square.png',
+    logoUrl: '/images/humiris-logo-light2.png',
+    dashboardUrl: 'https://platform.humiris.ai/api-key',
+    modelSlugs: ['Humiris/humiris-moai'],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: false,
+  },
+  {
+    slug: 'together',
+    type: ModelProviderType.TOGETHER,
+    name: 'Together.ai',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/together-logo-square.png',
+    logoUrl: '/images/together-logo-light.png',
+    dashboardUrl: 'https://api.together.xyz/settings/api-keys',
+    modelSlugs: [
+      'meta-llama/Llama-4-Scout-17B-16E-Instruct',
+      'meta-llama/Llama-3-70b-chat-hf',
+      'mistralai/Mixtral-8x7B-Instruct-v0.1',
+      'togethercomputer/RedPajama-INCITE-Chat-3B-v1',
+      'togethercomputer/CodeLlama-34b-Instruct',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'perplexity',
+    type: ModelProviderType.PERPLEXITY,
+    name: 'Perplexity',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/perplexity-logo-square.png',
+    logoUrl: '/images/perplexity-logo-light2.png',
+    dashboardUrl: 'https://www.perplexity.ai/settings/api',
+    modelSlugs: [
+      'llama-3.1-sonar-small-128k-online',
+      'llama-3.1-sonar-large-128k-online',
+      'llama-3.1-sonar-huge-128k-online',
+      'llama-3.1-sonar-small-128k-chat',
+      'llama-3.1-sonar-large-128k-chat',
+      'llama-3.1-8b-instruct',
+      'llama-3.1-70b-instruct',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+  {
+    slug: 'open-router',
+    type: ModelProviderType.OPEN_ROUTER,
+    name: 'Open Router',
+    description: 'Completions API, Function calling',
+    iconUrl: '/images/open-router-logo-square-light.svg',
+    logoUrl: '/images/open-router-logo-light.svg',
+    dashboardUrl: 'https://openrouter.ai/settings/keys',
+    modelSlugs: [
+      'openai/o1-mini',
+      'openai/o1-preview',
+      'openai/gpt-4o-mini',
+      'qwen/qwen-2.5-72b-instruct',
+    ],
+    storageProviderTypes: [StorageProviderType.SUPERINTERFACE_CLOUD],
+    isFunctionCallingAvailable: true,
+  },
+]

package/src/lib/modelProviders/serializeModelProvider.ts

@@ -0,0 +1,19 @@
+import type { ModelProvider } from '@prisma/client'
+
+export const serializeModelProvider = ({
+  provider,
+}: {
+  provider: ModelProvider
+}) => ({
+  id: provider.id,
+  type: provider.type,
+  name: provider.name,
+  apiKey: provider.apiKey,
+  endpoint: provider.endpoint,
+  apiVersion: provider.apiVersion,
+  workspaceId: provider.workspaceId,
+  createdAt: provider.createdAt.toISOString(),
+  updatedAt: provider.updatedAt.toISOString(),
+})
+
+export type SerializedModelProvider = ReturnType<typeof serializeModelProvider>

package/src/lib/models/getModels.ts

@@ -0,0 +1,27 @@
+import { buildOpenaiClient } from '@/lib/modelProviders/buildOpenaiClient'
+import type { ModelProvider } from '@prisma/client'
+
+export const getModels = async ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  const client = buildOpenaiClient({
+    modelProvider,
+  })
+
+  const models = []
+
+  try {
+    const list = await client.models.list()
+
+    for await (const model of list) {
+      models.push(model)
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (error) {
+    throw new Error(`Failed to load models from AI provider.`)
+  }
+
+  return models
+}

package/src/lib/models/serializeApiModel.ts

@@ -0,0 +1,5 @@
+import type OpenAI from 'openai'
+
+export const serializeApiModel = ({ model }: { model: OpenAI.Model }) => ({
+  id: model.id,
+})

package/src/lib/openai/getOpenaiAssistants.ts

@@ -0,0 +1,30 @@
+import { ModelProvider } from '@prisma/client'
+import { buildOpenaiClient } from '@/lib/modelProviders/buildOpenaiClient'
+import { isModelProviderValid } from '@/lib/modelProviders/isModelProviderValid'
+
+export const getOpenaiAssistants = async ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  if (!isModelProviderValid({ modelProvider })) {
+    return []
+  }
+
+  const client = buildOpenaiClient({
+    modelProvider,
+  })
+
+  const assistants = []
+
+  try {
+    for await (const assistant of client.beta.assistants.list({ limit: 100 })) {
+      assistants.push(assistant)
+    }
+  } catch (e) {
+    console.error(e)
+    return assistants
+  }
+
+  return assistants
+}

package/src/lib/organizationApiKeys/getOrganizationApiKey.ts

@@ -0,0 +1,23 @@
+import type { OrganizationApiKey } from '@prisma/client'
+import { validate } from 'uuid'
+import { prisma } from '@/lib/prisma'
+
+export const getOrganizationApiKey = async ({
+  authorization,
+}: {
+  authorization: string | null
+}): Promise<OrganizationApiKey | null> => {
+  if (!authorization) {
+    return null
+  }
+
+  const [, organizationApiKeyValue] = authorization.split('Bearer ')
+
+  if (!validate(organizationApiKeyValue)) {
+    return null
+  }
+
+  return prisma.organizationApiKey.findFirst({
+    where: { value: organizationApiKeyValue },
+  })
+}

package/src/lib/prisma/index.ts

@@ -0,0 +1,29 @@
+import { PrismaNeon } from '@prisma/adapter-neon'
+import { PrismaClient } from '@prisma/client'
+
+const prismaClientSingleton = () => {
+  const connectionString = `${process.env.DATABASE_URL}`
+
+  if (process.env.NODE_ENV === 'test') {
+    return new PrismaClient()
+  }
+
+  const adapter = new PrismaNeon({
+    connectionString,
+  })
+
+  return new PrismaClient({
+    adapter,
+    transactionOptions: {
+      timeout: 15000,
+    },
+  })
+}
+
+declare global {
+  var prisma: undefined | ReturnType<typeof prismaClientSingleton>
+}
+
+export const prisma = globalThis.prisma ?? prismaClientSingleton()
+
+if (process.env.NODE_ENV !== 'production') globalThis.prisma = prisma

package/src/lib/redis/index.ts

@@ -0,0 +1,3 @@
+import { Redis } from '@upstash/redis'
+
+export const redis = Redis.fromEnv()

package/src/lib/runs/createRunOpts.ts

@@ -0,0 +1,80 @@
+import type { OpenAI } from 'openai'
+import { Prisma, Thread, Assistant, TruncationType } from '@prisma/client'
+import { storageAssistantId } from '@/lib/assistants/storageAssistantId'
+import { tools } from '@/lib/tools/tools'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+
+const instructions = ({ assistant }: { assistant: Assistant }) => {
+  if (assistant.instructions.length > 0) {
+    return {
+      instructions: assistant.instructions,
+    }
+  }
+
+  if (
+    !isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    return {
+      instructions: '',
+    }
+  }
+
+  return {}
+}
+
+const truncationStrategy = ({ assistant }: { assistant: Assistant }) => {
+  if (assistant.truncationType === TruncationType.LAST_MESSAGES) {
+    return {
+      type: 'last_messages' as const,
+      last_messages: assistant.truncationLastMessagesCount,
+    }
+  } else if (assistant.truncationType === TruncationType.DISABLED) {
+    // @ts-expect-error - compat
+    return {
+      type: 'disabled',
+    } as OpenAI.Beta.Threads.Runs.Run.TruncationStrategy
+  } else {
+    return {
+      type: 'auto' as const,
+    }
+  }
+}
+
+export const createRunOpts = async ({
+  assistant,
+  thread,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      tools: {
+        include: {
+          fileSearchTool: true
+          webSearchTool: true
+          imageGenerationTool: true
+          codeInterpreterTool: true
+          computerUseTool: true
+        }
+      }
+      functions: true
+      modelProvider: true
+      mcpServers: {
+        include: {
+          computerUseTool: true
+          stdioTransport: true
+          httpTransport: true
+          sseTransport: true
+        }
+      }
+    }
+  }>
+  thread: Thread
+}) => ({
+  stream: true,
+  assistant_id: storageAssistantId({ assistant }),
+  ...instructions({ assistant }),
+  model: assistant.modelSlug,
+  truncation_strategy: truncationStrategy({ assistant }),
+  ...(await tools({ assistant, thread })),
+})

package/src/lib/storageProviders/getStorageProviderAssistants.ts

@@ -0,0 +1,19 @@
+import { ModelProvider } from '@prisma/client'
+import { getOpenaiAssistants } from '@/lib/openai/getOpenaiAssistants'
+import { getStorageProviderType } from '@/lib/storageProviders/getStorageProviderType'
+
+export const getStorageProviderAssistants = ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  const storageProviderType = getStorageProviderType({ modelProvider })
+
+  if (!storageProviderType) {
+    return []
+  }
+
+  return getOpenaiAssistants({
+    modelProvider,
+  })
+}

package/src/lib/storageProviders/getStorageProviderType.ts

@@ -0,0 +1,21 @@
+import {
+  ModelProvider,
+  StorageProviderType,
+  ModelProviderType,
+} from '@prisma/client'
+
+export const getStorageProviderType = ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  if (modelProvider.type === ModelProviderType.OPENAI) {
+    return StorageProviderType.OPENAI
+  }
+
+  if (modelProvider.type === ModelProviderType.AZURE_OPENAI) {
+    return StorageProviderType.AZURE_OPENAI
+  }
+
+  return null
+}

package/src/lib/storageProviders/isOpenaiAssistantsStorageProvider.ts

@@ -0,0 +1,8 @@
+import { StorageProviderType } from '@prisma/client'
+import { openaiAssistantsStorageProviderTypes } from '@/lib/storageProviders/openaiAssistantsStorageProviderTypes'
+
+export const isOpenaiAssistantsStorageProvider = ({
+  storageProviderType,
+}: {
+  storageProviderType: StorageProviderType
+}) => openaiAssistantsStorageProviderTypes.includes(storageProviderType)

package/src/lib/storageProviders/isResponsesStorageProvider.ts

@@ -0,0 +1,8 @@
+import { StorageProviderType } from '@prisma/client'
+import { responsesStorageProviderTypes } from '@/lib/storageProviders/responsesStorageProviderTypes'
+
+export const isResponsesStorageProvider = ({
+  storageProviderType,
+}: {
+  storageProviderType: StorageProviderType
+}) => responsesStorageProviderTypes.includes(storageProviderType)

package/src/lib/storageProviders/openaiAssistantsStorageProviderTypes.ts

@@ -0,0 +1,6 @@
+import { StorageProviderType } from '@prisma/client'
+
+export const openaiAssistantsStorageProviderTypes: StorageProviderType[] = [
+  StorageProviderType.OPENAI,
+  StorageProviderType.AZURE_OPENAI,
+]

package/src/lib/storageProviders/responsesStorageProviderTypes.ts

@@ -0,0 +1,6 @@
+import { StorageProviderType } from '@prisma/client'
+
+export const responsesStorageProviderTypes: StorageProviderType[] = [
+  StorageProviderType.OPENAI_RESPONSES,
+  StorageProviderType.AZURE_OPENAI_RESPONSES,
+]

package/src/lib/storageProviders/serializeApiStorageProviderAssistant.ts

@@ -0,0 +1,14 @@
+import type { OpenAI } from 'openai'
+
+export const serializeApiStorageProviderAssistant = ({
+  storageProviderAssistant,
+}: {
+  storageProviderAssistant: OpenAI.Beta.Assistant
+}) => ({
+  id: storageProviderAssistant.id,
+  model: storageProviderAssistant.model,
+  name: storageProviderAssistant.name,
+  description: storageProviderAssistant.description,
+  instructions: storageProviderAssistant.instructions,
+  tools: storageProviderAssistant.tools,
+})

package/src/lib/tasks/cancelScheduledTask.ts

@@ -0,0 +1,13 @@
+import { qstash } from '@/lib/upstash/qstash'
+import { type Task } from '@prisma/client'
+
+export const cancelScheduledTask = async ({ task }: { task: Task }) => {
+  if (!task.qstashMessageId) return
+  if (process.env.NODE_ENV === 'test') return
+
+  try {
+    await qstash.messages.delete(task.qstashMessageId)
+  } catch (error) {
+    console.error('Failed to cancel scheduled task:', error)
+  }
+}

package/src/lib/tasks/getNextOccurrence.ts

@@ -0,0 +1,77 @@
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc'
+import timezone from 'dayjs/plugin/timezone'
+
+dayjs.extend(utc)
+dayjs.extend(timezone)
+
+type TaskSchedule = PrismaJson.TaskSchedule
+type Unit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'
+
+const freqUnit: Record<string, Unit> = {
+  secondly: 'second',
+  minutely: 'minute',
+  hourly: 'hour',
+  daily: 'day',
+  weekly: 'week',
+  monthly: 'month',
+  yearly: 'year',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const fits = (d: dayjs.Dayjs, r: any) =>
+  (!r.byMonth || r.byMonth.includes(d.month() + 1)) &&
+  (!r.byDay || r.byDay.includes(d.format('dd').toUpperCase())) &&
+  (!r.byHour || r.byHour.includes(d.hour())) &&
+  (!r.byMinute || r.byMinute.includes(d.minute())) &&
+  (!r.bySecond || r.bySecond.includes(d.second()))
+
+export const getNextOccurrence = ({
+  schedule,
+  now = new Date(),
+}: {
+  schedule: TaskSchedule
+  now?: Date
+}): string | null => {
+  if (!schedule || typeof schedule !== 'object') return null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { start, timeZone = 'UTC', recurrenceRules = [] } = schedule as any
+  if (typeof start !== 'string') return null
+
+  if (!dayjs(start).isValid()) return null
+  const hasOffset = /([+-]\d\d:\d\d|Z)$/i.test(start)
+  const base = hasOffset ? dayjs(start).tz(timeZone) : dayjs.tz(start, timeZone)
+  const cursor = dayjs.tz(now, timeZone).add(1, 'second')
+
+  if (recurrenceRules.length === 0)
+    return base.isAfter(cursor) ? base.toISOString() : null
+
+  let best: dayjs.Dayjs | null = null
+
+  for (const r of recurrenceRules) {
+    const unit = freqUnit[r.frequency]
+    if (!unit) continue
+    const interval = Math.max(1, r.interval ?? 1)
+
+    let next = base
+    if (next.isBefore(cursor)) {
+      const diff = cursor.diff(base, unit)
+      const steps = Math.floor(diff / interval)
+      next = base.add(steps * interval, unit)
+      while (next.isBefore(cursor)) next = next.add(interval, unit)
+    }
+
+    let guard = 0
+    while (!fits(next, r) && guard < 5000) {
+      next = next.add(interval, unit)
+      guard++
+    }
+
+    if (r.until && next.isAfter(dayjs.tz(r.until, timeZone))) continue
+    if (r.count && base.add(interval * r.count, unit).isBefore(next)) continue
+
+    if (!best || next.isBefore(best)) best = next
+  }
+
+  return best ? best.toISOString() : null
+}

package/src/lib/tasks/getTaskToolKey.ts

@@ -0,0 +1,49 @@
+import {
+  Assistant,
+  Thread,
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+} from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+
+export const getTaskToolKey = async ({
+  thread,
+  assistant,
+  keyTemplate,
+}: {
+  thread: Thread
+  assistant: Assistant
+  keyTemplate: string | null
+}) => {
+  const missing: string[] = []
+  const key = (keyTemplate || '').replace(/{{\s*([\w-]+)\s*}}/g, (_, k) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (k in (thread.metadata || {})) return String((thread.metadata as any)[k])
+    if (k === 'threadId') return thread.id
+    if (k === 'assistantId') return assistant.id
+    missing.push(k)
+    return `{{${k}}}`
+  })
+
+  if (missing.length) {
+    const message = `Missing variables in key template: ${missing.join(', ')}`
+
+    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, key }
+}