latitude-sdk 3.0.2__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

@@ -8,15 +8,12 @@ import httpx_sse
 
 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
 
@@ -51,12 +48,18 @@ class Client:
 
     @asynccontextmanager
     async def request(
-        self, handler: RequestHandler, params: RequestParams, body: Optional[RequestBody] = None
+        self,
+        handler: RequestHandler,
+        params: Optional[RequestParams] = None,
+        body: Optional[RequestBody] = None,
+        stream: Optional[bool] = None,
     ) -> AsyncGenerator[ClientResponse, Any]:
         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,
@@ -78,7 +81,8 @@ class Client:
 
             while attempt <= self.options.retries:
                 try:
-                    response = await client.request(method=method, url=url, content=content)
+                    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]
@@ -121,6 +125,9 @@ class Client:
             )
 
         try:
+            if not response.is_stream_consumed:
+                await response.aread()
+
             error = ErrorResponse.model_validate_json(response.content)
 
             return ApiError(

latitude_sdk/client/payloads.py

@@ -44,6 +44,7 @@ class RunPromptRequestBody(Model):
     path: str
     parameters: Optional[Dict[str, Any]] = None
     custom_identifier: Optional[str] = Field(default=None, alias=str("customIdentifier"))
+    tools: Optional[List[str]] = None
     stream: Optional[bool] = None
 
 
@@ -53,6 +54,7 @@ class ChatPromptRequestParams(Model):
 
 class ChatPromptRequestBody(Model):
     messages: List[Message]
+    tools: Optional[List[str]] = None
     stream: Optional[bool] = None
 
 
@@ -80,14 +82,23 @@ class AnnotateEvaluationRequestParams(EvaluationRequestParams, Model):
 
 
 class AnnotateEvaluationRequestBody(Model):
-    score: int
-
     class Metadata(Model):
         reason: str
 
+    score: int
     metadata: Optional[Metadata] = None
 
 
+class ToolResultsRequestBody(Model):
+    tool_call_id: str = Field(alias=str("toolCallId"))
+    result: Any
+    is_error: Optional[bool] = Field(default=None, alias=str("isError"))
+
+
+class CreateProjectRequestBody(Model):
+    name: str
+
+
 RequestParams = Union[
     GetPromptRequestParams,
     GetAllPromptRequestParams,
@@ -105,6 +116,8 @@ RequestBody = Union[
     ChatPromptRequestBody,
     CreateLogRequestBody,
     AnnotateEvaluationRequestBody,
+    ToolResultsRequestBody,
+    CreateProjectRequestBody,
 ]
 
 
@@ -116,3 +129,6 @@ class RequestHandler(StrEnum):
     ChatPrompt = "CHAT_PROMPT"
     CreateLog = "CREATE_LOG"
     AnnotateEvaluation = "ANNOTATE_EVALUATION"
+    ToolResults = "TOOL_RESULTS"
+    GetAllProjects = "GET_ALL_PROJECTS"
+    CreateProject = "CREATE_PROJECT"

latitude_sdk/client/router.py

@@ -27,7 +27,7 @@ class Router:
     def __init__(self, options: RouterOptions):
         self.options = options
 
-    def resolve(self, handler: RequestHandler, params: RequestParams) -> Tuple[str, str]:
+    def resolve(self, handler: RequestHandler, params: Optional[RequestParams] = None) -> Tuple[str, str]:
         if handler == RequestHandler.GetPrompt:
             assert isinstance(params, GetPromptRequestParams)
 
@@ -90,6 +90,15 @@ class Router:
 
             return "POST", self.conversations().annotate(params.conversation_uuid, params.evaluation_uuid)
 
+        elif handler == RequestHandler.ToolResults:
+            return "POST", f"{self.options.gateway.base_url}/tools/results"
+
+        elif handler == RequestHandler.GetAllProjects:
+            return "GET", f"{self.options.gateway.base_url}/projects"
+
+        elif handler == RequestHandler.CreateProject:
+            return "POST", f"{self.options.gateway.base_url}/projects"
+
         raise TypeError(f"Unknown handler: {handler}")
 
     class Conversations(Model):

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

@@ -6,6 +6,7 @@ from latitude_sdk.client import Client, ClientOptions, RouterOptions
 from latitude_sdk.env import env
 from latitude_sdk.sdk.evaluations import Evaluations
 from latitude_sdk.sdk.logs import Logs
+from latitude_sdk.sdk.projects import Projects
 from latitude_sdk.sdk.prompts import Prompts
 from latitude_sdk.sdk.types import GatewayOptions, LogSources, SdkOptions
 from latitude_sdk.util import Model
@@ -49,6 +50,7 @@ class Latitude:
 
     promptl: Promptl
 
+    projects: Projects
     prompts: Prompts
     logs: Logs
     evaluations: Evaluations
@@ -76,6 +78,8 @@ 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)
         self.evaluations = Evaluations(self._client, self._options)

latitude_sdk/sdk/projects.py

@@ -0,0 +1,35 @@
+from typing import List
+
+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 CreateProjectResult(Model):
+    project: Project
+    version: Version
+
+
+class Projects:
+    _options: SdkOptions
+    _client: Client
+
+    def __init__(self, client: Client, options: SdkOptions):
+        self._options = options
+        self._client = client
+
+    async def get_all(self) -> List[Project]:
+        async with self._client.request(
+            handler=RequestHandler.GetAllProjects,
+        ) as response:
+            return _GetAllProjectResults.validate_json(response.content)
+
+    async def create(self, name: str) -> CreateProjectResult:
+        async with self._client.request(
+            handler=RequestHandler.CreateProject,
+            body=CreateProjectRequestBody(name=name),
+        ) as response:
+            return CreateProjectResult.model_validate_json(response.content)

latitude_sdk/sdk/prompts.py

@@ -1,7 +1,6 @@
-import asyncio
-from typing import Any, AsyncGenerator, List, Optional, Sequence, Tuple, Union
+from typing import Any, AsyncGenerator, List, Optional, Sequence
 
-from promptl_ai import Adapter, Message, MessageLike, Promptl, ToolMessage, ToolResultContent
+from promptl_ai import Adapter, Message, MessageLike, Promptl
 from promptl_ai.bindings.types import _Message
 
 from latitude_sdk.client import (
@@ -16,21 +15,22 @@ from latitude_sdk.client import (
     RequestHandler,
     RunPromptRequestBody,
     RunPromptRequestParams,
+    ToolResultsRequestBody,
 )
 from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
 from latitude_sdk.sdk.types import (
-    AGENT_END_TOOL_NAME,
     ChainEvents,
     FinishedResult,
     OnStep,
     OnToolCall,
     OnToolCallDetails,
     Prompt,
+    ProviderEvents,
+    ProviderEventToolCalled,
     Providers,
     SdkOptions,
     StreamCallbacks,
     StreamEvents,
-    ToolCall,
     ToolResult,
     _LatitudeEvent,
 )
@@ -52,10 +52,6 @@ _PROMPT_ATTR_TO_ADAPTER_ATTR = {
 }
 
 
-class OnToolCallPaused(Exception):
-    pass
-
-
 class PromptOptions(Model):
     project_id: Optional[int] = None
     version_uuid: Optional[str] = None
@@ -142,31 +138,19 @@ class Prompts:
                 response="Project ID is required",
             )
 
-    async def _extract_agent_tool_requests(
-        self, tool_requests: List[ToolCall]
-    ) -> Tuple[List[ToolCall], List[ToolCall]]:
-        agent: List[ToolCall] = []
-        other: List[ToolCall] = []
-
-        for tool in tool_requests:
-            if tool.name == AGENT_END_TOOL_NAME:
-                agent.append(tool)
-            else:
-                other.append(tool)
-
-        return agent, other
-
     async def _handle_stream(
-        self, stream: AsyncGenerator[ClientEvent, Any], on_event: Optional[StreamCallbacks.OnEvent]
+        self,
+        stream: AsyncGenerator[ClientEvent, Any],
+        on_event: Optional[StreamCallbacks.OnEvent],
+        tools: Optional[dict[str, OnToolCall]],
     ) -> FinishedResult:
         uuid = None
         conversation: List[Message] = []
         response = None
-        agent_response = None
-        tool_requests: List[ToolCall] = []
 
         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)
