@superinterface/server 1.0.0

package/src/lib/mcpServers/headers.ts

@@ -0,0 +1,113 @@
+import type { Prisma, Thread, Assistant } from '@prisma/client'
+import {
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+  TransportType,
+} from '@prisma/client'
+import { dash } from 'radash'
+import { interpolateFunctionValue } from '@/lib/functions/interpolateFunctionValue'
+import { createLog } from '@/lib/logs/createLog'
+
+const transportHeaders = ({
+  mcpServer,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+}) => {
+  if (mcpServer.transportType === TransportType.HTTP) {
+    return mcpServer.httpTransport!.headers
+  } else if (mcpServer.transportType === TransportType.SSE) {
+    return mcpServer.sseTransport!.headers
+  }
+
+  return {}
+}
+
+const interpolatedTransportHeaders = ({
+  mcpServer,
+  thread,
+  metadata,
+  assistant,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  thread: Thread
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  metadata?: Record<string, any>
+  assistant: Assistant
+}) => {
+  const result: Record<string, string> = {}
+  const missing: string[] = []
+
+  for (const [k, v] of Object.entries(transportHeaders({ mcpServer }))) {
+    const res = interpolateFunctionValue({
+      value: v,
+      args: metadata,
+      thread,
+      assistant,
+    })
+    result[k] = res.value
+    missing.push(...res.missing)
+  }
+
+  return { headers: result, missing }
+}
+
+export const headers = ({
+  thread,
+  mcpServer,
+  assistant,
+}: {
+  thread: Thread
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  assistant: Assistant
+}) => {
+  const { headers, missing } = interpolatedTransportHeaders({
+    mcpServer,
+    thread,
+    metadata: thread.metadata ?? {},
+    assistant,
+  })
+
+  if (missing.length) {
+    const message = `Missing variables in MCP server: ${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,
+      },
+    })
+
+    throw new Error(message)
+  }
+
+  const data = {
+    ...headers,
+    ...(thread.metadata ?? {}),
+  }
+
+  return Object.fromEntries(
+    Object.entries(data).map(([key, value]) => [dash(key), value]),
+  )
+}

package/src/lib/mcpServers/mcpServerSchema.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+import { TransportType } from '@prisma/client'
+import { isJSON } from '@/lib/misc/isJSON'
+
+const stdioTransportSchema = z.object({
+  command: z.string().min(1),
+  args: z.string().min(1),
+})
+
+const sseTransportSchema = z.object({
+  url: z.string().min(1).url(),
+  headers: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+const httpTransportSchema = z.object({
+  url: z.string().min(1).url(),
+  headers: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+export const baseSchema = z.object({
+  transportType: z
+    .nativeEnum(TransportType)
+    .refine((t) => t !== TransportType.STDIO, {
+      message: `transportType cannot be ${TransportType.STDIO}`,
+    }),
+  sseTransport: sseTransportSchema.nullable().optional(),
+  httpTransport: httpTransportSchema.nullable().optional(),
+})
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const superRefine = (values: any, ctx: any) => {
+  if (values.transportType === TransportType.STDIO) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `Transport type ${TransportType.STDIO} is not allowed.`,
+    })
+
+    const result = stdioTransportSchema.safeParse(values.stdioTransport)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['stdioTransport', ...issue.path],
+      }),
+    )
+  } else if (values.transportType === TransportType.SSE) {
+    const result = sseTransportSchema.safeParse(values.sseTransport)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['sseTransport', ...issue.path],
+      }),
+    )
+  } else if (values.transportType === TransportType.HTTP) {
+    const result = httpTransportSchema.safeParse(values.httpTransport)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['httpTransport', ...issue.path],
+      }),
+    )
+  }
+}
+
+export const mcpServerSchema = baseSchema.superRefine(superRefine)

package/src/lib/mcpServers/serializeApiMcpServer.ts

@@ -0,0 +1,51 @@
+import type { Prisma, SseTransport, HttpTransport } from '@prisma/client'
+
+const serializeApiSseTransport = ({
+  sseTransport,
+}: {
+  sseTransport: SseTransport
+}) => ({
+  id: sseTransport.id,
+  url: sseTransport.url,
+  headers: sseTransport.headers,
+  createdAt: sseTransport.createdAt.toISOString(),
+  updatedAt: sseTransport.updatedAt.toISOString(),
+})
+
+const serializeApiHttpTransport = ({
+  httpTransport,
+}: {
+  httpTransport: HttpTransport
+}) => ({
+  id: httpTransport.id,
+  url: httpTransport.url,
+  headers: httpTransport.headers,
+  createdAt: httpTransport.createdAt.toISOString(),
+  updatedAt: httpTransport.updatedAt.toISOString(),
+})
+
+export const serializeApiMcpServer = ({
+  mcpServer,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      sseTransport: true
+      httpTransport: true
+    }
+  }>
+}) => ({
+  id: mcpServer.id,
+  transportType: mcpServer.transportType,
+  sseTransport: mcpServer.sseTransport
+    ? serializeApiSseTransport({
+        sseTransport: mcpServer.sseTransport,
+      })
+    : null,
+  httpTransport: mcpServer.httpTransport
+    ? serializeApiHttpTransport({
+        httpTransport: mcpServer.httpTransport,
+      })
+    : null,
+  createdAt: mcpServer.createdAt.toISOString(),
+  updatedAt: mcpServer.updatedAt.toISOString(),
+})

package/src/lib/mcpServers/url.ts

@@ -0,0 +1,98 @@
+import type { Prisma, Thread, Assistant } from '@prisma/client'
+import {
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+  TransportType,
+} from '@prisma/client'
+import { interpolateFunctionValue } from '@/lib/functions/interpolateFunctionValue'
+import { createLog } from '@/lib/logs/createLog'
+
+const transportUrl = ({
+  mcpServer,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+}) => {
+  if (mcpServer.transportType === TransportType.HTTP) {
+    return mcpServer.httpTransport!.url
+  } else if (mcpServer.transportType === TransportType.SSE) {
+    return mcpServer.sseTransport!.url
+  }
+
+  return ''
+}
+
+const interpolatedTransportUrl = ({
+  mcpServer,
+  thread,
+  metadata,
+  assistant,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  thread: Thread
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  metadata?: Record<string, any>
+  assistant: Assistant
+}) => {
+  const { value, missing } = interpolateFunctionValue({
+    value: transportUrl({ mcpServer }),
+    args: metadata,
+    thread,
+    assistant,
+  })
+
+  return { url: value, missing }
+}
+
+export const url = ({
+  thread,
+  mcpServer,
+  assistant,
+}: {
+  thread: Thread
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  assistant: Assistant
+}) => {
+  const { url, missing } = interpolatedTransportUrl({
+    mcpServer,
+    thread,
+    metadata: thread.metadata ?? {},
+    assistant,
+  })
+
+  if (missing.length) {
+    const message = `Missing variables in MCP server: ${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,
+      },
+    })
+
+    throw new Error(message)
+  }
+
+  return url
+}

