lmnr 0.2.15__py3-none-any.whl → 0.3.0b1__py3-none-any.whl

lmnr-0.3.0b1.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.1
+Name: lmnr
+Version: 0.3.0b1
+Summary: Python SDK for Laminar AI
+License: Apache-2.0
+Author: lmnr.ai
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: backoff (>=2.2.1,<3.0.0)
+Requires-Dist: black (>=24.4.2,<25.0.0)
+Requires-Dist: openai (>=1.41.1,<2.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)
+Description-Content-Type: text/markdown
+
+# Laminar AI
+
+This repo provides core for code generation, Laminar CLI, and Laminar SDK.
+
+## Quickstart
+```sh
+python3 -m venv .myenv
+source .myenv/bin/activate  # or use your favorite env management tool
+
+pip install lmnr
+```
+
+
+## Decorator instrumentation example
+
+For easy automatic instrumentation, we provide you two simple primitives:
+
+- `observe` - a multi-purpose automatic decorator that starts traces and spans when functions are entered, and finishes them when functions return
+- `wrap_llm_call` - a function that takes in your LLM call and return a "decorated" version of it. This does all the same things as `observe`, plus
+a few utilities around LLM-specific things, such as counting tokens and recording model params.
+
+You can also import `lmnr_context` in order to interact and have more control over the context of the current span.
+
+```python
+import os
+from openai import OpenAI
+
+from lmnr import observe, wrap_llm_call, lmnr_context
+client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+
+@observe()  # annotate all functions you want to trace
+def poem_writer(topic="turbulence"):
+    prompt = f"write a poem about {topic}"
+
+    # wrap the actual final call to LLM with `wrap_llm_call`
+    response = wrap_llm_call(client.chat.completions.create)(
+        model="gpt-4o",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt},
+        ],
+    )
+
+    poem = response.choices[0].message.content
+
+    if topic in poem:
+        lmnr_context.event("topic_alignment")  # send an event with a pre-defined name
+    
+    # to trigger an automatic check for a possible event do:
+    lmnr_context.check_span_event("excessive_wordiness")
+
+    return poem
+
+if __name__ == "__main__":
+    print(poem_writer(topic="laminar flow"))
+```
+
+This gives an advantage of quick instrumentation, but is somewhat limited in flexibility + doesn't really work as expected with threading.
+This is due to the fact that we use `contextvars.ContextVar` for this, and how Python manages them between threads.
+
+If you want to instrument your code manually, follow on to the next section
+
+## Manual instrumentation example
+
+For manual instrumetation you will need to import the following:
+- `trace` - this is a function to start a trace. It returns a `TraceContext`
+- `TraceContext` - a pointer to the current trace that you can pass around functions as you want.
+- `SpanContext` - a pointer to the current span that you can pass around functions as you want
+
+Both `TraceContext` and `SpanContext` expose the following interfaces:
+- `span(name: str, **kwargs)` - create a child span within the current context. Returns `SpanContext`
+- `update(**kwargs)` - update the current trace or span and return it. Returns `TraceContext` or `SpanContext`. Useful when some metadata becomes known later during the program execution
+- `end(**kwargs)` – update the current span, and terminate it
+
+In addition, `SpanContext` allows you to:
+- `event(name: str, value: str | int = None)` - emit a custom event at any point
+- `evaluate_event(name: str, data: str)` - register a possible event for automatic checking by Laminar.
+
+Example:
+
+```python
+import os
+from openai import OpenAI
+
+from lmnr import trace, TraceContext, SpanContext
+client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+
+def poem_writer(t: TraceContext, topic = "turbulence"):
+    span: SpanContext = t.span(name="poem_writer", input=None)
+
+    prompt = f"write a poem about {topic}"
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": prompt},
+    ]
+    # create a child span within the current `poem_writer` span.
+    llm_span = span.span(name="OpenAI completion", input=messages, span_type="LLM")
+    
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello. What is the capital of France?"},
+        ],
+    )
+    poem = response.choices[0].message.content
+    if topic in poem:
+        llm_span.event("topic_alignment")  # send an event with a pre-defined name
+
+    # note that you can register possible events here as well, not only `llm_span.check_span_event()`
+    llm_span.end(output=poem, check_event_names=["excessive_wordiness"])
+    span.end(output=poem)
+    return poem
+
+
+t: TraceContext = trace(user_id="user", session_id="session", release="release")
+main(t, topic="laminar flow")
+t.end(success=True)
+```
+
+## Features
+
+- Make Laminar endpoint calls from your Python code
+- Make Laminar endpoint calls that can run your own functions as tools
+- CLI to generate code from pipelines you build on Laminar or execute your own functions while you test your flows in workshop
+
+## Making Laminar pipeline calls
+
+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 target is set, you can call it from Python in just a few lines.
+
+Example use:
+
+```python
+from lmnr import Laminar 
+
+# for decorator instrumentation, do: `from lmnr inport lmnr_context`
+
+l = Laminar('<YOUR_PROJECT_API_KEY>')
+result = l.run(  # lmnr_context.run( for decorator instrumentation
+    pipeline = 'my_pipeline_name',
+    inputs = {'input_node_name': 'some_value'},
+    # all environment variables
+    env = {'OPENAI_API_KEY': 'sk-some-key'},
+    # any metadata to attach to this run's trace
+    metadata = {'session_id': 'your_custom_session_id'}
+)
+```
+
+Resulting in:
+
+```python
+>>> result
+PipelineRunResponse(
+    outputs={'output': {'value': [ChatMessage(role='user', content='hello')]}},
+    # useful to locate your trace
+    run_id='53b012d5-5759-48a6-a9c5-0011610e3669'
+)
+```
+
+## PROJECT_API_KEY
+
+Read more [here](https://docs.lmnr.ai/api-reference/introduction#authentication) on how to get `PROJECT_API_KEY`.
+

lmnr-0.3.0b1.dist-info/RECORD

@@ -0,0 +1,21 @@
+lmnr/__init__.py,sha256=U3sQyxCHM9ojzfo05XYxM0T_Bh1StZFSp5K82NjATxc,242
+lmnr/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lmnr/sdk/client.py,sha256=6mp4sQF1IEESPYe6ABFgchMBQBKr2AT7eqP-mIC5cEA,5482
+lmnr/sdk/collector.py,sha256=6LRmPhOcmGplUDWm_sJh0dVrLTHknd_kmq7POGuAvoQ,5338
+lmnr/sdk/constants.py,sha256=USCfwuUqRx6_0xC8WUxqGj766dInqQkWJcf8U5vPK7s,34
+lmnr/sdk/context.py,sha256=jfu2HGyZEJYSDf-LQAmmK8MKFnNhYfR66k_baQWx99s,15271
+lmnr/sdk/decorators.py,sha256=B2wdhs45-ZM0niotZBOx5FSSCu_vGQ32pntG9o3fKKU,11860
+lmnr/sdk/interface.py,sha256=BucPNopp_Xvb1Tvn6We4ETvqqQiWtwjbCksAtt4qmvU,13717
+lmnr/sdk/providers/__init__.py,sha256=wNCgQnt9-bnTNXLQWdPgyKhqA1ajiaEd1Rr2KPOpazM,54
+lmnr/sdk/providers/base.py,sha256=xc6iA8yY_VK6tbzswt-3naZ53aAXtOLur9j8eimC_ZA,1054
+lmnr/sdk/providers/fallback.py,sha256=DXnxBX1vxusGSUC76d0AjouR4NSoajQMdMeG37TRf4k,4741
+lmnr/sdk/providers/openai.py,sha256=EygnBniKlcic6eIOfS5zORpytLqUYZxnDRB5Z4MnXZY,5193
+lmnr/sdk/providers/utils.py,sha256=ROt82VrvezExYOxionAynD3dp6oX5JoPW6F1ayTm7q8,946
+lmnr/sdk/tracing_types.py,sha256=RvVb8yCLjCu9DT59OX_tvUxaOTCtE6fcsDH4nMddzHA,6399
+lmnr/sdk/types.py,sha256=hVxOsa3oCQQ-8aS_WkOtErg4nHJRkBVySfYlTgDlDyk,2084
+lmnr/sdk/utils.py,sha256=1yhXtdGmVXfnc8SOQiTH_zAZGbZrzO8oaFd7q5nE7eY,3349
+lmnr-0.3.0b1.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.3.0b1.dist-info/METADATA,sha256=U5UBpCkOSbDzsoQw4b4GkJxGKgMlxv8qoVRLzAVupiw,6700
+lmnr-0.3.0b1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lmnr-0.3.0b1.dist-info/entry_points.txt,sha256=Qg7ZRax4k-rcQsZ26XRYQ8YFSBiyY2PNxYfq4a6PYXI,41
+lmnr-0.3.0b1.dist-info/RECORD,,

lmnr/cli/__main__.py

@@ -1,4 +0,0 @@
-from .cli import cli
-
-if __name__ == "__main__":
-    cli()

lmnr/cli/cli.py

@@ -1,230 +0,0 @@
-from pathlib import Path
-import sys
-import requests
-from dotenv import find_dotenv, get_key
-import importlib
-import os
-import click
-import logging
-from cookiecutter.main import cookiecutter
-from pydantic.alias_generators import to_pascal
-
-from lmnr.cli.zip import zip_directory
-from lmnr.sdk.registry import Registry as Pipeline
-from lmnr.sdk.remote_debugger import RemoteDebugger
-from lmnr.types import NodeFunction
-
-from .parser.parser import runnable_graph_to_template_vars
-
-from watchdog.observers import Observer
-from watchdog.events import PatternMatchingEventHandler
-import time
-
-logger = logging.getLogger(__name__)
-
-
-@click.group()
-@click.version_option()
-def cli():
-    "CLI for Laminar AI Engine"
-
-
-@cli.command(name="pull")
-@click.argument("pipeline_name")
-@click.argument("pipeline_version_name")
-@click.option(
-    "-p",
-    "--project-api-key",
-    help="Project API key",
-)
-@click.option(
-    "-l",
-    "--loglevel",
-    help="Sets logging level",
-)
-def pull(pipeline_name, pipeline_version_name, project_api_key, loglevel):
-    loglevel_str_to_val = {
-        "DEBUG": logging.DEBUG,
-        "INFO": logging.INFO,
-        "WARNING": logging.WARNING,
-        "ERROR": logging.ERROR,
-        "CRITICAL": logging.CRITICAL,
-    }
-    logging.basicConfig()
-    logging.getLogger().setLevel(loglevel_str_to_val.get(loglevel, logging.WARNING))
-
-    project_api_key = project_api_key or os.environ.get("LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        load_dotenv()
-        project_api_key = os.environ.get("LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        raise ValueError("LMNR_PROJECT_API_KEY is not set")
-
-    headers = {"Authorization": f"Bearer {project_api_key}"}
-    params = {
-        "pipelineName": pipeline_name,
-        "pipelineVersionName": pipeline_version_name,
-    }
-    res = requests.get(
-        "https://api.lmnr.ai/v2/pipeline-version-by-name",
-        headers=headers,
-        params=params,
-    )
-    if res.status_code != 200:
-        try:
-            res_json = res.json()
-        except Exception:
-            raise ValueError(
-                f"Error in fetching pipeline version: {res.status_code}\n{res.text}"
-            )
-        raise ValueError(
-            f"Error in fetching pipeline version: {res.status_code}\n{res_json}"
-        )
-
-    pipeline_version = res.json()
-
-    class_name = to_pascal(pipeline_name.replace(" ", "_").replace("-", "_"))
-
-    context = {
-        "pipeline_name": pipeline_name,
-        "pipeline_version_name": pipeline_version_name,
-        "class_name": class_name,
-        # _tasks starts from underscore because we don't want it to be templated
-        # some tasks contains LLM nodes which have prompts
-        # which we don't want to be rendered by cookiecutter
-        "_tasks": runnable_graph_to_template_vars(pipeline_version["runnableGraph"]),
-    }
-
-    logger.info(f"Context:\n{context}")
-    cookiecutter(
-        "https://github.com/lmnr-ai/lmnr-python-engine.git",
-        output_dir=".",
-        config_file=None,
-        extra_context=context,
-        no_input=True,
-        overwrite_if_exists=True,
-    )
-
-
-@cli.command(name="deploy")
-@click.argument("endpoint_id")
-@click.option(
-    "-p",
-    "--project-api-key",
-    help="Project API key",
-)
-def deploy(endpoint_id, project_api_key):
-    project_api_key = project_api_key or os.environ.get("LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        load_dotenv()
-        project_api_key = os.environ.get("LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        raise ValueError("LMNR_PROJECT_API_KEY is not set")
-
-    current_directory = Path.cwd()
-    zip_file_path = current_directory / "archive.zip"
-
-    zip_directory(current_directory, zip_file_path)
-
-    try:
-        url = f"https://api.lmnr.ai/v2/endpoints/{endpoint_id}/deploy-code"
-        with open(zip_file_path, "rb") as f:
-            headers = {
-                "Authorization": f"Bearer {project_api_key}",
-            }
-            files = {"file": f}
-            response = requests.post(url, headers=headers, files=files)
-
-            if response.status_code != 200:
-                raise ValueError(
-                    f"Error in deploying code: {response.status_code}\n{response.text}"
-                )
-    except Exception:
-        logging.exception("Error in deploying code")
-    finally:
-        Path.unlink(zip_file_path, missing_ok=True)
-
-
-def _load_functions(cur_dir: str) -> dict[str, NodeFunction]:
-    parent_dir, name = os.path.split(cur_dir)  # e.g. /Users/username, project_name
-
-    # Needed to __import__ pipeline.py
-    if sys.path[0] != parent_dir:
-        sys.path.insert(0, parent_dir)
-    # Needed to import src in pipeline.py and other files
-    if cur_dir not in sys.path:
-        sys.path.insert(0, cur_dir)
-
-    module_name = f"{name}.pipeline"
-    if module_name in sys.modules:
-        # Reload the module to get the updated version
-        importlib.reload(sys.modules[module_name])
-    else:
-        # Import the module for the first time
-        __import__(module_name)
-    
-    module = sys.modules[module_name]
-
-    matches = [v for v in module.__dict__.values() if isinstance(v, Pipeline)]
-    if not matches:
-        raise ValueError("No Pipeline found in the module")
-    if len(matches) > 1:
-        raise ValueError("Multiple Pipelines found in the module")
-    pipeline = matches[0]
-
-    return pipeline.functions
-
-class SimpleEventHandler(PatternMatchingEventHandler):
-    def __init__(self, project_api_key: str, session_id: str, functions: dict[str, NodeFunction]):
-        super().__init__(ignore_patterns=["*.pyc*", "*.pyo", "**/__pycache__"])
-        self.project_api_key = project_api_key
-        self.session_id = session_id
-        self.functions = functions
-        self.debugger = RemoteDebugger(project_api_key, session_id, functions)
-        self.debugger.start()
-
-    def on_any_event(self, event):
-        print(f"Files at {event.src_path} updated. Restarting debugger...")
-        self.debugger.stop()
-        self.functions = _load_functions(os.getcwd())
-        self.debugger = RemoteDebugger(self.project_api_key, self.session_id, self.functions)
-        self.debugger.start()
-
-@cli.command(name="dev")
-@click.option(
-    "-p",
-    "--project-api-key",
-    help="Project API key. If not provided, LMNR_PROJECT_API_KEY from os.environ or .env is used",
-)
-@click.option(
-    "-s",
-    "--dev-session-id",
-    help="Dev session ID. If not provided, LMNR_DEV_SESSION_ID from os.environ or .env is used",
-)
-def dev(project_api_key, dev_session_id):
-    cur_dir = os.getcwd()  # e.g. /Users/username/project_name
-    env_path = find_dotenv(usecwd=True)
-    project_api_key = project_api_key or os.environ.get("LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        project_api_key = get_key(env_path, "LMNR_PROJECT_API_KEY")
-    if not project_api_key:
-        raise ValueError("LMNR_PROJECT_API_KEY is not set")
-    
-    session_id = dev_session_id or os.environ.get("LMNR_DEV_SESSION_ID")
-    if not session_id:
-        session_id = get_key(env_path, "LMNR_DEV_SESSION_ID")
-    if not session_id:
-        raise ValueError("LMNR_DEV_SESSION_ID is not set")
-    functions = _load_functions(cur_dir)
-    
-    observer = Observer()
-    handler = SimpleEventHandler(project_api_key, session_id, functions)
-    observer.schedule(handler, cur_dir, recursive=True)
-    observer.start()
-    try:
-        while True:
-            time.sleep(1)
-    except KeyboardInterrupt:
-        handler.debugger.stop()
-        observer.stop()
-    observer.join()

lmnr/cli/parser/nodes/__init__.py

@@ -1,45 +0,0 @@
-from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass
-from typing import Optional
-import uuid
-
-
-@dataclass
-class Handle:
-    id: uuid.UUID
-    name: Optional[str]
-
-    @classmethod
-    def from_dict(cls, dict: dict) -> "Handle":
-        return cls(
-            id=uuid.UUID(dict["id"]),
-            name=(dict["name"] if "name" in dict else None),
-        )
-
-
-@abstractmethod
-class NodeFunctions(metaclass=ABCMeta):
-    @abstractmethod
-    def handles_mapping(
-        self, output_handle_id_to_node_name: dict[str, str]
-    ) -> list[tuple[str, str]]:
-        """
-        Returns a list of tuples mapping from this node's input
-        handle name to the unique name of the previous node.
-
-        Assumes previous node has only one output.
-        """
-        pass
-
-    @abstractmethod
-    def node_type(self) -> str:
-        pass
-
-    @abstractmethod
-    def config(self) -> dict:
-        """
-        Returns a dictionary of node-specific configuration.
-
-        E.g. prompt and model name for LLM node.
-        """
-        pass

lmnr/cli/parser/nodes/code.py

@@ -1,36 +0,0 @@
-from dataclasses import dataclass
-import uuid
-
-from lmnr.cli.parser.nodes import Handle, NodeFunctions
-from lmnr.cli.parser.utils import map_handles
-
-
-@dataclass
-class CodeNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    inputs: list[Handle]
-    outputs: list[Handle]
-    inputs_mappings: dict[uuid.UUID, uuid.UUID]
-    code: str
-    fn_name: str
-
-    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 "Code"
-
-    def config(self) -> dict:
-        return {
-            "code": self.code,
-            "fn_name": self.fn_name,
-            "fn_inputs": ", ".join(
-                f"{handle.name}=input_to_code_node_arg({handle.name})"
-                for handle in self.inputs
-            ),
-        }

lmnr/cli/parser/nodes/condition.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-import uuid
-
-from lmnr.cli.parser.nodes import Handle, NodeFunctions
-from lmnr.cli.parser.utils import map_handles
-
-
-@dataclass
-class ConditionNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    inputs: list[Handle]
-    outputs: list[Handle]
-    inputs_mappings: dict[uuid.UUID, uuid.UUID]
-    condition: str
-
-    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 "Condition"
-
-    def config(self) -> dict:
-        return {
-            "condition": self.condition,
-        }

lmnr/cli/parser/nodes/input.py

@@ -1,25 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-import uuid
-
-from lmnr.cli.parser.nodes import Handle, NodeFunctions
-from lmnr.types import NodeInput
-
-
-@dataclass
-class InputNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    outputs: list[Handle]
-    input: Optional[NodeInput]
-
-    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/cli/parser/nodes/json_extractor.py

@@ -1,29 +0,0 @@
-from dataclasses import dataclass
-
-import uuid
-
-from lmnr.cli.parser.nodes import Handle, NodeFunctions
-from lmnr.cli.parser.utils import map_handles
-
-
-@dataclass
-class JsonExtractorNode(NodeFunctions):
-    id: uuid.UUID
-    name: str
-    inputs: list[Handle]
-    outputs: list[Handle]
-    inputs_mappings: dict[uuid.UUID, uuid.UUID]
-    template: str
-
-    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 "JsonExtractor"
-
-    def config(self) -> dict:
-        return {"template": self.template}

lmnr/cli/parser/nodes/llm.py

@@ -1,56 +0,0 @@
-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,
-            "enable_structured_output": self.structured_output_enabled
-            and self.structured_output_schema is not None,
-            "structured_output_max_retries": self.structured_output_max_retries,
-            "structured_output_schema": self.structured_output_schema,
-            "structured_output_schema_target_str": (
-                "None"
-                if self.structured_output_schema_target is None
-                else f'"{self.structured_output_schema_target}"'
-            ),
-        }