lmnr 0.2.5__tar.gz → 0.2.6__tar.gz

{lmnr-0.2.5 → lmnr-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.2.5
+Version: 0.2.6
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -17,11 +17,12 @@ Requires-Dist: cookiecutter (>=2.6.0,<3.0.0)
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: urllib3 (==1.26.6)
 Requires-Dist: websockets (>=12.0,<13.0)
 Description-Content-Type: text/markdown
 
-# Python SDK for Laminar AI
+# Laminar AI
+
+This reipo provides core for code generation, Laminar CLI, and Laminar SDK.
 
 ## Quickstart
 ```sh
@@ -139,14 +140,6 @@ 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
-
-```python
-debugger.stop()
-```
-
 ## CLI for code generation
 
 ### Basic usage

{lmnr-0.2.5 → lmnr-0.2.6}/README.md

@@ -1,4 +1,6 @@
-# Python SDK for Laminar AI
+# Laminar AI
+
+This reipo provides core for code generation, Laminar CLI, and Laminar SDK.
 
 ## Quickstart
 ```sh
@@ -116,14 +118,6 @@ 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
-
-```python
-debugger.stop()
-```
-
 ## CLI for code generation
 
 ### Basic usage

{lmnr-0.2.5 → lmnr-0.2.6}/pyproject.toml

@@ -11,7 +11,7 @@ license = "Apache-2.0"
 
 [tool.poetry]
 name = "lmnr"
-version = "0.2.5"
+version = "0.2.6"
 description = "Python SDK for Laminar AI"
 authors = ["lmnr.ai"]
 readme = "README.md"
@@ -23,7 +23,6 @@ black = "^24.4.2"
 pydantic = "^2.7.4"
 click = "^8.1.7"
 requests = "^2.32.3"
-urllib3 = "1.26.6"
 websockets = "^12.0"
 cookiecutter = "^2.6.0"
 python-dotenv = "^1.0.1"

lmnr-0.2.6/src/lmnr/cli/parser/nodes/input.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Optional
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, HandleType, NodeFunctions
+from lmnr.types import NodeInput
+
+
+@dataclass
+class InputNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    outputs: list[Handle]
+    input: Optional[NodeInput]
+    input_type: HandleType
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        return []
+
+    def node_type(self) -> str:
+        return "Input"
+
+    def config(self) -> dict:
+        return {}

lmnr-0.2.6/src/lmnr/cli/parser/nodes/llm.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from typing import Optional
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class LLMNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    dynamic_inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    prompt: str
+    model: str
+    model_params: Optional[str]
+    stream: bool
+    structured_output_enabled: bool
+    structured_output_max_retries: int
+    structured_output_schema: Optional[str]
+    structured_output_schema_target: Optional[str]
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        combined_inputs = self.inputs + self.dynamic_inputs
+        return map_handles(
+            combined_inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "LLM"
+
+    def config(self) -> dict:
+        # For easier access in the template separate the provider and model here
+        provider, model = self.model.split(":", maxsplit=1)
+
+        return {
+            "prompt": self.prompt,
+            "provider": provider,
+            "model": model,
+            "model_params": self.model_params,
+            "stream": self.stream,
+            "structured_output_enabled": self.structured_output_enabled,
+            "structured_output_max_retries": self.structured_output_max_retries,
+            "structured_output_schema": self.structured_output_schema,
+            "structured_output_schema_target": self.structured_output_schema_target,
+        }

lmnr-0.2.6/src/lmnr/cli/parser/nodes/output.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class OutputNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        return map_handles(
+            self.inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "Output"
+
+    def config(self) -> dict:
+        return {}

lmnr-0.2.6/src/lmnr/cli/parser/nodes/semantic_search.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+import uuid
+
+from lmnr.cli.parser.nodes import Handle, NodeFunctions
+from lmnr.cli.parser.utils import map_handles
+
+
+@dataclass
+class FileMetadata:
+    id: uuid.UUID
+    created_at: datetime
+    project_id: uuid.UUID
+    filename: str
+
+
+@dataclass
+class Dataset:
+    id: uuid.UUID
+    created_at: datetime
+    project_id: uuid.UUID
+    name: str
+
+
+@dataclass
+class SemanticSearchDatasource:
+    type: str
+    id: uuid.UUID
+    # TODO: Paste other fields here, use Union[FileMetadata, Dataset]
+
+    @classmethod
+    def from_dict(cls, datasource_dict: dict) -> "SemanticSearchDatasource":
+        if datasource_dict["type"] == "File":
+            return cls(
+                type="File",
+                id=uuid.UUID(datasource_dict["id"]),
+            )
+        elif datasource_dict["type"] == "Dataset":
+            return cls(
+                type="Dataset",
+                id=uuid.UUID(datasource_dict["id"]),
+            )
+        else:
+            raise ValueError(
+                f"Invalid SemanticSearchDatasource type: {datasource_dict['type']}"
+            )
+
+
+@dataclass
+class SemanticSearchNode(NodeFunctions):
+    id: uuid.UUID
+    name: str
+    inputs: list[Handle]
+    outputs: list[Handle]
+    inputs_mappings: dict[uuid.UUID, uuid.UUID]
+    limit: int
+    threshold: float
+    template: str
+    datasources: list[SemanticSearchDatasource]
+
+    def handles_mapping(
+        self, output_handle_id_to_node_name: dict[str, str]
+    ) -> list[tuple[str, str]]:
+        return map_handles(
+            self.inputs, self.inputs_mappings, output_handle_id_to_node_name
+        )
+
+    def node_type(self) -> str:
+        return "SemanticSearch"
+
+    def config(self) -> dict:
+        return {
+            "limit": self.limit,
+            "threshold": self.threshold,
+            "template": self.template,
+            "datasource_ids": [str(datasource.id) for datasource in self.datasources],
+            "datasource_ids_list": str(
+                [str(datasource.id) for datasource in self.datasources]
+            ),
+        }

lmnr-0.2.6/src/lmnr/cli/parser/nodes/types.py

@@ -0,0 +1,91 @@
+from typing import Any, Union
+import uuid
+
+from lmnr.cli.parser.nodes import Handle
+from lmnr.cli.parser.nodes.input import InputNode
+from lmnr.cli.parser.nodes.llm import LLMNode
+from lmnr.cli.parser.nodes.output import OutputNode
+from lmnr.cli.parser.nodes.semantic_search import (
+    SemanticSearchDatasource,
+    SemanticSearchNode,
+)
+from lmnr.types import NodeInput, ChatMessage
+
+
+def node_input_from_json(json_val: Any) -> NodeInput:
+    if isinstance(json_val, str):
+        return json_val
+    elif isinstance(json_val, list):
+        return [ChatMessage.model_validate(msg) for msg in json_val]
+    else:
+        raise ValueError(f"Invalid NodeInput value: {json_val}")
+
+
+Node = Union[InputNode, OutputNode, LLMNode, SemanticSearchNode]
+
+
+def node_from_dict(node_dict: dict) -> Node:
+    if node_dict["type"] == "Input":
+        return InputNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
+            input=node_input_from_json(node_dict["input"]),
+            input_type=node_dict["inputType"],
+        )
+    elif node_dict["type"] == "Output":
+        return OutputNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
+            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
+            inputs_mappings={
+                uuid.UUID(k): uuid.UUID(v)
+                for k, v in node_dict["inputsMappings"].items()
+            },
+        )
+    elif node_dict["type"] == "LLM":
+        return LLMNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
+            dynamic_inputs=[
+                Handle.from_dict(handle) for handle in node_dict["dynamicInputs"]
+            ],
+            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
+            inputs_mappings={
+                uuid.UUID(k): uuid.UUID(v)
+                for k, v in node_dict["inputsMappings"].items()
+            },
+            prompt=node_dict["prompt"],
+            model=node_dict["model"],
+            model_params=(
+                node_dict["modelParams"] if "modelParams" in node_dict else None
+            ),
+            stream=False,
+            # TODO: Implement structured output
+            structured_output_enabled=False,
+            structured_output_max_retries=3,
+            structured_output_schema=None,
+            structured_output_schema_target=None,
+        )
+    elif node_dict["type"] == "SemanticSearch":
+        return SemanticSearchNode(
+            id=uuid.UUID(node_dict["id"]),
+            name=node_dict["name"],
+            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
+            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
+            inputs_mappings={
+                uuid.UUID(k): uuid.UUID(v)
+                for k, v in node_dict["inputsMappings"].items()
+            },
+            limit=node_dict["limit"],
+            threshold=node_dict["threshold"],
+            template=node_dict["template"],
+            datasources=[
+                SemanticSearchDatasource.from_dict(ds)
+                for ds in node_dict["datasources"]
+            ],
+        )
+    else:
+        raise ValueError(f"Node type {node_dict['type']} not supported")