package/src/lib/messages/content.ts

@@ -0,0 +1,60 @@
+import { ModelProviderType, Prisma } from '@prisma/client'
+import { toFile } from 'openai'
+import { buildOpenaiClient } from '@/lib/modelProviders/buildOpenaiClient'
+import { isEmpty } from 'radash'
+
+type Args = {
+  textContent?: string
+  audioContent?: string
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      workspace: {
+        include: {
+          modelProviders: true
+        }
+      }
+    }
+  }>
+}
+
+export const content = async ({
+  textContent,
+  audioContent,
+  assistant,
+}: Args) => {
+  if (textContent) {
+    return textContent
+  }
+
+  if (audioContent) {
+    const openaiModelProvider = assistant.workspace.modelProviders.find(
+      (mp) => mp.type === ModelProviderType.OPENAI,
+    )
+
+    if (!openaiModelProvider?.apiKey) {
+      throw new Error('No OpenAI API key found')
+    }
+
+    const client = buildOpenaiClient({
+      modelProvider: openaiModelProvider,
+    })
+
+    const base64Content = audioContent.split(',')[1]
+
+    if (isEmpty(base64Content)) {
+      return '-'
+    }
+
+    const audioBuffer = Buffer.from(base64Content, 'base64')
+    const file = await toFile(audioBuffer, 'message.mp3')
+
+    const transcription = await client.audio.transcriptions.create({
+      file,
+      model: 'whisper-1',
+    })
+
+    return transcription.text
+  }
+
+  throw new Error('No content found')
+}

package/src/lib/messages/textContent.ts

