latitude-sdk 4.0.0b1__py3-none-any.whl → 5.0.0b1__py3-none-any.whl

latitude_sdk/__init__.py

@@ -1 +1,7 @@
+from .version import version
+
+__version__ = version.pep440
+__version_info__ = version.info
+__version_semver__ = version.semver
+
 from .sdk import *

latitude_sdk/client/client.py

@@ -1,27 +1,19 @@
 import asyncio
 import json
 from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Awaitable, Callable, Optional
+from typing import Any, AsyncGenerator, Optional
 
 import httpx
 import httpx_sse
 
-from latitude_sdk.client.payloads import (
-    ErrorResponse,
-    RequestBody,
-    RequestHandler,
-    RequestParams,
-)
+from latitude_sdk.client.payloads import ErrorResponse, RequestBody, RequestHandler, RequestParams
 from latitude_sdk.client.router import Router, RouterOptions
-from latitude_sdk.sdk.errors import (
-    ApiError,
-    ApiErrorCodes,
-    ApiErrorDbRef,
-)
+from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes, ApiErrorDbRef
 from latitude_sdk.sdk.types import LogSources
 from latitude_sdk.util import Model
+from latitude_sdk.version import version
 
-RETRIABLE_STATUSES = [408, 409, 429, 500, 502, 503, 504]
+RETRIABLE_STATUSES = [408, 429, 500, 502, 503, 504]
 
 ClientEvent = httpx_sse.ServerSentEvent
 
@@ -60,165 +52,68 @@ class Client:
         handler: RequestHandler,
         params: Optional[RequestParams] = None,
         body: Optional[RequestBody] = None,
+        stream: Optional[bool] = None,
     ) -> AsyncGenerator[ClientResponse, Any]:
-        """
-        Main request handler that delegates to streaming or non-streaming methods.
-        """
-        is_streaming = self._is_streaming_request(body)
-
-        if is_streaming:
-            async with self._streaming_request(handler, params, body) as response:
-                yield response
-        else:
-            async with self._non_streaming_request(handler, params, body) as response:
-                yield response
-
-    def _is_streaming_request(self, body: Optional[RequestBody]) -> bool:
-        """Check if this is a streaming request based on the body."""
-        return body is not None and hasattr(body, "stream") and body.stream  # type: ignore
-
-    def _prepare_headers(self, is_streaming: bool) -> dict[str, str]:
-        """Prepare headers for the request."""
-        headers = {
-            "Authorization": f"Bearer {self.options.api_key}",
-            "Content-Type": "application/json",
-        }
-
-        if is_streaming:
-            headers["Accept"] = "text/event-stream"
-
-        return headers
-
-    def _prepare_content(self, body: Optional[RequestBody]) -> Optional[str]:
-        """Prepare request content from body."""
-        if not body:
-            return None
-
-        return json.dumps(
-            {
-                **json.loads(body.model_dump_json()),
-                "__internal": {"source": self.options.source},
-            }
-        )
-
-    @asynccontextmanager
-    async def _streaming_request(
-        self,
-        handler: RequestHandler,
-        params: Optional[RequestParams] = None,
-        body: Optional[RequestBody] = None,
-    ) -> AsyncGenerator[ClientResponse, Any]:
-        """Handle streaming requests with proper resource management."""
-        headers = self._prepare_headers(is_streaming=True)
-        content = self._prepare_content(body)
-        method, url = self.router.resolve(handler, params)
-
-        async with httpx.AsyncClient(
-            headers=headers,
+        client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {self.options.api_key}",
+                "X-Latitude-SDK-Version": version.semver,
+                "Content-Type": "application/json",
+                "Accept": "text/event-stream" if stream else "application/json",
+            },
             timeout=self.options.timeout,
             follow_redirects=False,
             max_redirects=0,
-        ) as client:
-            response = await self._execute_with_retry(
-                lambda: client.stream(method=method, url=url, content=content),  # type: ignore
-                is_streaming=True,
-            )
-
-            # For streaming responses, yield the response directly
-            # The caller is responsible for consuming the stream
-            yield response
-
-    @asynccontextmanager
-    async def _non_streaming_request(
-        self,
-        handler: RequestHandler,
-        params: Optional[RequestParams] = None,
-        body: Optional[RequestBody] = None,
-    ) -> AsyncGenerator[ClientResponse, Any]:
-        """Handle non-streaming requests with proper resource management."""
-        headers = self._prepare_headers(is_streaming=False)
-        content = self._prepare_content(body)
-        method, url = self.router.resolve(handler, params)
-
-        async with httpx.AsyncClient(
-            headers=headers,
-            timeout=self.options.timeout,
-            follow_redirects=False,
-            max_redirects=0,
-        ) as client:
-            response = await self._execute_with_retry(
-                lambda: client.request(method=method, url=url, content=content),  # type: ignore
-                is_streaming=False,
-            )
-
-            try:
-                # Pre-read the response text for non-streaming responses
-                # This ensures the response is fully loaded and validates it
-                _ = response.text
-                yield response
-            finally:
-                await response.aclose()
-
-    async def _execute_with_retry(
-        self,
-        request_func: Callable[[], Awaitable[ClientResponse]],
-        is_streaming: bool = False,
-    ) -> ClientResponse:
-        """Execute a request with retry logic."""
-        last_exception = None
-        last_response = None
-
-        for attempt in range(1, self.options.retries + 1):
-            response_cm = None
-            response = None
-
-            try:
-                if is_streaming:
-                    # For streaming, request_func returns a context manager
-                    response_cm = request_func()
-                    response = await response_cm.__aenter__()  # type: ignore
-                    # Store the context manager for proper cleanup
-                    response._stream_cm = response_cm  # pyright: ignore [reportAttributeAccessIssue]
-                else:
-                    response = await request_func()
+        )
+        response = None
+        attempt = 1
 
