@surph_ai/sdk 0.0.1

package/base/vinely-base/src/client/lib/utils.ts

@@ -0,0 +1,96 @@
+import axios from "axios"
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+import RPC from "./RPC"
+import API from "./API"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+interface UploadFileParams {
+  folder: string;
+  filedata: any;
+  filename: string;
+  filetype: string;
+}
+
+export const uploadFile = async ({
+  folder,
+  filedata,
+  filename,
+  filetype
+}: UploadFileParams) => {
+  try {
+    const { payload } = await RPC.call('s3', 'upload_url', {
+      folder,
+      filename,
+      filetype,
+      toStorage: 'false'
+    })
+
+    const { response } = payload
+    const upload = response.uploadUrl
+    // console.log('UPLOAD URL: ' + upload)
+
+    // this returns an empty string ("")
+    const { data } = await axios({
+      url: upload,
+      method: 'PUT',
+      data: filedata,
+      headers: { 'Content-Type': filetype }
+    })
+
+    return data
+  } catch (error) {
+    throw error
+  }
+}
+
+export const updateSpace = async (space: any, updates: Record<string, any>) => {
+  try {
+    const { payload } = await API.put(
+      `/space/${space._id}`,
+      updates,
+      null,
+      false
+    )
+
+    return payload
+  } catch (error) {
+    throw error
+  }
+}
+
+export const fetchSpace = async (params: any) => {
+  try {
+    const url = params._id ? `/space/${params._id}` : '/space'
+    const { payload } = await API.get(url, params)
+
+    // console.log('FETCH SPACE: ' + JSON.stringify(payload))
+
+    return payload
+  } catch (error) {
+    throw error
+  }
+}
+
+export const fetchMessages = async (site: string, threadId: string) => {
+  try {
+    const url = `/thread/${site}/${threadId}`
+    const { data } = await axios({
+      url,
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' }
+    })
+
+    // console.log('MESSAGES: ' + JSON.stringify(data))
+    if (data.error) {
+      throw new Error(data.error)
+    }
+
+    return data.payload
+  } catch (error) {
+    throw error
+  }
+}

package/base/vinely-base/src/server/index.ts

@@ -0,0 +1,63 @@
+import express, { Request, Response, NextFunction} from 'express'
+import turbo360 from '@turbo360/turbo-sdk'
+import main from './routes/main.js'
+import chat from './routes/chat.js'
+import mcp from './routes/mcp.js'
+import thread from './routes/thread.js'
+import rpc from './routes/rpc.js'
+import api from './routes/api.js'
+import fetchManifest from './utils/fetchManifest.js'
+// import { sessionMiddleware, setupPassport } from './utils/Auth.js'
+
+const ONE_DAY = 24 * 60 * 60 * 1000
+
+const app = express()
+
+turbo360.configureApp(app, {
+  views: 'views',
+  static: 'public',
+  viewEngine: 'mustache' // ejs or mustache
+})
+
+// setupPassport(app)
+// app.use(sessionMiddleware)
+
+app.use(async (req: any, res: Response, next: NextFunction) => {
+  try {
+    req._vineyard = await fetchManifest()
+    // console.log('MANIFEST: ' + JSON.stringify(req._vineyard))
+  } catch (error) {
+
+  } finally {
+    next()
+  }
+})
+
+// set routes
+app.use('/api/chat', chat)
+app.use('/api/mcp', mcp)
+app.use('/api', api)
+app.use('/thread', thread)
+app.post('/context', (req, res, next) => {
+  if (!req.body.context) {
+    return next()
+  }
+
+  const domain = (process.env.TURBO_ENV === 'local') ? 'localhost' : '.vinely.ai'
+  const token = process.env.VLY_CONTEXT as string
+  const cookie = req.body.context
+
+  res.cookie(token, JSON.stringify(cookie), {
+    maxAge: 14 * ONE_DAY,
+    httpOnly: true,
+    domain,
+  })
+
+  res.json({
+    data: 'context set'
+  })
+})
+app.use('/rpc', rpc)
+app.use('/', main)
+
+export default app

