langwatch 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

langwatch/__version__.py

@@ -1,3 +1,3 @@
 """Version information for LangWatch."""
 
-__version__ = "0.10.0" # x-release-please-version
+__version__ = "0.10.2" # x-release-please-version

langwatch/client.py

@@ -50,6 +50,7 @@ class Client(LangWatchClientProtocol):
     _registered_instrumentors: ClassVar[
         dict[opentelemetry.trace.TracerProvider, set[BaseInstrumentor]]
     ] = {}
+    _prompts_path: ClassVar[Optional[str]] = None
 
     # Regular attributes for protocol compatibility
     base_attributes: BaseAttributes
@@ -69,6 +70,7 @@ class Client(LangWatchClientProtocol):
         span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
         ignore_global_tracer_provider_override_warning: Optional[bool] = None,
         skip_open_telemetry_setup: Optional[bool] = None,
+        prompts_path: Optional[str] = None,
     ) -> "Client":
         """Ensure only one instance of Client exists (singleton pattern)."""
         if cls._instance is None:
@@ -88,6 +90,7 @@ class Client(LangWatchClientProtocol):
         span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
         ignore_global_tracer_provider_override_warning: Optional[bool] = None,
         skip_open_telemetry_setup: Optional[bool] = None,
+        prompts_path: Optional[str] = None,
     ):
         """
         Initialize the LangWatch tracing client.
@@ -140,6 +143,8 @@ class Client(LangWatchClientProtocol):
                 )
             if skip_open_telemetry_setup is not None:
                 Client._skip_open_telemetry_setup = skip_open_telemetry_setup
+            if prompts_path is not None:
+                Client._prompts_path = prompts_path
             if base_attributes is not None:
                 Client._base_attributes = base_attributes
                 # Ensure required SDK attributes remain present after reconfiguration
@@ -215,6 +220,9 @@ class Client(LangWatchClientProtocol):
         if skip_open_telemetry_setup is not None:
             Client._skip_open_telemetry_setup = skip_open_telemetry_setup
 
+        if prompts_path is not None:
+            Client._prompts_path = prompts_path
+
         if base_attributes is not None:
             Client._base_attributes = base_attributes
         elif not Client._base_attributes:
@@ -284,6 +292,7 @@ class Client(LangWatchClientProtocol):
         span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
         ignore_global_tracer_provider_override_warning: Optional[bool] = None,
         skip_open_telemetry_setup: Optional[bool] = None,
+        prompts_path: Optional[str] = None,
     ) -> "Client":
         """Create or get the singleton instance of the LangWatch client. Internal use only."""
         if cls._instance is None:
@@ -299,6 +308,7 @@ class Client(LangWatchClientProtocol):
                 span_exclude_rules=span_exclude_rules,
                 ignore_global_tracer_provider_override_warning=ignore_global_tracer_provider_override_warning,
                 skip_open_telemetry_setup=skip_open_telemetry_setup,
+                prompts_path=prompts_path,
             )
         return cls._instance
 
@@ -327,6 +337,7 @@ class Client(LangWatchClientProtocol):
         cls._skip_open_telemetry_setup = False
         cls._tracer_provider = None
         cls._rest_api_client = None
+        cls._prompts_path = None
         cls._registered_instrumentors.clear()
 
     @classmethod
@@ -416,6 +427,11 @@ class Client(LangWatchClientProtocol):
         """Get whether OpenTelemetry setup is skipped."""
         return Client._skip_open_telemetry_setup
 
+    @property
+    def prompts_path(self) -> Optional[str]:
+        """Get the base path for local prompt files."""
+        return Client._prompts_path
+
     @disable_sending.setter
     def disable_sending(self, value: bool) -> None:
         """Set whether sending is disabled. Spans are still created; the exporter conditionally drops them."""

langwatch/domain/__init__.py

@@ -43,6 +43,7 @@ class ChatMessage(TypedDict, total=False):
     tool_calls: Optional[List[ToolCall]]
     tool_call_id: Optional[str]
     name: Optional[str]
+    reasoning_content: Optional[str]
 
 
 class TypedValueChatMessages(TypedDict):
@@ -156,6 +157,7 @@ SpanTypes = Literal[
 class SpanMetrics(TypedDict, total=False):
     prompt_tokens: Optional[int]
     completion_tokens: Optional[int]
+    reasoning_tokens: Optional[int]
     cost: Optional[float]
     first_token_ms: Optional[int]
 
@@ -179,6 +181,7 @@ class SpanParams(TypedDict, total=False):
     functions: Optional[List[Dict[str, Any]]]
     user: Optional[str]
     response_format: Optional[Union[Dict[str, Any], BaseModel]]
+    reasoning_effort: Optional[str]
 
 
 class BaseSpan(TypedDict):

langwatch/dspy/__init__.py

@@ -6,7 +6,8 @@ import warnings
 import dspy
 from typing import Callable, List, Optional, Any, Type, Union
 from langwatch.utils.exceptions import better_raise_for_status
-from langwatch.utils.transformation import truncate_object_recursively
+from langwatch.utils.transformation import SerializableWithStringFallback, truncate_object_recursively
+from langwatch.utils.utils import safe_get
 from langwatch.telemetry.tracing import LangWatchTrace
 from typing_extensions import TypedDict
 import langwatch
@@ -824,6 +825,7 @@ class DSPyTracer:
                 "functions",
                 "user",
                 "response_format",
+                "reasoning_effort",
             ]
             for param in params:
                 if all_kwargs.get(param):
@@ -842,23 +844,44 @@ class DSPyTracer:
 
             result = self.__class__.__original_call__(self, prompt, messages, **kwargs)  # type: ignore
 
+            history = self.history[-1] if len(self.history) > 0 else None
+
             if span:
-                span.update(output=result)
+                # Capture full message from history (includes reasoning_content) instead of just result
+                choices = safe_get(history, "response", "choices")
+
+                if choices and len(choices) > 0:
+                    messages_output = []
+                    for choice in choices:
+                        msg = safe_get(choice, "message")
+                        if msg is not None:
+                            # Convert Pydantic model to dict if needed
+                            if hasattr(msg, "model_dump"):
+                                msg = msg.model_dump(exclude_unset=True)
+                            elif hasattr(msg, "dict"):
+                                msg = msg.dict(exclude_unset=True)
+                            messages_output.append(msg)
+                    if messages_output:
+                        span.update(output=messages_output)
+                    else:
+                        span.update(output=result)
+                else:
+                    span.update(output=result)
 
-            history = self.history[-1] if len(self.history) > 0 else None
-            if (
-                history
-                and "usage" in history
-                and "completion_tokens" in history["usage"]
-                and "prompt_tokens" in history["usage"]
-                and span
-            ):
-                span.update(
-                    metrics={
-                        "completion_tokens": history["usage"]["completion_tokens"],
-                        "prompt_tokens": history["usage"]["prompt_tokens"],
-                    }
+            completion_tokens = safe_get(history, "usage", "completion_tokens")
+            prompt_tokens = safe_get(history, "usage", "prompt_tokens")
+            if span and completion_tokens is not None and prompt_tokens is not None:
+                metrics = {
+                    "completion_tokens": completion_tokens,
+                    "prompt_tokens": prompt_tokens,
+                }
+                # Capture reasoning_tokens if available
+                reasoning_tokens = safe_get(
+                    history, "usage", "completion_tokens_details", "reasoning_tokens"
                 )
+                if reasoning_tokens is not None:
+                    metrics["reasoning_tokens"] = reasoning_tokens
+                span.update(metrics=metrics)
 
             return result
 
@@ -884,26 +907,36 @@ class DSPyTracer:
 
             result = self.__class__.__original_basic_request__(self, prompt, **kwargs)  # type: ignore
 
-            if (
-                span
-                and "choices" in result
-                and len(result["choices"]) == 1
-                and "message" in result["choices"][0]
-            ):
-                span.update(output=[result["choices"][0]["message"]])
-
-            if (
-                span
-                and "usage" in result
-                and "completion_tokens" in result["usage"]
-                and "prompt_tokens" in result["usage"]
-            ):
-                span.update(
-                    metrics={
-                        "completion_tokens": result["usage"]["completion_tokens"],
-                        "prompt_tokens": result["usage"]["prompt_tokens"],
-                    }
+            # Capture full messages from choices (includes reasoning_content)
+            choices = safe_get(result, "choices")
+            if span and choices and len(choices) > 0:
+                messages_output = []
+                for choice in choices:
+                    msg = safe_get(choice, "message")
+                    if msg is not None:
+                        # Convert Pydantic model to dict if needed
+                        if hasattr(msg, "model_dump"):
+                            msg = msg.model_dump(exclude_unset=True)
+                        elif hasattr(msg, "dict"):
+                            msg = msg.dict(exclude_unset=True)
+                        messages_output.append(msg)
+                if messages_output:
+                    span.update(output=messages_output)
+
+            completion_tokens = safe_get(result, "usage", "completion_tokens")
+            prompt_tokens = safe_get(result, "usage", "prompt_tokens")
+            if span and completion_tokens is not None and prompt_tokens is not None:
+                metrics = {
+                    "completion_tokens": completion_tokens,
+                    "prompt_tokens": prompt_tokens,
+                }
+                # Capture reasoning_tokens if available
+                reasoning_tokens = safe_get(
+                    result, "usage", "completion_tokens_details", "reasoning_tokens"
                 )
+                if reasoning_tokens is not None:
+                    metrics["reasoning_tokens"] = reasoning_tokens
+                span.update(metrics=metrics)
 
             return result
 

langwatch/experiment/experiment.py

@@ -302,6 +302,10 @@ class Experiment:
         iter_ctx = IterationContext(index=index, item=item)
         iter_token = _iteration_context.set(iter_ctx)
 
+        # Reset target context at the start of each iteration to prevent pollution
+        # from previous iterations (especially important for implicit Output targets)
+        _target_context.set(None)
+
         # Determine if we should create an iteration trace:
         # - Don't create if evaluation uses targets (each target creates its own trace)
         # - Don't create if we're collecting submit() calls (not in_thread yet)
@@ -340,6 +344,8 @@ class Experiment:
         finally:
             # Reset iteration context
             _iteration_context.reset(iter_token)
+            # Reset target context to prevent pollution to next iteration
+            _target_context.set(None)
 
         # Handle iteration trace cleanup
         # Note: If target() was used, it may have already closed the trace
@@ -715,9 +721,10 @@ class Experiment:
         """
         Log the model's response/output for the current target.
 
