@superinterface/server 1.0.0

package/src/lib/functions/interpolateFunctionValue.ts

@@ -0,0 +1,26 @@
+import { Assistant, Thread } from '@prisma/client'
+
+export const interpolateFunctionValue = ({
+  value,
+  args,
+  thread,
+  assistant,
+}: {
+  value: string | null | undefined
+  args?: Record<string, unknown> | null
+  thread: Thread
+  assistant: Assistant
+}) => {
+  const missing: string[] = []
+  const result = (value || '').replace(/{{\s*([\w-]+)\s*}}/g, (_, k) => {
+    if (args && k in args) return String(args[k] as unknown)
+    // 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}}}`
+  })
+
+  return { value: result, missing }
+}

package/src/lib/functions/serializeApiFunction.ts

@@ -0,0 +1,32 @@
+import { Prisma } from '@prisma/client'
+import { serializeApiHandler } from '@/lib/handlers/serializeApiHandler'
+
+export const serializeApiFunction = ({
+  fn,
+}: {
+  fn: Prisma.FunctionGetPayload<{
+    include: {
+      handler: {
+        include: {
+          requestHandler: true
+          firecrawlHandler: true
+          replicateHandler: true
+          clientToolHandler: true
+          assistantHandler: true
+          createTaskHandler: true
+          listTasksHandler: true
+          updateTaskHandler: true
+          deleteTaskHandler: true
+        }
+      }
+    }
+  }>
+}) => ({
+  id: fn.id,
+  openapiSpec: fn.openapiSpec,
+  handler: serializeApiHandler({
+    handler: fn.handler!,
+  }),
+  createdAt: fn.createdAt.toISOString(),
+  updatedAt: fn.updatedAt.toISOString(),
+})

package/src/lib/functions/updateFunction.ts

@@ -0,0 +1,42 @@
+import type { Prisma } from '@prisma/client'
+import type { HandlerInput } from '@/types'
+import { prisma } from '@/lib/prisma'
+import { handlerPrismaInput } from '@/lib/handlers/handlerPrismaInput'
+
+export async function updateFunction<
+  TInclude extends Prisma.FunctionInclude,
+>(params: {
+  fn: Prisma.FunctionGetPayload<{
+    include: {
+      assistant: true
+    }
+  }>
+  parsedInput: { openapiSpec: string; handler: HandlerInput }
+  include: TInclude
+}): Promise<Prisma.FunctionGetPayload<{ include: TInclude }>> {
+  const { fn, parsedInput, include } = params
+
+  return prisma.$transaction(async (tx) => {
+    await tx.handler.deleteMany({
+      where: { functionId: fn.id },
+    })
+
+    return tx.function.update({
+      where: { id: fn.id },
+      data: {
+        openapiSpec: JSON.parse(parsedInput.openapiSpec),
+        handler: {
+          create: {
+            type: parsedInput.handler.type,
+            ...(await handlerPrismaInput({
+              parsedInput,
+              action: 'create',
+              assistant: fn.assistant,
+            })),
+          },
+        },
+      },
+      include,
+    })
+  })
+}

package/src/lib/handlers/handlerPrismaInput.tsx