package/base/vinely-base/src/server/routes/api.ts

@@ -0,0 +1,38 @@
+import axios from 'axios'
+import { Router } from 'express'
+import APIMgr from '../utils/APIMgr.js'
+
+interface ReqParams {
+  url: string;
+  method: string;
+  headers: any;
+  data?: any
+}
+
+const router = Router()
+
+router.get('/:resource', async (req, res, next) => {
+  const path = `${req.params.resource}`
+  const { payload } = await APIMgr.get(path, req.query, null)
+  res.json({ payload })
+})
+
+router.get('/:resource/:id', async (req, res, next) => {
+  const path = `${req.params.resource}/${req.params.id}`
+  const { payload } = await APIMgr.get(path, null, null)
+  res.json({ payload })
+})
+
+router.post('/:resource', async (req, res, next) => {
+  const path = `${req.params.resource}`
+  const { payload } = await APIMgr.post(path, req.body, null)
+  res.json({ payload })
+})
+
+router.put('/:resource/:id', async (req, res, next) => {
+  const path = `${req.params.resource}/${req.params.id}`
+  const { payload } = await APIMgr.put(path, req.body, null)
+  res.json({ payload })
+})
+
+export default router

package/base/vinely-base/src/server/routes/chat.ts

@@ -0,0 +1,133 @@
+import { Router, Response, NextFunction } from "express"
+import { openai } from "@ai-sdk/openai"
+// import { anthropic } from "@ai-sdk/anthropic"
+import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import {
+  streamText,
+  UIMessage,
+  stepCountIs,
+  convertToModelMessages,
+  experimental_createMCPClient as createMCPClient, // https://github.com/vercel/ai/discussions/5257
+  experimental_MCPClient as MCPClient
+} from "ai"
+import { hasAuthProvider, getAuthProvider } from "../utils/mcp-auth.js";
+
+interface ChatMessages {
+  messages: UIMessage[]
+}
+
+/*
+const MCP_SERVERS: Record<string, string> = {
+  sports: 'https://mcp-sports-server-pbiesp.turbo360-staging.com/mcp',
+  population: 'https://mcp-population-server-jz3gg2.turbo360-staging.com/mcp',
+  domain: 'https://api.findadomain.dev/mcp',
+  notion: 'https://mcp.notion.com/mcp',
+  // notion: 'https://api.githubcopilot.com/mcp/',  // did not work
+  // notion: 'https://server.smithery.ai/@rashidazarang/airtable-mcp/mcp' // did not work
+  // notion: 'https://server.smithery.ai/@VeyraX/veyrax-mcp/mcp', // worked
+  airtable: 'https://server.smithery.ai/airtable-server/mcp', // worked
+  rube: 'https://rube.app/mcp',
+  google: 'https://mcp.composio.dev/composio/server/fdb469c6-c700-4014-9827-e3547a2c0240/mcp?include_composio_helper_actions=true',
+  // mola: 'http://localhost:3000/mcp',
+  mola: 'https://mola-mcp-mdmvrp.turbo360-staging.com/mcp',
+  square: 'https://mcp.squareup.com/sse',
+  stripe: 'https://mcp.stripe.com',
+  // dats2101: 'http://localhost:3000/mcp',
+  dats2101: 'https://dats2101-mcp-vw2biy.turbo360-staging.com/mcp',
+  econ1012: 'https://hayden-mcp-prsjjh.turbo360-staging.com/mcp',
+  levy: 'https://levy-mcp-i5tnpu.turbo360-staging.com/mcp',
+  splitLoyalty: 'https://split-loyalty-mcp-qcqbll.turbo360-staging.com/mcp',
+  // 'banter-egcda42e': 'http://localhost:3000/mcp',
+  'banter-egcda42e': 'https://banter-mcp-pxmukt.turbo360-staging.com/mcp',
+}
+*/
+
+const router = Router()
+
+router.post('/', async (req: any, res: Response, next: NextFunction) => {
+  // console.log('\nMANIFEST: ' + JSON.stringify(req._vineyard))
+  const { vly_context } = req.cookies // check if undefined
+  // console.log('\nVLY_CONTEXT: ' + vly_context)
+  const ctx = JSON.parse(vly_context)
+
+  const { messages }: ChatMessages = req.body
+  console.log('LOG: ' + JSON.stringify(messages))
+
+  const datasource: Record<string, any> = req._vineyard.datasources[ctx.vine]
+  console.log('DATASOURCE: ' + JSON.stringify(datasource))
+
+  const headers: Record<string, string> = { 'vinely-args': JSON.stringify(datasource) }
+  // console.log('HEADERS: ' + JSON.stringify(headers))
+
+  // if not specified, default to banter:
+  const mcps = datasource.mcps || [
+    {
+      name: 'banter-egcda42e',
+      url: 'https://banter-mcp-pxmukt.turbo360-staging.com/mcp'
+    }
+  ]
+
+  try {
+    const mcpClients = []
+    for (const mcp of mcps) {
+      let transport;
+      const url = new URL(mcp.url)
+      const opts: StreamableHTTPClientTransportOptions = {
+        requestInit: { headers }
+      }
+
+      if (hasAuthProvider(url)) {
+        transport = new StreamableHTTPClientTransport(
+          url,
+          {
+            ...opts,
+            authProvider: getAuthProvider(url),
+          },
+        )
+      } else {
+        transport = new StreamableHTTPClientTransport(url, opts)
+      }
+
+      const mcpClient = await createMCPClient({ transport, name: process.env.VLY_APP })
+      mcpClients.push(mcpClient)
+    }
+
+    const allTools: Record<string, any> = {}
+    for (const mcpClient of mcpClients) {
+      const tools = await mcpClient.tools() // this is an dictionary NOT an array
+      const toolNames: string[] = Object.keys(tools)
+
+      // TODO: prevent collision of tool names:
+      toolNames.forEach((toolName: string) => {
+        allTools[toolName] = tools[toolName]
+      })
+    }
+
+    const result = streamText({
+      // this text will come from the vineyard level (when creating a vineyard):
+      system: `
+        You are a helpful assistant helping college-level studies review course materials. You have access to tools that allow you to get information from their uploaded content. Use these tools as a primary source when answering questions rather than your inherent knowledge. When answering, always relate your answer to the materials the user uploaded.
+
+        When appropriate, suggest additional questions the user may ask you to help further their understanding of the subject content. When you have presented a lot of material, offer to ask them a question to confirm their understanding.
+      `,
+      model: openai("gpt-4o"),
+      messages: convertToModelMessages(messages),
+      stopWhen: stepCountIs(5), // stop after 5 steps if tools were called
+      tools: allTools
+    })
+
+    console.log('RESULT: ' + JSON.stringify(result) + '\n')
+
+    res.set({
+      'connection': 'keep-alive',
+      'keep-alive': 'timeout=5',
+      'transfer-encoding': 'chunked'
+    })
+
+    result.pipeUIMessageStreamToResponse(res)
+  } catch (error: any) {
+    console.log('ERR: ' + error)
+  }
+})
+
+export default router