-                response.raise_for_status()  # type: ignore
-                return response  # type: ignore
+        try:
+            method, url = self.router.resolve(handler, params)
+            content = None
+            if body:
+                content = json.dumps(
+                    {
+                        **json.loads(body.model_dump_json()),
+                        "__internal": {"source": self.options.source},
+                    }
+                )
+
+            while attempt <= self.options.retries:
+                try:
+                    request = client.build_request(method=method, url=url, content=content)
+                    response = await client.send(request=request, stream=stream or False)
+                    response.raise_for_status()
+
+                    yield response  # pyright: ignore [reportReturnType]
+                    break
 
-            except Exception as exception:
-                last_exception = exception
+                except Exception as exception:
+                    if isinstance(exception, ApiError):
+                        raise exception
 
-                # For HTTP errors, get the response from the exception
-                if isinstance(exception, httpx.HTTPStatusError):
-                    last_response = exception.response
-                else:
-                    last_response = getattr(exception, "response", None)
+                    if attempt >= self.options.retries:
+                        raise await self._exception(exception, response) from exception
 
-                # Don't retry ApiErrors - they're business logic errors
-                if isinstance(exception, ApiError):
-                    raise exception
+                    if response and response.status_code in RETRIABLE_STATUSES:
+                        await asyncio.sleep(self.options.delay * (2 ** (attempt - 1)))
+                    else:
+                        raise await self._exception(exception, response) from exception
 
-                # If this is the last attempt, break to raise the exception
-                if attempt >= self.options.retries:
-                    break
+                finally:
+                    if response:
+                        await response.aclose()
 
-                # Check if we should retry based on status code
-                if (
-                    isinstance(exception, httpx.HTTPStatusError)
-                    and exception.response.status_code in RETRIABLE_STATUSES
-                ):
-                    await asyncio.sleep(self._calculate_delay(attempt))
-                    continue
+                    attempt += 1
 
-                # For non-retriable errors, don't retry
-                break
+        except Exception as exception:
+            if isinstance(exception, ApiError):
+                raise exception
 
-        # If we get here, all retries failed
-        raise await self._exception(last_exception, last_response) from last_exception  # type: ignore
+            raise await self._exception(exception, response) from exception
 
-    def _calculate_delay(self, attempt: int) -> float:
-        """Calculate exponential backoff delay."""
-        return self.options.delay * (2 ** (attempt - 1))
+        finally:
+            await client.aclose()
 
     async def _exception(self, exception: Exception, response: Optional[httpx.Response] = None) -> ApiError:
         if not response:
@@ -229,41 +124,17 @@ class Client:
                 response=str(exception),
             )
 
-        # Try to safely get response text and content, handling streaming responses
-        response_text = ""
-        response_content = b""
-
         try:
-            # Check if this is a streaming response
-            content_type = response.headers.get("content-type", "")
-            is_streaming = "text/event-stream" in content_type
+            if not response.is_stream_consumed:
+                await response.aread()
 
-            # For streaming responses, try to read content but don't access text
-            if is_streaming:
-                # For streaming responses, we can access content but not text
-                response_content = response.content
-                response_text = ""
-            else:
-                # For non-streaming responses, we can safely access both
-                response_content = response.content
-                response_text = response.text
-        except Exception:
-            # If we can't read the response (e.g., streaming response that hasn't been read),
-            # try to get what we can
-            try:
-                response_content = response.content
-            except Exception:
-                response_content = b""
-            response_text = ""
-
-        try:
-            error = ErrorResponse.model_validate_json(response_content)
+            error = ErrorResponse.model_validate_json(response.content)
 
             return ApiError(
                 status=response.status_code,
                 code=error.code,
                 message=error.message,
-                response=response_text,
+                response=response.text,
                 db_ref=ApiErrorDbRef(**dict(error.db_ref)) if error.db_ref else None,
             )
 