{lmnr-0.2.5 → lmnr-0.2.6}/src/lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/engine/engine.py

@@ -9,7 +9,8 @@ import queue
 from .task import Task
 from .action import NodeRunError, RunOutput
 from .state import State
-from lmnr_engine.types import Message, NodeInput
+from lmnr.types import NodeInput
+from lmnr_engine.types import Message
 
 
 logger = logging.getLogger(__name__)

{lmnr-0.2.5 → lmnr-0.2.6}/src/lmnr/cli/{{cookiecutter.lmnr_pipelines_dir_name}}/pipelines/{{cookiecutter.pipeline_dir_name}}/nodes/functions.py

@@ -132,6 +132,42 @@ def {{task.function_name}}({{ task.handle_args }}, _env: dict[str, str]) -> RunO
     return RunOutput(status="Success", output=completion_message)
 
 
+{% elif task.node_type == "SemanticSearch" %}
+def {{task.function_name}}(query: NodeInput, _env: dict[str, str]) -> RunOutput:
+    {% set datasources_length=task.config.datasource_ids|length %}
+    {% if datasources_length == 0 %}
+    raise NodeRunError("No datasources provided")
+    {% endif %}
+
+    headers = {
+        "Authorization": f"Bearer {_env['LMNR_PROJECT_API_KEY']}",
+    }
+    data = {
+        "query": query,
+        "limit": {{ task.config.limit }},
+        "threshold": {{ task.config.threshold }},
+        "datasourceIds": {{ task.config.datasource_ids_list }},
+    }
+    query_res = requests.post("https://api.lmnr.ai/v2/semantic-search", headers=headers, json=data)
+    if query_res.status_code != 200:
+        raise NodeRunError(f"Vector search request failed: {query_res.text}")
+
+    results = query_res.json()
+
+    def render_query_res_point(template: str, point: dict, relevance_index: int) -> str:
+        data = point["data"]
+        data["relevance_index"] = relevance_index
+        res = template
+        for key, value in data.items():
+            res = res.replace("{{'{{'}}" + key + "{{'}}'}}", str(value))
+        return res
+
+    rendered_res_points = [render_query_res_point("""{{task.config.template}}""", res_point, index + 1) for (index, res_point) in enumerate(results)]
+    output = "\n".join(rendered_res_points)
+
+    return RunOutput(status="Success", output=output)
+
+
 {% elif task.node_type == "Output" %}
 def {{task.function_name}}(output: NodeInput, _env: dict[str, str]) -> RunOutput:
     return RunOutput(status="Success", output=output)

