@surph_ai/sdk 0.0.26 → 0.0.27

package/index.js

@@ -0,0 +1,5 @@
+const { Surph } = require('./platform')
+
+module.exports = {
+  surph: new Surph()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surph_ai/sdk",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "description": "",
   "main": "index.js",
   "types": "./types.d.ts",

package/platform/constants.js

@@ -0,0 +1,4 @@
+module.exports = {
+  SURPH_URL: 'https://surph.ai',
+  RPC_URL: 'https://rpc.surph.ai'
+}

package/platform/context.js

@@ -0,0 +1,44 @@
+const { SURPH_URL } = require('./constants')
+
+const fetchContext = async (contextSlug) => {
+  try {
+    const resp = await fetch(`${SURPH_URL}/api/contexts?slug=${contextSlug}`)
+    const { success, payload, error = null } = await resp.json()
+    if (!success) {
+      throw new Error(error)
+    }
+
+    if (payload.length === 0) {
+      throw new Error(`Context ${contextSlug} not found.`)
+    }
+
+    const context = payload[0]
+    return context
+  } catch (error) {
+    throw error
+  }
+}
+
+const searchContext = async (contextSlug, query) => {
+  try {
+    // const resp = await fetch(`${SURPH_URL}/api/contexts?slug=${contextSlug}`)
+    // const { success, payload, error = null } = await resp.json()
+    // if (!success) {
+    //   throw new Error(error)
+    // }
+
+    // if (payload.length === 0) {
+    //   throw new Error(`Context ${contextSlug} not found.`)
+    // }
+
+    // const context = payload[0]
+    // return context
+  } catch (error) {
+    throw error
+  }
+}
+
+module.exports = {
+  fetchContext,
+  searchContext
+}

package/platform/index.js

@@ -0,0 +1,27 @@
+const { fetchContext, searchContext } = require('./context')
+const { fetchUser } = require('./user')
+const { search } = require('./tools')
+
+class Surph {
+  constructor() {
+  
+  }
+
+  async fetchUser(username) {
+    return await fetchUser(username)
+  }
+
+  async fetchContext(slug) {
+    return await fetchContext(slug)
+  }
+
+  async searchContext(ctxSlug, query) {
+    return await searchContext(ctxSlug, query)
+  }
+
+  async search(query, ctxSlug = null) {
+    return await search(query, ctxSlug)
+  }
+}
+
+module.exports = { Surph }

package/platform/tools.js

@@ -0,0 +1,29 @@
+const { SURPH_URL, RPC_URL } = require('./constants')
+
+const search = async (query, contextSlug = null) => {
+  try {
+    const resp = await fetch(`${RPC_URL}/tools/search`, {
+      method: 'POST',
+      body: JSON.stringify({ query, context: contextSlug }),
+      headers: {
+        'Accept': 'application/json',
+        'Content-type': 'application/json',
+        'x-surph-client': 'surph-sdk'
+      }
+    })
+
+    const { response } = await resp.json()
+    if (response.error) {
+      throw new Error(response.error)
+    }
+
+    return response
+  } catch (error) {
+    throw error
+  }
+}
+
+
+module.exports = {
+  search,
+}

package/platform/user.js

@@ -0,0 +1,24 @@
+const { SURPH_URL } = require('./constants')
+
+const fetchUser = async (username) => {
+  try {
+    const resp = await fetch(`${SURPH_URL}/api/users?username=${username}`)
+    const { success, payload, error = null } = await resp.json()
+    if (!success) {
+      throw new Error(error)
+    }
+
+    if (payload.length === 0) {
+      throw new Error(`User ${username} not found.`)
+    }
+
+    const user = payload[0]
+    return user
+  } catch (error) {
+    throw error
+  }
+}
+
+module.exports = {
+  fetchUser,
+}

package/scaffold/tool/tools/index.ts

@@ -1,11 +1,13 @@
 import type { ToolHandler, ToolContext, User } from '@surph_ai/sdk';
+import { surph } from '@surph_ai/sdk';
 
 type ToolArgs = {
   // your custom tool args goes here
 };
 
-const handler: ToolHandler<ToolArgs> = async ({ args, user, context }) => {
+const handler: ToolHandler<ToolArgs> = async ({ args, user, context }: Record<string, any>) => {
   // your custom tool code goes here
 };
 
 export default handler;
+

package/toolserver/routes/tool.js

@@ -96,8 +96,8 @@ router.post('/custom', async (req, res, next) => {
 
     const tools = await loadTool()
     const response = await handler({ args, context, user }, tools)
-    if (resp.error) {
-      throw new Error(resp.error);
+    if (response.error) {
+      throw new Error(response.error);
     }
 
     res.json({ response })

package/types.d.ts

@@ -61,3 +61,12 @@ export type ToolHandler<
   TArgs = Record<string, unknown>,
   TResult = unknown,
 > = (input: ToolHandlerInput<TArgs>) => Promise<TResult> | TResult;
+
+export interface Surph {
+  fetchUser(username: string): Promise<User>;
+  fetchContext(slug: string | ToolContext): Promise<unknown>;
+  searchContext(ctxSlug: string, query: string): Promise<unknown>;
+  search(query: string, ctxSlug?: string | null): Promise<unknown>;
+}
+
+export declare const surph: Surph;