@@ -272,5 +143,5 @@ class Client:
                 status=response.status_code,
                 code=ApiErrorCodes.InternalServerError,
                 message=str(exception),
-                response=response_text,
+                response=response.text,
             )

latitude_sdk/client/payloads.py

@@ -44,8 +44,8 @@ class RunPromptRequestBody(Model):
     path: str
     parameters: Optional[Dict[str, Any]] = None
     custom_identifier: Optional[str] = Field(default=None, alias=str("customIdentifier"))
-    stream: Optional[bool] = None
     tools: Optional[List[str]] = None
+    stream: Optional[bool] = None
 
 
 class ChatPromptRequestParams(Model):
@@ -54,6 +54,7 @@ class ChatPromptRequestParams(Model):
 
 class ChatPromptRequestBody(Model):
     messages: List[Message]
+    tools: Optional[List[str]] = None
     stream: Optional[bool] = None
 
 
@@ -81,11 +82,10 @@ class AnnotateEvaluationRequestParams(EvaluationRequestParams, Model):
 
 
 class AnnotateEvaluationRequestBody(Model):
-    score: int
-
     class Metadata(Model):
         reason: str
 
+    score: int
     metadata: Optional[Metadata] = None
 
 

latitude_sdk/sdk/__init__.py

@@ -2,5 +2,6 @@ from .errors import *
 from .evaluations import *
 from .latitude import *
 from .logs import *
+from .projects import *
 from .prompts import *
 from .types import *

latitude_sdk/sdk/errors.py

@@ -7,6 +7,7 @@ from latitude_sdk.util import Model, StrEnum
 class ApiErrorCodes(StrEnum):
     # LatitudeErrorCodes
     NotFoundError = "NotFoundError"
+    BadRequestError = "BadRequestError"
 
     # RunErrorCodes
     AIRunError = "ai_run_error"

latitude_sdk/sdk/evaluations.py

@@ -1,5 +1,4 @@
-from datetime import datetime
-from typing import Any, Optional, Union
+from typing import Optional
 
 from latitude_sdk.client import (
     AnnotateEvaluationRequestBody,
@@ -7,24 +6,16 @@ from latitude_sdk.client import (
     Client,
     RequestHandler,
 )
-from latitude_sdk.sdk.types import SdkOptions
-from latitude_sdk.util import Field, Model
+from latitude_sdk.sdk.types import EvaluationResult, SdkOptions
+from latitude_sdk.util import Model
 
 
 class AnnotateEvaluationOptions(Model):
     reason: str
 
 
-class AnnotateEvaluationResult(Model):
-    uuid: str
-    score: int
-    normalized_score: int = Field(alias=str("normalizedScore"))
-    metadata: dict[str, Any]
-    has_passed: bool = Field(alias=str("hasPassed"))
-    created_at: datetime = Field(alias=str("createdAt"))
-    updated_at: datetime = Field(alias=str("updatedAt"))
-    version_uuid: str = Field(alias=str("versionUuid"))
-    error: Optional[Union[str, None]] = None
+class AnnotateEvaluationResult(EvaluationResult, Model):
+    pass
 
 
 class Evaluations:

latitude_sdk/sdk/latitude.py

@@ -78,6 +78,7 @@ class Latitude:
         )
 
         self.promptl = Promptl(self._options.promptl)
+
         self.projects = Projects(self._client, self._options)
         self.prompts = Prompts(self._client, self.promptl, self._options)
         self.logs = Logs(self._client, self._options)

latitude_sdk/sdk/projects.py

@@ -1,41 +1,35 @@
-import json
 from typing import List
 
-from latitude_sdk.client import Client
-from latitude_sdk.client.payloads import CreateProjectRequestBody, RequestHandler
+from latitude_sdk.client import Client, CreateProjectRequestBody, RequestHandler
 from latitude_sdk.sdk.types import Project, SdkOptions, Version
+from latitude_sdk.util import Adapter as AdapterUtil
+from latitude_sdk.util import Model
 
+_GetAllProjectResults = AdapterUtil[List[Project]](List[Project])
 
-class CreateProjectResponse:
-    def __init__(self, project: Project, version: Version):
-        self.project = project
-        self.version = version
+
+class CreateProjectResult(Model):
+    project: Project
+    version: Version
 
 
 class Projects:
-    _client: Client
     _options: SdkOptions
+    _client: Client
 
     def __init__(self, client: Client, options: SdkOptions):
-        self._client = client
         self._options = options
+        self._client = client
 
     async def get_all(self) -> List[Project]:
         async with self._client.request(
             handler=RequestHandler.GetAllProjects,
-            params=None,
         ) as response:
-            projects_data = json.loads(response.content)
-            return [Project.model_validate_json(json.dumps(project)) for project in projects_data]
+            return _GetAllProjectResults.validate_json(response.content)
 