{lmnr-0.2.5 → lmnr-0.2.6}/src/lmnr/sdk/endpoint.py

@@ -4,7 +4,7 @@ import pydantic
 import requests
 from lmnr.types import (
     EndpointRunError, EndpointRunResponse, NodeInput, EndpointRunRequest,
-    ToolCall, SDKError
+    ToolCallError, ToolCallRequest, ToolCallResponse, SDKError
 )
 from typing import Callable, Optional
 from websockets.sync.client import connect
@@ -126,31 +126,52 @@ class Laminar:
             }
         ) as websocket:
             websocket.send(request.model_dump_json())
+            req_id = None
 
             while True:
                 message = websocket.recv()
                 try:
-                    tool_call = ToolCall.model_validate_json(message)
+                    tool_call = ToolCallRequest.model_validate_json(message)
+                    req_id = tool_call.req_id
                     matching_tools = [
                         tool for tool in tools
-                        if tool.__name__ == tool_call.function.name
+                        if tool.__name__ == tool_call.toolCall.function.name
                     ]
                     if not matching_tools:
                         raise SDKError(
-                            f'Tool {tool_call.function.name} not found.'
+                            f'Tool {tool_call.toolCall.function.name} not found.'
                             ' Registered tools: '
                             f'{", ".join([tool.__name__ for tool in tools])}'
                         )
                     tool = matching_tools[0]
-                    if tool.__name__ == tool_call.function.name:
                         # default the arguments to an empty dictionary