@@ -0,0 +1,141 @@
+import { HandlerType } from '@prisma/client'
+import type { Assistant } from '@prisma/client'
+import type { HandlerInput } from '@/types'
+import { prisma } from '@/lib/prisma'
+import { ValidationError } from '@/lib/errors'
+
+export const handlerPrismaInput = async ({
+  parsedInput,
+  action,
+  assistant,
+}: {
+  parsedInput: {
+    handler: HandlerInput
+  }
+  action: 'create' | 'update'
+  assistant: Assistant
+}) => {
+  if (parsedInput.handler.type === HandlerType.REQUEST) {
+    if (!parsedInput.handler.requestHandler)
+      throw new ValidationError('Request handler is required.')
+
+    return {
+      requestHandler: {
+        [action]: {
+          method: parsedInput.handler.requestHandler.method,
+          url: parsedInput.handler.requestHandler.url,
+          headers: JSON.parse(parsedInput.handler.requestHandler.headers),
+          body: JSON.parse(parsedInput.handler.requestHandler.body),
+        },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.FIRECRAWL) {
+    if (!parsedInput.handler.firecrawlHandler)
+      throw new ValidationError('Firecrawl handler is required.')
+
+    return {
+      firecrawlHandler: {
+        [action]: {
+          type: parsedInput.handler.firecrawlHandler.type,
+          apiKey: parsedInput.handler.firecrawlHandler.apiKey,
+          body: JSON.parse(parsedInput.handler.firecrawlHandler.body),
+        },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.ASSISTANT) {
+    if (!parsedInput.handler.assistantHandler)
+      throw new ValidationError('Assistant handler is required.')
+
+    const handlerAssistant = await prisma.assistant.findFirst({
+      where: {
+        id: parsedInput.handler.assistantHandler.assistantId,
+        workspaceId: assistant.workspaceId,
+      },
+    })
+
+    if (!handlerAssistant) throw new ValidationError('Assistant not found.')
+
+    return {
+      assistantHandler: {
+        [action]: {
+          assistantId: handlerAssistant.id,
+        },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.REPLICATE) {
+    if (!parsedInput.handler.replicateHandler)
+      throw new ValidationError('Replicate handler is required.')
+
+    return {
+      replicateHandler: {
+        [action]: {
+          type: parsedInput.handler.replicateHandler.type,
+          apiKey: parsedInput.handler.replicateHandler.apiKey,
+          identifier: parsedInput.handler.replicateHandler.identifier,
+          body: JSON.parse(parsedInput.handler.replicateHandler.body),
+        },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.CLIENT_TOOL) {
+    if (!parsedInput.handler.clientToolHandler)
+      throw new ValidationError('Client tool handler is required.')
+
+    return {
+      clientToolHandler: {
+        [action]: {
+          type: parsedInput.handler.clientToolHandler.type,
+          name: parsedInput.handler.clientToolHandler.name,
+          arguments: JSON.parse(
+            parsedInput.handler.clientToolHandler.arguments,
+          ),
+        },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.CREATE_TASK) {
+    if (!parsedInput.handler.createTaskHandler)
+      throw new ValidationError('Task handler is required.')
+
+    const keyTemplate = parsedInput.handler.createTaskHandler.keyTemplate
+
+    return {
+      createTaskHandler: {
+        [action]: { keyTemplate },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.LIST_TASKS) {
+    if (!parsedInput.handler.listTasksHandler)
+      throw new ValidationError('Task handler is required.')
+
+    const keyTemplate = parsedInput.handler.listTasksHandler.keyTemplate
+
+    return {
+      listTasksHandler: {
+        [action]: { keyTemplate },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.UPDATE_TASK) {
+    if (!parsedInput.handler.updateTaskHandler)
+      throw new ValidationError('Task handler is required.')
+
+    const keyTemplate = parsedInput.handler.updateTaskHandler.keyTemplate
+
+    return {
+      updateTaskHandler: {
+        [action]: { keyTemplate },
+      },
+    }
+  } else if (parsedInput.handler.type === HandlerType.DELETE_TASK) {
+    if (!parsedInput.handler.deleteTaskHandler)
+      throw new ValidationError('Task handler is required.')
+
+    const keyTemplate = parsedInput.handler.deleteTaskHandler.keyTemplate
+
+    return {
+      deleteTaskHandler: {
+        [action]: { keyTemplate },
+      },
+    }
+  } else {
+    throw new ValidationError('Handler type not supported.')
+  }
+}

package/src/lib/handlers/serializeApiHandler.ts

@@ -0,0 +1,94 @@
+import { Prisma, HandlerType } from '@prisma/client'
+
+export const serializeApiHandler = ({
+  handler,
+}: {
+  handler: Prisma.HandlerGetPayload<{
+    include: {
+      requestHandler: true
+      firecrawlHandler: true
+      replicateHandler: true
+      clientToolHandler: true
+      assistantHandler: true
+      createTaskHandler: true
+      listTasksHandler: true
+      updateTaskHandler: true
+      deleteTaskHandler: true
+    }
+  }>
+}) => ({
+  type: handler.type,
+  ...(handler.type === HandlerType.REQUEST
+    ? {
+        requestHandler: {
+          url: handler.requestHandler!.url,
+          method: handler.requestHandler!.method,
+          headers: handler.requestHandler!.headers,
+          body: handler.requestHandler!.body,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.FIRECRAWL
+    ? {
+        firecrawlHandler: {
+          type: handler.firecrawlHandler!.type,
+          apiKey: handler.firecrawlHandler!.apiKey,
+          body: handler.firecrawlHandler!.body,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.REPLICATE
+    ? {
+        replicateHandler: {
+          type: handler.replicateHandler!.type,
+          apiKey: handler.replicateHandler!.apiKey,
+          identifier: handler.replicateHandler!.identifier,
+          body: handler.replicateHandler!.body,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.CLIENT_TOOL
+    ? {
+        clientToolHandler: {
+          type: handler.clientToolHandler!.type,
+          name: handler.clientToolHandler!.name,
+          arguments: handler.clientToolHandler!.arguments,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.ASSISTANT
+    ? {
+        assistantHandler: {
+          assistantId: handler.assistantHandler!.assistantId,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.LIST_TASKS
+    ? {
+        listTasksHandler: {
+          keyTemplate: handler.listTasksHandler!.keyTemplate,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.CREATE_TASK
+    ? {
+        createTaskHandler: {
+          keyTemplate: handler.createTaskHandler!.keyTemplate,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.UPDATE_TASK
+    ? {
+        updateTaskHandler: {
+          keyTemplate: handler.updateTaskHandler!.keyTemplate,
+        },
+      }
+    : {}),
+  ...(handler.type === HandlerType.DELETE_TASK
+    ? {
+        deleteTaskHandler: {
+          keyTemplate: handler.deleteTaskHandler!.keyTemplate,
+        },
+      }
+    : {}),
+})

package/src/lib/iconAvatars/serializeIconAvatar.ts

@@ -0,0 +1,9 @@
+import { IconAvatar } from '@prisma/client'
+
+export const serializeIconAvatar = ({
+  iconAvatar,
+}: {
+  iconAvatar: IconAvatar
+}) => ({
+  name: iconAvatar.name,
+})

package/src/lib/imageAvatars/serializeImageAvatar.ts

@@ -0,0 +1,9 @@
+import { ImageAvatar } from '@prisma/client'
+
+export const serializeImageAvatar = ({
+  imageAvatar,
+}: {
+  imageAvatar: ImageAvatar
+}) => ({
+  url: imageAvatar.url,
+})

package/src/lib/initialMessages/schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod'
+import { MessageRole } from '@prisma/client'
+
+export const initialMessagesSchema = z.object({
+  initialMessages: z.array(
+    z.object({
+      content: z.string().min(1),
+      role: z.nativeEnum(MessageRole),
+    }),
+  ),
+})

package/src/lib/initialMessages/serializeApiInitialMessage.ts

@@ -0,0 +1,15 @@
+import type { InitialMessage } from '@prisma/client'
+
+export const serializeApiInitialMessage = ({
+  initialMessage,
+}: {
+  initialMessage: InitialMessage
+}) => ({
+  id: initialMessage.id,
+  role: initialMessage.role,
+  content: initialMessage.content,
+  orderNumber: initialMessage.orderNumber,
+  assistantId: initialMessage.assistantId,
+  createdAt: initialMessage.createdAt.toISOString(),
+  updatedAt: initialMessage.updatedAt.toISOString(),
+})

package/src/lib/initialMessages/updateInitialMessages.ts

@@ -0,0 +1,33 @@
+import { MessageRole, InitialMessage } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+
+export const updateInitialMessages = async ({
+  assistantId,
+  initialMessages,
+}: {
+  assistantId: string
+  initialMessages: { role: MessageRole; content: string }[]
+}) => {
+  const messages: InitialMessage[] = await prisma.$transaction(async (tx) => {
+    await tx.initialMessage.deleteMany({
+      where: { assistantId },
+    })
+
+    if (initialMessages.length === 0) {
+      return [] as InitialMessage[]
+    }
+
+    const created = await tx.initialMessage.createManyAndReturn({
+      data: initialMessages.map((m, index) => ({
+        assistantId,
+        role: m.role,
+        content: m.content,
+        orderNumber: index,
+      })),
+    })
+
+    return created
+  })
+
+  return messages.sort((a, b) => a.orderNumber - b.orderNumber)
+}

package/src/lib/logs/createLog.ts

@@ -0,0 +1,17 @@
+import { type Prisma } from '@prisma/client'
+import { waitUntil } from '@vercel/functions'
+import { prisma } from '@/lib/prisma'
+
+export const createLog = ({ log }: { log: Prisma.LogUncheckedCreateInput }) =>
+  waitUntil(
+    new Promise(async (resolve) => {
+      console.log('Logging error.')
+
+      await prisma.log.create({
+        data: log,
+      })
+
+      console.log('Successfully logged error.')
+      resolve(true)
+    }),
+  )

package/src/lib/mcpServers/closeMcpConnection.ts

@@ -0,0 +1,16 @@
+// import { v4 as uuidv4 } from 'uuid'
+import type { McpConnection } from '@/types'
+
+export const closeMcpConnection = async ({
+  mcpConnection,
+}: {
+  mcpConnection: McpConnection
+}) => {
+  // await mcpConnection.transport.send({
+  //   id: `close-${uuidv4()}`,
+  //   jsonrpc: '2.0',
+  //   method: 'ping',
+  // })
+  await mcpConnection.client.close()
+  await mcpConnection.transport.close()
+}

package/src/lib/mcpServers/connectMcpServer.ts

@@ -0,0 +1,117 @@
+import type { Prisma, Thread, Assistant } from '@prisma/client'
+import { TransportType } from '@prisma/client'
+import { EventSource } from 'eventsource'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+import type { McpConnection } from '@/types'
+import { headers as getHeaders } from '@/lib/mcpServers/headers'
+import { url as getUrl } from '@/lib/mcpServers/url'
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+;(global as any).EventSource = EventSource
+
+const fetchWithHeaders =
+  ({ headers }: { headers: Record<string, string> }) =>
+  (url: string | URL, init?: RequestInit) => {
+    const fetchHeaders = new Headers({
+      ...(init?.headers ?? {}),
+      ...headers,
+    })
+
+    return fetch(url.toString(), {
+      ...init,
+      headers: fetchHeaders,
+    })
+  }
+
+export const getTransport = ({
+  mcpServer,
+  thread,
+  assistant,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      stdioTransport: true
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  thread: Thread
+  assistant: Assistant
+}) => {
+  if (mcpServer.transportType === TransportType.STDIO) {
+    throw new Error('STDIO transport is not supported.')
+  }
+
+  if (mcpServer.transportType === TransportType.HTTP) {
+    const headers = getHeaders({
+      thread,
+      mcpServer,
+      assistant,
+    })
+    const url = getUrl({ thread, mcpServer, assistant })
+
+    return new StreamableHTTPClientTransport(new URL(url), {
+      requestInit: {
+        headers,
+      },
+    })
+  }
+
+  if (mcpServer.transportType === TransportType.SSE) {
+    const url = getUrl({ thread, mcpServer, assistant })
+
+    const headers = getHeaders({
+      thread,
+      mcpServer,
+      assistant,
+    })
+
+    return new SSEClientTransport(new URL(url), {
+      eventSourceInit: {
+        fetch: fetchWithHeaders({ headers }),
+      },
+      requestInit: {
+        headers,
+      },
+    })
+  }
+
+  throw new Error(`Unknown transport type ${mcpServer.transportType}`)
+}
+
+export const connectMcpServer = async ({
+  mcpServer,
+  thread,
+  assistant,
+}: {
+  mcpServer: Prisma.McpServerGetPayload<{
+    include: {
+      stdioTransport: true
+      httpTransport: true
+      sseTransport: true
+    }
+  }>
+  thread: Thread
+  assistant: Assistant
+}) => {
+  const client = new Client(
+    {
+      name: 'superinterface-mcp-client',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {},
+    },
+  )
+
+  const transport = getTransport({ mcpServer, thread, assistant })
+  await client.connect(transport)
+
+  return {
+    mcpConnection: {
+      client,
+      transport,
+    } as McpConnection,
+  }
+}

package/src/lib/mcpServers/getToolCallMcpServer.ts

@@ -0,0 +1,62 @@
+import OpenAI from 'openai'
+import { Prisma, Thread } from '@prisma/client'
+import { forEach } from 'p-iteration'
+import { connectMcpServer } from '@/lib/mcpServers/connectMcpServer'
+import type { McpConnection } from '@/types'
+import { closeMcpConnection } from '@/lib/mcpServers/closeMcpConnection'
+
+export const getToolCallMcpServer = async ({
+  assistant,
+  toolCall,
+  thread,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      mcpServers: {
+        include: {
+          stdioTransport: true
+          httpTransport: true
+          sseTransport: true
+        }
+      }
+    }
+  }>
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  thread: Thread
+}) => {
+  let mcpConnection: McpConnection | null = null
+
+  await forEach(assistant.mcpServers, async (mcpServer) => {
+    if (mcpConnection) return false
+
+    const { mcpConnection: innerMcpConnection } = await connectMcpServer({
+      mcpServer,
+      thread,
+      assistant,
+    })
+
+    const listToolsResponse =
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (await innerMcpConnection.client.listTools()) as any
+
+    const tool = listToolsResponse.tools.find(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (tool: any) => tool.name === toolCall.function.name,
+    )
+
+    if (!tool) {
+      await closeMcpConnection({
+        mcpConnection: innerMcpConnection,
+      })
+      return false
+    }
+
+    mcpConnection = innerMcpConnection
+
+    return true
+  })
+
+  return {
+    mcpConnection: mcpConnection as McpConnection | null,
+  }
+}