latitude-sdk 3.0.1__py3-none-any.whl → 4.0.0b1__py3-none-any.whl

latitude_sdk/client/client.py

@@ -1,12 +1,17 @@
 import asyncio
 import json
 from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Optional
+from typing import Any, AsyncGenerator, Awaitable, Callable, 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,
@@ -51,65 +56,169 @@ 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,
+    ) -> 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]:
-        client = httpx.AsyncClient(
-            headers={
-                "Authorization": f"Bearer {self.options.api_key}",
-                "Content-Type": "application/json",
-            },
+        """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,
             timeout=self.options.timeout,
             follow_redirects=False,
             max_redirects=0,
-        )
-        response = None
-        attempt = 1
+        ) as client:
+            response = await self._execute_with_retry(
+                lambda: client.stream(method=method, url=url, content=content),  # type: ignore
+                is_streaming=True,
+            )
 
-        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:
-                    response = await client.request(method=method, url=url, content=content)
-                    response.raise_for_status()
-
-                    yield response  # pyright: ignore [reportReturnType]
-                    break
+            # 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
 
-                except Exception as exception:
-                    if isinstance(exception, ApiError):
-                        raise exception
+        for attempt in range(1, self.options.retries + 1):
+            response_cm = None
+            response = None
 
-                    if attempt >= self.options.retries:
-                        raise await self._exception(exception, response) from exception
+            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()
 
-                    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
+                response.raise_for_status()  # type: ignore
+                return response  # type: ignore
 
-                finally:
-                    if response:
-                        await response.aclose()
+            except Exception as exception:
+                last_exception = exception
 
-                    attempt += 1
+                # 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)
 
-        except Exception as exception:
-            if isinstance(exception, ApiError):
-                raise exception
+                # Don't retry ApiErrors - they're business logic errors
+                if isinstance(exception, ApiError):
+                    raise exception
 
-            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
+
+                # 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
+
+                # For non-retriable errors, don't retry
+                break
 
-        finally:
-            await client.aclose()
+        # If we get here, all retries failed
+        raise await self._exception(last_exception, last_response) from last_exception  # type: ignore
+
+    def _calculate_delay(self, attempt: int) -> float:
+        """Calculate exponential backoff delay."""
+        return self.options.delay * (2 ** (attempt - 1))
 
     async def _exception(self, exception: Exception, response: Optional[httpx.Response] = None) -> ApiError:
         if not response:
@@ -120,14 +229,41 @@ 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
+
+            # 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,
             )
 
@@ -136,5 +272,5 @@ class Client:
                 status=response.status_code,
                 code=ApiErrorCodes.InternalServerError,
                 message=str(exception),
-                response=response.text,
+                response=response_text,
             )

latitude_sdk/client/payloads.py

@@ -45,6 +45,7 @@ class RunPromptRequestBody(Model):
     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
 
 
 class ChatPromptRequestParams(Model):
@@ -88,6 +89,16 @@ class AnnotateEvaluationRequestBody(Model):
     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/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,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)
         self.evaluations = Evaluations(self._client, self._options)

latitude_sdk/sdk/projects.py

@@ -0,0 +1,41 @@
+import json
+from typing import List
+
+from latitude_sdk.client import Client
+from latitude_sdk.client.payloads import CreateProjectRequestBody, RequestHandler
+from latitude_sdk.sdk.types import Project, SdkOptions, Version
+
+
+class CreateProjectResponse:
+    def __init__(self, project: Project, version: Version):
+        self.project = project
+        self.version = version
+
+
+class Projects:
+    _client: Client
+    _options: SdkOptions
+
+    def __init__(self, client: Client, options: SdkOptions):
+        self._client = client
+        self._options = options
+
+    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]
+
+    async def create(self, name: str) -> CreateProjectResponse:
+        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"])),
+            )

latitude_sdk/sdk/prompts.py

@@ -1,7 +1,11 @@
-import asyncio
-from typing import Any, AsyncGenerator, List, Optional, Sequence, Tuple, Union
+from typing import Any, AsyncGenerator, Callable, 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,10 +20,10 @@ 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,
@@ -30,7 +34,6 @@ from latitude_sdk.sdk.types import (
     SdkOptions,
     StreamCallbacks,
     StreamEvents,
-    ToolCall,
     ToolResult,
     _LatitudeEvent,
 )
@@ -52,10 +55,6 @@ _PROMPT_ATTR_TO_ADAPTER_ATTR = {
 }
 
 
-class OnToolCallPaused(Exception):
-    pass
-
-
 class PromptOptions(Model):
     project_id: Optional[int] = None
     version_uuid: Optional[str] = None
@@ -142,28 +141,15 @@ 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],
+        on_tool_call: Optional[Callable[[dict[str, Any]], Any]] = None,
     ) -> FinishedResult:
         uuid = None
         conversation: List[Message] = []
         response = None
-        agent_response = None
-        tool_requests: List[ToolCall] = []
 
         async for stream_event in stream:
             event = None
@@ -176,9 +162,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 +174,10 @@ 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)
+
             else:
                 raise ApiError(
                     status=500,
@@ -210,22 +197,12 @@ 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()
-
     @staticmethod
     async def _wrap_tool_handler(
         handler: OnToolCall, arguments: dict[str, Any], details: OnToolCallDetails
@@ -237,67 +214,64 @@ class Prompts:
 
             return ToolResult(**tool_result, result=result)
         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:
-            raise ApiError(
-                status=400,
-                code=ApiErrorCodes.AIRunError,
-                message="Tools not supplied",
-                response="Tools 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",
-                )
+    async def _handle_tool_call(
+        self,
+        event: dict[str, Any],
+        tools: 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:
+            return
+
+        tool_result = await self._wrap_tool_handler(
+            tool,
+            args,
+            OnToolCallDetails(
+                id=toolCallId,
+                name=toolName,
+                arguments=args,
+            ),
+        )
 
-        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,
-                    ),
+        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),
                 )
-                for tool_call in result.tool_requests
-            ],
-            return_exceptions=False,
-        )
 
-        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
-        ]
+            # Add context about which tool failed
+            message = f"Failed to execute tool {toolName}. \nLatitude API returned the following error:\
+                    \n\n{exception.message}"
 
-        next_result = await self.chat(result.uuid, tool_messages, ChatPromptOptions(**dict(options)))
+            raise ApiError(
+                status=exception.status,
+                code=exception.code,
+                message=message,
+                response=exception.response,
+            ) from exception
 
-        return FinishedResult(**dict(next_result)) if next_result else None
+    def _on_tool_call(self, tools: dict[str, OnToolCall]) -> Callable[[dict[str, Any]], Any]:
+        return lambda event: self._handle_tool_call(event, tools)
 
     async def get(self, path: str, options: Optional[GetPromptOptions] = None) -> GetPromptResult:
         options = GetPromptOptions(**{**dict(self._options), **dict(options or {})})
@@ -365,21 +339,18 @@ class Prompts:
                     parameters=options.parameters,
                     custom_identifier=options.custom_identifier,
                     stream=options.stream,
+                    tools=list(options.tools.keys()) if options.tools and options.stream else None,
                 ),
             ) 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,
+                        self._on_tool_call(options.tools if options.tools else {}),
+                    )
                 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)))
 
@@ -402,7 +373,10 @@ 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 {})})
 
@@ -420,18 +394,14 @@ class Prompts:
                 ),
             ) 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,
+                        self._on_tool_call(options.tools if options.tools else {}),
+                    )
                 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)))
 
@@ -481,7 +451,10 @@ 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

@@ -1,7 +1,6 @@
 from datetime import datetime
 from typing import (
     Any,
-    Callable,
     List,
     Literal,
     Optional,
@@ -70,7 +69,6 @@ class FinishReason(StrEnum):
 
 
 AGENT_START_TOOL_NAME = "start_autonomous_chain"
-AGENT_END_TOOL_NAME = "end_autonomous_chain"
 
 
 class ToolCall(Model):
@@ -131,7 +129,6 @@ class ChainEvents(StrEnum):
     StepCompleted = "step-completed"
     ChainCompleted = "chain-completed"
     ChainError = "chain-error"
-    ToolsRequested = "tools-requested"
 
 
 class GenericChainEvent(Model):
@@ -185,11 +182,6 @@ class ChainEventChainError(GenericChainEvent):
     error: ChainError
 
 
-class ChainEventToolsRequested(GenericChainEvent):
-    type: Literal[ChainEvents.ToolsRequested] = ChainEvents.ToolsRequested
-    tools: List[ToolCall]
-
-
 ChainEvent = Union[
     ChainEventChainStarted,
     ChainEventStepStarted,
@@ -200,7 +192,6 @@ ChainEvent = Union[
     ChainEventStepCompleted,
     ChainEventChainCompleted,
     ChainEventChainError,
-    ChainEventToolsRequested,
 ]
 
 LatitudeEvent = ChainEvent
@@ -211,8 +202,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 +229,22 @@ class Log(Model):
     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):
+    uuid: str
+    name: str
+    project_id: int = Field(alias=str("projectId"))
+    created_at: datetime = Field(alias=str("createdAt"))
+    updated_at: datetime = Field(alias=str("updatedAt"))
+
+
 class StreamCallbacks(Model):
     @runtime_checkable
     class OnEvent(Protocol):
@@ -263,10 +268,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-3.0.1.dist-info → latitude_sdk-4.0.0b1.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 3.0.1
+Version: 4.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
 Project-URL: documentation, https://github.com/latitude-dev/latitude-llm/tree/main/packages/sdks/python#readme
 Author-email: Latitude Data SL <hello@latitude.so>
 Maintainer-email: Latitude Data SL <hello@latitude.so>
-License-Expression: LGPL-3.0
+License-Expression: MIT
+License-File: LICENSE.md
 Requires-Python: <3.13,>=3.9
 Requires-Dist: httpx-sse>=0.4.0
 Requires-Dist: httpx>=0.28.1
@@ -45,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
 
@@ -59,7 +60,9 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
-## Run only one test
+### Running only a specific test
+
+Mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -69,13 +72,13 @@ 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:
+Another way is to specify the test in line:
 
 ```python
 uv run scripts/test.py <test_path>::<test_case>::<test_name>
@@ -83,4 +86,4 @@ 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-4.0.0b1.dist-info/RECORD

@@ -0,0 +1,22 @@
+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,,

latitude_sdk-4.0.0b1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Latitude Data SL 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

latitude_sdk-3.0.1.dist-info/RECORD

@@ -1,20 +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.1.dist-info/METADATA,sha256=9z1D0tOFBqpvUZl89T75YQdbJZqbkhVDI3VPlT4yhZg,2327
-latitude_sdk-3.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-latitude_sdk-3.0.1.dist-info/RECORD,,