+                    if tool.__name__ == tool_call.toolCall.function.name:
                         arguments = {}
                         try:
-                            arguments = json.loads(tool_call.function.arguments)
+                            arguments = json.loads(tool_call.toolCall.function.arguments)
                         except:
                             pass
-                        response = tool(**arguments)
-                        websocket.send(json.dumps(response))
+                        try:
+                            response = tool(**arguments)
+                        except Exception as e:
+                            error_message = 'Error occurred while running tool' +\
+                             f'{tool.__name__}: {e}'
+                            e = ToolCallError(error=error_message, reqId=req_id)
+                            websocket.send(e.model_dump_json())
+                        formatted_response = None
+                        try:
+                            formatted_response = ToolCallResponse(
+                                reqId=tool_call.reqId,
+                                response=response
+                            )
+                        except pydantic.ValidationError as e:
+                            formatted_response = ToolCallResponse(
+                                reqId=tool_call.reqId,
+                                response=str(response)
+                            )
+                        websocket.send(
+                            formatted_response.model_dump_json()
+                        )
                 except pydantic.ValidationError as e:
                     message_json = json.loads(message)
                     keys = list(message_json.keys())
@@ -161,6 +182,5 @@ class Laminar:
                     result = EndpointRunResponse.model_validate(message_json)
                     websocket.close()
                     return result
-                except Exception:
-                    websocket.close()
-                    raise SDKError('Error communicating to backend through websocket')
+                except Exception as e:
+                    raise SDKError(f'Error communicating to backend through websocket {e}')

lmnr-0.2.6/src/lmnr/sdk/remote_debugger.py

@@ -0,0 +1,139 @@
+from typing import Callable, Optional
+from websockets.sync.client import connect
+import pydantic
+import websockets
+from lmnr.types import (
+    DeregisterDebuggerRequest, NodeInput, RegisterDebuggerRequest,
+    SDKError, ToolCallError, ToolCallRequest, ToolCallResponse
+)
+import uuid
+import json
+from threading import Thread
+
+class RemoteDebugger:
+    def __init__(
+        self,
+        project_api_key: str,
+        tools: list[Callable[..., NodeInput]] = []
+    ):
+        self.project_api_key = project_api_key
+        self.url = 'wss://api.lmnr.ai/v2/endpoint/ws'
+        self.tools = tools
+        self.thread = Thread(target=self._run)
+        self.stop_flag = False
+        self.session = None
+    
+    def start(self) -> Optional[str]:
+        self.stop_flag = False
+        self.session = self._generate_session_id()
+        self.thread.start()
+        return self.session
+    
+    def stop(self):
+        self.stop_flag = True
+        self.thread.join()
+        self.session = None
+        # python allows running threads only once, so we need to create
+        # a new thread
+        # in case the user wants to start the debugger again
+        self.thread = Thread(target=self._run)
+    
+    def get_session_id(self) -> str:
+        return self.session
+    
+    def _run(self):
+        request = RegisterDebuggerRequest(debuggerSessionId=self.session)
+        with connect(
+            self.url,
+            additional_headers={
+                'Authorization': f'Bearer {self.project_api_key}'
+            }
+        ) as websocket:
+            websocket.send(request.model_dump_json())
+            print(self._format_session_id_and_registerd_functions())
+            req_id = None
+
+            while not self.stop_flag:
+                try:
+                    # blocks the thread until a message 
+                    # is received or a timeout (3 seconds) occurs
+                    message = websocket.recv(3)
+                except TimeoutError:
+                    continue
+                except websockets.exceptions.ConnectionClosedError:
+                    print("Connection closed. Please restart the debugger.")
+                    return
+                try:
+                    tool_call = ToolCallRequest.model_validate_json(message)
+                    req_id = tool_call.reqId
+                except:
+                    raise SDKError(f'Invalid message received:\n{message}')
+                matching_tools = [
+                    tool for tool in self.tools
+                    if tool.__name__ == tool_call.toolCall.function.name
+                ]
+                if not matching_tools:
+                    error_message = \
+                        f'Tool {tool_call.toolCall.function.name} not found' +\
+                        '. Registered tools: ' +\
+                        {", ".join([tool.__name__ for tool in self.tools])}
+                    e = ToolCallError(error=error_message, reqId=req_id)
+                    websocket.send(e.model_dump_json())
+                    continue
+                tool = matching_tools[0]
+                if tool.__name__ == tool_call.toolCall.function.name:
+                    # default the arguments to an empty dictionary
+                    arguments = {}
+                    try:
+                        arguments = json.loads(
+                            tool_call.toolCall.function.arguments)
+                    except:
+                        pass
+                    try:
+                        response = tool(**arguments)
+                    except Exception as e:
+                        error_message = 'Error occurred while running tool' +\
+                            f'{tool.__name__}: {e}'
+                        e = ToolCallError(error=error_message, reqId=req_id)
+                        websocket.send(e.model_dump_json())
+                    formatted_response = None
+                    try:
+                        formatted_response = ToolCallResponse(
+                            reqId=tool_call.reqId,
+                            response=response
+                        )
+                    except pydantic.ValidationError as e:
+                        formatted_response = ToolCallResponse(
+                            reqId=tool_call.reqId,
+                            response=str(response)
+                        )
+                    websocket.send(
+                        formatted_response.model_dump_json()
+                    )
+            websocket.send(
+                DeregisterDebuggerRequest(
+                    debuggerSessionId=self.session,
+                    deregister=True
+                ).model_dump_json()
+            )
+
+    def _generate_session_id(self) -> str:
+        return uuid.uuid4().urn[9:]
+
+    def _format_session_id_and_registerd_functions(self) -> str:
+        registered_functions = \
+            ',\n'.join(['- ' + tool.__name__ for tool in self.tools])
+        return \
+f"""
+========================================
+Debugger Session ID:
+{self.session}
+========================================
+
+Registered functions:
+{registered_functions}
+
+========================================
+"""
+
+    