package/base/vinely-base/src/server/routes/main.ts

@@ -0,0 +1,36 @@
+import { Router, Response, NextFunction } from 'express'
+
+const router = Router()
+
+const isLocal = process.env.TURBO_ENV === 'local'
+
+const partials = {
+  imports: `partials/imports.${isLocal ? 'dev' : 'prod'}`
+}
+
+router.get('/', (req: any, res: Response, next: NextFunction) => {
+  res.render('landing', {
+    isLocal,
+    partials,
+    CDN: process.env.CDN,
+    context: JSON.stringify({
+      vineyard: req._vineyard
+    })
+  })
+})
+
+router.get('/:mcp', (req, res, next) => {
+  const mcp = req.params.mcp
+  const ONE_DAY = 24 * 60 * 60 * 1000
+  const domain = isLocal ? 'localhost' : '.vinely.ai'
+
+  res.cookie('vly_mcp', mcp, {
+    maxAge: 14 * ONE_DAY,
+    httpOnly: true,
+    domain,
+  })
+
+  res.redirect('/')
+})
+
+export default router

package/base/vinely-base/src/server/routes/mcp.ts

@@ -0,0 +1,52 @@
+import { Router, Response, NextFunction } from "express"
+import { handleMCPAuthCallback, setupAuthProvider } from "../utils/mcp-auth.js"
+
+const MCP_CLIENT_NAME = "Test MCP Client"
+
+const router = Router()
+
+router.get('/setup', async (req: any, res: Response, next: NextFunction) => {
+  const { mcpUrl } = req.query
+  if (!mcpUrl) {
+    res.status(400).json({
+      data: 'Malformed request: mcpUrl required.'
+    })
+
+    return
+  }
+
+  let url;
+  try {
+    url = new URL(decodeURIComponent(mcpUrl))
+  }
+  catch {
+    // return new Response("Malformed request.", { status: 400 });
+    res.status(400).json({
+      data: 'Malformed request.'
+    })
+
+    return
+  }
+
+  try {
+    const redirectUrl = await setupAuthProvider(MCP_CLIENT_NAME, new URL(url))
+    if (redirectUrl) {
+      res.redirect(redirectUrl.toString())
+      return
+    }
+
+    // res.send('Authentication initiated')
+  }
+  catch (error) {
+    console.error("Error initiating MCP authentication: ", error)
+    res.status(500).json({
+      data: 'Failed to initiate MCP authentication.'
+    })
+  }
+})
+
+router.get('/auth', async (req: any, res: Response, next: NextFunction) => {
+  return await handleMCPAuthCallback(req, res)
+})
+
+export default router

