spiceflow 1.1.18 → 1.3.0

package/src/mcp-transport.ts

@@ -0,0 +1,148 @@
+// https://github.com/modelcontextprotocol/typescript-sdk/blob/3164da64d085ec4e022ae881329eee7b72f208d4/src/server/sse.ts
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
+import {
+  JSONRPCMessage,
+  JSONRPCMessageSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+import { randomUUID } from 'node:crypto'
+
+/**
+ * Server transport for SSE: this will send messages over an SSE connection and receive messages from HTTP POST requests.
+ *
+ * This transport is only available in Node.js environments.
+ */
+export class SSEServerTransportSpiceflow implements Transport {
+  private _sessionId: string
+  private _endpoint: string
+  private _writableStream?: WritableStreamDefaultWriter<Uint8Array>
+  response?: Response
+
+  onclose?: () => void
+  onerror?: (error: Error) => void
+  onmessage?: (message: JSONRPCMessage) => void
+
+  /**
+   * Creates a new SSE server transport, which will direct the client to POST messages to the relative or absolute URL identified by `_endpoint`.
+   */
+  constructor(endpoint: string) {
+    this._sessionId = randomUUID()
+    this._endpoint = endpoint
+  }
+
+  /**
+   * Handles the initial SSE connection request.
+   *
+   * This should be called when a GET request is made to establish the SSE stream.
+   */
+  async start(): Promise<void> {
+    if (this.response) {
+      throw new Error(
+        'SSEServerTransport already started! If using Server class, note that connect() calls start() automatically.',
+      )
+    }
+
+    const headers = new Headers({
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      // https://github.com/vercel/next.js/issues/9965
+      'content-encoding': 'none',
+      Connection: 'keep-alive',
+    })
+
+    // Create a TransformStream
+    const transformStream = new TransformStream()
+    const { readable, writable } = transformStream
+
+    // Create the Response from the readable side
+    this.response = new Response(readable, { headers })
+
+    // Obtain a writer from the writable end
+    this._writableStream = writable.getWriter()
+    this._writableStream?.write(
+      new TextEncoder().encode(
+        `event: endpoint\ndata: ${encodeURI(this._endpoint)}?sessionId=${
+          this._sessionId
+        }\n\n`,
+      ),
+    )
+
+    // readable.getReader().closed.then(() => {
+    //   this.response = undefined
+    //   this._writableStream = undefined
+    //   this.onclose?.()
+    // })
+  }
+
+  /**
+   * Handles incoming POST messages.
+   *
+   * This should be called when a POST request is made to send a message to the server.
+   */
+  async handlePostMessage(
+    req: Request,
+    parsedBody?: unknown,
+  ): Promise<Response> {
+    if (!this.response) {
+      const message = 'SSE connection not established'
+      throw new Error(message)
+    }
+
+    let body = await req.json()
+
+    try {
+      await this.handleMessage(
+        typeof body === 'string' ? JSON.parse(body) : body,
+      )
+    } catch {
+      return new Response(`Invalid message: ${body}`, { status: 400 })
+    }
+
+    return new Response('Accepted', { status: 202 })
+  }
+
+  /**
+   * Handle a client message, regardless of how it arrived. This can be used to inform the server of messages that arrive via a means different than HTTP POST.
+   */
+  async handleMessage(message: unknown): Promise<void> {
+    let parsedMessage: JSONRPCMessage
+    try {
+      parsedMessage = JSONRPCMessageSchema.parse(message)
+    } catch (error) {
+      this.onerror?.(error as Error)
+      throw error
+    }
+
+    this.onmessage?.(parsedMessage)
+  }
+
+  async close(): Promise<void> {
+    if (this._writableStream) {
+      await this._writableStream.close()
+    }
+    this.response = undefined
+    this._writableStream = undefined
+    this.onclose?.()
+  }
+
+  async send(message: JSONRPCMessage): Promise<void> {
+    if (!this._writableStream) {
+      throw new Error('Not connected')
+    }
+
+    const encoder = new TextEncoder()
+    const data = encoder.encode(
+      `event: message\ndata: ${JSON.stringify(message)}\n\n`,
+    )
+
+    await this._writableStream.write(data)
+  }
+
+  /**
+   * Returns the session ID for this transport.
+   *
+   * This can be used to route incoming POST requests.
+   */
+  get sessionId(): string {
+    return this._sessionId
+  }
+}

package/src/mcp.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach, beforeAll } from 'vitest'
+import { EventSource } from 'eventsource'
+
+import { mcp } from './mcp.js'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+
+import {
+  ListResourcesResultSchema,
+  ListToolsRequestSchema,
+  ListToolsResultSchema,
+  ReadResourceResultSchema,
+  CallToolResultSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
+import { z } from 'zod'
+import { Spiceflow } from './spiceflow.js'
+describe('MCP Plugin', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(global as any).EventSource = EventSource
+
+  let app: Spiceflow
+  let port: number
+  let client: Client
+  let transport: SSEClientTransport
+
+  beforeAll(async () => {
+    port = await getAvailablePort()
+
+    app = new Spiceflow()
+      .use(mcp({ path: '/mcp' }))
+      .get('/goSomething', () => 'hi')
+      .get('/users', () => ({ users: [{ id: 1, name: 'John' }] }))
+      .get(
+        '/somethingElse/:id',
+        ({ params: { id } }) => {
+          return 'hello ' + id
+        },
+        {
+          params: z.object({ id: z.string() }),
+        },
+      )
+      .get(
+        '/search',
+        ({ query }) => {
+          return { results: [`Found results for: ${query.q}`] }
+        },
+        {
+          query: z
+            .object({
+              q: z.string().describe('Search query'),
+              limit: z.number().optional().describe('Max number of results'),
+            })
+            .required(),
+        },
+      )
+    await app.listen(port)
+
+    transport = new SSEClientTransport(new URL(`http://localhost:${port}/mcp`))
+
+    client = new Client(
+      {
+        name: 'example-client',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {},
+      },
+    )
+
+    await client.connect(transport)
+  })
+
+  it('should list and call available tools', async () => {
+    const resources = await client.request(
+      { method: 'tools/list' },
+      ListToolsResultSchema,
+    )
+
+    expect(resources).toBeDefined()
+    expect(resources).toHaveProperty('tools')
+    expect(resources).toMatchInlineSnapshot(`
+      {
+        "tools": [
+          {
+            "description": "GET /goSomething",
+            "inputSchema": {
+              "properties": {},
+              "required": [],
+              "type": "object",
+            },
+            "name": "GET /goSomething",
+          },
+          {
+            "description": "GET /users",
+            "inputSchema": {
+              "properties": {},
+              "required": [],
+              "type": "object",
+            },
+            "name": "GET /users",
+          },
+          {
+            "description": "GET /somethingElse/:id",
+            "inputSchema": {
+              "properties": {
+                "params": {
+                  "$schema": "http://json-schema.org/draft-07/schema#",
+                  "additionalProperties": false,
+                  "properties": {
+                    "id": {
+                      "type": "string",
+                    },
+                  },
+                  "required": [
+                    "id",
+                  ],
+                  "type": "object",
+                },
+              },
+              "required": [],
+              "type": "object",
+            },
+            "name": "GET /somethingElse/:id",
+          },
+          {
+            "description": "GET /search",
+            "inputSchema": {
+              "properties": {
+                "query": {
+                  "$schema": "http://json-schema.org/draft-07/schema#",
+                  "additionalProperties": false,
+                  "properties": {
+                    "limit": {
+                      "type": "number",
+                    },
+                    "q": {
+                      "description": "Search query",
+                      "type": "string",
+                    },
+                  },
+                  "required": [
+                    "q",
+                    "limit",
+                  ],
+                  "type": "object",
+                },
+              },
+              "required": [],
+              "type": "object",
+            },
+            "name": "GET /search",
+          },
+        ],
+      }
+    `)
+
+    const resourceContent = await client.request(
+      {
+        method: 'tools/call',
+        params: {
+          name: 'POST /somethingElse/:id',
+          arguments: {
+            params: { id: 'xxx' },
+          },
+        },
+      },
+      CallToolResultSchema,
+    )
+
+    expect(resourceContent).toBeDefined()
+    expect(resourceContent).toHaveProperty('content')
+    expect(resourceContent).toMatchInlineSnapshot(`
+      {
+        "content": [
+          {
+            "text": "Tool POST /somethingElse/:id not found",
+            "type": "text",
+          },
+        ],
+        "isError": true,
+      }
+    `)
+  })
+
+  it('should list and read available resources', async () => {
+    const resources = await client.request(
+      { method: 'resources/list' },
+      ListResourcesResultSchema,
+    )
+
+    expect(resources).toBeDefined()
+
+    expect(resources.resources).toMatchInlineSnapshot(`
+      [
+        {
+          "mimeType": "application/json",
+          "name": "GET /goSomething",
+          "uri": "http://localhost:3000/goSomething",
+        },
+        {
+          "mimeType": "application/json",
+          "name": "GET /users",
+          "uri": "http://localhost:3000/users",
+        },
+      ]
+    `)
+
+    const resourceContent = await client.request(
+      {
+        method: 'resources/read',
+        params: {
+          uri: `http://localhost:${port}/users`,
+        },
+      },
+      ReadResourceResultSchema,
+    )
+
+    expect(resourceContent).toBeDefined()
+    expect(resourceContent.contents).toMatchInlineSnapshot(`
+      [
+        {
+          "mimeType": "application/json",
+          "text": "{
+        "users": [
+          {
+            "id": 1,
+            "name": "John"
+          }
+        ]
+      }",
+          "uri": "http://localhost:3000/users",
+        },
+      ]
+    `)
+  })
+})
+
+async function getAvailablePort(startPort = 3000, maxRetries = 10) {
+  const net = await import('net')
+
+  return await new Promise<number>((resolve, reject) => {
+    let port = startPort
+    let attempts = 0
+
+    const checkPort = () => {
+      const server = net.createServer()
+
+      server.once('error', (err: any) => {
+        if (err.code === 'EADDRINUSE') {
+          attempts++
+          if (attempts >= maxRetries) {
+            reject(new Error('No available ports found'))
+          } else {
+            port++
+            checkPort()
+          }
+        } else {
+          reject(err)
+        }
+      })
+
+      server.once('listening', () => {
+        server.close(() => {
+          resolve(port)
+        })
+      })
+
+      server.listen(port)
+    }
+
+    checkPort()
+  })
+}