{lmnr-0.2.5 → lmnr-0.2.6}/src/lmnr/types.py

@@ -1,13 +1,16 @@
-
 import requests
 import pydantic
+import uuid
 from typing import Union, Optional
 
+
 class ChatMessage(pydantic.BaseModel):
     role: str
     content: str
 
-NodeInput = Union[str, list[ChatMessage]] # TypeAlias
+
+NodeInput = Union[str, list[ChatMessage]]  # TypeAlias
+
 
 class EndpointRunRequest(pydantic.BaseModel):
     inputs: dict[str, NodeInput]
@@ -15,10 +18,12 @@ class EndpointRunRequest(pydantic.BaseModel):
     env: dict[str, str] = pydantic.Field(default_factory=dict)
     metadata: dict[str, str] = pydantic.Field(default_factory=dict)
 
+
 class EndpointRunResponse(pydantic.BaseModel):
     outputs: dict[str, dict[str, NodeInput]]
     run_id: str
 
+
 class EndpointRunError(Exception):
     error_code: str
     error_message: str
@@ -26,39 +31,57 @@ class EndpointRunError(Exception):
     def __init__(self, response: requests.Response):
         try:
             resp_json = response.json()
-            self.error_code = resp_json['error_code']
-            self.error_message = resp_json['error_message']
+            self.error_code = resp_json["error_code"]
+            self.error_message = resp_json["error_message"]
             super().__init__(self.error_message)
-        except:
+        except Exception:
             super().__init__(response.text)
-    
+
     def __str__(self) -> str:
         try:
-            return str({'error_code': self.error_code, 'error_message': self.error_message})
-        except:
+            return str(
+                {"error_code": self.error_code, "error_message": self.error_message}
+            )
+        except Exception:
             return super().__str__()
-        
+
+
 class SDKError(Exception):
     def __init__(self, error_message: str):
         super().__init__(error_message)
 
+
 class ToolCallRequest(pydantic.BaseModel):
     name: str
     arguments: str
 
+
 class ToolCall(pydantic.BaseModel):
     id: Optional[str]
     type: Optional[str]
     function: ToolCallRequest
 
-ToolCallResponse = NodeInput
+
+# TODO: allow snake_case and manually convert to camelCase
+class ToolCallRequest(pydantic.BaseModel):
+    reqId: uuid.UUID
+    toolCall: ToolCall
+
+
+class ToolCallResponse(pydantic.BaseModel):
+    reqId: uuid.UUID
+    response: NodeInput
+
+
 class ToolCallError(pydantic.BaseModel):
+    reqId: uuid.UUID
     error: str
 
-# TODO: allow snake_case and manually convert to camelCase
+
 class RegisterDebuggerRequest(pydantic.BaseModel):
     debuggerSessionId: str
 
