@lmnr-ai/lmnr 0.2.3 → 0.2.5

package/README.md

@@ -57,10 +57,16 @@ This only works in Node execution context; browser context is not supported.
 
 Example use:
 
-```typescript
+```js
 import { Laminar, NodeInput } from '@lmnr-ai/lmnr';
 
-const myTool = ({arg1, arg2}: {arg1: string, arg2: number}): NodeInput => {
+// make sure to setup arguments as object
+const myTool = ({
+  arg1, arg2
+  }: {
+    arg1: string,
+    arg2: number
+  }): NodeInput => {
   // this tool teaches LLMs the beauty of JavaScript!
   return arg1 + arg2;
 }
@@ -83,7 +89,7 @@ If your pipeline contains tool call nodes, they will be able to call your local
 If you want to test them from the Laminar workshop in your browser, you can attach to your
 locally running debugger.
 
-### Step by step instructions to use `LaminarRemoteDebugger`:
+### Step-by-step instructions to use `LaminarRemoteDebugger`:
 
 #### 1. Create your pipeline with tool call nodes
 
@@ -94,15 +100,21 @@ Add tool calls to your pipeline; node names must match the functions you want to
 Example:
 
 ```js
-import { LaminarRemoteDebugger } from '@lmnr-ai/lmnr';
-
-const myTool = ({arg1, arg2}: {arg1: string, arg2: number}): NodeInput => {
+import { LaminarRemoteDebugger, NodeInput } from '@lmnr-ai/lmnr';
+
+// make sure to setup arguments as object
+const myTool = ({
+  arg1, arg2
+  }: {
+    arg1: string,
+    arg2: number
+  }): NodeInput => {
   // this tool teaches LLMs the beauty of JavaScript!
   return arg1 + arg2;
 }
 
-debugger = LaminarRemoteDebugger('<YOUR_PROJECT_API_KEY>', [my_tool]);
-debugger.start();
+const dbgr = new LaminarRemoteDebugger('<YOUR_PROJECT_API_KEY>', [myTool]);
+dbgr.start();
 // the session id will be printed to console.
 // It is also returned from this promise, but you may not want to `await` it
 ```
@@ -118,10 +130,3 @@ Set up `DEBUGGER_SESSION_ID` environment variable in your pipeline.
 
 You can run as many sessions as you need, experimenting with your flows.
 
-#### 5. Stop the debugger
-
-In order to stop the session, do
-
-```js
-debugger.stop()
-```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmnr-ai/lmnr",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "TypeScript SDK for Laminar AI",
   "main": "src/index.ts",
   "repository": {

package/src/index.ts

@@ -1,4 +1,4 @@
-import { NodeInput, EndpointRunResponse, EndpointRunRequest, NodeWebSocketMessage, ToolCall, WebSocketError } from './types';
+import { EndpointRunResponse, EndpointRunRequest, NodeWebSocketMessage, WebSocketError, ToolCallRequest, ToolCallResponse, ToolCallError } from './types';
 import { isBrowser, isNode } from 'browser-or-node';
 import { WebSocket } from 'ws';
 
@@ -53,11 +53,10 @@ export class Laminar {
 
     private async _ws_run(request: EndpointRunRequest): Promise<EndpointRunResponse> {
         if (isBrowser) {
-            throw new Error('Running tools in the browser is not supported yet. Please use the Node.js environment.');
+            throw new Error('Running tools in the browser is not supported. Please use the Node.js environment.');
         } else if (isNode) {
             return this._ws_run_node(request);
-        }
-        else {
+        } else {
             throw new Error('Unsupported environment');
         }
     }
@@ -71,6 +70,7 @@ export class Laminar {
     }: EndpointRunRequest): Promise<EndpointRunResponse> {
         const socket = new  WebSocket(this.ws_url, [], {headers: {'Authorization': `Bearer ${this.projectApiKey}`}});
         let response: EndpointRunResponse | null = null;
+        let reqId: string | null = null;
         
         socket.on('open', () => {
             socket.send(JSON.stringify({
@@ -83,19 +83,32 @@ export class Laminar {
         });
         socket.on('message', (data: NodeWebSocketMessage) => {
             try {
-                const toolCall = JSON.parse(data.toString()) as ToolCall;
-                const matchingTool = tools.find(tool => tool.name === toolCall.function.name);
+                const toolCall = JSON.parse(data.toString()) as ToolCallRequest;
+                reqId = toolCall.reqId;
+                const matchingTool = tools.find(tool => tool.name === toolCall.toolCall.function.name);
                 if (!matchingTool) {
                     throw new WebSocketError(
-                        `Tool ${toolCall.function.name} not found. Registered tools: ${tools.map(tool => tool.name).join(', ')}`
+                        `Tool ${toolCall.toolCall.function.name} not found. ` +
+                         `Registered tools: ${tools.map(tool => tool.name).join(', ')}`
                     );
                 }
                 let args = {}
                 try {
-                    args = JSON.parse(toolCall.function.arguments);
+                    args = JSON.parse(toolCall.toolCall.function.arguments);
                 } catch (e) {}
-                const result = matchingTool(args);
-                socket.send(JSON.stringify(result));
+                try {
+                    const result = matchingTool(args);
+                    const toolResponse = {
+                        reqId,
+                        response: result
+                    } as ToolCallResponse;
+                    socket.send(JSON.stringify(toolResponse));
+                } catch (e) {
+                    socket.send(JSON.stringify({
+                        reqId,
+                        error: (e as Error).message
+                    } as ToolCallError));
+                }
             } catch (e) {
                 if (e instanceof WebSocketError) {
                     throw e;

package/src/remote_debugger.ts

@@ -1,4 +1,12 @@
-import { NodeWebSocketMessage, RegisterDebuggerRequest, Tool, ToolCall, WebSocketError } from "./types";
+import {
+    DeregisterDebuggerRequest,
+    NodeWebSocketMessage,
+    RegisterDebuggerRequest,
+    Tool,
+    ToolCallRequest,
+    ToolCallError,
+    ToolCallResponse,
+} from "./types";
 import { v4 as uuidv4 } from 'uuid';
 import { WebSocket } from 'ws';
 
@@ -18,7 +26,8 @@ export class RemoteDebugger {
 
     public async start(): Promise<string> {
         this.sessionId = this.generateSessionId();
-        console.log(this.formatSessionId());
+        console.log(this.formatSessionIdAndRegisteredTools());
+        let reqId: string | null = null;
 
         this.socket.on('open', () => {
             this.socket.send(JSON.stringify({
@@ -28,21 +37,38 @@ export class RemoteDebugger {
 
         this.socket.on('message', (data: NodeWebSocketMessage) => {
             try {
-                const toolCall = JSON.parse(data.toString()) as ToolCall;
-                const matchingTool = this.tools.find(tool => tool.name === toolCall.function.name);
+                const toolCall = JSON.parse(data.toString()) as ToolCallRequest;
+                reqId = toolCall.reqId;
+                const matchingTool = this.tools.find(tool => tool.name === toolCall.toolCall.function.name);
                 if (!matchingTool) {
-                    console.error(
-                        `Tool ${toolCall.function.name} not found. Registered tools: ${this.tools.map(tool => tool.name).join(', ')}`
-                    );
+                    const errMsg = `Tool ${toolCall.toolCall.function.name} not found. ` + 
+                        `Registered tools: ${this.tools.map(tool => tool.name).join(', ')}`;
+                    console.error(errMsg);
+                    this.socket.send(JSON.stringify({
+                        reqId,
+                        error: errMsg
+                    } as ToolCallError));
                     return;
                 }
                 let args = {}
                 try {
-                    args = JSON.parse(toolCall.function.arguments);
+                    args = JSON.parse(toolCall.toolCall.function.arguments);
                 } catch (e) {}
-                const result = matchingTool(args);
-                this.socket.send(JSON.stringify(result));
+                try {
+                    const result = matchingTool(args); // NodeInput
+                    const toolResponse = {
+                        reqId,
+                        response: result
+                    } as ToolCallResponse;
+                    this.socket.send(JSON.stringify(toolResponse));
+                } catch (e) {
+                    this.socket.send(JSON.stringify({
+                        reqId,
+                        error: (e as Error).message
+                    } as ToolCallError));
+                }
             } catch (e) {
+                console.error(`Received invalid message: ${data.toString()}`);
                 this.socket.send(JSON.stringify({
                     deregister: true,
                     debuggerSessionId: this.sessionId
@@ -58,7 +84,7 @@ export class RemoteDebugger {
         this.socket.send(JSON.stringify({
             deregister: true,
             debuggerSessionId: this.sessionId
-        } as RegisterDebuggerRequest));
+        } as DeregisterDebuggerRequest));
         this.socket.close();
     }
 
@@ -70,12 +96,16 @@ export class RemoteDebugger {
         return uuidv4();
     }
 
-    private formatSessionId(): string {
+    private formatSessionIdAndRegisteredTools(): string {
         return `
 ========================================
 Debugger Session ID:
 ${this.sessionId}
 ========================================
+
+Registered functions:
+${this.tools.map(tool => '- ' + tool.name).join(',\n')}
+========================================
 `
     }
 }

package/src/types.ts

@@ -20,6 +20,11 @@ export type EndpointRunResponse = {
     runId: string;
 }
 
+export type ToolCallRequest = {
+    reqId: string;
+    toolCall: ToolCall;
+}
+
 export type ToolFunctionCall = {
     name: string;
     arguments: string;
@@ -31,6 +36,11 @@ export type ToolCall = {
     function: ToolFunctionCall;
 }
 
+export type ToolCallResponse = {
+    reqId: string;
+    response: NodeInput;
+}
+
 export type NodeWebSocketMessage = {
     type: 'utf8' | 'binary';
     utf8Data?: string;
@@ -45,4 +55,9 @@ export type DeregisterDebuggerRequest = {
     debuggerSessionId: string;
 }
 
+export type ToolCallError = {
+    reqId: string;
+    error: string;
+}
+
 export class WebSocketError extends Error {}