@@ -0,0 +1,13 @@
+import type OpenAI from 'openai'
+
+export const textContent = ({
+  message,
+}: {
+  message: OpenAI.Beta.Threads.Messages.Message
+}) => {
+  const textContents = message.content.filter(
+    (content) => content.type === 'text',
+  ) as OpenAI.Beta.Threads.Messages.TextContentBlock[]
+
+  return textContents.map((textContent) => textContent.text.value).join('\n\n')
+}

package/src/lib/metadata/serializeMetadata.ts

@@ -0,0 +1,34 @@
+import { LogRequestMethod, LogRequestRoute, LogLevel } from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+
+export const serializeMetadata = ({
+  variables,
+  workspaceId,
+}: {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  variables: Record<string, any>
+  workspaceId: string
+}): Record<string, string> => {
+  const metadata: Record<string, string> = {}
+
+  for (const [key, value] of Object.entries(variables)) {
+    try {
+      metadata[key] = String(value)
+    } catch (error) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Failed to serialize key "${key}": ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          workspaceId,
+        },
+      })
+    }
+  }
+
+  return metadata
+}

package/src/lib/misc/isJSON.ts

@@ -0,0 +1,9 @@
+export const isJSON = (value: string) => {
+  try {
+    JSON.parse(value)
+    return true
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (e) {
+    return false
+  }
+}

package/src/lib/misc/merge/customizer.ts

@@ -0,0 +1,8 @@
+import _ from 'lodash'
+
+// @ts-expect-error broad type
+export const customizer = (objectValue, srcValue) => {
+  if (!_.isArray(objectValue)) return
+
+  return srcValue
+}

package/src/lib/misc/merge/index.ts

@@ -0,0 +1,6 @@
+import _ from 'lodash'
+import { customizer } from './customizer'
+
+// @ts-expect-error broad type
+export const merge = (obj, ...sources) =>
+  _.mergeWith(_.cloneDeep(obj), ...sources, customizer)

package/src/lib/modelProviders/buildAzureOpenaiClientAdapter.ts

@@ -0,0 +1,33 @@
+import { ModelProvider } from '@prisma/client'
+import { AzureOpenAI } from 'openai'
+import { azureOpenaiClientAdapter } from 'supercompat'
+
+export const buildAzureOpenaiClientAdapter = ({
+  modelProvider,
+  baseURL,
+}: {
+  modelProvider: ModelProvider
+  baseURL?: string
+}) => {
+  const azureOpenai = new AzureOpenAI({
+    apiKey: modelProvider.apiKey,
+    endpoint: modelProvider.endpoint!,
+    apiVersion: modelProvider.apiVersion || '2025-04-01-preview',
+    ...(baseURL ? { baseURL } : {}),
+    defaultHeaders: {
+      'HTTP-Referer': 'https://superinterface.ai',
+      'X-Title': 'Superinterface',
+    },
+    // @ts-expect-error duplex is not yet in the types
+    fetch: (url: RequestInfo, init?: RequestInit): Promise<Response> =>
+      fetch(url, {
+        ...(init || {}),
+        // @ts-expect-error  duplex is not yet in the types
+        duplex: 'half',
+      }),
+  })
+
+  return azureOpenaiClientAdapter({
+    azureOpenai,
+  })
+}

package/src/lib/modelProviders/buildOpenaiClient.ts

@@ -0,0 +1,14 @@
+import { ModelProvider } from '@prisma/client'
+import { clientAdapter } from '@/lib/modelProviders/clientAdapter'
+import { supercompat } from 'supercompat'
+
+export const buildOpenaiClient = ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) =>
+  supercompat({
+    client: clientAdapter({
+      modelProvider,
+    }),
+  })

package/src/lib/modelProviders/buildOpenaiClientAdapter.ts

@@ -0,0 +1,30 @@
+import { ModelProvider } from '@prisma/client'
+import OpenAI from 'openai'
+import { openaiClientAdapter } from 'supercompat'
+
+export const buildOpenaiClientAdapter = ({
+  modelProvider,
+  baseURL,
+  apiKey,
+}: {
+  modelProvider: ModelProvider
+  baseURL?: string
+  apiKey?: string
+}) =>
+  openaiClientAdapter({
+    openai: new OpenAI({
+      apiKey: apiKey ?? modelProvider.apiKey,
+      ...(baseURL ? { baseURL } : {}),
+      defaultHeaders: {
+        'HTTP-Referer': 'https://superinterface.ai',
+        'X-Title': 'Superinterface',
+      },
+      // @ts-expect-error duplex is not yet in the types
+      fetch: (url: RequestInfo, init?: RequestInit): Promise<Response> =>
+        fetch(url, {
+          ...(init || {}),
+          // @ts-expect-error duplex is not yet in the types
+          duplex: 'half',
+        }),
+    }),
+  })