+
 class DeregisterDebuggerRequest(pydantic.BaseModel):
     debuggerSessionId: str
     deregister: bool

lmnr-0.2.5/src/lmnr/cli/parser/nodes/types.py

@@ -1,157 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Optional, Union
-import uuid
-from lmnr.cli.parser.nodes import Handle, HandleType, NodeFunctions
-from lmnr.cli.parser.utils import map_handles
-from lmnr.types import NodeInput, ChatMessage
-
-
-def node_input_from_json(json_val: Any) -> NodeInput:
-    if isinstance(json_val, str):
-        return json_val
-    elif isinstance(json_val, list):
-        return [ChatMessage.model_validate(msg) for msg in json_val]
-    else:
-        raise ValueError(f"Invalid NodeInput value: {json_val}")
-
-
-# TODO: Convert to Pydantic
-@dataclass
-class InputNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    outputs: list[Handle]
-    input: Optional[NodeInput]
-    input_type: HandleType
-
-    def handles_mapping(
-        self, output_handle_id_to_node_name: dict[str, str]
-    ) -> list[tuple[str, str]]:
-        return []
-
-    def node_type(self) -> str:
-        return "Input"
-
-    def config(self) -> dict:
-        return {}
-
-
-# TODO: Convert to Pydantic
-@dataclass
-class LLMNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    inputs: list[Handle]
-    dynamic_inputs: list[Handle]
-    outputs: list[Handle]
-    inputs_mappings: dict[uuid.UUID, uuid.UUID]
-    prompt: str
-    model: str
-    model_params: Optional[str]
-    stream: bool
-    structured_output_enabled: bool
-    structured_output_max_retries: int
-    structured_output_schema: Optional[str]
-    structured_output_schema_target: Optional[str]
-
-    def handles_mapping(
-        self, output_handle_id_to_node_name: dict[str, str]
-    ) -> list[tuple[str, str]]:
-        combined_inputs = self.inputs + self.dynamic_inputs
-        return map_handles(
-            combined_inputs, self.inputs_mappings, output_handle_id_to_node_name
-        )
-
-    def node_type(self) -> str:
-        return "LLM"
-
-    def config(self) -> dict:
-        # For easier access in the template separate the provider and model here
-        provider, model = self.model.split(":", maxsplit=1)
-
-        return {
-            "prompt": self.prompt,
-            "provider": provider,
-            "model": model,
-            "model_params": self.model_params,
-            "stream": self.stream,
-            "structured_output_enabled": self.structured_output_enabled,
-            "structured_output_max_retries": self.structured_output_max_retries,
-            "structured_output_schema": self.structured_output_schema,
-            "structured_output_schema_target": self.structured_output_schema_target,
-        }
-
-
-# TODO: Convert to Pydantic
-@dataclass
-class OutputNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    inputs: list[Handle]
-    outputs: list[Handle]
-    inputs_mappings: dict[uuid.UUID, uuid.UUID]
-
-    def handles_mapping(
-        self, output_handle_id_to_node_name: dict[str, str]
-    ) -> list[tuple[str, str]]:
-        return map_handles(
-            self.inputs, self.inputs_mappings, output_handle_id_to_node_name
-        )
-
-    def node_type(self) -> str:
-        return "Output"
-
-    def config(self) -> dict:
-        return {}
-
-
-Node = Union[InputNode, OutputNode, LLMNode]
-
-
-def node_from_dict(node_dict: dict) -> Node:
-    if node_dict["type"] == "Input":
-        return InputNode(
-            id=uuid.UUID(node_dict["id"]),
-            name=node_dict["name"],
-            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
-            input=node_input_from_json(node_dict["input"]),
-            input_type=node_dict["inputType"],
-        )
-    elif node_dict["type"] == "Output":
-        return OutputNode(
-            id=uuid.UUID(node_dict["id"]),
-            name=node_dict["name"],
-            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
-            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
-            inputs_mappings={
-                uuid.UUID(k): uuid.UUID(v)
-                for k, v in node_dict["inputsMappings"].items()
-            },
-        )
-    elif node_dict["type"] == "LLM":
-        return LLMNode(
-            id=uuid.UUID(node_dict["id"]),
-            name=node_dict["name"],
-            inputs=[Handle.from_dict(handle) for handle in node_dict["inputs"]],
-            dynamic_inputs=[
-                Handle.from_dict(handle) for handle in node_dict["dynamicInputs"]
-            ],
-            outputs=[Handle.from_dict(handle) for handle in node_dict["outputs"]],
-            inputs_mappings={
-                uuid.UUID(k): uuid.UUID(v)
-                for k, v in node_dict["inputsMappings"].items()
-            },
-            prompt=node_dict["prompt"],
-            model=node_dict["model"],
-            model_params=(
-                node_dict["modelParams"] if "modelParams" in node_dict else None
-            ),
-            stream=False,
-            # TODO: Implement structured output
-            structured_output_enabled=False,
-            structured_output_max_retries=3,
-            structured_output_schema=None,
-            structured_output_schema_target=None,
-        )
-    else:
-        raise ValueError(f"Node type {node_dict['type']} not supported")