-    async def create(self, name: str) -> CreateProjectResponse:
+    async def create(self, name: str) -> CreateProjectResult:
         async with self._client.request(
             handler=RequestHandler.CreateProject,
-            params=None,
             body=CreateProjectRequestBody(name=name),
         ) as response:
-            response_data = json.loads(response.content)
-            return CreateProjectResponse(
-                project=Project.model_validate_json(json.dumps(response_data["project"])),
-                version=Version.model_validate_json(json.dumps(response_data["version"])),
-            )
+            return CreateProjectResult.model_validate_json(response.content)

latitude_sdk/sdk/prompts.py

@@ -1,11 +1,6 @@
-from typing import Any, AsyncGenerator, Callable, List, Optional, Sequence
+from typing import Any, AsyncGenerator, List, Optional, Sequence
 
-from promptl_ai import (
-    Adapter,
-    Message,
-    MessageLike,
-    Promptl,
-)
+from promptl_ai import Adapter, Message, MessageLike, Promptl
 from promptl_ai.bindings.types import _Message
 
 from latitude_sdk.client import (
@@ -30,6 +25,8 @@ from latitude_sdk.sdk.types import (
     OnToolCall,
     OnToolCallDetails,
     Prompt,
+    ProviderEvents,
+    ProviderEventToolCalled,
     Providers,
     SdkOptions,
     StreamCallbacks,
@@ -145,7 +142,7 @@ class Prompts:
         self,
         stream: AsyncGenerator[ClientEvent, Any],
         on_event: Optional[StreamCallbacks.OnEvent],
-        on_tool_call: Optional[Callable[[dict[str, Any]], Any]] = None,
+        tools: Optional[dict[str, OnToolCall]],
     ) -> FinishedResult:
         uuid = None
         conversation: List[Message] = []
@@ -153,6 +150,7 @@ class Prompts:
 
         async for stream_event in stream:
             event = None
+            tool_call = None
 
             if stream_event.event == str(StreamEvents.Latitude):
                 event = _LatitudeEvent.validate_json(stream_event.data)
@@ -174,9 +172,8 @@ class Prompts:
                 event = stream_event.json()
                 event["event"] = StreamEvents.Provider
 
-                # Handle tool calls when received in the stream
-                if on_tool_call and event.get("type") == "tool-call":
-                    await on_tool_call(event)
+                if event.get("type") == str(ProviderEvents.ToolCalled):
+                    tool_call = ProviderEventToolCalled.model_validate_json(stream_event.data)
 
             else:
                 raise ApiError(
@@ -189,6 +186,9 @@ class Prompts:
             if on_event:
                 on_event(event)
 
+            if tool_call:
+                await self._handle_tool_call(tool_call, tools)
+
         if not uuid or not response:
             raise ApiError(
                 status=500,
@@ -197,11 +197,7 @@ class Prompts:
                 response="Stream ended without a chain-complete event. Missing uuid or response.",
             )
 
-        return FinishedResult(
-            uuid=uuid,
-            conversation=conversation,
-            response=response,
-        )
+        return FinishedResult(uuid=uuid, conversation=conversation, response=response)
 
     @staticmethod
     async def _wrap_tool_handler(
@@ -212,66 +208,45 @@ class Prompts:
         try:
             result = await handler(arguments, details)
 
-            return ToolResult(**tool_result, result=result)
+            return ToolResult(**tool_result, result=result, is_error=False)
         except Exception as exception:
             return ToolResult(**tool_result, result=str(exception), is_error=True)
 
     async def _handle_tool_call(
-        self,
-        event: dict[str, Any],
-        tools: dict[str, OnToolCall],
+        self, tool_call: ProviderEventToolCalled, tools: Optional[dict[str, OnToolCall]]
     ) -> None:
-        toolCallId: str = event["toolCallId"]
-        toolName: str = event["toolName"]
-        args: dict[str, Any] = event["args"]
-
-        tool = tools.get(toolName)
-        if not tool:
+        # NOTE: Do not handle tool calls if user specified no tools
+        if not tools:
             return
 
+        tool_handler = tools.get(tool_call.name)
+        if not tool_handler:
+            raise ApiError(
+                status=400,
+                code=ApiErrorCodes.AIRunError,
+                message=f"Tool {tool_call.name} not supplied",
+                response=f"Tool {tool_call.name} not supplied",
+            )
+
         tool_result = await self._wrap_tool_handler(
-            tool,
-            args,
+            tool_handler,
+            tool_call.arguments,
             OnToolCallDetails(
-                id=toolCallId,
-                name=toolName,
-                arguments=args,
+                id=tool_call.id,
+                name=tool_call.name,
+                arguments=tool_call.arguments,
             ),
         )
 
-        try:
-            async with self._client.request(
-                handler=RequestHandler.ToolResults,
-                params=None,
-                body=ToolResultsRequestBody(
-                    tool_call_id=toolCallId,
-                    result=tool_result.result,
-                    is_error=tool_result.is_error,
-                ),
-            ) as _:
-                pass
-        except Exception as exception:
-            if not isinstance(exception, ApiError):
-                exception = ApiError(
-                    status=500,
-                    code=ApiErrorCodes.InternalServerError,
-                    message=str(exception),
-                    response=str(exception),
-                )
-
-            # Add context about which tool failed
-            message = f"Failed to execute tool {toolName}. \nLatitude API returned the following error:\
-                    \n\n{exception.message}"
-
-            raise ApiError(
-                status=exception.status,
-                code=exception.code,
-                message=message,
-                response=exception.response,
-            ) from exception
-
-    def _on_tool_call(self, tools: dict[str, OnToolCall]) -> Callable[[dict[str, Any]], Any]:
-        return lambda event: self._handle_tool_call(event, tools)
+        async with self._client.request(
+            handler=RequestHandler.ToolResults,
+            body=ToolResultsRequestBody(
+                tool_call_id=tool_call.id,
+                result=tool_result.result,
+                is_error=tool_result.is_error,
+            ),
+        ):
+            pass
 
     async def get(self, path: str, options: Optional[GetPromptOptions] = None) -> GetPromptResult:
         options = GetPromptOptions(**{**dict(self._options), **dict(options or {})})
@@ -338,16 +313,13 @@ class Prompts:
                     path=path,
                     parameters=options.parameters,
                     custom_identifier=options.custom_identifier,
-                    stream=options.stream,
                     tools=list(options.tools.keys()) if options.tools and options.stream else None,
+                    stream=options.stream,
                 ),
+                stream=options.stream,
             ) as response:
                 if options.stream:
-                    result = await self._handle_stream(
-                        response.sse(),
-                        options.on_event,
-                        self._on_tool_call(options.tools if options.tools else {}),
-                    )
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = RunPromptResult.model_validate_json(response.content)
 
@@ -373,10 +345,7 @@ class Prompts:
             return None
 
     async def chat(
-        self,
-        uuid: str,
-        messages: Sequence[MessageLike],
-        options: Optional[ChatPromptOptions] = None,
+        self, uuid: str, messages: Sequence[MessageLike], options: Optional[ChatPromptOptions] = None
     ) -> Optional[ChatPromptResult]:
         options = ChatPromptOptions(**{**dict(self._options), **dict(options or {})})
 
@@ -390,15 +359,13 @@ class Prompts:
                 ),
                 body=ChatPromptRequestBody(
                     messages=messages,
+                    tools=list(options.tools.keys()) if options.tools and options.stream else None,
                     stream=options.stream,
                 ),
