@superinterface/server 1.0.0

package/src/lib/toolCalls/handleToolCall.ts

@@ -0,0 +1,121 @@
+import OpenAI from 'openai'
+import { Prisma, Thread } from '@prisma/client'
+import { handleFunction } from '@/lib/functions/handleFunction'
+import { handleComputerCall } from '@/lib/computerCalls/handleComputerCall'
+import { LogRequestMethod, LogRequestRoute, LogLevel } from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+
+export const handleToolCall =
+  ({
+    assistant,
+    thread,
+  }: {
+    assistant: Prisma.AssistantGetPayload<{
+      include: {
+        tools: {
+          include: {
+            computerUseTool: {
+              include: {
+                mcpServer: {
+                  include: {
+                    stdioTransport: true
+                    sseTransport: true
+                    httpTransport: true
+                  }
+                }
+              }
+            }
+          }
+        }
+        mcpServers: {
+          include: {
+            computerUseTool: true
+            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
+              }
+            }
+          }
+        }
+      }
+    }>
+    thread: Thread
+  }) =>
+  async ({
+    toolCall,
+    controller,
+    run,
+  }: {
+    toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+    controller: ReadableStreamDefaultController
+    run: OpenAI.Beta.Threads.Runs.Run
+  }) => {
+    if (toolCall.type === 'function') {
+      if (!toolCall.function) {
+        createLog({
+          log: {
+            requestMethod: LogRequestMethod.POST,
+            requestRoute: LogRequestRoute.MESSAGES,
+            level: LogLevel.ERROR,
+            status: 500,
+            message: 'No function specified.',
+            workspaceId: assistant.workspaceId,
+            assistantId: assistant.id,
+            threadId: thread.id,
+          },
+        })
+
+        return {
+          tool_call_id: toolCall.id,
+          output: 'No function specified',
+        }
+      }
+
+      return handleFunction({
+        assistant,
+        toolCall,
+        controller,
+        run,
+        thread,
+      })
+    } else if (toolCall.type === 'computer_call') {
+      return handleComputerCall({
+        assistant,
+        toolCall,
+        thread,
+      })
+    } else {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          message: `Unknown tool call type: ${toolCall.type}`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        output: `Unknown tool call type: ${toolCall.type}`,
+      }
+    }
+  }

package/src/lib/toolCalls/messagesToOutput.ts

@@ -0,0 +1,8 @@
+import type OpenAI from 'openai'
+import { textContent } from '@/lib/messages/textContent'
+
+export const messagesToOutput = ({
+  messages,
+}: {
+  messages: OpenAI.Beta.Threads.Messages.Message[]
+}) => messages.map((message) => textContent({ message })).join('\n\n')

package/src/lib/toolCalls/streamOutput.ts