package/src/lib/modelProviders/clientAdapter.ts

@@ -0,0 +1,121 @@
+import Groq from 'groq-sdk'
+import OpenAI from 'openai'
+import { Mistral } from '@mistralai/mistralai'
+import Anthropic from '@anthropic-ai/sdk'
+import {
+  mistralClientAdapter,
+  groqClientAdapter,
+  perplexityClientAdapter,
+  humirisClientAdapter,
+  googleClientAdapter,
+  togetherClientAdapter,
+  anthropicClientAdapter,
+} from 'supercompat'
+import { ModelProvider, ModelProviderType } from '@prisma/client'
+import { buildOpenaiClientAdapter } from '@/lib/modelProviders/buildOpenaiClientAdapter'
+import { buildAzureOpenaiClientAdapter } from '@/lib/modelProviders/buildAzureOpenaiClientAdapter'
+
+export const clientAdapter = ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  if (modelProvider.type === ModelProviderType.OPENAI) {
+    return buildOpenaiClientAdapter({
+      modelProvider,
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.AZURE_OPENAI) {
+    return buildAzureOpenaiClientAdapter({
+      modelProvider,
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.PERPLEXITY) {
+    return perplexityClientAdapter({
+      perplexity: new OpenAI({
+        apiKey: modelProvider.apiKey,
+        baseURL: 'https://api.perplexity.ai/',
+        // @ts-expect-error duplex is not yet in the types
+        fetch: (url: RequestInfo, init?: RequestInit): Promise<Response> =>
+          fetch(url, {
+            ...(init || {}),
+            // @ts-expect-error duplex is not yet in the types
+            duplex: 'half',
+          }),
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.TOGETHER) {
+    return togetherClientAdapter({
+      together: new OpenAI({
+        apiKey: modelProvider.apiKey,
+        baseURL: 'https://api.together.xyz/v1',
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.OPEN_ROUTER) {
+    return buildOpenaiClientAdapter({
+      modelProvider,
+      baseURL: 'https://openrouter.ai/api/v1',
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.MISTRAL) {
+    return mistralClientAdapter({
+      mistral: new Mistral({
+        apiKey: modelProvider.apiKey,
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.ANTHROPIC) {
+    return anthropicClientAdapter({
+      anthropic: new Anthropic({
+        apiKey: modelProvider.apiKey,
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.GROQ) {
+    return groqClientAdapter({
+      groq: new Groq({
+        apiKey: modelProvider.apiKey || process.env.COMMUNITY_TEST_GROQ_API_KEY,
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.OLLAMA) {
+    return buildOpenaiClientAdapter({
+      modelProvider,
+      baseURL: modelProvider.endpoint ?? '',
+      apiKey: 'ollama',
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.HUMIRIS) {
+    return humirisClientAdapter({
+      humiris: new OpenAI({
+        apiKey: modelProvider.apiKey,
+        baseURL: 'https://moai-service-app.humiris.ai/api/openai/v1/',
+        defaultHeaders: {
+          'moai-api-key': modelProvider.apiKey,
+        },
+      }),
+    })
+  }
+
+  if (modelProvider.type === ModelProviderType.GOOGLE) {
+    return googleClientAdapter({
+      google: new OpenAI({
+        apiKey: modelProvider.apiKey,
+        baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+      }),
+    })
+  }
+
+  throw new Error(`Invalid model provider type: ${modelProvider.type}`)
+}

package/src/lib/modelProviders/isModelProviderValid.ts

@@ -0,0 +1,23 @@
+import { ModelProvider, ModelProviderType } from '@prisma/client'
+
+export const isModelProviderValid = ({
+  modelProvider,
+}: {
+  modelProvider: ModelProvider
+}) => {
+  if (modelProvider.type === ModelProviderType.OLLAMA) {
+    return !!modelProvider.endpoint
+  }
+
+  if (!modelProvider.apiKey) {
+    return false
+  }
+
+  if (modelProvider.type === ModelProviderType.AZURE_OPENAI) {
+    if (!modelProvider.endpoint) {
+      return false
+    }
+  }
+
+  return true
+}