+                stream=options.stream,
             ) as response:
                 if options.stream:
-                    result = await self._handle_stream(
-                        response.sse(),
-                        options.on_event,
-                        self._on_tool_call(options.tools if options.tools else {}),
-                    )
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = ChatPromptResult.model_validate_json(response.content)
 
@@ -451,10 +418,7 @@ class Prompts:
         )
 
     async def render_chain(
-        self,
-        prompt: Prompt,
-        on_step: OnStep,
-        options: Optional[RenderChainOptions] = None,
+        self, prompt: Prompt, on_step: OnStep, options: Optional[RenderChainOptions] = None
     ) -> RenderChainResult:
         options = RenderChainOptions(**{**dict(self._options), **dict(options or {})})
         adapter = options.adapter or _PROVIDER_TO_ADAPTER.get(prompt.provider or Providers.OpenAI, Adapter.OpenAI)

latitude_sdk/sdk/types.py

@@ -30,6 +30,10 @@ class Providers(StrEnum):
     Google = "google"
     GoogleVertex = "google_vertex"
     AnthropicVertex = "anthropic_vertex"
+    XAI = "xai"
+    AmazonBedrock = "amazon_bedrock"
+    DeepSeek = "deepseek"
+    Perplexity = "perplexity"
     Custom = "custom"
 
 
@@ -68,9 +72,6 @@ class FinishReason(StrEnum):
     Unknown = "unknown"
 
 
-AGENT_START_TOOL_NAME = "start_autonomous_chain"
-
-
 class ToolCall(Model):
     id: str
     name: str
@@ -116,6 +117,23 @@ class StreamEvents(StrEnum):
     Provider = "provider-event"
 
 
+# NOTE: Incomplete list
+class ProviderEvents(StrEnum):
+    ToolCalled = "tool-call"
+
+
+# NOTE: Incomplete event
+class GenericProviderEvent(Model):
+    event: Literal[StreamEvents.Provider] = StreamEvents.Provider
+
+
+# NOTE: Incomplete event
+class ProviderEventToolCalled(GenericProviderEvent, Model):
+    id: str = Field(alias=str("toolCallId"))
+    name: str = Field(alias=str("toolName"))
+    arguments: dict[str, Any] = Field(alias=str("args"))
+
+
 ProviderEvent = dict[str, Any]
 
 