@@ -0,0 +1,106 @@
+import type OpenAI from 'openai'
+import { validate } from 'uuid'
+import { enqueueJson } from '@superinterface/react/utils'
+import { prisma } from '@/lib/prisma'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const deltaContent = ({ data }: { data: any }) => {
+  return (
+    data.delta.content
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map((content: any) => {
+        if (content.type === 'text') {
+          return content.text.value
+        }
+
+        return ''
+      })
+      .join('\n\n')
+  )
+}
+
+export const streamOutput = async ({
+  toolCall,
+  run,
+  messageResponse,
+  onThreadMessageCompleted = () => {},
+  onThreadRunStepCompleted = () => {},
+  controller,
+}: {
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  run: OpenAI.Beta.Threads.Runs.Run
+  controller: ReadableStreamDefaultController
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  messageResponse: ReadableStream<any>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onThreadMessageCompleted?: ({ message }: { message: any }) => void
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onThreadRunStepCompleted?: ({ runStep }: { runStep: any }) => void
+}) => {
+  // TODO figure out how to stream non-prisma runs
+  if (!validate(run.id)) {
+    return
+  }
+
+  // TODO: get real run step id somehow
+  const latestRunStep = await prisma.runStep.findFirst({
+    where: {
+      runId: run.id,
+    },
+    orderBy: {
+      createdAt: 'desc',
+    },
+  })
+
+  const index =
+    run.required_action?.submit_tool_outputs.tool_calls.findIndex(
+      (tc) => tc.id === toolCall.id,
+    ) ?? 0
+
+  // @ts-expect-error unclear type
+  for await (const value of messageResponse) {
+    const data = JSON.parse(Buffer.from(value).toString('utf-8'))
+
+    if (data.event === 'thread.message.delta') {
+      enqueueJson({
+        controller,
+        value: {
+          event: 'thread.run.step.delta',
+          data: {
+            object: 'thread.run.step.delta',
+            run_id: run.id,
+            // TODO: proper id
+            id: latestRunStep?.id ?? '1',
+            delta: {
+              step_details: {
+                type: 'tool_calls',
+                tool_calls: [
+                  {
+                    id: toolCall.id,
+                    type: 'function',
+                    index,
+                    function: {
+                      output: deltaContent({ data: data.data }),
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      })
+    }
+
+    if (data.event === 'thread.message.completed') {
+      onThreadMessageCompleted({
+        message: data.data,
+      })
+    }
+
+    if (data.event === 'thread.run.step.completed') {
+      onThreadRunStepCompleted({
+        runStep: data.data,
+      })
+    }
+  }
+}

package/src/lib/tools/tools/index.ts

@@ -0,0 +1,316 @@
+import type { Prisma, Thread } from '@prisma/client'
+import {
+  TransportType,
+  ToolType,
+  ImageGenerationToolSize,
+} from '@prisma/client'
+import { flat } from 'radash'
+import { map } from 'p-iteration'
+import type OpenAI from 'openai'
+import { modelProviderConfigs } from '@/lib/modelProviders/modelProviderConfigs'
+import { isOpenaiAssistantsStorageProvider } from '@/lib/storageProviders/isOpenaiAssistantsStorageProvider'
+import { connectMcpServer } from '@/lib/mcpServers/connectMcpServer'
+import type { ModelProviderConfig } from '@/types'
+import { closeMcpConnection } from '@/lib/mcpServers/closeMcpConnection'
+import { isResponsesStorageProvider } from '@/lib/storageProviders/isResponsesStorageProvider'
+import { url } from '@/lib/mcpServers/url'
+import { headers } from '@/lib/mcpServers/headers'
+
+const serializeImageGenerationToolSize = ({
+  tool,
+}: {
+  tool: Prisma.ToolGetPayload<{
+    include: { imageGenerationTool: true }
+  }>
+}) => {
+  if (tool.imageGenerationTool!.size === ImageGenerationToolSize.AUTO) {
+    return 'auto'
+  } else if (
+    tool.imageGenerationTool!.size === ImageGenerationToolSize.SIZE_1024_1024
+  ) {
+    return '1024x1024'
+  } else if (
+    tool.imageGenerationTool!.size === ImageGenerationToolSize.SIZE_1024_1536
+  ) {
+    return '1024x1536'
+  } else if (
+    tool.imageGenerationTool!.size === ImageGenerationToolSize.SIZE_1536_1024
+  ) {
+    return '1536x1024'
+  }
+}
+
+const nativeTools = ({
+  assistant,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      tools: {
+        include: {
+          fileSearchTool: true
+          webSearchTool: true
+          imageGenerationTool: true
+          codeInterpreterTool: true
+          computerUseTool: true
+        }
+      }
+    }
+  }>
+  modelProviderConfig: ModelProviderConfig
+}): OpenAI.Beta.Assistants.AssistantTool[] => {
+  if (
+    !isOpenaiAssistantsStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    }) &&
+    !isResponsesStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    })
+  ) {
+    return []
+  }
+
+  return assistant.tools
+    .map((tool) => {
+      if (tool.type === ToolType.FILE_SEARCH) {
+        if (
+          isOpenaiAssistantsStorageProvider({
+            storageProviderType: assistant.storageProviderType,
+          })
+        ) {
+          return {
+            type: 'file_search' as const,
+          }
+        }
+
+        return {
+          type: 'file_search' as const,
+          file_search: {
+            vector_store_ids: tool.fileSearchTool!.vectorStoreIds,
+            max_num_results: tool.fileSearchTool!.maxNumResults,
+          },
+        }
+      } else if (tool.type === ToolType.CODE_INTERPRETER) {
+        if (
+          isOpenaiAssistantsStorageProvider({
+            storageProviderType: assistant.storageProviderType,
+          })
+        ) {
+          return {
+            type: 'code_interpreter' as const,
+          }
+        }
+
+        return {
+          type: 'code_interpreter' as const,
+          code_interpreter: {
+            container: {
+              type: 'auto' as const,
+            },
+          },
+        }
+      } else if (tool.type === ToolType.IMAGE_GENERATION) {
+        return {
+          type: 'image_generation' as const,
+          image_generation: {
+            quality: tool.imageGenerationTool!.quality.toLowerCase() as
+              | 'auto'
+              | 'low'
+              | 'medium'
+              | 'high',
+            output_format:
+              tool.imageGenerationTool!.outputFormat.toLowerCase() as
+                | 'png'
+                | 'jpeg'
+                | 'webp',
+            size: serializeImageGenerationToolSize({ tool }),
+            partial_images: tool.imageGenerationTool!.partialImages,
+          },
+        }
+      } else if (tool.type === ToolType.WEB_SEARCH) {
+        return {
+          type: 'web_search' as const,
+        }
+      } else if (tool.type === ToolType.COMPUTER_USE) {
+        if (!tool.computerUseTool!.mcpServerId) {
+          return null
+        }
+
+        return {
+          type: 'computer_use_preview',
+          computer_use_preview: {
+            environment: tool.computerUseTool!.environment.toLowerCase(),
+            display_width: tool.computerUseTool!.displayWidth,
+            display_height: tool.computerUseTool!.displayHeight,
+          },
+        }
+      }
+
+      return null
+    })
+    .filter(Boolean) as OpenAI.Beta.Assistants.AssistantTool[]
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const serializeTool = ({ tool }: { tool: any }) => ({
+  name: tool.name,
+  description: tool.description,
+  parameters: tool.inputSchema,
+})
+
+const mcpServerToolsAsFunction = ({
+  mcpServers,
+  thread,
+  assistant,
+}: {
+  mcpServers: Prisma.McpServerGetPayload<{
+    include: {
+      stdioTransport: true
+      httpTransport: true
+      sseTransport: true
+      computerUseTool: true
+    }
+  }>[]
+  thread: Thread
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      mcpServers: {
+        include: {
+          stdioTransport: true
+          httpTransport: true
+          sseTransport: true
+          computerUseTool: true
+        }
+      }
+    }
+  }>
+}) =>
+  map(mcpServers, async (mcpServer) => {
+    const { mcpConnection } = await connectMcpServer({
+      mcpServer,
+      thread,
+      assistant,
+    })
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const listToolsResponse = (await mcpConnection.client.listTools()) as any
+
+    await closeMcpConnection({
+      mcpConnection,
+    })
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return listToolsResponse.tools.map((tool: any) => ({
+      type: 'function',
+      function: serializeTool({ tool }),
+    })) as OpenAI.Beta.Assistants.AssistantTool[]
+  })
+
+const mcpServerTools = async ({
+  assistant,
+  thread,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      mcpServers: {
+        include: {
+          stdioTransport: true
+          httpTransport: true
+          sseTransport: true
+          computerUseTool: true
+        }
+      }
+    }
+  }>
+  thread: Thread
+}) => {
+  const nonComputerUseMcpServers = assistant.mcpServers.filter(
+    (mcpServer) => !mcpServer.computerUseTool,
+  )
+
+  if (
+    isResponsesStorageProvider({
+      storageProviderType: assistant.storageProviderType,
+    }) &&
+    assistant.modelSlug.match('computer-use')
+  ) {
+    const httpMcpServers = nonComputerUseMcpServers.filter(
+      (mcpServer) => mcpServer.transportType === TransportType.HTTP,
+    )
+
+    const nativeMcpServerTools = httpMcpServers.map((mcpServer) => ({
+      type: 'mcp',
+      mcp: {
+        server_label: `mcp-server-${mcpServer.id}`,
+        server_url: url({ thread, mcpServer, assistant }),
+        headers: headers({ thread, mcpServer, assistant }),
+        require_approval: 'never',
+      },
+    }))
+
+    return [
+      ...nativeMcpServerTools,
+      ...(await mcpServerToolsAsFunction({
+        mcpServers: nonComputerUseMcpServers,
+        thread,
+        assistant,
+      })),
+    ]
+  }
+
+  const result = await mcpServerToolsAsFunction({
+    mcpServers: nonComputerUseMcpServers,
+    thread,
+    assistant,
+  })
+
+  return flat(result)
+}
+
+export const tools = 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
+}) => {
+  const modelProviderConfig = modelProviderConfigs.find(
+    (config) => config.type === assistant.modelProvider.type,
+  )
+
+  if (!modelProviderConfig) return {}
+  if (!modelProviderConfig.isFunctionCallingAvailable) {
+    return {}
+  }
+
+  return {
+    tools: [
+      ...(await mcpServerTools({ assistant, thread })),
+      ...assistant.functions.map((fn) => ({
+        type: 'function' as const,
+        function: fn.openapiSpec as unknown as OpenAI.FunctionDefinition,
+      })),
+      ...nativeTools({ assistant, modelProviderConfig }),
+    ] as OpenAI.Beta.Assistants.AssistantTool[],
+  }
+}