-        Must be called inside a `target()` context. The response will be stored
-        in the dataset entry's `predicted` field, which is displayed in the
-        results table.
+        Can be called inside a `target()` context, or outside of one. When called
+        outside a target context, an implicit "Output" target is created automatically.
+        The response will be stored in the dataset entry's `predicted` field, which
+        is displayed in the results table.
 
         Args:
             response: The model's output. Can be a string (will be wrapped as
@@ -725,30 +732,131 @@ class Experiment:
 
         Example:
             ```python
+            # With explicit target
             with evaluation.target("gpt-4", {"model": "openai/gpt-4"}):
                 response = call_gpt4(row["question"])
                 evaluation.log_response(response)  # Store the output
                 evaluation.log("quality", index=index, score=0.95)  # Log metrics
-            ```
 
-        Raises:
-            RuntimeError: If called outside of a target() context.
+            # Without explicit target (creates implicit "Output" target)
+            for index, row in evaluation.loop(df.iterrows()):
+                response = my_model(row["question"])
+                evaluation.log_response(response)  # Creates "Output" target
+                evaluation.log("quality", index=index, score=0.95)
+            ```
         """
         ctx = _target_context.get()
-        if ctx is None:
-            raise RuntimeError(
-                "log_response() must be called inside a target() context. "
-                "Example: with evaluation.target('my-target'): evaluation.log_response(response)"
-            )
 
         # Normalize response to dict format
         if isinstance(response, str):
-            ctx.predicted = {"output": response}
+            predicted = {"output": response}
         elif isinstance(response, dict):
-            ctx.predicted = response
+            predicted = response
         else:
             # Try to convert to string for other types
-            ctx.predicted = {"output": str(response)}
+            predicted = {"output": str(response)}
+
+        if ctx is None:
+            # Create implicit "Output" target and dataset entry immediately
+            self._create_implicit_output_target(predicted)
+        else:
+            # Inside explicit target context - just set predicted
+            ctx.predicted = predicted
+
+    def _create_implicit_output_target(self, predicted: Dict[str, Any]) -> None:
+        """
+        Create an implicit "Output" target when log_response() is called outside
+        a target() context. This enables a simpler API for single-target evaluations.
+
+        Creates the dataset entry immediately with the predicted response.
+        """
+        target_name = "Output"
+
+        # Mark that targets are being used
+        if not self._evaluation_uses_targets:
+            self._evaluation_uses_targets = True
+            # Close the active iteration trace if any
+            if self._active_iteration_trace is not None:
+                self._active_iteration_trace.__exit__(None, None, None)
+                self._active_iteration_trace = None
+
+        self._current_iteration_used_with_target = True
+
+        # Register the target
+        self._register_target(target_name, None)
+
+        # Get index and item from iteration context
+        iter_ctx = _iteration_context.get()
+        if iter_ctx is not None:
+            index = iter_ctx.index
+            current_item = iter_ctx.item
+        else:
+            index = self._current_index
+            current_item = self._current_item
+
+        # Create a trace for this implicit target
+        tracer = trace.get_tracer("langwatch-evaluation")
+        root_context = otel_context.Context()
+
+        # Start span and get trace_id
+        with tracer.start_span(
+            f"evaluation.target.{target_name}",
+            context=root_context,
+            attributes={
+                "evaluation.run_id": self.run_id,
+                "evaluation.index": index,
+                "evaluation.target": target_name,
+            },
+        ) as span:
+            span_context = span.get_span_context()
+            trace_id = format(span_context.trace_id, "032x")
+
+        # Create and set target context (for subsequent log() calls)
+        ctx = TargetContext(
+            target_id=target_name,
+            index=index,
+            trace_id=trace_id,
+            predicted=predicted,
+        )
+        _target_context.set(ctx)
+
+        # Create dataset entry immediately
+        entry_data: Any = (
+            current_item.to_dict()
+            if hasattr(current_item, "to_dict")
+            else (
+                current_item.__dict__
+                if hasattr(current_item, "__dict__")
+                else (
+                    current_item[1].to_dict()
+                    if type(current_item) == tuple
+                    and hasattr(current_item[1], "to_dict")
+                    else (
+                        current_item[1].__dict__
+                        if type(current_item) == tuple
+                        and hasattr(current_item[1], "__dict__")
+                        else {
+                            "entry": json.dumps(
+                                current_item, cls=SerializableWithStringFallback
+                            )
+                        }
+                    )
+                )
+            )
+        )
+
+        batch_entry = BatchEntry(
+            index=index,
+            entry=entry_data,
+            duration=0,  # Duration not tracked for implicit targets
+            error=None,
+            trace_id=trace_id,
+            target_id=target_name,
+            predicted=predicted,
+        )
+
+        with self.lock:
+            self.batch["dataset"].append(batch_entry)
 
     def log(
         self,

langwatch/litellm.py

@@ -246,6 +246,9 @@ class LiteLLMPatch:
                 SpanMetrics(
                     prompt_tokens=safe_get(usage, "prompt_tokens"),
                     completion_tokens=safe_get(usage, "completion_tokens"),
+                    reasoning_tokens=safe_get(
+                        usage, "completion_tokens_details", "reasoning_tokens"
+                    ),
                 )
                 if usage
                 else SpanMetrics()
@@ -281,6 +284,9 @@ class LiteLLMPatch:
             metrics=SpanMetrics(
                 prompt_tokens=safe_get(response, "usage", "prompt_tokens"),
                 completion_tokens=safe_get(response, "usage", "completion_tokens"),
+                reasoning_tokens=safe_get(
+                    response, "usage", "completion_tokens_details", "reasoning_tokens"
+                ),
             ),
             timestamps=timestamps,
             **kwargs,
@@ -338,6 +344,7 @@ class LiteLLMPatch:
             "functions",
             "user",
             "response_format",
+            "reasoning_effort",
         ]
         for param in params:
             if kwargs.get(param):

langwatch/openai.py

@@ -296,6 +296,9 @@ class OpenAICompletionTracer:
             metrics=SpanMetrics(
                 prompt_tokens=safe_get(response, "usage", "prompt_tokens"),
                 completion_tokens=safe_get(response, "usage", "completion_tokens"),
+                reasoning_tokens=safe_get(
+                    response, "usage", "completion_tokens_details", "reasoning_tokens"
+                ),
             ),
             timestamps=timestamps,
             **kwargs,
@@ -336,22 +339,31 @@ class OpenAICompletionTracer:
             if len(outputs) == 0
             else outputs[0] if len(outputs) == 1 else {"type": "list", "value": outputs}
         )
-        params = SpanParams(
-            temperature=kwargs.get("temperature", 1.0),
-            stream=kwargs.get("stream", False),
-        )
-        functions = kwargs.get("functions", None)
-        if functions:
-            params["functions"] = functions
-        tools = kwargs.get("tools", None)
-        if tools:
-            params["tools"] = tools
-        tool_choice = kwargs.get("tool_choice", None)
-        if tool_choice:
-            params["tool_choice"] = tool_choice
-        response_format = kwargs.get("response_format", None)
-        if response_format:
-            params["response_format"] = response_format
+        span_params = SpanParams()
+        param_names = [
+            "frequency_penalty",
+            "logit_bias",
+            "logprobs",
+            "top_logprobs",
+            "max_tokens",
+            "n",
+            "presence_penalty",
+            "seed",
+            "stop",
+            "stream",
+            "temperature",
+            "top_p",
+            "tools",
+            "tool_choice",
+            "parallel_tool_calls",
+            "functions",
+            "user",
+            "response_format",
+            "reasoning_effort",
+        ]
+        for param in param_names:
+            if kwargs.get(param) is not None:
+                span_params[param] = kwargs.get(param)
 
         vendor = (
             "azure"
@@ -367,7 +379,7 @@ class OpenAICompletionTracer:
             ),
             output=output,
             error=error,
-            params=params,
+            params=span_params,
             metrics=metrics,
             timestamps=timestamps,
         )
@@ -611,6 +623,9 @@ class OpenAIChatCompletionTracer:
                 SpanMetrics(
                     prompt_tokens=usage.prompt_tokens if usage else None,
                     completion_tokens=usage.completion_tokens if usage else None,
+                    reasoning_tokens=safe_get(
+                        usage, "completion_tokens_details", "reasoning_tokens"
+                    ),
                 )
                 if usage
                 else SpanMetrics()
@@ -643,6 +658,9 @@ class OpenAIChatCompletionTracer:
             metrics=SpanMetrics(
                 prompt_tokens=safe_get(response, "usage", "prompt_tokens"),
                 completion_tokens=safe_get(response, "usage", "completion_tokens"),
+                reasoning_tokens=safe_get(
+                    response, "usage", "completion_tokens_details", "reasoning_tokens"
+                ),
             ),
             timestamps=timestamps,
             **kwargs,
@@ -683,22 +701,31 @@ class OpenAIChatCompletionTracer:
             if len(outputs) == 0
             else outputs[0] if len(outputs) == 1 else {"type": "list", "value": outputs}
         )
-        params = SpanParams(
-            temperature=kwargs.get("temperature", 1.0),
-            stream=kwargs.get("stream", False),
-        )
-        functions = kwargs.get("functions", None)
-        if functions:
-            params["functions"] = functions
-        tools = kwargs.get("tools", None)
-        if tools:
-            params["tools"] = tools
-        tool_choice = kwargs.get("tool_choice", None)
-        if tool_choice:
-            params["tool_choice"] = tool_choice
-        response_format = kwargs.get("response_format", None)
-        if response_format:
-            params["response_format"] = response_format
+        span_params = SpanParams()
+        param_names = [
+            "frequency_penalty",
+            "logit_bias",
+            "logprobs",
+            "top_logprobs",
+            "max_tokens",
+            "n",
+            "presence_penalty",
+            "seed",
+            "stop",
+            "stream",
+            "temperature",
+            "top_p",
+            "tools",
+            "tool_choice",
+            "parallel_tool_calls",
+            "functions",
+            "user",
+            "response_format",
+            "reasoning_effort",
+        ]
+        for param in param_names:
+            if kwargs.get(param) is not None:
+                span_params[param] = kwargs.get(param)
 
         vendor = (
             "azure"
@@ -714,7 +741,7 @@ class OpenAIChatCompletionTracer:
             ),
             output=output,
             error=error,
-            params=params,
+            params=span_params,
             metrics=metrics,
             timestamps=timestamps,
         )

langwatch/prompts/local_loader.py

@@ -24,6 +24,8 @@ logger = logging.getLogger(__name__)
 class LocalPromptLoader:
     """Loads prompts from local files in CLI format."""
 
+    _warned_no_prompts_path: bool = False
+
     def __init__(self, base_path: Optional[Path] = None):
         """Initialize with base path (defaults to current working directory at load time)."""
         self._base_path = base_path
@@ -43,6 +45,16 @@ class LocalPromptLoader:
             # Check if prompts.json exists
             prompts_json_path = self.base_path / "prompts.json"
             if not prompts_json_path.exists():
+                # Warn once if no prompts_path was configured and prompts.json doesn't exist
+                if self._base_path is None and not LocalPromptLoader._warned_no_prompts_path:
+                    LocalPromptLoader._warned_no_prompts_path = True
+                    warnings.warn(
+                        f"No prompts.json found at {prompts_json_path}. "
+                        f"If you have local prompt files, configure the path with "
+                        f"langwatch.setup(prompts_path='/path/to/prompts') or ensure "
+                        f"prompts.json is in the current working directory.",
+                        UserWarning,
+                    )
                 logger.debug(
                     f"No prompts.json found at {prompts_json_path}, falling back to API"
                 )

langwatch/prompts/prompt_facade.py

@@ -8,6 +8,7 @@ or when API is unavailable.
 
 Follows the facade pattern to coordinate between LocalPromptLoader and PromptApiService.
 """
+from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional
 import time
 from langwatch.generated.langwatch_rest_api_client.client import (
@@ -35,10 +36,16 @@ class PromptsFacade:
     work even when offline or when API is unavailable.
     """
 
-    def __init__(self, rest_api_client: LangWatchRestApiClient):
+    def __init__(
+        self,
+        rest_api_client: LangWatchRestApiClient,
+        prompts_path: Optional[str] = None,
+    ):
         """Initialize the prompt service facade with dependencies."""
         self._api_service = PromptApiService(rest_api_client)
-        self._local_loader = LocalPromptLoader()
+        self._local_loader = LocalPromptLoader(
+            base_path=Path(prompts_path) if prompts_path else None
+        )
         self._cache: Dict[str, Dict[str, Any]] = {}
 
     @classmethod
@@ -50,7 +57,7 @@ class PromptsFacade:
             raise RuntimeError(
                 "LangWatch client has not been initialized. Call setup() first."
             )
-        return cls(instance.rest_api_client)
+        return cls(instance.rest_api_client, prompts_path=instance.prompts_path)
 
     def get(
         self,

langwatch/types.py

@@ -89,6 +89,11 @@ class LangWatchClientProtocol(Protocol):
         """Get whether OpenTelemetry setup is skipped."""
         ...
 
+    @property
+    def prompts_path(self) -> Optional[str]:
+        """Get the base path for local prompt files."""
+        ...
+
     # Regular attributes (not properties)
     base_attributes: BaseAttributes
     tracer_provider: Optional[TracerProvider]

langwatch/utils/initialization.py

@@ -3,14 +3,16 @@
 import logging
 import os
 import sys
+from pathlib import Path
 from typing import List, Optional, Sequence
-from opentelemetry.sdk.trace import TracerProvider
+
 from opentelemetry import trace
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.sdk.trace import TracerProvider
 
-from langwatch.state import get_instance, set_instance
 from langwatch.client import Client
 from langwatch.domain import BaseAttributes, SpanProcessingExcludeRule
+from langwatch.state import get_instance, set_instance
 
 logger: logging.Logger = logging.getLogger(__name__)
 
@@ -41,6 +43,7 @@ def setup(
     span_exclude_rules: Optional[List[SpanProcessingExcludeRule]] = None,
     debug: Optional[bool] = None,
     skip_open_telemetry_setup: Optional[bool] = None,
+    prompts_path: Optional[str] = None,
 ) -> Client:
     """
     Initialize the LangWatch client.
@@ -54,6 +57,7 @@ def setup(
         span_exclude_rules: Optional. A list of rules that will be applied to spans processed by the exporter.
         debug: Whether to enable debug logging for the LangWatch client.
         skip_open_telemetry_setup: Whether to skip setting up the OpenTelemetry tracer provider. If this is skipped, instrumentors will be added to the global tracer provider.
+        prompts_path: The base path for local prompt files. If not set, defaults to the current working directory.
     Returns:
         The LangWatch client.
     """
@@ -62,6 +66,11 @@ def setup(
     if debug:
         logger.info("Setting up LangWatch client...")
 
+    if prompts_path is not None:
+        prompts_path = str(
+            Path(prompts_path).resolve()
+        )  # Convert to absolute path asap
+
     # Get existing client to check if we're changing the API key
     existing_client = get_instance()
     changed_api_key = False
@@ -87,6 +96,7 @@ def setup(
         span_exclude_rules=span_exclude_rules,
         ignore_global_tracer_provider_override_warning=changed_api_key,
         skip_open_telemetry_setup=skip_open_telemetry_setup,
+        prompts_path=prompts_path,
     )
 
     if debug:

langwatch/utils/utils.py

@@ -5,9 +5,11 @@ from pydantic import BaseModel
 
 def safe_get(d: Union[Dict[str, Any], BaseModel], *keys: str) -> Optional[Any]:
     for key in keys:
+        if d is None:
+            return None
         if isinstance(d, dict):
             d = d.get(key, None)
-        if hasattr(d, key):
+        elif hasattr(d, key):
             d = getattr(d, key)
         else:
             return None

{langwatch-0.10.0.dist-info → langwatch-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langwatch
-Version: 0.10.0
+Version: 0.10.2
 Summary: LangWatch Python SDK, for monitoring your LLMs
 Author-email: Langwatch Engineers <engineering@langwatch.ai>
 License: MIT

{langwatch-0.10.0.dist-info → langwatch-0.10.2.dist-info}/RECORD

@@ -1,24 +1,24 @@
 langwatch/__init__.py,sha256=VGkLDw3h8hOtzyaTMObWupGTQosn4E17Dk5zcfDmy7g,4462
-langwatch/__version__.py,sha256=o5DKyCSbKMRVAiPvoV2UuvLgN1NaTqfqaz2GumN3K3A,92
+langwatch/__version__.py,sha256=adHQtrIBxR2urwtvyvknbyN66CZvRupt68CR0Ym8N58,92
 langwatch/attributes.py,sha256=nXdI_G85wQQCAdAcwjCiLYdEYj3wATmfgCmhlf6dVIk,3910
 langwatch/batch_evaluation.py,sha256=Y_S3teXpHV07U-vvJYyV1PB6d0CgyFM_rTzPp6GnEBo,16165
-langwatch/client.py,sha256=WTNcYSik7kZ2kH-qGDnhbMTosc8e_Xhab_lZlfh5TC8,25559
+langwatch/client.py,sha256=xwqvTnbAZ-Qr8OnI8-D8cV3J7YPsJ6l0trHbd2PSi6Q,26148
 langwatch/evaluations.py,sha256=-rvlpw8J3-0lMn9tdnte1Z3qHpuE60DGB3gmI8VMexQ,8983
 langwatch/guardrails.py,sha256=4d320HyklXPUVszF34aWsDKGzuvPggcDM_f45_eJTnc,1352
 langwatch/langchain.py,sha256=HjbBBIDwwt688g0W4K0EsZGuGBbo1Mv5LQ-7Mkn56iQ,18726
-langwatch/litellm.py,sha256=mPcw5cLykt0SQf9bTNSoT7elMx4gj-wZ_K2PC14Bw50,11998
+langwatch/litellm.py,sha256=v2fXvsdvqRdSLVwTKNBbiJJy9YJvV9M9OSnugIMvNtg,12328
 langwatch/login.py,sha256=o0DxYVMhMCRHeopyF0qlj_U4o6yD1rL8QjfKvKnHv0s,965
-langwatch/openai.py,sha256=h_NCIwJ0qs57PS-R7gQZsnf2_EBAahlYQMuqS9-Cj3Q,25139
+langwatch/openai.py,sha256=UnfZtskUSvpnZUA-2CHpP3iRjrG3DmDQ1Xftuos6JMk,25724
 langwatch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langwatch/state.py,sha256=qXvPAjO90jdokCU6tPSwjHIac4QU_5N0pSd9dfmc9kY,1204
 langwatch/tracer.py,sha256=t5FOdP1es9H_pPGqGUBLXCyEln0tTi4m4M9b6WxCrPU,975
-langwatch/types.py,sha256=h6r3tNTzWqENx-9j_JPmOMZfFoKq9SNpEtxpAACk2G0,3114
+langwatch/types.py,sha256=HtnfmGc3p6k7rLitnJsf3MOXZfvjyZ8soB74kPyoCGY,3242
 langwatch/dataset/__init__.py,sha256=hZBcbjXuBO2qE5osJtd9wIE9f45F6-jpNTrne5nk4eE,2606
-langwatch/domain/__init__.py,sha256=gSCOV3WkRhp_--9D1vxw7BYpnMRbpGh-2NbsXd4KZC0,6074
-langwatch/dspy/__init__.py,sha256=wp8AmobV8XGVWOI8MQFmXPHu-8Wq3wvjB6YiHQm9Fdg,33007
+langwatch/domain/__init__.py,sha256=BVpWugFqiohIA2MiTZy3x1BQCbIgN3okIXzmT6BHUkQ,6183
+langwatch/dspy/__init__.py,sha256=ahOMnNefVD9xsf7Z0P6iE0SbKylANixrNZkbKoK2FTs,35208
 langwatch/evaluation/__init__.py,sha256=8SOSZZbSzXa1jL-9Zlyt0f9u5sOA_TrO1J61ueASBLI,16980
 langwatch/experiment/__init__.py,sha256=nv2OfoNMMZwUA9KfozW2ZNaR1-J1LCmU4NykjGfe9is,3001
-langwatch/experiment/experiment.py,sha256=5xj58FKVC0y_LxgfwjJZP9lDp7tZ9FUUbERBtui_nC8,33026
+langwatch/experiment/experiment.py,sha256=BoTia3NPi_OcMSVGWN4xdNHrj5DC46_ZzcPhNhzNECc,37144
 langwatch/experiment/platform_run.py,sha256=qiy_bwp786TbkH4HIlZVlJPmCtQlStAq9vUdG4-3VdU,13850
 langwatch/exporters/filterable_batch_span_exporter.py,sha256=MlhZjui56XD6p2sa8kEGyr-Hb3wqudknngmemnB4Twg,2142
 langwatch/generated/langwatch_rest_api_client/__init__.py,sha256=8r-9pAj7fK7vnVX3mT0y_zS4B9ZRqD6RZiBo5fPra60,156
@@ -394,10 +394,10 @@ langwatch/generated/langwatch_rest_api_client/models/timestamps.py,sha256=-nRKUP
 langwatch/generated/langwatch_rest_api_client/models/trace.py,sha256=K9Lc_EQOrJ2dqMXx9EpiUXReT1_uYF7WRfYyhlfbi3I,7537
 langwatch/prompts/__init__.py,sha256=OGf3BrzVsTZnSPYSqSqe_eWmGIBRiOUlovOduYzKCx4,1259
 langwatch/prompts/errors.py,sha256=kmaGeA1QPot9Ii5lgooxmAFlvUPOGjAnzzPBuw4h6Bw,5124
-langwatch/prompts/local_loader.py,sha256=luvk39Kc4S-x4lBSms-AoWqg0Im_Uu-Lcpt3cRJFmdY,6774
+langwatch/prompts/local_loader.py,sha256=DifYVaAIdEdsApChPIEx0zsYinNixJoPgi8s0zy1MNY,7490
 langwatch/prompts/prompt.py,sha256=SgLDo9hO-CuRE-AZ8zx9v7-KqjiabiW8GzD9jdx1IoA,6914
 langwatch/prompts/prompt_api_service.py,sha256=tHhwIRjUBSM43_jwDAoGCHJjvvqVeSCrUPwcwMvUHho,9823
-langwatch/prompts/prompt_facade.py,sha256=fc16TB4ZBhKpwXVx9SNTJxLvQVms4eu4w0ZOH4Kk55w,8950
+langwatch/prompts/prompt_facade.py,sha256=yUq9-5JHcHrgiz9EgijzNXp_KkK6ZUouoGtEtF4_xdE,9154
 langwatch/prompts/decorators/prompt_service_tracing.py,sha256=uSYw0vExo7AuxbcCRnxbYl6UOfOQSC0IsisSqYy153Y,2395
 langwatch/prompts/decorators/prompt_tracing.py,sha256=x_PQvJlGbGF1h2HtGNiqaZ8K1qNd1jRf5pTOBTQx-7M,3963
 langwatch/prompts/types/__init__.py,sha256=jwaFV4VJHrOE6dm6yyLtWk6_7dqZpR5uZjN1cswtga4,579
@@ -413,10 +413,10 @@ langwatch/telemetry/__tests__/test_tracing.py,sha256=Px2vcpbRWBgwwaXzw3MgRfkcL-I
 langwatch/utils/__init__.py,sha256=3rqQTgzEtmICJW_KSPuLa5q8p5udxt5SRi28Z2vZB10,138
 langwatch/utils/capture.py,sha256=uVKPqHCm-o8CpabsUfhqbNFr5sgUHzcKnBadvL2oIwI,1172
 langwatch/utils/exceptions.py,sha256=b-dorrnQ9XBJcijLLNJP9LRQzdOZGEiyQ3f8GcA1kgk,1046
-langwatch/utils/initialization.py,sha256=1KoZmkHOvGEVF0j-4t4xRQdA_2C_SPiF7qFXqEG4Nkw,4553
+langwatch/utils/initialization.py,sha256=2egw2aXGYdbgLsyOfkQ3Oz0JFbfnQnpiFg_Q-gcoEgo,4915
 langwatch/utils/module.py,sha256=KLBNOK3mA9gCSifCcQX_lOtU48BJQDWvFKtF6NMvwVA,688
 langwatch/utils/transformation.py,sha256=76MGXyrYTxM0Yri36NJqLK-XxL4BBYdmKWAXXlw3D4Q,7690
-langwatch/utils/utils.py,sha256=ZCOSie4o9LdJ7odshNfCNjmgwgQ27ojc5ENqt1rXuSs,596
-langwatch-0.10.0.dist-info/METADATA,sha256=ZiqO5NpMuwsb60yAVPverSp8GXlMyIctxaDgO3DSRoA,13193
-langwatch-0.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langwatch-0.10.0.dist-info/RECORD,,
+langwatch/utils/utils.py,sha256=RW01NPA_cpWsTlUvLd0FGuoVECtMVO9Bj4gdIVx8fUg,644
+langwatch-0.10.2.dist-info/METADATA,sha256=rs-hw9hPy3Ap1y3PqwtA7oKvTCwj7i4eDchq7xmpMC0,13193
+langwatch-0.10.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langwatch-0.10.2.dist-info/RECORD,,