@superinterface/server 1.0.0

package/src/lib/computerCalls/handleComputerCall/index.ts

@@ -0,0 +1,173 @@
+import OpenAI from 'openai'
+import {
+  Prisma,
+  Thread,
+  LogRequestMethod,
+  LogRequestRoute,
+  LogLevel,
+  ToolType,
+} from '@prisma/client'
+import { createLog } from '@/lib/logs/createLog'
+import { closeMcpConnection } from '@/lib/mcpServers/closeMcpConnection'
+import {
+  CallToolResultSchema,
+  CallToolResult,
+} from '@modelcontextprotocol/sdk/types.js'
+import { connectMcpServer } from '@/lib/mcpServers/connectMcpServer'
+
+const getContent = ({
+  mcpServerToolOutput,
+}: {
+  mcpServerToolOutput: CallToolResult
+}) => mcpServerToolOutput.content.find((c) => c.type === 'image')
+
+const getImageUrl = ({
+  mcpServerToolOutput,
+}: {
+  mcpServerToolOutput: CallToolResult
+}) => {
+  const content = getContent({ mcpServerToolOutput })
+  if (!content) return null
+
+  return `data:${content.mimeType};base64,${content.data}`
+}
+
+export const handleComputerCall = async ({
+  assistant,
+  toolCall,
+  thread,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      tools: {
+        include: {
+          computerUseTool: {
+            include: {
+              mcpServer: {
+                include: {
+                  stdioTransport: true
+                  sseTransport: true
+                  httpTransport: true
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }>
+  toolCall: OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall
+  thread: Thread
+}) => {
+  const tool = assistant.tools.find(
+    (tool) => tool.type === ToolType.COMPUTER_USE,
+  )
+
+  if (!tool || !tool.computerUseTool || !tool.computerUseTool.mcpServer) {
+    createLog({
+      log: {
+        requestMethod: LogRequestMethod.POST,
+        requestRoute: LogRequestRoute.MESSAGES,
+        level: LogLevel.ERROR,
+        status: 500,
+        message: 'No computer use tool configured.',
+        workspaceId: assistant.workspaceId,
+        assistantId: assistant.id,
+        threadId: thread.id,
+      },
+    })
+
+    return {
+      tool_call_id: toolCall.id,
+      output: 'No computer use tool configured.',
+    }
+  }
+
+  const { mcpConnection } = await connectMcpServer({
+    thread,
+    assistant,
+    mcpServer: tool.computerUseTool.mcpServer,
+  })
+
+  try {
+    const mcpServerToolOutput = (await mcpConnection.client.callTool(
+      {
+        name: 'computer_call',
+        arguments: {
+          // @ts-expect-error computer_call is compatability type
+          action: toolCall.computer_call.action,
+        },
+      },
+      CallToolResultSchema,
+      {
+        timeout: 300000,
+      },
+    )) as CallToolResult
+
+    await closeMcpConnection({
+      mcpConnection,
+    })
+
+    const imageUrl = getImageUrl({
+      mcpServerToolOutput,
+    })
+
+    if (!imageUrl) {
+      createLog({
+        log: {
+          requestMethod: LogRequestMethod.POST,
+          requestRoute: LogRequestRoute.MESSAGES,
+          level: LogLevel.ERROR,
+          status: 500,
+          // @ts-expect-error compat
+          message: `Error calling computer_call with action ${JSON.stringify(toolCall.computer_call.action)}: No image in content`,
+          workspaceId: assistant.workspaceId,
+          assistantId: assistant.id,
+          threadId: thread.id,
+        },
+      })
+
+      return {
+        tool_call_id: toolCall.id,
+        // @ts-expect-error compat
+        output: `Error calling computer_call with action ${JSON.stringify(toolCall.computer_call.action)}: No image in content`,
+      }
+    }
+
+    const acknowledgedSafetyChecks =
+      // @ts-expect-error compat
+      toolCall.computer_call.pending_safety_checks.map((psc) => ({
+        id: psc.id,
+      }))
+
+    return {
+      tool_call_id: toolCall.id,
+      output: JSON.stringify({
+        type: 'computer_screenshot',
+        image_url: imageUrl,
+      }),
+      acknowledged_safety_checks: acknowledgedSafetyChecks,
+    }
+    // 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,
+        // @ts-expect-error compat
+        message: `Error calling computer_call with action ${JSON.stringify(toolCall.computer_call.action)}: ${e.message}`,
+        workspaceId: assistant.workspaceId,
+        assistantId: assistant.id,
+        threadId: thread.id,
+      },
+    })
+
+    return {
+      tool_call_id: toolCall.id,
+      // @ts-expect-error compat
+      output: `Error calling computer_call with action ${JSON.stringify(toolCall.computer_call.action)}: ${e.message}`,
+    }
+  }
+}

package/src/lib/errors/index.ts

@@ -0,0 +1,10 @@
+export class ValidationError extends Error {
+  static defaultMessage = 'Validation failed.'
+
+  constructor(message: string = ValidationError.defaultMessage) {
+    super(message)
+    this.name = this.constructor.name
+  }
+}
+
+export const publicErrors = [ValidationError]

package/src/lib/errors/serializeError.ts

@@ -0,0 +1,11 @@
+const causeMessage = ({ error }: { error: Error }) => {
+  if (error.cause instanceof Error) return ` ${error.cause.message}`
+  if (error.cause) return ` ${error.cause}`
+  return ''
+}
+
+export const serializeError = ({ error }: { error: unknown }): string => {
+  if (!(error instanceof Error)) return String(error)
+
+  return `${error.message}${causeMessage({ error })}`
+}

package/src/lib/functions/createFunction.ts

@@ -0,0 +1,32 @@
+import type { Assistant, Prisma } from '@prisma/client'
+import type { HandlerInput } from '@/types'
+import { prisma } from '@/lib/prisma'
+import { handlerPrismaInput } from '@/lib/handlers/handlerPrismaInput'
+
+export async function createFunction<
+  TInclude extends Prisma.FunctionInclude,
+>(params: {
+  assistant: Assistant
+  parsedInput: { openapiSpec: string; handler: HandlerInput }
+  include: TInclude // ← required
+}): Promise<Prisma.FunctionGetPayload<{ include: TInclude }>> {
+  const { assistant, parsedInput, include } = params
+
+  return prisma.function.create({
+    data: {
+      openapiSpec: JSON.parse(parsedInput.openapiSpec),
+      assistantId: assistant.id,
+      handler: {
+        create: {
+          type: parsedInput.handler.type,
+          ...(await handlerPrismaInput({
+            parsedInput,
+            action: 'create',
+            assistant,
+          })),
+        },
+      },
+    },
+    include,
+  })
+}

package/src/lib/functions/functionSchema.ts

@@ -0,0 +1,201 @@
+import {
+  HandlerType,
+  MethodType,
+  FirecrawlHandlerType,
+  ReplicateHandlerType,
+  ClientToolHandlerType,
+} from '@prisma/client'
+import { z } from 'zod'
+import { isJSON } from '@/lib/misc/isJSON'
+
+const requestHandlerSchema = z.object({
+  method: z.nativeEnum(MethodType),
+  url: z.string().min(1).url(),
+  headers: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+  body: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+const firecrawlHandlerSchema = z.object({
+  type: z.nativeEnum(FirecrawlHandlerType),
+  apiKey: z.string().min(1),
+  body: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+const assistantHandlerSchema = z.object({
+  assistantId: z.string().min(1),
+})
+
+const replicateHandlerSchema = z.object({
+  type: z.nativeEnum(ReplicateHandlerType),
+  identifier: z.string().min(1),
+  apiKey: z.string().min(1),
+  body: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+const clientToolHandlerSchema = z.object({
+  type: z.nativeEnum(ClientToolHandlerType),
+  name: z.string().min(1),
+  arguments: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+})
+
+const taskHandlerSchema = z.object({
+  keyTemplate: z.string(),
+})
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const superRefine = (values: any, ctx: any) => {
+  if (values.handler.type === HandlerType.REQUEST) {
+    const result = requestHandlerSchema.safeParse(values.handler.requestHandler)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'requestHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.FIRECRAWL) {
+    const result = firecrawlHandlerSchema.safeParse(
+      values.handler.firecrawlHandler,
+    )
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'firecrawlHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.ASSISTANT) {
+    const result = assistantHandlerSchema.safeParse(
+      values.handler.assistantHandler,
+    )
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'assistantHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.REPLICATE) {
+    const result = replicateHandlerSchema.safeParse(
+      values.handler.replicateHandler,
+    )
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'replicateHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.CLIENT_TOOL) {
+    const result = clientToolHandlerSchema.safeParse(
+      values.handler.clientToolHandler,
+    )
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'clientToolHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.CREATE_TASK) {
+    const result = taskHandlerSchema.safeParse(values.handler.createTaskHandler)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'createTaskHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.LIST_TASKS) {
+    const result = taskHandlerSchema.safeParse(values.handler.listTasksHandler)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'listTasksHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.UPDATE_TASK) {
+    const result = taskHandlerSchema.safeParse(values.handler.updateTaskHandler)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'updateTaskHandler', ...issue.path],
+      }),
+    )
+  }
+
+  if (values.handler.type === HandlerType.DELETE_TASK) {
+    const result = taskHandlerSchema.safeParse(values.handler.deleteTaskHandler)
+
+    if (result.success) return
+
+    result.error.issues.forEach((issue) =>
+      ctx.addIssue({
+        ...issue,
+        path: ['handler', 'deleteTaskHandler', ...issue.path],
+      }),
+    )
+  }
+}
+
+export const baseSchema = z.object({
+  openapiSpec: z.string().min(1).refine(isJSON, {
+    message: 'Must be a valid JSON string.',
+  }),
+  handler: z.object({
+    type: z.nativeEnum(HandlerType),
+    requestHandler: requestHandlerSchema.nullable().optional(),
+    firecrawlHandler: firecrawlHandlerSchema.nullable().optional(),
+    assistantHandler: assistantHandlerSchema.nullable().optional(),
+    replicateHandler: replicateHandlerSchema.nullable().optional(),
+    clientToolHandler: clientToolHandlerSchema.nullable().optional(),
+    createTaskHandler: taskHandlerSchema.nullable().optional(),
+    listTasksHandler: taskHandlerSchema.nullable().optional(),
+    updateTaskHandler: taskHandlerSchema.nullable().optional(),
+    deleteTaskHandler: taskHandlerSchema.nullable().optional(),
+  }),
+})
+
+export const functionSchema = baseSchema.superRefine(superRefine)

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

@@ -0,0 +1,43 @@
+import OpenAI from 'openai'
+import type { Prisma } from '@prisma/client'
+import { isObject } from 'radash'
+
+export const getFunction = ({
+  assistant,
+  toolCall,
+}: {
+  assistant: Prisma.AssistantGetPayload<{
+    include: {
+      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
+}) => {
+  const validFunctions = assistant.functions.filter((fn) => {
+    if (!fn.openapiSpec) return false
+    if (!isObject(fn.openapiSpec)) return false
+    if (!fn.openapiSpec.name) return false
+
+    return true
+  })
+
+  return validFunctions.find(
+    (fn) => fn.openapiSpec.name === toolCall.function.name,
+  )
+}