package/src/lib/upstash/qstash.ts

@@ -0,0 +1,5 @@
+import { Client } from '@upstash/qstash'
+
+export const qstash = new Client({
+  token: process.env.QSTASH_TOKEN,
+})

package/src/lib/upstash/upstashWorkflowClient.ts

@@ -0,0 +1,5 @@
+import { Client } from '@upstash/workflow'
+
+export const upstashWorkflowClient = new Client({
+  token: process.env.QSTASH_TOKEN,
+})

package/src/lib/workspaces/serializeApiWorkspace.ts

@@ -0,0 +1,12 @@
+import type { Workspace } from '@prisma/client'
+
+export const serializeApiWorkspace = ({
+  workspace,
+}: {
+  workspace: Workspace
+}) => ({
+  id: workspace.id,
+  name: workspace.name,
+  createdAt: workspace.createdAt.toISOString(),
+  updatedAt: workspace.updatedAt.toISOString(),
+})

package/src/types/index.ts

@@ -0,0 +1,133 @@
+import type { OpenAI } from 'openai'
+import type {
+  StorageProviderType,
+  ModelProviderType,
+  FirecrawlHandlerType,
+  ReplicateHandlerType,
+  ClientToolHandlerType,
+  HandlerType,
+  MethodType,
+} from '@prisma/client'
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import type { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
+
+export type ModelProviderConfig = {
+  slug: string
+  type: ModelProviderType
+  name: string
+  logoUrl: string
+  iconUrl: string
+  dashboardUrl: string
+  description: string
+  modelSlugs: string[]
+  storageProviderTypes: StorageProviderType[]
+  isFunctionCallingAvailable: boolean
+}
+
+export type McpConnection = {
+  client: Client
+  transport: SSEClientTransport
+}
+
+export type RecurrenceRule = {
+  frequency: 'daily' | 'weekly' | 'monthly' | 'yearly'
+  byDay?: string[]
+  byMonth?: number[]
+  byHour?: number[]
+  byMinute?: number[]
+  bySecond?: number[]
+  until?: string
+  count?: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any
+}
+
+export type HandlerInput = {
+  type: HandlerType
+  requestHandler?: {
+    method: MethodType
+    url: string
+    headers: string
+    body: string
+  } | null
+  firecrawlHandler?: {
+    type: FirecrawlHandlerType
+    apiKey: string
+    body: string
+  } | null
+  assistantHandler?: {
+    assistantId: string
+  } | null
+  replicateHandler?: {
+    type: ReplicateHandlerType
+    identifier: string
+    apiKey: string
+    body: string
+  } | null
+  clientToolHandler?: {
+    type: ClientToolHandlerType
+    name: string
+    arguments: string
+  } | null
+  createTaskHandler?: {
+    keyTemplate: string
+  } | null
+  listTasksHandler?: {
+    keyTemplate: string
+  } | null
+  updateTaskHandler?: {
+    keyTemplate: string
+  } | null
+  deleteTaskHandler?: {
+    keyTemplate: string
+  } | null
+}
+
+declare global {
+  namespace PrismaJson {
+    type MessageContent = OpenAI.Beta.Threads.Messages.MessageContent
+    type MessageIncompleteDetails =
+      OpenAI.Beta.Threads.Messages.Message['incomplete_details']
+    type MessageMetadata = OpenAI.Beta.Threads.Messages.Message['metadata']
+    type MessageToolCalls = OpenAI.Beta.Threads.Runs.ToolCall
+    type MessageAttachment = OpenAI.Beta.Threads.Messages.Message.Attachment
+
+    type RunRequiredAction = OpenAI.Beta.Threads.Runs.Run['required_action']
+    type RunLastError = OpenAI.Beta.Threads.Runs.Run['last_error']
+    type RunTools = OpenAI.Beta.Threads.Runs.Run['tools']
+    type RunMetadata = OpenAI.Beta.Threads.Runs.Run['metadata']
+    type RunUsage = OpenAI.Beta.Threads.Runs.Run['usage']
+    type RunTruncationStrategy =
+      OpenAI.Beta.Threads.Runs.Run['truncation_strategy']
+    type RunResponseFormat = OpenAI.Beta.Threads.Runs.Run['response_format']
+
+    type RunStepStepDetails =
+      | OpenAI.Beta.Threads.Runs.MessageCreationStepDetails
+      | OpenAI.Beta.Threads.Runs.ToolCallsStepDetails
+    type RunStepLastErrorMessage =
+      OpenAI.Beta.Threads.Runs.RunStep['last_error']
+    type RunStepMetadata = OpenAI.Beta.Threads.Runs.RunStep['metadata']
+    type RunStepUsage = OpenAI.Beta.Threads.Runs.RunStep['usage']
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    type OpenapiSpec = Record<string, any>
+    type RequestHandlerHeaders = Record<string, string>
+    type RequestHandlerBody = Record<string, string>
+
+    type FirecrawlHandlerBody = Record<string, string>
+    type ReplicateHandlerBody = Record<string, string>
+    type ClientToolHandlerArguments = Record<string, string>
+
+    type HttpTransportHeaders = Record<string, string>
+    type SseTransportHeaders = Record<string, string>
+
+    type ThreadMetadata = Record<string, string>
+    type TaskSchedule = {
+      start: string
+      due?: string
+      recurrenceRules?: RecurrenceRule[]
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      [key: string]: any
+    }
+  }
+}