langwatch 0.2.18__py3-none-any.whl → 0.3.0__py3-none-any.whl

langwatch/__init__.py

@@ -19,11 +19,11 @@ if TYPE_CHECKING:
     import langwatch.dataset as dataset
     import langwatch.dspy as dspy
     import langwatch.langchain as langchain
-    from .prompts.service import PromptService
+    from .prompts.prompt_facade import PromptsFacade
 
     # Type hint for the prompts service specifically
     # required to get the instance typing correct
-    prompts: PromptService
+    prompts: PromptsFacade
 
 
 @module_property
@@ -61,10 +61,10 @@ def __getattr__(name: str):
             globals()[name] = module
             return module
     elif name == "prompts":
-        # Special-case: expose a PromptService instance at langwatch.prompts
-        from .prompts.service import PromptService
+        # Special-case: expose a PromptsFacade instance at langwatch.prompts
+        from .prompts.prompt_facade import PromptsFacade
 
-        svc = PromptService.from_global()
+        svc = PromptsFacade.from_global()
         globals()[name] = svc  # Cache for subsequent access
         return svc
 

langwatch/__version__.py

@@ -1,3 +1,3 @@
 """Version information for LangWatch."""
 
-__version__ = "0.2.18"
+__version__ = "0.2.19"

langwatch/generated/langwatch_rest_api_client/models/__init__.py

@@ -486,17 +486,7 @@ from .post_api_scenario_events_body_type_1_results_type_0_verdict import (
 )
 from .post_api_scenario_events_body_type_1_status import PostApiScenarioEventsBodyType1Status
 from .post_api_scenario_events_body_type_2 import PostApiScenarioEventsBodyType2
-from .post_api_scenario_events_body_type_2_messages_item_type_0 import PostApiScenarioEventsBodyType2MessagesItemType0
-from .post_api_scenario_events_body_type_2_messages_item_type_1 import PostApiScenarioEventsBodyType2MessagesItemType1
-from .post_api_scenario_events_body_type_2_messages_item_type_2 import PostApiScenarioEventsBodyType2MessagesItemType2
-from .post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item import (
-    PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItem,
-)
-from .post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item_function import (
-    PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItemFunction,
-)
-from .post_api_scenario_events_body_type_2_messages_item_type_3 import PostApiScenarioEventsBodyType2MessagesItemType3
-from .post_api_scenario_events_body_type_2_messages_item_type_4 import PostApiScenarioEventsBodyType2MessagesItemType4
+from .post_api_scenario_events_body_type_2_messages_item import PostApiScenarioEventsBodyType2MessagesItem
 from .post_api_scenario_events_response_201 import PostApiScenarioEventsResponse201
 from .post_api_scenario_events_response_400 import PostApiScenarioEventsResponse400
 from .post_api_scenario_events_response_401 import PostApiScenarioEventsResponse401