package/base/vinely-base/src/server/routes/rpc.ts

@@ -0,0 +1,64 @@
+import axios from 'axios'
+import { Router } from 'express'
+
+const router = Router()
+
+router.get('/:service/:action', (req, res, next) => {
+  res.json({
+    data: `RPC call ${req.params.service}:${req.params.action} must be POST request.`
+  })
+})
+
+router.post('/:action', async (req, res, next) => {
+  try {
+    const url = `${process.env.VINELY_RPC}/${req.params.action}`
+    const { data } = await axios({
+      url,
+      method: 'post',
+      data: req.body,
+      headers: {
+        'Accept': 'application/json',
+        'vinely-client': 'dashboard'
+      }
+    })
+
+    if (data.error) {
+      throw new Error(data.error)
+    }
+
+    res.json({ payload: data })
+  } catch (error: any) {
+    res.json({
+      error: error.message
+    })
+  }
+})
+
+router.post('/:service/:action', async (req, res, next) => {
+  try {
+    const url = `${process.env.VINELY_RPC}/${req.params.service}/${req.params.action}`
+    const { data } = await axios({
+      url,
+      method: 'post',
+      data: req.body,
+      headers: {
+        'Accept': 'application/json',
+        'vinely-client': 'dashboard'
+      }
+    })
+
+    // console.log('RPC: ' + JSON.stringify(data))
+    if (data.error) {
+      throw new Error(data.error)
+    }
+
+
+    res.json({ payload: data })
+  } catch (error: any) {
+    res.json({
+      error: error.message
+    })
+  }
+})
+
+export default router

package/base/vinely-base/src/server/routes/thread.ts

@@ -0,0 +1,44 @@
+import axios from 'axios'
+import { Router, Response, NextFunction } from 'express'
+
+const router = Router()
+
+const isLocal = process.env.TURBO_ENV === 'local'
+
+const partials = {
+  imports: `partials/imports.${isLocal ? 'dev' : 'prod'}`
+}
+
+router.get('/:thread_id', (req: any, res: Response, next: NextFunction) => {
+  res.render('landing', {
+    isLocal,
+    partials,
+    CDN: process.env.CDN,
+    context: JSON.stringify({
+      vineyard: req._vineyard
+    })
+  })
+})
+
+router.get('/:site/:thread_id', async (req: any, res: Response, next: NextFunction) => {
+  try {
+    const { site, thread_id } = req.params
+    const url = `https://vinely.s3.us-east-1.amazonaws.com/sites/${site}/threads/${thread_id}.json`
+
+    const { data } = await axios({
+      url,
+      method: 'get',
+      headers: {
+        Accept: 'application/json'
+      }
+    })
+
+    res.json({ payload: data })
+  } catch (error: any) {
+    res.json({
+      error: error.message
+    })
+  }
+})
+
+export default router