@@ -176,9 +160,6 @@ class Prompts:
                 if event.type == ChainEvents.ProviderCompleted:
                     response = event.response
 
-                elif event.type == ChainEvents.ToolsRequested:
-                    tool_requests = event.tools
-
                 elif event.type == ChainEvents.ChainError:
                     raise ApiError(
                         status=400,
@@ -191,6 +172,9 @@ class Prompts:
                 event = stream_event.json()
                 event["event"] = StreamEvents.Provider
 
+                if event.get("type") == str(ProviderEvents.ToolCalled):
+                    tool_call = ProviderEventToolCalled.model_validate_json(stream_event.data)
+
             else:
                 raise ApiError(
                     status=500,
@@ -202,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,
@@ -210,21 +197,7 @@ class Prompts:
                 response="Stream ended without a chain-complete event. Missing uuid or response.",
             )
 
-        agent_requests, tool_requests = await self._extract_agent_tool_requests(tool_requests)
-        if len(agent_requests) > 0:
-            agent_response = agent_requests[0].arguments
-
-        return FinishedResult(
-            uuid=uuid,
-            conversation=conversation,
-            response=response,
-            agent_response=agent_response,
-            tool_requests=tool_requests,
-        )
-
-    @staticmethod
-    def _pause_tool_execution() -> Any:
-        raise OnToolCallPaused()
+        return FinishedResult(uuid=uuid, conversation=conversation, response=response)
 
     @staticmethod
     async def _wrap_tool_handler(
@@ -235,69 +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:
-            if isinstance(exception, OnToolCallPaused):
-                raise exception
-
             return ToolResult(**tool_result, result=str(exception), is_error=True)
 
-    async def _handle_tool_calls(
-        self, result: FinishedResult, options: Union[RunPromptOptions, ChatPromptOptions]
-    ) -> Optional[FinishedResult]:
-        if not options.tools:
+    async def _handle_tool_call(
+        self, tool_call: ProviderEventToolCalled, tools: Optional[dict[str, OnToolCall]]
+    ) -> None:
+        # 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="Tools not supplied",
-                response="Tools not supplied",
+                message=f"Tool {tool_call.name} not supplied",
+                response=f"Tool {tool_call.name} not supplied",
             )
 
-        for tool_call in result.tool_requests:
-            if tool_call.name not in options.tools:
-                raise ApiError(
-                    status=400,
-                    code=ApiErrorCodes.AIRunError,
-                    message=f"Tool {tool_call.name} not supplied",
-                    response=f"Tool {tool_call.name} not supplied",
-                )
-
-        tool_results = await asyncio.gather(
-            *[
-                self._wrap_tool_handler(
-                    options.tools[tool_call.name],
-                    tool_call.arguments,
-                    OnToolCallDetails(
-                        id=tool_call.id,
-                        name=tool_call.name,
-                        conversation_uuid=result.uuid,
-                        messages=result.conversation,
-                        pause_execution=self._pause_tool_execution,
-                        requested_tool_calls=result.tool_requests,
-                    ),
-                )
-                for tool_call in result.tool_requests
-            ],
-            return_exceptions=False,
+        tool_result = await self._wrap_tool_handler(
+            tool_handler,
+            tool_call.arguments,
+            OnToolCallDetails(
+                id=tool_call.id,
+                name=tool_call.name,
+                arguments=tool_call.arguments,
+            ),
         )
 
-        tool_messages = [
-            ToolMessage(
-                content=[
-                    ToolResultContent(
-                        id=tool_result.id,
-                        name=tool_result.name,
-                        result=tool_result.result,
-                        is_error=tool_result.is_error,
-                    )
-                ]
-            )
-            for tool_result in tool_results
-        ]
-
-        next_result = await self.chat(result.uuid, tool_messages, ChatPromptOptions(**dict(options)))
-
-        return FinishedResult(**dict(next_result)) if next_result else None
+        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 {})})
@@ -364,22 +313,16 @@ class Prompts:
                     path=path,
                     parameters=options.parameters,
                     custom_identifier=options.custom_identifier,
