@lmnr-ai/lmnr 0.2.6 → 0.3.0

package/README.md

@@ -14,9 +14,9 @@ npm install @lmnr-ai/lmnr
 
 ## Making Laminar endpoint calls
 
-After you are ready to use your pipeline in your code, deploy it in Laminar following the [docs](https://docs.lmnr.ai/pipeline/run-save-deploy#deploying-a-pipeline-version).
+After you are ready to use your pipeline in your code, deploy it in Laminar by selecting the target version for the pipeline.
 
-Once your pipeline is deployed, you can call it from JS in just a few lines.
+Once your pipeline target is set, you can call it from JS in just a few lines.
 
 Example use:
 
@@ -25,7 +25,7 @@ import { Laminar, NodeInput } from '@lmnr-ai/lmnr';
 
 const l = new Laminar('<YOUR_PROJECT_API_KEY>');
 const result = await l.run({
-    endpoint: 'my_endpoint_name',
+    pipeline: 'my_pipeline_name',
     inputs: {'input': [{'role': 'user', 'content': 'hello'}]},
     env: {'OPENAI_API_KEY': 'sk-some-key'}, // optional
     metadata: {'session_id': 'your_custom_session_id'}, // optional
@@ -41,92 +41,3 @@ Resulting in:
   runId: '05383a95-d316-4391-a64b-06c54d12982a'
 }
 ```
-
-### Making calls to pipelines that run your own logic
-
-If your pipeline contains tool call nodes, they will be able to call your local code.
-The only difference is that you need to pass references
-to the functions you want to call right into our SDK.
-
-Tools must be functions that take in one object argument and perform
-the ES5+ object destructuring magic, e.g. `foo({a, b})`. Tools must return
-either a string or a list of chat messages
-
-Please note that, if you specify tools, a bi-directional communication to Laminar API will be established.
-This only works in Node execution context; browser context is not supported.
-
-Example use:
-
-```js
-import { Laminar, 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;
-}
-
-const l = new Laminar('<YOUR_PROJECT_API_KEY>');
-const result = await l.run({
-    endpoint: 'my_endpoint_name',
-    inputs: {'input': [{'role': 'user', 'content': 'hello'}]},
-    env: {'OPENAI_API_KEY': 'sk-some-key'}, // optional
-    metadata: {'session_id': 'your_custom_session_id'}, // optional
-    // specify as many tools as needed,
-    // Each tool name must match tool node name in the pipeline
-    tools: [myTool],
-});
-```
-
-### LaminarRemoteDebugger
-
-If your pipeline contains tool call nodes, they will be able to call your local code.
-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`:
-
-#### 1. Create your pipeline with tool call nodes
-
-Add tool calls to your pipeline; node names must match the functions you want to call.
-
-#### 2. Start LaminarRemoteDebugger in your code
-
-Example:
-
-```js
-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;
-}
-
-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
-```
-
-This will establish a connection with Laminar API and allow for the pipeline execution
-to call your local functions.
-
-#### 3. Link lmnr.ai workshop to your debugger
-
-Set up `DEBUGGER_SESSION_ID` environment variable in your pipeline.
-
-#### 4. Run and experiment
-
-You can run as many sessions as you need, experimenting with your flows.
-

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@lmnr-ai/lmnr",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "TypeScript SDK for Laminar AI",
   "main": "src/index.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lmnr-ai/ts-sdk.git"
+    "url": "git+https://github.com/lmnr-ai/lmnr-ts.git"
   },
   "keywords": [
     "laminar",
@@ -13,24 +13,21 @@
     "sdk",
     "lmnr.ai"
   ],
-  "author": "founders@laminar.ai",
+  "author": "founders@lmnr.ai",
   "license": "Apache-2.0",
   "bugs": {
-    "url": "https://github.com/lmnr-ai/ts-sdk/issues"
-  },
-  "homepage": "https://github.com/lmnr-ai/ts-sdk#readme",
-  "dependencies": {
-    "@types/ws": "^8.5.10",
-    "browser-or-node": "^3.0.0",
-    "uuid": "^10.0.0",
-    "ws": "^8.18.0"
+    "url": "https://github.com/lmnr-ai/lmnr-ts/issues"
   },
+  "homepage": "https://github.com/lmnr-ai/lmnr-ts#README",
   "devDependencies": {
     "@types/uuid": "^10.0.0",
     "bufferutil": "^4.0.8",
     "tsup": "^8.2.1",
     "typescript": "^5.5.3"
   },
+  "dependencies": {
+    "@types/node": "^22.5.0"
+  },
   "scripts": {
     "build": "tsup",
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/index.ts

@@ -1,39 +1,30 @@
-import { EndpointRunResponse, EndpointRunRequest, NodeWebSocketMessage, WebSocketError, ToolCallRequest, ToolCallResponse, ToolCallError } from './types';
-import { isBrowser, isNode } from 'browser-or-node';
-import { WebSocket } from 'ws';
+import { PipelineRunResponse, PipelineRunRequest } from './types';
 
-export { NodeInput, EndpointRunResponse, EndpointRunRequest, ChatMessage } from './types';
-export { RemoteDebugger as LaminarRemoteDebugger } from './remote_debugger';
+export { NodeInput, PipelineRunResponse, PipelineRunRequest, ChatMessage } from './types';
 
 export class Laminar {
     private readonly projectApiKey: string;
     private readonly url: string;
-    private readonly ws_url: string;
-    private readonly response: EndpointRunResponse | null = null;
+    private readonly response: PipelineRunResponse | null = null;
 
     constructor(projectApiKey: string) {
-        this.projectApiKey = projectApiKey;
-        this.url = 'https://api.lmnr.ai/v2/endpoint/run'
-        this.ws_url = 'wss://api.lmnr.ai/v2/endpoint/ws'
+        this.projectApiKey = projectApiKey ?? process.env.LMNR_PROJECT_API_KEY;
+        this.url = 'https://api.lmnr.ai/v1/pipeline/run'
     }
 
-    public async run(request: EndpointRunRequest): Promise<EndpointRunResponse> {
+    public async run({
+        pipeline,
+        inputs,
+        env = {},
+        metadata = {},
+    }: PipelineRunRequest): Promise<PipelineRunResponse> {
         if (this.projectApiKey === undefined) {
-            throw new Error('Please initialize the Laminar object with your project API key');
+            throw new Error(
+                'Please initialize the Laminar object with your project API key ' +
+                'or set the LMNR_PROJECT_API_KEY environment variable'
+            );
         }
 
-        if (request.tools !== undefined && request.tools.length > 0) {
-            return this._ws_run(request);
-        }
-        return this._run(request);
-    }
-
-    private async _run({
-        endpoint,
-        inputs,
-        env = {},
-        metadata = {}
-    }: EndpointRunRequest): Promise<EndpointRunResponse> {
         const response = await fetch(this.url, {
             method: 'POST',
             headers: {
@@ -42,87 +33,12 @@ export class Laminar {
             },
             body: JSON.stringify({
                 inputs,
-                endpoint,
-                env,
-                metadata
-            })
-        });
-
-        return await response.json() as EndpointRunResponse;
-    }
-
-    private async _ws_run(request: EndpointRunRequest): Promise<EndpointRunResponse> {
-        if (isBrowser) {
-            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 {
-            throw new Error('Unsupported environment');
-        }
-    }
-
-    private async _ws_run_node({
-        endpoint,
-        inputs,
-        env = {},
-        metadata = {},
-        tools = [],
-    }: 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({
-                inputs,
-                endpoint,
+                pipeline,
                 env,
                 metadata,
-                tools,
-            }));
-        });
-        socket.on('message', (data: NodeWebSocketMessage) => {
-            try {
-                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.toolCall.function.name} not found. ` +
-                         `Registered tools: ${tools.map(tool => tool.name).join(', ')}`
-                    );
-                }
-                let args = {}
-                try {
-                    args = JSON.parse(toolCall.toolCall.function.arguments);
-                } catch (e) {}
-                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;
-                }
-                response = JSON.parse(data.toString()) as EndpointRunResponse;
-                socket.close();
-            }
+            })
         });
 
-        // TODO: Implement a better way to wait for the response
-        while (!response) {
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-        }
-
-        return response;
+        return await response.json() as PipelineRunResponse;
     }
-}
+}

package/src/types.ts

@@ -7,57 +7,14 @@ export type NodeInput = ChatMessage[] | string;
 
 export type Tool = (...args: any) => NodeInput | Promise<NodeInput>;
 
-export type EndpointRunRequest = {
+export type PipelineRunRequest = {
     inputs: Record<string, NodeInput>;
-    endpoint: string;
+    pipeline: string;
     env?: Record<string, string>;
     metadata?: Record<string, string>;
-    tools?: Tool[];
 }
 
-export type EndpointRunResponse = {
+export type PipelineRunResponse = {
     outputs: Record<string, Record<string, NodeInput>>;
     runId: string;
 }
-
-export type ToolCallRequest = {
-    reqId: string;
-    toolCall: ToolCall;
-}
-
-export type ToolFunctionCall = {
-    name: string;
-    arguments: string;
-}
-
-export type ToolCall = {
-    id: string;
-    type: 'function';
-    function: ToolFunctionCall;
-}
-
-export type ToolCallResponse = {
-    reqId: string;
-    response: NodeInput;
-}
-
-export type NodeWebSocketMessage = {
-    type: 'utf8' | 'binary';
-    utf8Data?: string;
-}
-
-export type RegisterDebuggerRequest = {
-    debuggerSessionId: string;
-}
-
-export type DeregisterDebuggerRequest = {
-    deregister: true;
-    debuggerSessionId: string;
-}
-
-export type ToolCallError = {
-    reqId: string;
-    error: string;
-}
-
-export class WebSocketError extends Error {}

package/src/remote_debugger.ts

@@ -1,111 +0,0 @@
-import {
-    DeregisterDebuggerRequest,
-    NodeWebSocketMessage,
-    RegisterDebuggerRequest,
-    Tool,
-    ToolCallRequest,
-    ToolCallError,
-    ToolCallResponse,
-} from "./types";
-import { v4 as uuidv4 } from 'uuid';
-import { WebSocket } from 'ws';
-
-
-export class RemoteDebugger {
-    private readonly projectApiKey: string;
-    private readonly url: string = 'wss://api.lmnr.ai/v2/endpoint/ws';
-    private readonly tools: Tool[];
-    private sessionId: string | null = null;
-    private socket;
-
-    constructor(projectApiKey: string, tools: Tool[]) {
-        this.projectApiKey = projectApiKey;
-        this.tools = tools;
-        this.socket = new  WebSocket(this.url, [], {headers: {'Authorization': `Bearer ${this.projectApiKey}`}});
-    }
-
-    public async start(): Promise<string> {
-        this.sessionId = this.generateSessionId();
-        console.log(this.formatSessionIdAndRegisteredTools());
-        let reqId: string | null = null;
-
-        this.socket.on('open', () => {
-            this.socket.send(JSON.stringify({
-                debuggerSessionId: this.sessionId
-            } as RegisterDebuggerRequest));
-        });
-
-        this.socket.on('message', (data: NodeWebSocketMessage) => {
-            try {
-                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) {
-                    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.toolCall.function.arguments);
-                } catch (e) {}
-                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
-                } as RegisterDebuggerRequest));
-                this.socket.close();
-            }
-        });
-
-        return this.sessionId;
-    }
-
-    public stop() {
-        this.socket.send(JSON.stringify({
-            deregister: true,
-            debuggerSessionId: this.sessionId
-        } as DeregisterDebuggerRequest));
-        this.socket.close();
-    }
-
-    public getSessionId(): string | null {
-        return this.sessionId;
-    }
-
-    private generateSessionId(): string {
-        return uuidv4();
-    }
-
-    private formatSessionIdAndRegisteredTools(): string {
-        return `
-========================================
-Debugger Session ID:
-${this.sessionId}
-========================================
-
-Registered functions:
-${this.tools.map(tool => '- ' + tool.name).join(',\n')}
-========================================
-`
-    }
-}