@@ -137,20 +155,20 @@ class GenericChainEvent(Model):
     uuid: str
 
 
-class ChainEventChainStarted(GenericChainEvent):
+class ChainEventChainStarted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ChainStarted] = ChainEvents.ChainStarted
 
 
-class ChainEventStepStarted(GenericChainEvent):
+class ChainEventStepStarted(GenericChainEvent, Model):
     type: Literal[ChainEvents.StepStarted] = ChainEvents.StepStarted
 
 
-class ChainEventProviderStarted(GenericChainEvent):
+class ChainEventProviderStarted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ProviderStarted] = ChainEvents.ProviderStarted
     config: dict[str, Any]
 
 
-class ChainEventProviderCompleted(GenericChainEvent):
+class ChainEventProviderCompleted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ProviderCompleted] = ChainEvents.ProviderCompleted
     provider_log_uuid: str = Field(alias=str("providerLogUuid"))
     token_usage: ModelUsage = Field(alias=str("tokenUsage"))
@@ -158,26 +176,26 @@ class ChainEventProviderCompleted(GenericChainEvent):
     response: ChainResponse
 
 
-class ChainEventToolsStarted(GenericChainEvent):
+class ChainEventToolsStarted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ToolsStarted] = ChainEvents.ToolsStarted
     tools: List[ToolCall]
 
 
-class ChainEventToolCompleted(GenericChainEvent):
+class ChainEventToolCompleted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ToolCompleted] = ChainEvents.ToolCompleted
 
 
-class ChainEventStepCompleted(GenericChainEvent):
+class ChainEventStepCompleted(GenericChainEvent, Model):
     type: Literal[ChainEvents.StepCompleted] = ChainEvents.StepCompleted
 
 
-class ChainEventChainCompleted(GenericChainEvent):
+class ChainEventChainCompleted(GenericChainEvent, Model):
     type: Literal[ChainEvents.ChainCompleted] = ChainEvents.ChainCompleted
     token_usage: ModelUsage = Field(alias=str("tokenUsage"))
     finish_reason: FinishReason = Field(alias=str("finishReason"))
 
 
-class ChainEventChainError(GenericChainEvent):
+class ChainEventChainError(GenericChainEvent, Model):
     type: Literal[ChainEvents.ChainError] = ChainEvents.ChainError
     error: ChainError
 
@@ -229,6 +247,18 @@ class Log(Model):
     updated_at: datetime = Field(alias=str("updatedAt"))
 
 
+class EvaluationResult(Model):
+    uuid: str
+    version_uuid: str = Field(alias=str("versionUuid"))
+    score: int
+    normalized_score: int = Field(alias=str("normalizedScore"))
+    metadata: dict[str, Any]
+    has_passed: bool = Field(alias=str("hasPassed"))
+    error: Optional[Union[str, None]] = None
+    created_at: datetime = Field(alias=str("createdAt"))
+    updated_at: datetime = Field(alias=str("updatedAt"))
+
+
 class Project(Model):
     id: int
     uuid: Optional[str] = None
@@ -238,11 +268,14 @@ class Project(Model):
 
 
 class Version(Model):
+    id: int
     uuid: str
-    name: str
+    title: str
+    description: Optional[str] = None
     project_id: int = Field(alias=str("projectId"))
     created_at: datetime = Field(alias=str("createdAt"))
     updated_at: datetime = Field(alias=str("updatedAt"))
+    merged_at: Optional[datetime] = Field(default=None, alias=str("mergedAt"))
 
 
 class StreamCallbacks(Model):

latitude_sdk/util/utils.py

@@ -5,6 +5,11 @@ from typing import Any, Callable, List, TypeVar
 import pydantic
 from typing_extensions import ParamSpec, Self
 
+
+def get_package() -> str:
+    return (__package__ or __name__).split(".")[0].replace("_", "-")
+
+
 T = TypeVar("T", str, bool, int, List[str])
 
 

latitude_sdk/version/__init__.py

@@ -0,0 +1 @@
+from .version import *

latitude_sdk/version/version.py