+                    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)
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = RunPromptResult.model_validate_json(response.content)
 
-            if options.tools and result.tool_requests:
-                try:
-                    # NOTE: The last sdk.chat called will already call on_finished
-                    final_result = await self._handle_tool_calls(result, options)
-                    return RunPromptResult(**dict(final_result)) if final_result else None
-                except OnToolCallPaused:
-                    pass
-
             if options.on_finished:
                 options.on_finished(FinishedResult(**dict(result)))
 
@@ -416,22 +359,16 @@ 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)
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = ChatPromptResult.model_validate_json(response.content)
 
-            if options.tools and result.tool_requests:
-                try:
-                    # NOTE: The last sdk.chat called will already call on_finished
-                    final_result = await self._handle_tool_calls(result, options)
-                    return ChatPromptResult(**dict(final_result)) if final_result else None
-                except OnToolCallPaused:
-                    pass
-
             if options.on_finished:
                 options.on_finished(FinishedResult(**dict(result)))
 

latitude_sdk/sdk/types.py

@@ -1,7 +1,6 @@
 from datetime import datetime
 from typing import (
     Any,
-    Callable,
     List,
     Literal,
     Optional,
@@ -31,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"
 
 
@@ -69,10 +72,6 @@ class FinishReason(StrEnum):
     Unknown = "unknown"
 
 
-AGENT_START_TOOL_NAME = "start_autonomous_chain"
-AGENT_END_TOOL_NAME = "end_autonomous_chain"
-
-
 class ToolCall(Model):
     id: str
     name: str
@@ -118,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]
 
 
@@ -131,7 +147,6 @@ class ChainEvents(StrEnum):
     StepCompleted = "step-completed"
     ChainCompleted = "chain-completed"
     ChainError = "chain-error"
-    ToolsRequested = "tools-requested"
 
 
 class GenericChainEvent(Model):
