@superinterface/server 1.0.0

package/src/lib/functions/handleFunction/index.ts

@@ -0,0 +1,474 @@
+import OpenAI from 'openai'
+import {
+  Prisma,
+  HandlerType,
+  Thread,
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+} from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+import { getFunction } from './getFunction'
+import { handleRequest } from './handleRequest'
+import { handleFirecrawl } from './handleFirecrawl'
+import { handleReplicate } from './handleReplicate'
+import { handleAssistant } from './handleAssistant'
+import { handleClientTool } from './handleClientTool'
+import { handleCreateTask } from './tasks/handleCreateTask'
+import { handleListTasks } from './tasks/handleListTasks'
+import { handleUpdateTask } from './tasks/handleUpdateTask'
+import { handleDeleteTask } from './tasks/handleDeleteTask'
+import { getToolCallMcpServer } from '@/lib/mcpServers/getToolCallMcpServer'
+import { closeMcpConnection } from '@/lib/mcpServers/closeMcpConnection'
+import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js'
+
+export const handleFunction = async ({
+  assistant,
+  toolCall,
+  controller,
+  run,
+  thread,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      mcpServers: {
+        include: {
+          stdioTransport: true
+          httpTransport: true
+          sseTransport: true
+        }
+      }
+      functions: {
+        include: {
+          handler: {
+            include: {
+              requestHandler: true
+              firecrawlHandler: true
+              replicateHandler: true
+              clientToolHandler: true
+              assistantHandler: true
+              createTaskHandler: true
+              listTasksHandler: true
+              updateTaskHandler: true
+              deleteTaskHandler: true
+            }
+          }
+        }
+      }
+    }
+  }>
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  controller: ReadableStreamDefaultController
+  run: OpenAI.Beta.Threads.Runs.Run
+  thread: Thread
+}) => {
+  const fn = getFunction({
+    toolCall,
+    assistant,
+  })
+
+  if (!fn) {
+    const { mcpConnection } = await getToolCallMcpServer({
+      toolCall,
+      assistant,
+      thread,
+    })
+
+    if (!mcpConnection) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} not found.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} not found.`,
+      }
+    }
+
+    let args
+
+    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 function arguments: ${e.message}`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Failed parsing function arguments: ${e.message}`,
+      }
+    }
+
+    try {
+      const mcpServerToolOutput = await mcpConnection.client.callTool(
+        {
+          name: toolCall.function.name,
+          arguments: args,
+        },
+        CallToolResultSchema,
+        {
+          timeout: 300000,
+        },
+      )
+
+      await closeMcpConnection({
+        mcpConnection,
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: JSON.stringify(mcpServerToolOutput),
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (e: any) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Error calling function ${toolCall.function.name}: ${e.message}`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Error calling function ${toolCall.function.name}: ${e.message}`,
+      }
+    }
+  }
+
+  if (!fn.handler) {
+    createLog({
+      log: {
+        requestMethod: LogRequestMethod.POST,
+        requestRoute: LogRequestRoute.MESSAGES,
+        level: LogLevel.ERROR,
+        status: 500,
+        message: `Function ${toolCall.function.name} has no handler.`,
+        workspaceId: assistant.workspaceId,
+        assistantId: assistant.id,
+        threadId: thread.id,
+      },
+    })
+
+    return {
+      tool_call_id: toolCall.id,
+      output: `Function ${toolCall.function.name} has no handler.`,
+    }
+  }
+
+  if (fn.handler.type === HandlerType.REQUEST) {
+    if (!fn.handler.requestHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no request handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no request handler.`,
+      }
+    }
+
+    return handleRequest({
+      requestHandler: fn.handler.requestHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.CLIENT_TOOL) {
+    if (!fn.handler.clientToolHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no client tool handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no client tool handler.`,
+      }
+    }
+
+    return handleClientTool({
+      clientToolHandler: fn.handler.clientToolHandler,
+      controller,
+      toolCall,
+      assistant,
+      thread,
+      run,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.FIRECRAWL) {
+    if (!fn.handler.firecrawlHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no Firecrawl handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no Firecrawl handler.`,
+      }
+    }
+
+    return handleFirecrawl({
+      firecrawlHandler: fn.handler.firecrawlHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.REPLICATE) {
+    if (!fn.handler.replicateHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no Replicate handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no Replicate handler.`,
+      }
+    }
+
+    return handleReplicate({
+      replicateHandler: fn.handler.replicateHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.ASSISTANT) {
+    if (!fn.handler.assistantHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no assistant handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no assistant handler.`,
+      }
+    }
+
+    return handleAssistant({
+      assistantHandler: fn.handler.assistantHandler,
+      toolCall,
+      controller,
+      run,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.CREATE_TASK) {
+    const taskHandler = fn.handler.createTaskHandler
+
+    if (!taskHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no task handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no task handler.`,
+      }
+    }
+
+    return handleCreateTask({
+      taskHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.LIST_TASKS) {
+    const taskHandler = fn.handler.listTasksHandler
+
+    if (!taskHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no task handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no task handler.`,
+      }
+    }
+
+    return handleListTasks({
+      taskHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.UPDATE_TASK) {
+    const taskHandler = fn.handler.updateTaskHandler
+
+    if (!taskHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no task handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no task handler.`,
+      }
+    }
+
+    return handleUpdateTask({
+      taskHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  if (fn.handler.type === HandlerType.DELETE_TASK) {
+    const taskHandler = fn.handler.deleteTaskHandler
+
+    if (!taskHandler) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Function ${toolCall.function.name} has no task handler.`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Function ${toolCall.function.name} has no task handler.`,
+      }
+    }
+
+    return handleDeleteTask({
+      taskHandler,
+      toolCall,
+      assistant,
+      thread,
+    })
+  }
+
+  createLog({
+    log: {
+      requestMethod: LogRequestMethod.POST,
+      requestRoute: LogRequestRoute.MESSAGES,
+      level: LogLevel.ERROR,
+      status: 500,
+      message: `Function ${toolCall.function.name} handler type ${fn.handler.type} not supported.`,
+      workspaceId: assistant.workspaceId,
+      assistantId: assistant.id,
+      threadId: thread.id,
+    },
+  })
+
+  return {
+    tool_call_id: toolCall.id,
+    output: `Function ${toolCall.function.name} handler type ${fn.handler.type} not supported.`,
+  }
+}

package/src/lib/functions/handleFunction/tasks/handleCreateTask.ts

@@ -0,0 +1,58 @@
+import OpenAI from 'openai'
+import { CreateTaskHandler, Assistant, Thread } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+import { serializeTask } from '@/lib/tasks/serializeTask'
+import { validateSchedule } from '@/lib/tasks/validateSchedule'
+import { createTaskToolSchema } from '@/lib/tasks/schemas'
+import { parseTaskToolArgs } from '@/lib/tasks/parseTaskToolArgs'
+import { getTaskToolKey } from '@/lib/tasks/getTaskToolKey'
+import { scheduleTask } from '@/lib/tasks/scheduleTask'
+
+export const handleCreateTask = async ({
+  taskHandler,
+  toolCall,
+  assistant,
+  thread,
+}: {
+  taskHandler: CreateTaskHandler
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  assistant: Assistant
+  thread: Thread
+}) => {
+  const parsedArgs = parseTaskToolArgs({ toolCall, assistant, thread })
+  if (!parsedArgs.ok)
+    return { tool_call_id: toolCall.id, output: parsedArgs.error }
+
+  const check = createTaskToolSchema.safeParse(parsedArgs.args)
+  if (!check.success)
+    return { tool_call_id: toolCall.id, output: check.error.toString() }
+  const args = check.data
+
+  const { ok, key, error } = await getTaskToolKey({
+    thread,
+    assistant,
+    keyTemplate: taskHandler.keyTemplate,
+  })
+
+  if (!ok) return { tool_call_id: toolCall.id, output: error }
+
+  if (!validateSchedule(args.schedule)) {
+    return { tool_call_id: toolCall.id, output: 'Invalid schedule.' }
+  }
+  const task = await prisma.task.create({
+    data: {
+      title: args.title,
+      message: args.message,
+      schedule: args.schedule,
+      threadId: thread.id,
+      key: key ?? '',
+    },
+  })
+
+  await scheduleTask({ task })
+
+  return {
+    tool_call_id: toolCall.id,
+    output: JSON.stringify({ task: serializeTask({ task }) }),
+  }
+}

package/src/lib/functions/handleFunction/tasks/handleDeleteTask.ts

@@ -0,0 +1,62 @@
+import OpenAI from 'openai'
+import { DeleteTaskHandler, Assistant, Thread } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+import { serializeTask } from '@/lib/tasks/serializeTask'
+import { deleteTaskSchema } from '@/lib/tasks/schemas'
+import { parseTaskToolArgs } from '@/lib/tasks/parseTaskToolArgs'
+import { getTaskToolKey } from '@/lib/tasks/getTaskToolKey'
+import { cancelScheduledTask } from '@/lib/tasks/cancelScheduledTask'
+
+export const handleDeleteTask = async ({
+  taskHandler,
+  toolCall,
+  assistant,
+  thread,
+}: {
+  taskHandler: DeleteTaskHandler
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  assistant: Assistant
+  thread: Thread
+}) => {
+  const parsedArgs = parseTaskToolArgs({ toolCall, assistant, thread })
+  if (!parsedArgs.ok)
+    return { tool_call_id: toolCall.id, output: parsedArgs.error }
+
+  const check = deleteTaskSchema.safeParse(parsedArgs.args)
+  if (!check.success)
+    return { tool_call_id: toolCall.id, output: check.error.toString() }
+  const args = check.data
+
+  const { ok, key, error } = await getTaskToolKey({
+    thread,
+    assistant,
+    keyTemplate: taskHandler.keyTemplate,
+  })
+
+  if (!ok) return { tool_call_id: toolCall.id, output: error }
+
+  const existing = await prisma.task.findFirst({
+    where: {
+      id: args.taskId,
+      key,
+      thread: {
+        assistant: {
+          workspaceId: assistant.workspaceId,
+        },
+      },
+    },
+  })
+
+  if (!existing) {
+    return { tool_call_id: toolCall.id, output: 'Task not found.' }
+  }
+
+  await cancelScheduledTask({ task: existing })
+
+  const task = await prisma.task.delete({ where: { id: args.taskId } })
+
+  return {
+    tool_call_id: toolCall.id,
+    output: JSON.stringify({ task: serializeTask({ task }) }),
+  }
+}

package/src/lib/functions/handleFunction/tasks/handleListTasks.ts

@@ -0,0 +1,53 @@
+import OpenAI from 'openai'
+import { ListTasksHandler, Assistant, Thread } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+import { serializeTask } from '@/lib/tasks/serializeTask'
+import { listTasksSchema } from '@/lib/tasks/schemas'
+import { parseTaskToolArgs } from '@/lib/tasks/parseTaskToolArgs'
+import { getTaskToolKey } from '@/lib/tasks/getTaskToolKey'
+
+export const handleListTasks = async ({
+  taskHandler,
+  toolCall,
+  assistant,
+  thread,
+}: {
+  taskHandler: ListTasksHandler
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  assistant: Assistant
+  thread: Thread
+}) => {
+  const parsedArgs = parseTaskToolArgs({ toolCall, assistant, thread })
+  if (!parsedArgs.ok)
+    return { tool_call_id: toolCall.id, output: parsedArgs.error }
+
+  const check = listTasksSchema.safeParse(parsedArgs.args)
+  if (!check.success)
+    return { tool_call_id: toolCall.id, output: check.error.toString() }
+
+  const { ok, key, error } = await getTaskToolKey({
+    thread,
+    assistant,
+    keyTemplate: taskHandler.keyTemplate,
+  })
+  if (!ok) return { tool_call_id: toolCall.id, output: error }
+
+  const tasks = await prisma.task.findMany({
+    where: {
+      key,
+      thread: {
+        assistant: {
+          workspaceId: assistant.workspaceId,
+        },
+      },
+    },
+    orderBy: { createdAt: 'desc' },
+  })
+
+  return {
+    tool_call_id: toolCall.id,
+    output: JSON.stringify({
+      tasks: tasks.map((t) => serializeTask({ task: t })),
+    }),
+  }
+}

package/src/lib/functions/handleFunction/tasks/handleUpdateTask.ts

@@ -0,0 +1,70 @@
+import OpenAI from 'openai'
+import { UpdateTaskHandler, Assistant, Thread } from '@prisma/client'
+import { prisma } from '@/lib/prisma'
+import { serializeTask } from '@/lib/tasks/serializeTask'
+import { validateSchedule } from '@/lib/tasks/validateSchedule'
+import { updateTaskSchema } from '@/lib/tasks/schemas'
+import { parseTaskToolArgs } from '@/lib/tasks/parseTaskToolArgs'
+import { getTaskToolKey } from '@/lib/tasks/getTaskToolKey'
+import { scheduleTask } from '@/lib/tasks/scheduleTask'
+
+export const handleUpdateTask = async ({
+  taskHandler,
+  toolCall,
+  assistant,
+  thread,
+}: {
+  taskHandler: UpdateTaskHandler
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  assistant: Assistant
+  thread: Thread
+}) => {
+  const parsedArgs = parseTaskToolArgs({ toolCall, assistant, thread })
+  if (!parsedArgs.ok)
+    return { tool_call_id: toolCall.id, output: parsedArgs.error }
+
+  const check = updateTaskSchema.safeParse(parsedArgs.args)
+  if (!check.success)
+    return { tool_call_id: toolCall.id, output: check.error.toString() }
+  const args = check.data
+
+  const { ok, key, error } = await getTaskToolKey({
+    thread,
+    assistant,
+    keyTemplate: taskHandler.keyTemplate,
+  })
+
+  if (!ok) return { tool_call_id: toolCall.id, output: error }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const updateData: any = {}
+  if (args.title !== undefined) updateData.title = args.title
+  if (args.message !== undefined) updateData.message = args.message
+  if (args.schedule !== undefined) {
+    if (!validateSchedule(args.schedule)) {
+      return { tool_call_id: toolCall.id, output: 'Invalid schedule.' }
+    }
+    updateData.schedule = args.schedule
+  }
+  if (args.key !== undefined) updateData.key = args.key ?? ''
+
+  const task = await prisma.task.update({
+    where: {
+      id: args.taskId,
+      key,
+      thread: {
+        assistant: {
+          workspaceId: assistant.workspaceId,
+        },
+      },
+    },
+    data: updateData,
+  })
+
+  await scheduleTask({ task })
+
+  return {
+    tool_call_id: toolCall.id,
+    output: JSON.stringify({ task: serializeTask({ task }) }),
+  }
+}