latitude-sdk 0.1.0b8__tar.gz → 1.0.0__tar.gz

{latitude_sdk-0.1.0b8 → latitude_sdk-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 0.1.0b8
+Version: 1.0.0
 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
@@ -11,7 +11,8 @@ License-Expression: LGPL-3.0
 Requires-Python: <3.13,>=3.9
 Requires-Dist: httpx-sse>=0.4.0
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: latitude-telemetry>=0.1.0b6
+Requires-Dist: latitude-telemetry>=1.0.0
+Requires-Dist: promptl-ai>=1.0.1
 Requires-Dist: pydantic>=2.10.3
 Requires-Dist: typing-extensions>=4.12.2
 Description-Content-Type: text/markdown

{latitude_sdk-0.1.0b8 → latitude_sdk-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "0.1.0-beta.8"
+version = "1.0.0"
 description = "Latitude SDK for Python"
 authors = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
 maintainers = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
@@ -15,7 +15,8 @@ dependencies = [
     "httpx-sse>=0.4.0",
     "pydantic>=2.10.3",
     "typing-extensions>=4.12.2",
-    "latitude-telemetry>=0.1.0b6",
+    "latitude-telemetry>=1.0.0",
+    "promptl-ai>=1.0.1",
 ]
 
 [dependency-groups]

{latitude_sdk-0.1.0b8 → latitude_sdk-1.0.0}/src/latitude_sdk/client/payloads.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict, List, Optional, Union
 
-from latitude_sdk.sdk.types import DbErrorRef, Message
+from promptl_ai import Message
+
+from latitude_sdk.sdk.types import DbErrorRef
 from latitude_sdk.util import Field, Model, StrEnum
 
 

{latitude_sdk-0.1.0b8 → latitude_sdk-1.0.0}/src/latitude_sdk/sdk/evaluations.py

@@ -8,10 +8,7 @@ from latitude_sdk.client import (
     TriggerEvaluationRequestBody,
     TriggerEvaluationRequestParams,
 )
-from latitude_sdk.sdk.types import (
-    EvaluationResult,
-    SdkOptions,
-)
+from latitude_sdk.sdk.types import EvaluationResult, SdkOptions
 from latitude_sdk.util import Model
 
 
@@ -40,7 +37,9 @@ class Evaluations:
         self._options = options
         self._client = client
 
-    async def trigger(self, uuid: str, options: TriggerEvaluationOptions) -> TriggerEvaluationResult:
+    async def trigger(self, uuid: str, options: Optional[TriggerEvaluationOptions] = None) -> TriggerEvaluationResult:
+        options = TriggerEvaluationOptions(**{**dict(self._options), **dict(options or {})})
+
         async with self._client.request(
             handler=RequestHandler.TriggerEvaluation,
             params=TriggerEvaluationRequestParams(
@@ -55,6 +54,8 @@ class Evaluations:
     async def create_result(
         self, uuid: str, evaluation_uuid: str, options: CreateEvaluationResultOptions
     ) -> CreateEvaluationResultResult:
+        options = CreateEvaluationResultOptions(**{**dict(self._options), **dict(options)})
+
         async with self._client.request(
             handler=RequestHandler.CreateEvaluationResult,
             params=CreateEvaluationResultRequestParams(

{latitude_sdk-0.1.0b8 → latitude_sdk-1.0.0}/src/latitude_sdk/sdk/latitude.py

@@ -1,6 +1,7 @@
 from typing import Optional
 
 from latitude_telemetry import Telemetry, TelemetryOptions
+from promptl_ai import Promptl, PromptlOptions
 
 from latitude_sdk.client import Client, ClientOptions, RouterOptions
 from latitude_sdk.env import env
@@ -20,6 +21,7 @@ class InternalOptions(Model):
 
 
 class LatitudeOptions(SdkOptions, Model):
+    promptl: Optional[PromptlOptions] = None
     telemetry: Optional[TelemetryOptions] = None
     internal: Optional[InternalOptions] = None
 
@@ -39,7 +41,7 @@ DEFAULT_INTERNAL_OPTIONS = InternalOptions(
 
 
 DEFAULT_LATITUDE_OPTIONS = LatitudeOptions(
-    telemetry=None,  # Note: Telemetry is opt-in
+    telemetry=None,  # NOTE: Telemetry is opt-in
     internal=DEFAULT_INTERNAL_OPTIONS,
 )
 
@@ -48,15 +50,16 @@ class Latitude:
     _options: LatitudeOptions
     _client: Client
 
+    promptl: Promptl
     telemetry: Optional[Telemetry]
 
     prompts: Prompts
     logs: Logs
     evaluations: Evaluations
 
-    def __init__(self, api_key: str, options: LatitudeOptions):
+    def __init__(self, api_key: str, options: Optional[LatitudeOptions] = None):
+        options = LatitudeOptions(**{**dict(DEFAULT_LATITUDE_OPTIONS), **dict(options or {})})
         options.internal = InternalOptions(**{**dict(DEFAULT_INTERNAL_OPTIONS), **dict(options.internal or {})})
-        options = LatitudeOptions(**{**dict(DEFAULT_LATITUDE_OPTIONS), **dict(options)})
         self._options = options
 
         assert self._options.internal is not None
@@ -77,9 +80,10 @@ class Latitude:
             )
         )
 
+        self.promptl = Promptl(self._options.promptl)
         if self._options.telemetry:
             self.telemetry = Telemetry(api_key, self._options.telemetry)
 
-        self.prompts = Prompts(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-0.1.0b8 → latitude_sdk-1.0.0}/src/latitude_sdk/sdk/logs.py

@@ -1,13 +1,11 @@
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Optional, Sequence
+
+from promptl_ai import MessageLike
+from promptl_ai.bindings.types import _Message
 
 from latitude_sdk.client import Client, CreateLogRequestBody, CreateLogRequestParams, RequestHandler
 from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
-from latitude_sdk.sdk.types import (
-    Log,
-    Message,
-    SdkOptions,
-    _Message,
-)
+from latitude_sdk.sdk.types import Log, SdkOptions
 from latitude_sdk.util import Model
 
 
@@ -32,9 +30,8 @@ class Logs:
         self._options = options
         self._client = client
 
-    def _ensure_options(self, options: LogOptions) -> LogOptions:
-        project_id = options.project_id or self._options.project_id
-        if not project_id:
+    def _ensure_log_options(self, options: LogOptions):
+        if not options.project_id:
             raise ApiError(
                 status=404,
                 code=ApiErrorCodes.NotFoundError,
@@ -42,16 +39,11 @@ class Logs:
                 response="Project ID is required",
             )
 
-        version_uuid = options.version_uuid or self._options.version_uuid
-
-        return LogOptions(project_id=project_id, version_uuid=version_uuid)
-
     async def create(
-        self, path: str, messages: Sequence[Union[Message, Dict[str, Any]]], options: CreateLogOptions
+        self, path: str, messages: Sequence[MessageLike], options: Optional[CreateLogOptions] = None
     ) -> CreateLogResult:
-        log_options = self._ensure_options(options)
-        options = CreateLogOptions(**{**dict(options), **dict(log_options)})
-
+        options = CreateLogOptions(**{**dict(self._options), **dict(options or {})})
+        self._ensure_log_options(options)
         assert options.project_id is not None
 
         messages = [_Message.validate_python(message) for message in messages]

latitude_sdk-1.0.0/src/latitude_sdk/sdk/prompts.py

@@ -0,0 +1,453 @@
+import asyncio
+from typing import Any, AsyncGenerator, Dict, List, Optional, Sequence, Union
+
+from promptl_ai import Adapter, Message, MessageLike, Promptl, ToolMessage, ToolResultContent
+from promptl_ai.bindings.types import _Message
+
+from latitude_sdk.client import (
+    ChatPromptRequestBody,
+    ChatPromptRequestParams,
+    Client,
+    ClientEvent,
+    GetOrCreatePromptRequestBody,
+    GetOrCreatePromptRequestParams,
+    GetPromptRequestParams,
+    RequestHandler,
+    RunPromptRequestBody,
+    RunPromptRequestParams,
+)
+from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
+from latitude_sdk.sdk.types import (
+    ChainEventCompleted,
+    ChainEventError,
+    ChainEvents,
+    ChainEventStep,
+    ChainEventStepCompleted,
+    FinishedEvent,
+    OnStep,
+    OnToolCall,
+    OnToolCallDetails,
+    Prompt,
+    Providers,
+    SdkOptions,
+    StreamCallbacks,
+    StreamEvents,
+    StreamTypes,
+    ToolResult,
+)
+from latitude_sdk.util import Model
+
+_PROVIDER_TO_ADAPTER = {
+    Providers.OpenAI: Adapter.OpenAI,
+    Providers.Anthropic: Adapter.Anthropic,
+}
+
+_PROMPT_ATTR_TO_ADAPTER_ATTR = {
+    "maxTokens": ("max_tokens", [Adapter.OpenAI, Adapter.Anthropic]),
+    "topP": ("top_p", [Adapter.OpenAI, Adapter.Anthropic]),
+    "topK": ("top_k", [Adapter.OpenAI, Adapter.Anthropic]),
+    "presencePenalty": ("presence_penalty", [Adapter.OpenAI, Adapter.Anthropic]),
+    "stopSequences": ("stop_sequences", [Adapter.OpenAI, Adapter.Anthropic]),
+    "toolChoice": ("tool_choice", [Adapter.OpenAI, Adapter.Anthropic]),
+}
+
+
+class OnToolCallPaused(Exception):
+    pass
+
+
+class PromptOptions(Model):
+    project_id: Optional[int] = None
+    version_uuid: Optional[str] = None
+
+
+class GetPromptOptions(PromptOptions, Model):
+    pass
+
+
+class GetPromptResult(Prompt, Model):
+    pass
+
+
+class GetOrCreatePromptOptions(PromptOptions, Model):
+    prompt: Optional[str] = None
+
+
+class GetOrCreatePromptResult(Prompt, Model):
+    pass
+
+
+class RunPromptOptions(StreamCallbacks, PromptOptions, Model):
+    custom_identifier: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+    tools: Optional[Dict[str, OnToolCall]] = None
+    stream: Optional[bool] = None
+
+
+class RunPromptResult(FinishedEvent, Model):
+    pass
+
+
+class ChatPromptOptions(StreamCallbacks, Model):
+    tools: Optional[Dict[str, OnToolCall]] = None
+    stream: Optional[bool] = None
+
+
+class ChatPromptResult(FinishedEvent, Model):
+    pass
+
+
+class RenderPromptOptions(Model):
+    parameters: Optional[Dict[str, Any]] = None
+    adapter: Optional[Adapter] = None
+
+
+class RenderPromptResult(Model):
+    messages: List[MessageLike]
+    config: Dict[str, Any]
+
+
+class RenderChainOptions(Model):
+    parameters: Optional[Dict[str, Any]] = None
+    adapter: Optional[Adapter] = None
+
+
+class RenderChainResult(RenderPromptResult, Model):
+    pass
+
+
+class Prompts:
+    _options: SdkOptions
+    _client: Client
+    _promptl: Promptl
+
+    def __init__(self, client: Client, promptl: Promptl, options: SdkOptions):
+        self._options = options
+        self._client = client
+        self._promptl = promptl
+
+    def _ensure_prompt_options(self, options: PromptOptions):
+        if not options.project_id:
+            raise ApiError(
+                status=404,
+                code=ApiErrorCodes.NotFoundError,
+                message="Project ID is required",
+                response="Project ID is required",
+            )
+
+    async def _handle_stream(
+        self, stream: AsyncGenerator[ClientEvent, Any], on_event: Optional[StreamCallbacks.OnEvent]
+    ) -> FinishedEvent:
+        uuid = None
+        conversation: List[Message] = []
+        response = None
+
+        async for stream_event in stream:
+            event = None
+
+            if stream_event.event == str(StreamEvents.Latitude):
+                type = stream_event.json().get("type")
+
+                if type == str(ChainEvents.Step):
+                    event = ChainEventStep.model_validate_json(stream_event.data)
+                    conversation.extend(event.messages)
+
+                elif type == str(ChainEvents.StepCompleted):
+                    event = ChainEventStepCompleted.model_validate_json(stream_event.data)
+
+                elif type == str(ChainEvents.Completed):
+                    event = ChainEventCompleted.model_validate_json(stream_event.data)
+                    uuid = event.uuid
+                    conversation.extend(event.messages or [])
+                    response = event.response
+
+                elif type == str(ChainEvents.Error):
+                    event = ChainEventError.model_validate_json(stream_event.data)
+                    raise ApiError(
+                        status=400,
+                        code=ApiErrorCodes.AIRunError,
+                        message=event.error.message,
+                        response=stream_event.data,
+                    )
+
+                else:
+                    raise ApiError(
+                        status=500,
+                        code=ApiErrorCodes.InternalServerError,
+                        message=f"Unknown latitude event: {type}",
+                        response=stream_event.data,
+                    )
+
+            elif stream_event.event == str(StreamEvents.Provider):
+                event = stream_event.json()
+                event["event"] = StreamEvents.Provider
+
+            else:
+                raise ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=f"Unknown stream event: {stream_event.event}",
+                    response=stream_event.data,
+                )
+
+            if on_event:
+                on_event(event)
+
+        if not uuid or not response:
+            raise ApiError(
+                status=500,
+                code=ApiErrorCodes.InternalServerError,
+                message="Stream ended without a chain-complete event. Missing uuid or response.",
+                response="Stream ended without a chain-complete event. Missing uuid or response.",
+            )
+
+        # NOTE: FinishedEvent not in on_event
+        return FinishedEvent(uuid=uuid, conversation=conversation, response=response)
+
+    def _pause_tool_execution(self) -> ToolResult:
+        raise OnToolCallPaused()
+
+    async def _handle_tool_calls(
+        self, result: FinishedEvent, options: Union[RunPromptOptions, ChatPromptOptions]
+    ) -> Optional[FinishedEvent]:
+        # Seems Python cannot infer the type
+        assert result.response.type == StreamTypes.Text and result.response.tool_calls is not None
+
+        if not options.tools:
+            raise ApiError(
+                status=400,
+                code=ApiErrorCodes.AIRunError,
+                message="Tools not supplied",
+                response="Tools not supplied",
+            )
+
+        for tool_call in result.response.tool_calls:
+            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",
+                )
+
+        details = OnToolCallDetails(
+            conversation_uuid=result.uuid,
+            messages=result.conversation,
+            pause_execution=self._pause_tool_execution,
+            requested_tool_calls=result.response.tool_calls,
+        )
+
+        tool_results = await asyncio.gather(
+            *[options.tools[tool_call.name](tool_call, details) for tool_call in result.response.tool_calls],
+            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
+        ]
+
+        next_result = await self.chat(result.uuid, tool_messages, ChatPromptOptions(**dict(options)))
+
+        return FinishedEvent(**dict(next_result)) if next_result else None
+
+    async def get(self, path: str, options: Optional[GetPromptOptions] = None) -> GetPromptResult:
+        options = GetPromptOptions(**{**dict(self._options), **dict(options or {})})
+        self._ensure_prompt_options(options)
+        assert options.project_id is not None
+
+        async with self._client.request(
+            handler=RequestHandler.GetPrompt,
+            params=GetPromptRequestParams(
+                project_id=options.project_id,
+                version_uuid=options.version_uuid,
+                path=path,
+            ),
+        ) as response:
+            return GetPromptResult.model_validate_json(response.content)
+
+    async def get_or_create(
+        self, path: str, options: Optional[GetOrCreatePromptOptions] = None
+    ) -> GetOrCreatePromptResult:
+        options = GetOrCreatePromptOptions(**{**dict(self._options), **dict(options or {})})
+        self._ensure_prompt_options(options)
+        assert options.project_id is not None
+
+        async with self._client.request(
+            handler=RequestHandler.GetOrCreatePrompt,
+            params=GetOrCreatePromptRequestParams(
+                project_id=options.project_id,
+                version_uuid=options.version_uuid,
+            ),
+            body=GetOrCreatePromptRequestBody(
+                path=path,
+                prompt=options.prompt,
+            ),
+        ) as response:
+            return GetOrCreatePromptResult.model_validate_json(response.content)
+
+    async def run(self, path: str, options: Optional[RunPromptOptions] = None) -> Optional[RunPromptResult]:
+        options = RunPromptOptions(**{**dict(self._options), **dict(options or {})})
+        self._ensure_prompt_options(options)
+        assert options.project_id is not None
+
+        try:
+            async with self._client.request(
+                handler=RequestHandler.RunPrompt,
+                params=RunPromptRequestParams(
+                    project_id=options.project_id,
+                    version_uuid=options.version_uuid,
+                ),
+                body=RunPromptRequestBody(
+                    path=path,
+                    parameters=options.parameters,
+                    custom_identifier=options.custom_identifier,
+                    stream=options.stream,
+                ),
+            ) as response:
+                if options.stream:
+                    result = await self._handle_stream(response.sse(), options.on_event)
+                else:
+                    result = RunPromptResult.model_validate_json(response.content)
+
+            if options.tools and result.response.type == StreamTypes.Text and result.response.tool_calls:
+                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(FinishedEvent(**dict(result)))
+
+            return RunPromptResult(**dict(result))
+
+        except Exception as exception:
+            if not isinstance(exception, ApiError):
+                exception = ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=str(exception),
+                    response=str(exception),
+                )
+
+            if not options.on_error:
+                raise exception
+
+            options.on_error(exception)
+
+            return None
+
+    async def chat(
+        self, uuid: str, messages: Sequence[MessageLike], options: Optional[ChatPromptOptions] = None
+    ) -> Optional[ChatPromptResult]:
+        options = ChatPromptOptions(**{**dict(self._options), **dict(options or {})})
+
+        messages = [_Message.validate_python(message) for message in messages]
+
+        try:
+            async with self._client.request(
+                handler=RequestHandler.ChatPrompt,
+                params=ChatPromptRequestParams(
+                    conversation_uuid=uuid,
+                ),
+                body=ChatPromptRequestBody(
+                    messages=messages,
+                    stream=options.stream,
+                ),
+            ) as response:
+                if options.stream:
+                    result = await self._handle_stream(response.sse(), options.on_event)
+                else:
+                    result = ChatPromptResult.model_validate_json(response.content)
+
+            if options.tools and result.response.type == StreamTypes.Text and result.response.tool_calls:
+                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(FinishedEvent(**dict(result)))
+
+            return ChatPromptResult(**dict(result))
+
+        except Exception as exception:
+            if not isinstance(exception, ApiError):
+                exception = ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=str(exception),
+                    response=str(exception),
+                )
+
+            if not options.on_error:
+                raise exception
+
+            options.on_error(exception)
+
+            return None
+
+    def _adapt_prompt_config(self, config: Dict[str, Any], adapter: Adapter) -> Dict[str, Any]:
+        adapted_config: Dict[str, Any] = {}
+
+        for attr, value in config.items():
+            if attr in _PROMPT_ATTR_TO_ADAPTER_ATTR and adapter in _PROMPT_ATTR_TO_ADAPTER_ATTR[attr][1]:
+                adapted_config[_PROMPT_ATTR_TO_ADAPTER_ATTR[attr][0]] = value
+            else:
+                adapted_config[attr] = value
+
+        return adapted_config
+
+    async def render(self, prompt: str, options: Optional[RenderPromptOptions] = None) -> RenderPromptResult:
+        options = RenderPromptOptions(**{**dict(self._options), **dict(options or {})})
+        adapter = options.adapter or Adapter.OpenAI
+
+        result = self._promptl.prompts.render(
+            prompt=prompt,
+            parameters=options.parameters,
+            adapter=adapter,
+        )
+
+        return RenderPromptResult(
+            messages=result.messages,
+            config=self._adapt_prompt_config(result.config, adapter),
+        )
+
+    async def render_chain(
+        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)
+
+        chain = self._promptl.chains.create(
+            prompt=prompt.content,
+            parameters=options.parameters,
+            adapter=adapter,
+        )
+
+        step = None
+        response = None
+        while not chain.completed:
+            step = chain.step(response)
+            if not step.completed:
+                response = await on_step(step.messages, self._adapt_prompt_config(step.config, adapter))
+
+        assert step is not None
+
+        return RenderChainResult(
+            messages=step.messages,
+            config=self._adapt_prompt_config(step.config, adapter),
+        )