package/src/mcp.ts

@@ -0,0 +1,270 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import { SSEServerTransportSpiceflow } from './mcp-transport.js'
+import { isZodSchema, Spiceflow } from './spiceflow.js'
+
+function getJsonSchema(schema: any) {
+  if (!schema) return undefined
+  if (isZodSchema(schema)) {
+    return zodToJsonSchema(schema, {})
+  }
+  return schema
+}
+
+export const mcp = <Path extends string = '/mcp'>({
+  path = '/mcp' as Path,
+  name = 'spiceflow',
+  version = '1.0.0',
+} = {}) => {
+  const server = new Server(
+    { name, version },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+    },
+  )
+
+  const transports = new Map<string, SSEServerTransportSpiceflow>()
+  const messagePath = path + '/message'
+  let app = new Spiceflow({ name: 'mcp' })
+    .post(messagePath, async ({ request, query }) => {
+      const sessionId = query.sessionId!
+
+      const t = transports.get(sessionId)
+      if (!t) {
+        return new Response('Session not found', { status: 404 })
+      }
+
+      await t.handlePostMessage(request)
+      return 'ok'
+    })
+    .get(path, async ({ request }) => {
+      const transport = new SSEServerTransportSpiceflow(messagePath)
+      transports.set(transport.sessionId, transport)
+      server.onclose = () => {
+        transports.delete(transport.sessionId)
+      }
+      await server.connect(transport)
+
+      request.signal.addEventListener('abort', () => {
+        transport.close().catch((error) => {
+          console.error('Error closing transport:', error)
+        })
+      })
+
+      if (request.method === 'POST') {
+        return await transport.handlePostMessage(request)
+      }
+      let routes = app
+        .getAllRoutes()
+        .filter((x) => x.path !== path && x.path !== messagePath)
+
+      server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+          tools: routes.map((route) => {
+            const bodySchema = getJsonSchema(route.hooks?.body)
+            const querySchema = getJsonSchema(route.hooks?.query)
+            const paramsSchema = getJsonSchema(route.hooks?.params)
+
+            const properties: Record<string, any> = {}
+            const required: string[] = []
+
+            if (bodySchema) {
+              properties.body = bodySchema
+              required.push('body')
+            }
+            if (querySchema?.properties) {
+              properties.query = querySchema
+            }
+            if (paramsSchema?.properties) {
+              properties.params = paramsSchema
+            }
+
+            return {
+              name: getRouteName({ method: route.method, path: route.path }),
+
+              description:
+                route.hooks?.detail?.description ||
+                `${route.method} ${route.path}`,
+              inputSchema: {
+                type: 'object',
+                properties,
+                required,
+              },
+            }
+          }),
+        }
+      })
+
+      server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolName = request.params.name
+        let { path, method } = getPathFromToolName(toolName)
+
+        const route = routes.find(
+          (r) =>
+            r.method.toUpperCase() === method.toUpperCase() && r.path === path,
+        )
+
+        if (!route) {
+          return {
+            content: [{ type: 'text', text: `Tool ${toolName} not found` }],
+            isError: true,
+          }
+        }
+
+        try {
+          const { body, query, params } = request.params.arguments || {}
+
+          if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+              path = path.replace(`:${key}`, encodeURIComponent(String(value)))
+            })
+          }
+          const url = new URL(`http://localhost${path}`)
+          if (query) {
+            Object.entries(query).forEach(([key, value]) => {
+              url.searchParams.set(key, String(value))
+            })
+          }
+
+          const response = await app.topLevelApp!.handle(
+            new Request(url, {
+              method: route.method,
+              headers: {
+                'content-type': 'application/json',
+              },
+              body: body ? JSON.stringify(body) : undefined,
+            }),
+          )
+
+          const isError = !response.ok
+
+          const contentType = response.headers.get('content-type')
+          if (contentType?.includes('application/json')) {
+            const json = await response.json()
+            return {
+              isError,
+              content: [{ type: 'text', text: JSON.stringify(json, null, 2) }],
+            }
+          }
+
+          const text = await response.text()
+          return {
+            isError,
+            content: [{ type: 'text', text }],
+          }
+        } catch (error: any) {
+          return {
+            content: [{ type: 'text', text: error.message || 'Unknown error' }],
+            isError: true,
+          }
+        }
+      })
+      const resourcesRoutes = routes.filter((route) => {
+        if (route.method !== 'GET') return false
+
+        if (route.path.includes(':')) return false
+
+        const querySchema = route.hooks?.query
+
+        if (querySchema) {
+          const jsonSchema = getJsonSchema(querySchema)
+          if (jsonSchema?.required?.length) {
+            return false
+          }
+        }
+
+        return true
+      })
+      server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        const resources = resourcesRoutes.map((route) => ({
+          uri: new URL(route.path, `http://${request.headers.get('host')}`)
+            .href,
+          mimeType: 'application/json',
+          name: `GET ${route.path}`,
+        }))
+        return { resources }
+      })
+
+      server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const resourceUrl = new URL(request.params.uri)
+        const path = resourceUrl.pathname
+
+        const route = resourcesRoutes.find(
+          (route) => route.path === path && route.method === 'GET',
+        )
+        if (!route) {
+          throw new Error('Resource not found')
+        }
+
+        const response = await app.topLevelApp!.handle(
+          new Request(resourceUrl, {
+            method: 'GET',
+            headers: {
+              'content-type': 'application/json',
+            },
+          }),
+        )
+
+        const contentType = response.headers.get('content-type')
+        const text = await response.text()
+        if (contentType?.includes('application/json')) {
+          return {
+            contents: [
+              {
+                uri: request.params.uri,
+                mimeType: 'application/json',
+                text: text,
+              },
+            ],
+          }
+        }
+
+        return {
+          contents: [
+            {
+              uri: request.params.uri,
+              mimeType: 'text/plain',
+              text,
+            },
+          ],
+        }
+      })
+
+      return transport.response
+    })
+
+  return app
+}
+
+function getRouteName({
+  method,
+  path,
+}: {
+  method: string
+  path: string
+}): string {
+  return `${method.toUpperCase()} ${path}`
+}
+
+function getPathFromToolName(toolName: string): {
+  path: string
+  method: string
+} {
+  const parts = toolName.split(' ')
+  if (parts.length < 2) {
+    throw new Error('Invalid tool name format')
+  }
+  const method = parts[0].toUpperCase()
+  const path = parts.slice(1).join(' ')
+  return { path, method }
+}