lmnr-0.2.5/src/lmnr/sdk/remote_debugger.py

@@ -1,96 +0,0 @@
-from typing import Callable, Optional
-from websockets.sync.client import connect
-import websockets
-from lmnr.types import DeregisterDebuggerRequest, NodeInput, RegisterDebuggerRequest, SDKError, ToolCall, ToolCallError
-import uuid
-import json
-from threading import Thread
-
-class RemoteDebugger:
-    def __init__(self, project_api_key: str, tools: list[Callable[..., NodeInput]] = []):
-        self.project_api_key = project_api_key
-        self.url = 'wss://api.lmnr.ai/v2/endpoint/ws'
-        self.tools = tools
-        self.thread = Thread(target=self._run)
-        self.stop_flag = False
-        self.session = None
-    
-    def start(self) -> Optional[str]:
-        self.stop_flag = False
-        self.session = self._generate_session_id()
-        self.thread.start()
-        return self.session
-    
-    def stop(self):
-        self.stop_flag = True
-        self.thread.join()
-        self.session = None
-        # python allows running threads only once, so we need to create a new thread
-        # in case the user wants to start the debugger again
-        self.thread = Thread(target=self._run)
-    
-    def get_session_id(self) -> str:
-        return self.session
-    
-    def _run(self):
-        request = RegisterDebuggerRequest(debuggerSessionId=self.session)
-        with connect(
-            self.url,
-            additional_headers={
-                'Authorization': f'Bearer {self.project_api_key}'
-            }
-        ) as websocket:
-            websocket.send(request.model_dump_json())
-            print(self._format_session_id())
-            while not self.stop_flag:
-                try:
-                    # blocks the thread until a message is received or a timeout (3 seconds) occurs
-                    message = websocket.recv(3)
-                except TimeoutError:
-                    continue
-                except websockets.exceptions.ConnectionClosedError:
-                    print("Connection closed. Please restart the debugger.")
-                    return
-                try:
-                    tool_call = ToolCall.model_validate_json(message)
-                except:
-                    raise SDKError(f'Invalid message received:\n{message}')
-                matching_tools = [
-                    tool for tool in self.tools
-                    if tool.__name__ == tool_call.function.name
-                ]
-                if not matching_tools:
-                    error_message = f'Tool {tool_call.function.name} not found.' +\
-                    f' Registered tools: {", ".join([tool.__name__ for tool in self.tools])}'
-                    e = ToolCallError(error=error_message)
-                    websocket.send(e.model_dump_json())
-                    continue
-                tool = matching_tools[0]
-                if tool.__name__ == tool_call.function.name:
-                    # default the arguments to an empty dictionary
-                    arguments = {}
-                    try:
-                        arguments = json.loads(tool_call.function.arguments)
-                    except:
-                        pass
-                    try:
-                        response = tool(**arguments)  # of type NodeInput
-                        websocket.send(json.dumps(response))
-                    except Exception as e:
-                        error_message = f'Error occurred while running tool {tool.__name__}: {e}'
-                        e = ToolCallError(error=error_message)
-                        websocket.send(e.model_dump_json())
-            websocket.send(DeregisterDebuggerRequest(debuggerSessionId=self.session, deregister=True).model_dump_json())
-
-    def _generate_session_id(self) -> str:
-        return uuid.uuid4().urn[9:]
-
-    def _format_session_id(self) -> str:
-        return \
-f"""
-========================================
-Debugger Session ID:
-{self.session}
-========================================
-"""
-