@@ -0,0 +1,63 @@
+import re
+from importlib.metadata import version as get_version
+from typing import Union
+
+from latitude_sdk.util import Model, get_package
+
+_PEP440_PATTERN = re.compile(
+    r"^(\d+(?:\.\d+){0,2})"  # major.minor.patch
+    r"(?:([abcu]|rc|u)(\d+))?"  # prerelease+number
+    r"(?:\.dev(\d+))?$"  # .dev+number
+)
+
+_PEP440_PRERELEASES = {
+    "a": "alpha",
+    "b": "beta",
+    "u": "unknown",
+    "rc": "rc",
+}
+
+
+def _to_semver(pepver: str) -> str:
+    version = _PEP440_PATTERN.match(pepver)
+    if not version:
+        return pepver
+
+    release, prerelease, prenumber, devnumber = version.groups()
+
+    parts = release.split(".")
+    major = parts[0] if len(parts) > 0 else "0"
+    minor = parts[1] if len(parts) > 1 else "0"
+    patch = parts[2] if len(parts) > 2 else "0"
+
+    semver = f"{major}.{minor}.{patch}"
+    if prerelease:
+        semver += f"-{_PEP440_PRERELEASES.get(prerelease, 'unknown')}"
+        if prenumber:
+            semver += f".{prenumber}"
+    if devnumber:
+        semver += f"+dev.{devnumber}"
+
+    return semver
+
+
+def _to_info(pepver: str) -> tuple[Union[int, str], ...]:
+    return tuple(int(x) if x.isdigit() else x for x in pepver.split("."))
+
+
+class Version(Model):
+    pep440: str
+    semver: str
+    info: tuple[Union[int, str], ...]
+
+
+try:
+    _version = get_version(get_package())
+except Exception:
+    _version = "0.0.0u0"
+
+version = Version(
+    pep440=_version,
+    semver=_to_semver(_version),
+    info=_to_info(_version),
+)