package/base/vinely-base/src/server/utils/APIMgr.ts

@@ -0,0 +1,156 @@
+import axios from 'axios'
+// import moment from 'moment'
+
+const parseError = (err: any) => {
+  if (!err.response) {
+    return err
+  }
+
+  if (!err.response.data) {
+    return err
+  }
+
+  const { status, data } =  err.response
+  const error = new Error(JSON.stringify({
+    ...data,
+    status,
+  }))
+
+  error.name = data.type
+  return error
+}
+
+const queryParamsToString = (query: any) => {
+  const keys = Object.keys(query)
+  const lastIndex = keys.length - 1
+  let queryString = ''
+  keys.forEach((key, i) => {
+    queryString += `${key}=${query[key]}`
+    if (i !== lastIndex)
+      queryString += '&'
+  })
+
+  return queryString
+}
+
+const API_VERSION = process.env.VLY_API_BASE
+// const API_VERSION = `http://localhost:3000/rest`
+
+const DEFAULT_HEADERS = {
+  'Accept': 'application/json',
+  'Content-Type': 'application/json',
+  'X-Requested-With': 'XMLHttpRequest',
+  // 'Cache-Control': 'no-cache',
+  // 'Pragma': 'no-cache',
+}
+
+class APIMgr {
+  constructor() {
+
+  }
+
+  defaultHeaders(reqHeaders: any) {
+    const headers: any = {
+      ...DEFAULT_HEADERS,
+      // 'Client-TzOffset': tzOffsetHeader(),
+    }
+
+    if (!reqHeaders)
+      return headers
+
+    Object.keys(reqHeaders).forEach((headerName: string) => {
+      headers[headerName] = reqHeaders[headerName]
+    })
+
+    return headers
+  }
+
+  async get(endpoint: string, params: any, reqHeaders: any) {
+    const headers = this.defaultHeaders(reqHeaders)
+    // console.log('HEADERS: ' + JSON.stringify(headers))
+
+    const url = params
+      ? `${API_VERSION}/${endpoint}?${queryParamsToString(params)}`
+      : `${API_VERSION}/${endpoint}`
+
+    // console.log('API MGR GET: ' + url)
+    try {
+      const { data } = await axios({
+        // url: `${API_VERSION}/${endpoint}`,
+        url,
+        method: 'get',
+        headers,
+      })
+
+      return data
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+
+  async post(endpoint: string, body: any, reqHeaders: any) {
+    const headers = this.defaultHeaders(reqHeaders)
+
+    try {
+      const { data } = await axios({
+        url: `${API_VERSION}/${endpoint}`,
+        method: 'post',
+        data: body,
+        headers,
+      })
+
+      return data
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+
+  async put(endpoint: string, body: any, reqHeaders: any, isFormData = false) {
+    try {
+      const headers = this.defaultHeaders(reqHeaders)
+
+      if (isFormData === true) {
+        const resp = await axios.put(`${API_VERSION}/${endpoint}`, body, {
+          responseType: 'blob',
+          headers: {
+            ...headers,
+            'content-type': 'multipart/form-data',
+          },
+        })
+
+        return resp
+      }
+
+      const { data } = await axios({
+        url: `${API_VERSION}/${endpoint}`,
+        method: 'put',
+        data: body,
+        headers,
+      })
+
+      return data
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+
+  /*
+  async delete(endpoint, body, reqHeaders) {
+    const headers = this.defaultHeaders(reqHeaders)
+
+    try {
+      const { data } = await axios({
+        url: `${API_VERSION}/${endpoint}`,
+        method: 'delete',
+        headers,
+      })
+
+      return data
+    } catch (error) {
+      throw parseError(error)
+    }
+  }
+  */
+}
+
+export default new APIMgr()