@@ -853,13 +843,7 @@ __all__ = (
     "PostApiScenarioEventsBodyType1ResultsType0Verdict",
     "PostApiScenarioEventsBodyType1Status",
     "PostApiScenarioEventsBodyType2",
-    "PostApiScenarioEventsBodyType2MessagesItemType0",
-    "PostApiScenarioEventsBodyType2MessagesItemType1",
-    "PostApiScenarioEventsBodyType2MessagesItemType2",
-    "PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItem",
-    "PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItemFunction",
-    "PostApiScenarioEventsBodyType2MessagesItemType3",
-    "PostApiScenarioEventsBodyType2MessagesItemType4",
+    "PostApiScenarioEventsBodyType2MessagesItem",
     "PostApiScenarioEventsResponse201",
     "PostApiScenarioEventsResponse400",
     "PostApiScenarioEventsResponse401",

langwatch/generated/langwatch_rest_api_client/models/post_api_scenario_events_body_type_2.py

@@ -7,21 +7,7 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.post_api_scenario_events_body_type_2_messages_item_type_0 import (
-        PostApiScenarioEventsBodyType2MessagesItemType0,
-    )
-    from ..models.post_api_scenario_events_body_type_2_messages_item_type_1 import (
-        PostApiScenarioEventsBodyType2MessagesItemType1,
-    )
-    from ..models.post_api_scenario_events_body_type_2_messages_item_type_2 import (
-        PostApiScenarioEventsBodyType2MessagesItemType2,
-    )
-    from ..models.post_api_scenario_events_body_type_2_messages_item_type_3 import (
-        PostApiScenarioEventsBodyType2MessagesItemType3,
-    )
-    from ..models.post_api_scenario_events_body_type_2_messages_item_type_4 import (
-        PostApiScenarioEventsBodyType2MessagesItemType4,
-    )
+    from ..models.post_api_scenario_events_body_type_2_messages_item import PostApiScenarioEventsBodyType2MessagesItem
 
 
 T = TypeVar("T", bound="PostApiScenarioEventsBodyType2")
@@ -33,9 +19,7 @@ class PostApiScenarioEventsBodyType2:
     Attributes:
         type_ (Literal['SCENARIO_MESSAGE_SNAPSHOT']):
         timestamp (float):
-        messages (list[Union['PostApiScenarioEventsBodyType2MessagesItemType0',
-            'PostApiScenarioEventsBodyType2MessagesItemType1', 'PostApiScenarioEventsBodyType2MessagesItemType2',
-            'PostApiScenarioEventsBodyType2MessagesItemType3', 'PostApiScenarioEventsBodyType2MessagesItemType4']]):
+        messages (list['PostApiScenarioEventsBodyType2MessagesItem']):
         batch_run_id (str):
         scenario_id (str):
         scenario_run_id (str):
@@ -45,15 +29,7 @@ class PostApiScenarioEventsBodyType2:
 
     type_: Literal["SCENARIO_MESSAGE_SNAPSHOT"]
     timestamp: float
-    messages: list[
-        Union[
-            "PostApiScenarioEventsBodyType2MessagesItemType0",
-            "PostApiScenarioEventsBodyType2MessagesItemType1",
-            "PostApiScenarioEventsBodyType2MessagesItemType2",
-            "PostApiScenarioEventsBodyType2MessagesItemType3",
-            "PostApiScenarioEventsBodyType2MessagesItemType4",
-        ]
-    ]
+    messages: list["PostApiScenarioEventsBodyType2MessagesItem"]
     batch_run_id: str
     scenario_id: str
     scenario_run_id: str
@@ -62,37 +38,13 @@ class PostApiScenarioEventsBodyType2:
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_0 import (
-            PostApiScenarioEventsBodyType2MessagesItemType0,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_1 import (
-            PostApiScenarioEventsBodyType2MessagesItemType1,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_2 import (
-            PostApiScenarioEventsBodyType2MessagesItemType2,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_3 import (
-            PostApiScenarioEventsBodyType2MessagesItemType3,
-        )
-
         type_ = self.type_
 
         timestamp = self.timestamp
 
         messages = []
         for messages_item_data in self.messages:
-            messages_item: dict[str, Any]
-            if isinstance(messages_item_data, PostApiScenarioEventsBodyType2MessagesItemType0):
-                messages_item = messages_item_data.to_dict()
-            elif isinstance(messages_item_data, PostApiScenarioEventsBodyType2MessagesItemType1):
-                messages_item = messages_item_data.to_dict()
-            elif isinstance(messages_item_data, PostApiScenarioEventsBodyType2MessagesItemType2):
-                messages_item = messages_item_data.to_dict()
-            elif isinstance(messages_item_data, PostApiScenarioEventsBodyType2MessagesItemType3):
-                messages_item = messages_item_data.to_dict()
-            else:
-                messages_item = messages_item_data.to_dict()
-
+            messages_item = messages_item_data.to_dict()
             messages.append(messages_item)
 
         batch_run_id = self.batch_run_id
@@ -126,20 +78,8 @@ class PostApiScenarioEventsBodyType2:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_0 import (
-            PostApiScenarioEventsBodyType2MessagesItemType0,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_1 import (
-            PostApiScenarioEventsBodyType2MessagesItemType1,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_2 import (
-            PostApiScenarioEventsBodyType2MessagesItemType2,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_3 import (
-            PostApiScenarioEventsBodyType2MessagesItemType3,
-        )
-        from ..models.post_api_scenario_events_body_type_2_messages_item_type_4 import (
-            PostApiScenarioEventsBodyType2MessagesItemType4,
+        from ..models.post_api_scenario_events_body_type_2_messages_item import (
+            PostApiScenarioEventsBodyType2MessagesItem,
         )
 
         d = dict(src_dict)
@@ -152,55 +92,7 @@ class PostApiScenarioEventsBodyType2:
         messages = []
         _messages = d.pop("messages")
         for messages_item_data in _messages:
-
-            def _parse_messages_item(
-                data: object,
-            ) -> Union[
-                "PostApiScenarioEventsBodyType2MessagesItemType0",
-                "PostApiScenarioEventsBodyType2MessagesItemType1",
-                "PostApiScenarioEventsBodyType2MessagesItemType2",
-                "PostApiScenarioEventsBodyType2MessagesItemType3",
-                "PostApiScenarioEventsBodyType2MessagesItemType4",
-            ]:
-                try:
-                    if not isinstance(data, dict):
-                        raise TypeError()
-                    messages_item_type_0 = PostApiScenarioEventsBodyType2MessagesItemType0.from_dict(data)
-
-                    return messages_item_type_0
-                except:  # noqa: E722
-                    pass
-                try:
-                    if not isinstance(data, dict):
-                        raise TypeError()
-                    messages_item_type_1 = PostApiScenarioEventsBodyType2MessagesItemType1.from_dict(data)
-
-                    return messages_item_type_1
-                except:  # noqa: E722
-                    pass
-                try:
-                    if not isinstance(data, dict):
-                        raise TypeError()
-                    messages_item_type_2 = PostApiScenarioEventsBodyType2MessagesItemType2.from_dict(data)
-
-                    return messages_item_type_2
-                except:  # noqa: E722
-                    pass
-                try:
-                    if not isinstance(data, dict):
-                        raise TypeError()
-                    messages_item_type_3 = PostApiScenarioEventsBodyType2MessagesItemType3.from_dict(data)
-
-                    return messages_item_type_3
-                except:  # noqa: E722
-                    pass
-                if not isinstance(data, dict):
-                    raise TypeError()
-                messages_item_type_4 = PostApiScenarioEventsBodyType2MessagesItemType4.from_dict(data)
-
-                return messages_item_type_4
-
-            messages_item = _parse_messages_item(messages_item_data)
+            messages_item = PostApiScenarioEventsBodyType2MessagesItem.from_dict(messages_item_data)
 
             messages.append(messages_item)
 

langwatch/generated/langwatch_rest_api_client/models/{post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item_function.py → post_api_scenario_events_body_type_2_messages_item.py}

@@ -1,54 +1,55 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItemFunction")
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PostApiScenarioEventsBodyType2MessagesItem")
 
 
 @_attrs_define
-class PostApiScenarioEventsBodyType2MessagesItemType2ToolCallsItemFunction:
+class PostApiScenarioEventsBodyType2MessagesItem:
     """
     Attributes:
-        name (str):
-        arguments (str):
+        id (Union[Unset, str]):
+        trace_id (Union[Unset, str]):
     """
 
-    name: str
-    arguments: str
+    id: Union[Unset, str] = UNSET
+    trace_id: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        name = self.name
+        id = self.id
 
-        arguments = self.arguments
+        trace_id = self.trace_id
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "name": name,
-                "arguments": arguments,
-            }
-        )
+        field_dict.update({})
+        if id is not UNSET:
+            field_dict["id"] = id
+        if trace_id is not UNSET:
+            field_dict["trace_id"] = trace_id
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        name = d.pop("name")
+        id = d.pop("id", UNSET)
 
-        arguments = d.pop("arguments")
+        trace_id = d.pop("trace_id", UNSET)
 
-        post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item_function = cls(
-            name=name,
-            arguments=arguments,
+        post_api_scenario_events_body_type_2_messages_item = cls(
+            id=id,
+            trace_id=trace_id,
         )
 
-        post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item_function.additional_properties = d
-        return post_api_scenario_events_body_type_2_messages_item_type_2_tool_calls_item_function
+        post_api_scenario_events_body_type_2_messages_item.additional_properties = d
+        return post_api_scenario_events_body_type_2_messages_item
 
     @property
     def additional_keys(self) -> list[str]:

langwatch/prompts/__init__.py

@@ -1,5 +1,5 @@
-from .service import PromptService
+from .prompt_facade import PromptsFacade
 
 __all__ = [
-    "PromptService",
+    "PromptsFacade",
 ]

langwatch/prompts/decorators/prompt_service_tracing.py

@@ -48,9 +48,11 @@ class PromptServiceTracing:
 
                     span.set_attributes(
                         {
-                            AttributeKey.LangWatchPromptId: result.id,
-                            AttributeKey.LangWatchPromptVersionId: result.version_id,
-                            AttributeKey.LangWatchPromptHandle: result.handle,
+                            AttributeKey.LangWatchPromptId: result.get("id"),
+                            AttributeKey.LangWatchPromptVersionId: result.get(
+                                "version_id"
+                            ),
+                            AttributeKey.LangWatchPromptHandle: result.get("handle"),
                         }
                     )
                     return result
@@ -63,7 +65,7 @@ class PromptServiceTracing:
     @staticmethod
     def _create_span_name(span_name: str) -> str:
         """Create a span name for the prompt"""
-        return "PromptService" + "." + span_name
+        return "PromptApiService" + "." + span_name
 
 
 prompt_service_tracing = PromptServiceTracing()

langwatch/prompts/local_loader.py

@@ -0,0 +1,170 @@
+"""
+Local prompt file loader for LangWatch Python SDK.
+
+Reads prompts from local files in the CLI format:
+- prompts.json: Configuration file
+- prompts-lock.json: Lock file with materialized paths
+- *.prompt.yaml: Individual prompt files
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import warnings
+
+import yaml
+
+from .types import PromptData, MessageDict, ResponseFormatDict
+
+logger = logging.getLogger(__name__)
+
+
+class LocalPromptLoader:
+    """Loads prompts from local files in CLI format."""
+
+    def __init__(self, base_path: Optional[Path] = None):
+        """Initialize with base path (defaults to current working directory)."""
+        self.base_path = base_path or Path.cwd()
+
+    def load_prompt(self, prompt_id: str) -> Optional[PromptData]:
+        """
+        Load a prompt from local files.
+
+        Returns None if prompt not found locally.
+        """
+        try:
+            # Check if prompts.json exists
+            prompts_json_path = self.base_path / "prompts.json"
+            if not prompts_json_path.exists():
+                logger.debug(
+                    f"No prompts.json found at {prompts_json_path}, falling back to API"
+                )
+                return None
+
+            # Load prompts.json
+            try:
+                with open(prompts_json_path, "r") as f:
+                    prompts_config = json.load(f)
+            except (json.JSONDecodeError, OSError) as e:
+                warnings.warn(
+                    f"Failed to read prompts.json at {prompts_json_path}: {e}. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            # Check if prompt exists in config
+            if prompt_id not in prompts_config.get("prompts", {}):
+                logger.debug(
+                    f"Prompt '{prompt_id}' not found in prompts.json, falling back to API"
+                )
+                return None
+
+            # Load prompts-lock.json to get materialized path
+            prompts_lock_path = self.base_path / "prompts-lock.json"
+            if not prompts_lock_path.exists():
+                warnings.warn(
+                    f"prompts.json exists but prompts-lock.json not found at {prompts_lock_path}. "
+                    f"Run 'langwatch prompts pull' to sync local prompts. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            try:
+                with open(prompts_lock_path, "r") as f:
+                    prompts_lock = json.load(f)
+            except (json.JSONDecodeError, OSError) as e:
+                warnings.warn(
+                    f"Failed to read prompts-lock.json at {prompts_lock_path}: {e}. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            # Get materialized path
+            prompt_info = prompts_lock.get("prompts", {}).get(prompt_id)
+            if not prompt_info:
+                warnings.warn(
+                    f"Prompt '{prompt_id}' found in prompts.json but not in prompts-lock.json. "
+                    f"Run 'langwatch prompts pull' to sync local prompts. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            materialized_path = prompt_info.get("materialized")
+            if not materialized_path:
+                warnings.warn(
+                    f"Prompt '{prompt_id}' in prompts-lock.json has no materialized path. "
+                    f"Run 'langwatch prompts pull' to sync local prompts. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            # Load the actual prompt file
+            prompt_file_path = self.base_path / materialized_path
+            if not prompt_file_path.exists():
+                warnings.warn(
+                    f"Prompt file not found at {prompt_file_path}. "
+                    f"Run 'langwatch prompts pull' to sync local prompts. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            try:
+                with open(prompt_file_path, "r") as f:
+                    prompt_data = yaml.safe_load(f)
+            except (yaml.YAMLError, OSError) as e:
+                warnings.warn(
+                    f"Failed to parse prompt file at {prompt_file_path}: {e}. "
+                    f"Falling back to API for prompt '{prompt_id}'.",
+                    UserWarning,
+                )
+                return None
+
+            # Build PromptData directly
+            logger.info(
+                f"Successfully loaded prompt '{prompt_id}' from local file: {prompt_file_path}"
+            )
+
+            # Convert messages
+            messages = []
+            if "messages" in prompt_data:
+                messages = [
+                    MessageDict(role=msg["role"], content=msg["content"])
+                    for msg in prompt_data["messages"]
+                ]
+
+            # Convert response format if present
+            response_format = None
+            if "response_format" in prompt_data and prompt_data["response_format"]:
+                response_format = ResponseFormatDict(
+                    type="json_schema", json_schema=prompt_data["response_format"]
+                )
+
+            return PromptData(
+                handle=prompt_id,  # The prompt_id parameter is the handle
+                model=prompt_data["model"],  # Required field - let it fail if missing
+                messages=messages,
+                prompt=prompt_data.get("prompt"),
+                temperature=prompt_data.get("temperature"),
+                max_tokens=prompt_data.get("max_tokens"),
+                response_format=response_format,
+                version=prompt_info.get("version"),
+                version_id=prompt_info.get("versionId"),
+                # id and scope are not available in local files
+            )
+
+        except Exception as e:
+            # If any unexpected error occurs, warn and fall back to API
+            warnings.warn(
+                f"Unexpected error loading prompt '{prompt_id}' from local files: {e}. "
+                f"Falling back to API.",
+                UserWarning,
+            )
+            return None

langwatch/prompts/prompt.py

@@ -1,13 +1,12 @@
-from typing import List, Any, Dict, Union, Optional, cast
-from openai.types.chat import ChatCompletionMessageParam
+from typing import List, Any, Dict, Union, Optional, cast, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from openai.types.chat import ChatCompletionMessageParam
+
 from liquid import Environment, StrictUndefined, Undefined
 from liquid.exceptions import UndefinedError
-from langwatch.generated.langwatch_rest_api_client.models.get_api_prompts_by_id_response_200 import (
-    GetApiPromptsByIdResponse200,
-)
-from .formatter import PromptFormatter
 from .decorators.prompt_tracing import prompt_tracing
-from .types import MessageDict
+from .types import PromptData, MessageDict
 
 
 class PromptCompilationError(Exception):
@@ -34,31 +33,30 @@ class Prompt:
     Handles formatting messages with variables using Liquid templating.
     """
 
-    def __init__(
-        self,
-        config: GetApiPromptsByIdResponse200,
-        formatter: PromptFormatter = PromptFormatter(),
-    ):
-        self._config = config
-        self._formatter = formatter
+    def __init__(self, data: PromptData):
+        # Store raw data for backward compatibility
+        self._data = data.copy()
 
-    def __getattr__(self, name: str) -> Any:
-        """Delegate attribute access to the underlying config object"""
-        if hasattr(self._config, name):
-            return getattr(self._config, name)
-        raise AttributeError(
-            f"'{self.__class__.__name__}' object has no attribute '{name}'"
-        )
+        # Assign all fields directly as instance attributes
+        for key, value in data.items():
+            setattr(self, key, value)
 
-    @property
-    def raw(self) -> Any:
-        """Get the raw prompt data from the API"""
-        return self._config
+        # Set prompt default only if not provided (like TypeScript)
+        if not hasattr(self, "prompt") or self.prompt is None:
+            self.prompt = self._extract_system_prompt()
 
     @property
-    def version_number(self) -> int:
-        """Returns the version number of the prompt."""
-        return int(self._config.version)
+    def raw(self) -> PromptData:
+        """Get the raw prompt data"""
+        return self._data
+
+    def _extract_system_prompt(self) -> str:
+        """Extract system prompt from messages, like TypeScript version."""
+        if hasattr(self, "messages") and self.messages:
+            for message in self.messages:
+                if message.get("role") == "system":
+                    return message.get("content", "")
+        return ""
 
     def _compile(self, variables: TemplateVariables, strict: bool) -> "CompiledPrompt":
         """
@@ -70,19 +68,19 @@ class Prompt:
 
             # Compile main prompt
             compiled_prompt = ""
-            if self._config.prompt:
-                template = env.from_string(self._config.prompt)
+            if hasattr(self, "prompt") and self.prompt:
+                template = env.from_string(self.prompt)
                 compiled_prompt = template.render(**variables)
 
             # Compile messages
             compiled_messages: List[MessageDict] = []
-            if self._config.messages:
-                for message in self._config.messages:
-                    content: str = message.content
+            if hasattr(self, "messages") and self.messages:
+                for message in self.messages:
+                    content: str = message["content"]
                     template = env.from_string(content)
                     compiled_content = template.render(**variables)
                     compiled_message = MessageDict(
-                        role=message.role.value,
+                        role=message["role"],
                         content=compiled_content,
                     )
                     compiled_messages.append(compiled_message)
@@ -96,12 +94,16 @@ class Prompt:
             )
 
         except UndefinedError as error:
-            template_str = self._config.prompt or str(self._config.messages or [])
+            template_str = getattr(self, "prompt", "") or str(
+                getattr(self, "messages", [])
+            )
             raise PromptCompilationError(
                 f"Failed to compile prompt template: {str(error)}", template_str, error
             )
         except Exception as error:
-            template_str = self._config.prompt or str(self._config.messages or [])
+            template_str = getattr(self, "prompt", "") or str(
+                getattr(self, "messages", [])
+            )
             raise PromptCompilationError(
                 f"Failed to compile prompt template: {str(error)}", template_str, error
             )
@@ -168,21 +170,17 @@ class CompiledPrompt:
         self.variables = variables  # Store the original compilation variables
         self._compiled_messages = compiled_messages
 
-        # Expose original prompt properties for convenience
-        self.id = original_prompt.id
-        self.version = original_prompt.version
-        self.version_id = original_prompt.version_id
-        # ... other properties as needed
+        # Properties are delegated via __getattr__ below
 
     @property
-    def messages(self) -> List[ChatCompletionMessageParam]:
+    def messages(self) -> List["ChatCompletionMessageParam"]:
         """
         Returns the compiled messages as a list of ChatCompletionMessageParam objects.
         This is a convenience method to make the messages accessible as a list of
         ChatCompletionMessageParam objects, which is the format expected by the OpenAI API.
         """
         messages = [
-            cast(ChatCompletionMessageParam, msg) for msg in self._compiled_messages
+            cast("ChatCompletionMessageParam", msg) for msg in self._compiled_messages
         ]
 
         return messages