{latitude_sdk-4.0.0b1.dist-info → latitude_sdk-5.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 4.0.0b1
+Version: 5.0.0b1
 Summary: Latitude SDK for Python
 Project-URL: repository, https://github.com/latitude-dev/latitude-llm/tree/main/packages/sdks/python
 Project-URL: homepage, https://github.com/latitude-dev/latitude-llm/tree/main/packages/sdks/python#readme
@@ -62,7 +62,13 @@ Requires uv `0.5.10` or higher.
 
 ### Running only a specific test
 
-Mark the test with an `only` marker:
+Specify the test inline:
+
+```python
+uv run scripts/test.py <test_path>::<test_case>::<test_name>
+```
+
+Or mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -78,12 +84,6 @@ async def my_test(self):
 uv run scripts/test.py -m only
 ```
 
-Another way is to specify the test in line:
-
-```python
-uv run scripts/test.py <test_path>::<test_case>::<test_name>
-```
-
 ## License
 
 The SDK is licensed under the [MIT License](https://opensource.org/licenses/MIT) - read the [LICENSE](/LICENSE) file for details.

latitude_sdk-5.0.0b1.dist-info/RECORD

@@ -0,0 +1,24 @@
+latitude_sdk/__init__.py,sha256=Xp6tiHlLtEQxfii5F_gTya5jZdbD63ySlnPI4pJU-58,147
+latitude_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+latitude_sdk/client/__init__.py,sha256=d8CnNB8UoGwcftiIeeC0twdg01qNvfpj-v7O40I7IiE,68
+latitude_sdk/client/client.py,sha256=lidk9T5aeocg_rpihl_FUnYTK2kZDtsCFa8IrCCM3tE,4815
+latitude_sdk/client/payloads.py,sha256=fJftAEQpbNef8cknAZpt_07Ye8n_9EWRuhfoI-DrZvs,3035
+latitude_sdk/client/router.py,sha256=k5OT42_3riJlTm5Q2BU3AplmpN1FdMxQeIj8GptcllQ,4616
+latitude_sdk/env/__init__.py,sha256=66of5veJ-u1aNI025L65Rrj321AjrYevMqomTMYIrPQ,19
+latitude_sdk/env/env.py,sha256=MnXexPOHE6aXcAszrDCbW7hzACUv4YtU1bfxpYwvHNw,455
+latitude_sdk/sdk/__init__.py,sha256=UDgjaJ5vTIqv-DPYt4Dtav_7zWUYKcPn3T34oAP2Tps,161
+latitude_sdk/sdk/errors.py,sha256=WNdieePfS6KRiOXUXlh3ryko_Uw_jRjZJg2XZamLYNg,1787
+latitude_sdk/sdk/evaluations.py,sha256=mk_mvS8T4oymvMuKt_lAB1H6RCMfzNDcRT0mTKUYWu4,1451
+latitude_sdk/sdk/latitude.py,sha256=0FjPKe3ZAl8YsOkTL77NKPFBoHrMFyg6SfQmKW-8h6E,2703
+latitude_sdk/sdk/logs.py,sha256=CyHkRJvPl_p7wTSvR9bgxEI5akS0Tjc9FeQRb2C2vMg,1997
+latitude_sdk/sdk/projects.py,sha256=C1f8eQ6Sz1plCvL-l0XDKorCTtz_r13eyG_rIYv29ew,1134
+latitude_sdk/sdk/prompts.py,sha256=1tUNbuqRfZs963x5IOygGU36No-5nJiK3hIBzLEQ1sE,15156
+latitude_sdk/sdk/types.py,sha256=MWJS5rcotbBQjIucvHBlreALMde6_NxJGP3iq5x9eK0,8603
+latitude_sdk/util/__init__.py,sha256=alIDGBnxWH4JvP-UW-7N99seBBi0r1GV1h8f1ERFBec,21
+latitude_sdk/util/utils.py,sha256=kbYWGMIMBsEV-u5woUgW77C-1mSUXyAo6VLuThQ_cj0,2942
+latitude_sdk/version/__init__.py,sha256=av5cneIPX5Jet6040Rlaf9ODQFSRVirka1iagoQJYvA,23
+latitude_sdk/version/version.py,sha256=J-Hw4S7ezvrqUHHbmTboBGNmo4l1LwGcbN6MiZX1Krc,1467
+latitude_sdk-5.0.0b1.dist-info/METADATA,sha256=zCmM2wU49INrMNDRKe-9slQO9800TIxZCJMe3mMg4sI,2356
+latitude_sdk-5.0.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+latitude_sdk-5.0.0b1.dist-info/licenses/LICENSE.md,sha256=yFReu_tr5pjxslWkQREfxA9yVm2r6gay2s6SFCh0XfQ,1073
+latitude_sdk-5.0.0b1.dist-info/RECORD,,

latitude_sdk-4.0.0b1.dist-info/RECORD

@@ -1,22 +0,0 @@
-latitude_sdk/__init__.py,sha256=-AbNXLmzDZeGbRdDIOpNjdCbacOvLBflSJwQtLlZfgk,19
-latitude_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-latitude_sdk/client/__init__.py,sha256=d8CnNB8UoGwcftiIeeC0twdg01qNvfpj-v7O40I7IiE,68
-latitude_sdk/client/client.py,sha256=PR89Qy0hL0GQEEKs4eys7wc3BhIPF_P9N-AJB6ufrV8,9676
-latitude_sdk/client/payloads.py,sha256=z0tLYE9clybYaFWHgMVJgj9w-6exUQgfdB8egLw1-5E,2998
-latitude_sdk/client/router.py,sha256=k5OT42_3riJlTm5Q2BU3AplmpN1FdMxQeIj8GptcllQ,4616
-latitude_sdk/env/__init__.py,sha256=66of5veJ-u1aNI025L65Rrj321AjrYevMqomTMYIrPQ,19
-latitude_sdk/env/env.py,sha256=MnXexPOHE6aXcAszrDCbW7hzACUv4YtU1bfxpYwvHNw,455
-latitude_sdk/sdk/__init__.py,sha256=C9LlIjfnrS7KOK3-ruXKmbT77nSQMm23nZ6-t8sO8ME,137
-latitude_sdk/sdk/errors.py,sha256=9GlGdDE8LGy3dE2Ry_BipBg-tDbQx7LWXJfSnTJSSBE,1747
-latitude_sdk/sdk/evaluations.py,sha256=UP0DKMOLbqcCYrJcxiqgsqUM3anGs8pkAZu1DoOSwxI,1845
-latitude_sdk/sdk/latitude.py,sha256=-569RfclTdfjuEIrbz0y6mH3o3LF7KAAWqphLPBN0dU,2702
-latitude_sdk/sdk/logs.py,sha256=CyHkRJvPl_p7wTSvR9bgxEI5akS0Tjc9FeQRb2C2vMg,1997
-latitude_sdk/sdk/projects.py,sha256=1l6Vvu01-Oi7tp2L1lAhWyZelWIqJVju6rJlR91MVCQ,1458
-latitude_sdk/sdk/prompts.py,sha256=pi2eAYssCcc6q6kwfzyYfV4z2gRoN_eAS1rXYEAobd8,15949
-latitude_sdk/sdk/types.py,sha256=lfSjZUrPed8tNHeJ4vi0HLvpWHFthN9MFCKWGcNY-vg,7481
-latitude_sdk/util/__init__.py,sha256=alIDGBnxWH4JvP-UW-7N99seBBi0r1GV1h8f1ERFBec,21
-latitude_sdk/util/utils.py,sha256=hMOmF-u1QaDgOwXN6ME6n4TaQ70yZKLvijDUqNCMwXI,2844
-latitude_sdk-4.0.0b1.dist-info/METADATA,sha256=o9eFEHQ7z5h7c-A5qpHwwbUDR6pLhO7Bhs-Gpo0u2tA,2372
-latitude_sdk-4.0.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-latitude_sdk-4.0.0b1.dist-info/licenses/LICENSE.md,sha256=yFReu_tr5pjxslWkQREfxA9yVm2r6gay2s6SFCh0XfQ,1073
-latitude_sdk-4.0.0b1.dist-info/RECORD,,