@@ -140,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"))
@@ -161,35 +176,30 @@ 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
 
 
-class ChainEventToolsRequested(GenericChainEvent):
-    type: Literal[ChainEvents.ToolsRequested] = ChainEvents.ToolsRequested
-    tools: List[ToolCall]
-
-
 ChainEvent = Union[
     ChainEventChainStarted,
     ChainEventStepStarted,
@@ -200,7 +210,6 @@ ChainEvent = Union[
     ChainEventStepCompleted,
     ChainEventChainCompleted,
     ChainEventChainError,
-    ChainEventToolsRequested,
 ]
 
 LatitudeEvent = ChainEvent
@@ -211,8 +220,6 @@ class FinishedResult(Model):
     uuid: str
     conversation: List[Message]
     response: ChainResponse
-    agent_response: Optional[dict[str, Any]] = Field(default=None, alias=str("agentResponse"))
-    tool_requests: List[ToolCall] = Field(alias=str("toolRequests"))
 
 
 StreamEvent = Union[ProviderEvent, LatitudeEvent]
@@ -240,6 +247,37 @@ 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
+    name: str
+    created_at: datetime = Field(alias=str("createdAt"))
+    updated_at: datetime = Field(alias=str("updatedAt"))
+
+
+class Version(Model):
+    id: int
+    uuid: 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):
     @runtime_checkable
     class OnEvent(Protocol):
@@ -263,10 +301,7 @@ class StreamCallbacks(Model):
 class OnToolCallDetails(Model):
     id: str
     name: str
-    conversation_uuid: str
-    messages: List[Message]
-    pause_execution: Callable[[], ToolResult]
-    requested_tool_calls: List[ToolCall]
+    arguments: dict[str, Any]
 
 
 @runtime_checkable

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-3.0.2.dist-info → latitude_sdk-5.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 3.0.2
+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
@@ -46,7 +46,7 @@ await sdk.prompts.run("joke-teller", RunPromptOptions(
 ))
 ```
 
-Find more [examples](https://github.com/latitude-dev/latitude-llm/tree/main/examples/sdks/python).
+Find more [examples](https://docs.latitude.so/examples/sdk).
 
 ## Development
 
@@ -60,7 +60,15 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
-## Run only one test
+### Running only a specific test
+
+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
@@ -70,18 +78,12 @@ async def my_test(self):
     # ... your code
 ```
 
-And then run the tests with the marker `only`:
+...and then run the tests with the marker `only`:
 
 ```sh
 uv run scripts/test.py -m only
 ```
 
-Other way is all in line:
-
-```python
-uv run scripts/test.py <test_path>::<test_case>::<test_name>
-```
-
 ## License
 
-The SDK is licensed under the [LGPL-3.0 License](https://opensource.org/licenses/LGPL-3.0) - read the [LICENSE](/LICENSE) file for details.
+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-3.0.2.dist-info/RECORD

@@ -1,21 +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=Tlg0IU7_64O9yo0BfQEdVwVsjp-5_DUwJZqlX3uEb0w,4399
-latitude_sdk/client/payloads.py,sha256=XiGadgaZhCMKa2auBPLln6RTEt8RwEqx_H8FoSv5h2c,2554
-latitude_sdk/client/router.py,sha256=sdNvUNXqoM5TDmvN7toyJWuI8Lt4Z6MhKmWWKitEFes,4218
-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=lUlGOiZXSFt0zm3sTHfBgjKzbcVJueMk6MXTGn9WCn8,2570
-latitude_sdk/sdk/logs.py,sha256=CyHkRJvPl_p7wTSvR9bgxEI5akS0Tjc9FeQRb2C2vMg,1997
-latitude_sdk/sdk/prompts.py,sha256=WztCpDSt0mxng0N2hyIrrzEw1TanqGRIl7Cpc_5ei4M,17369
-latitude_sdk/sdk/types.py,sha256=e_AQ6YGRNgYvPJOxD5rndH5zPtslKMBhBtLocWlIHQE,7626
-latitude_sdk/util/__init__.py,sha256=alIDGBnxWH4JvP-UW-7N99seBBi0r1GV1h8f1ERFBec,21
-latitude_sdk/util/utils.py,sha256=hMOmF-u1QaDgOwXN6ME6n4TaQ70yZKLvijDUqNCMwXI,2844
-latitude_sdk-3.0.2.dist-info/METADATA,sha256=g4QEGAQTK70uOBQ8Sp82rlqsvQ5IckTW2d1qEoAkmKw,2347
-latitude_sdk-3.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-latitude_sdk-3.0.2.dist-info/licenses/LICENSE.md,sha256=yFReu_tr5pjxslWkQREfxA9yVm2r6gay2s6SFCh0XfQ,1073
-latitude_sdk-3.0.2.dist-info/RECORD,,