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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 0.1.0b9
+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.0b9 → latitude_sdk-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "0.1.0-beta.9"
+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.0b9 → 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.0b9 → 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,8 +37,8 @@ class Evaluations:
         self._options = options
         self._client = client
 
-    async def trigger(self, uuid: str, options: TriggerEvaluationOptions) -> TriggerEvaluationResult:
-        options = TriggerEvaluationOptions(**{**dict(self._options), **dict(options)})
+    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,

{latitude_sdk-0.1.0b9 → 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
 
@@ -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.0b9 → 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
 
 
@@ -42,9 +40,9 @@ class Logs:
             )
 
     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:
-        options = CreateLogOptions(**{**dict(self._options), **dict(options)})
+        options = CreateLogOptions(**{**dict(self._options), **dict(options or {})})
         self._ensure_log_options(options)
         assert options.project_id is not None
 

{latitude_sdk-0.1.0b9 → latitude_sdk-1.0.0}/src/latitude_sdk/sdk/prompts.py

@@ -1,6 +1,9 @@
 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,
@@ -21,21 +24,33 @@ from latitude_sdk.sdk.types import (
     ChainEventStep,
     ChainEventStepCompleted,
     FinishedEvent,
-    Message,
+    OnStep,
     OnToolCall,
     OnToolCallDetails,
     Prompt,
+    Providers,
     SdkOptions,
     StreamCallbacks,
     StreamEvents,
     StreamTypes,
-    ToolMessage,
     ToolResult,
-    ToolResultContent,
-    _Message,
 )
 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
@@ -82,13 +97,34 @@ 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, options: SdkOptions):
+    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:
@@ -224,8 +260,8 @@ class Prompts:
 
         return FinishedEvent(**dict(next_result)) if next_result else None
 
-    async def get(self, path: str, options: GetPromptOptions) -> GetPromptResult:
-        options = GetPromptOptions(**{**dict(self._options), **dict(options)})
+    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
 
@@ -239,8 +275,10 @@ class Prompts:
         ) as response:
             return GetPromptResult.model_validate_json(response.content)
 
-    async def get_or_create(self, path: str, options: GetOrCreatePromptOptions) -> GetOrCreatePromptResult:
-        options = GetOrCreatePromptOptions(**{**dict(self._options), **dict(options)})
+    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
 
@@ -257,12 +295,12 @@ class Prompts:
         ) as response:
             return GetOrCreatePromptResult.model_validate_json(response.content)
 
-    async def run(self, path: str, options: RunPromptOptions) -> Optional[RunPromptResult]:
-        try:
-            options = RunPromptOptions(**{**dict(self._options), **dict(options)})
-            self._ensure_prompt_options(options)
-            assert options.project_id is not None
+    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(
@@ -311,13 +349,13 @@ class Prompts:
             return None
 
     async def chat(
-        self, uuid: str, messages: Sequence[Union[Message, Dict[str, Any]]], options: ChatPromptOptions
+        self, uuid: str, messages: Sequence[MessageLike], options: Optional[ChatPromptOptions] = None
     ) -> Optional[ChatPromptResult]:
-        try:
-            options = ChatPromptOptions(**{**dict(self._options), **dict(options)})
+        options = ChatPromptOptions(**{**dict(self._options), **dict(options or {})})
 
-            messages = [_Message.validate_python(message) for message in messages]
+        messages = [_Message.validate_python(message) for message in messages]
 
+        try:
             async with self._client.request(
                 handler=RequestHandler.ChatPrompt,
                 params=ChatPromptRequestParams(
@@ -362,6 +400,54 @@ class Prompts:
 
             return None
 
-    # TODO: render - needs PromptL in Python
+    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
 
-    # TODO: render_chain - needs PromptL in Python
+    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),
+        )

{latitude_sdk-0.1.0b9 → latitude_sdk-1.0.0}/src/latitude_sdk/sdk/types.py

@@ -1,8 +1,10 @@
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Literal, Optional, Protocol, Union, runtime_checkable
+from typing import Any, Callable, Dict, List, Literal, Optional, Protocol, Sequence, Union, runtime_checkable
+
+from promptl_ai import Message, MessageLike
 
 from latitude_sdk.sdk.errors import ApiError
-from latitude_sdk.util import Adapter, Field, Model, StrEnum
+from latitude_sdk.util import Field, Model, StrEnum
 
 
 class DbErrorRef(Model):
@@ -28,87 +30,6 @@ class Prompt(Model):
     provider: Optional[Providers] = None
 
 
-class ContentType(StrEnum):
-    Text = "text"
-    Image = "image"
-    File = "file"
-    ToolCall = "tool-call"
-    ToolResult = "tool-result"
-
-
-class TextContent(Model):
-    type: Literal[ContentType.Text] = ContentType.Text
-    text: str
-
-
-class ImageContent(Model):
-    type: Literal[ContentType.Image] = ContentType.Image
-    image: str
-
-
-class FileContent(Model):
-    type: Literal[ContentType.File] = ContentType.File
-    file: str
-    mime_type: str = Field(alias=str("mimeType"))
-
-
-class ToolCallContent(Model):
-    type: Literal[ContentType.ToolCall] = ContentType.ToolCall
-    id: str = Field(alias=str("toolCallId"))
-    name: str = Field(alias=str("toolName"))
-    arguments: Dict[str, Any] = Field(alias=str("args"))
-
-
-class ToolResultContent(Model):
-    type: Literal[ContentType.ToolResult] = ContentType.ToolResult
-    id: str = Field(alias=str("toolCallId"))
-    name: str = Field(alias=str("toolName"))
-    result: Any
-    is_error: Optional[bool] = Field(default=None, alias=str("isError"))
-
-
-MessageContent = Union[
-    str,
-    List[TextContent],
-    List[ImageContent],
-    List[FileContent],
-    List[ToolCallContent],
-    List[ToolResultContent],
-]
-
-
-class MessageRole(StrEnum):
-    System = "system"
-    User = "user"
-    Assistant = "assistant"
-    Tool = "tool"
-
-
-class SystemMessage(Model):
-    role: Literal[MessageRole.System] = MessageRole.System
-    content: Union[str, List[TextContent]]
-
-
-class UserMessage(Model):
-    role: Literal[MessageRole.User] = MessageRole.User
-    content: Union[str, List[Union[TextContent, ImageContent, FileContent]]]
-    name: Optional[str] = None
-
-
-class AssistantMessage(Model):
-    role: Literal[MessageRole.Assistant] = MessageRole.Assistant
-    content: Union[str, List[Union[TextContent, ToolCallContent]]]
-
-
-class ToolMessage(Model):
-    role: Literal[MessageRole.Tool] = MessageRole.Tool
-    content: List[ToolResultContent]
-
-
-Message = Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]
-_Message = Adapter(Message)
-
-
 class ModelUsage(Model):
     prompt_tokens: int = Field(alias=str("promptTokens"))
     completion_tokens: int = Field(alias=str("completionTokens"))
@@ -306,6 +227,13 @@ class OnToolCall(Protocol):
     async def __call__(self, call: ToolCall, details: OnToolCallDetails) -> ToolResult: ...
 
 
+@runtime_checkable
+class OnStep(Protocol):
+    async def __call__(
+        self, messages: List[MessageLike], config: Dict[str, Any]
+    ) -> Union[str, MessageLike, Sequence[MessageLike]]: ...
+
+
 class SdkOptions(Model):
     project_id: Optional[int] = None
     version_uuid: Optional[str] = None

{latitude_sdk-0.1.0b9 → latitude_sdk-1.0.0}/src/latitude_sdk/util/utils.py

@@ -64,6 +64,10 @@ class StrEnum(str, Enum):
 Field = pydantic.Field
 Config = pydantic.ConfigDict
 Adapter = pydantic.TypeAdapter
+Aliases = pydantic.AliasChoices
+Validator = pydantic.WrapValidator
+ValidatorInfo = pydantic.ValidationInfo
+ValidatorHandler = pydantic.ValidatorFunctionWrapHandler
 
 
 class Model(pydantic.BaseModel):
@@ -76,12 +80,12 @@ class Model(pydantic.BaseModel):
     @is_like(pydantic.BaseModel.model_dump)
     def model_dump(self, *args: Any, **kwargs: Any) -> Any:
         exclude_none = kwargs.pop("exclude_none", True)
-        return super().model_dump(*args, exclude_none=exclude_none, **kwargs)
+        by_alias = kwargs.pop("by_alias", True)
+        return super().model_dump(*args, exclude_none=exclude_none, by_alias=by_alias, **kwargs)
 
     @is_like(pydantic.BaseModel.dict)  # pyright: ignore [reportDeprecated]
     def dict(self, *args: Any, **kwargs: Any) -> Any:
-        exclude_none = kwargs.pop("exclude_none", True)
-        return super().dict(*args, exclude_none=exclude_none, **kwargs)  # pyright: ignore [reportDeprecated]
+        raise NotImplementedError("deprecated")
 
     @is_like(pydantic.BaseModel.model_dump_json)
     def model_dump_json(self, *args: Any, **kwargs: Any) -> Any:
@@ -91,6 +95,4 @@ class Model(pydantic.BaseModel):
 
     @is_like(pydantic.BaseModel.json)  # pyright: ignore [reportDeprecated]
     def json(self, *args: Any, **kwargs: Any) -> Any:
-        exclude_none = kwargs.pop("exclude_none", True)
-        by_alias = kwargs.pop("by_alias", True)
-        return super().json(*args, exclude_none=exclude_none, by_alias=by_alias, **kwargs)  # pyright: ignore [reportDeprecated]
+        raise NotImplementedError("deprecated")

{latitude_sdk-0.1.0b9 → latitude_sdk-1.0.0}/tests/evaluations/trigger_test.py

@@ -31,14 +31,13 @@ class TestTriggerEvaluation(TestCase):
 
     async def test_fails(self):
         conversation_uuid = "conversation-uuid"
-        options = TriggerEvaluationOptions()
         endpoint = f"/conversations/{conversation_uuid}/evaluate"
         endpoint_mock = self.gateway_mock.post(endpoint).mock(
             return_value=httpx.Response(500, json=fixtures.ERROR_RESPONSE)
         )
 
         with self.assertRaisesRegex(type(fixtures.ERROR), fixtures.ERROR.message):
-            await self.sdk.evaluations.trigger(conversation_uuid, options)
+            await self.sdk.evaluations.trigger(conversation_uuid)
         requests = cast(List[httpx.Request], [request for request, _ in endpoint_mock.calls])  # type: ignore
 
         [

{latitude_sdk-0.1.0b9 → latitude_sdk-1.0.0}/tests/prompts/chat_test.py

@@ -50,15 +50,15 @@ class TestChatPromptSync(TestCase):
         on_event_mock = Mock()
         on_finished_mock = Mock()
         on_error_mock = Mock()
-        actual_tool = AsyncMock(side_effect=fixtures.CONVERSATION_TOOL_RESULTS)
-        other_tool = AsyncMock()
+        actual_tool_mock = AsyncMock(side_effect=fixtures.CONVERSATION_TOOL_RESULTS)
+        other_tool_mock = AsyncMock()
         conversation_uuid = "conversation-uuid"
         messages = self.create_conversation(4)
         options = ChatPromptOptions(
             on_event=on_event_mock,
             on_finished=on_finished_mock,
             on_error=on_error_mock,
-            tools={"calculator": actual_tool, "other_tool": other_tool},
+            tools={"calculator": actual_tool_mock, "other_tool": other_tool_mock},
             stream=False,
         )
         endpoint = re.compile(r"/conversations/(?P<uuid>[a-zA-Z0-9-]+)/chat")
@@ -99,7 +99,7 @@ class TestChatPromptSync(TestCase):
         on_error_mock.assert_not_called()
         [
             self.assertEqual(
-                actual_tool.call_args_list[index][0],
+                actual_tool_mock.call_args_list[index][0],
                 (
                     fixtures.CONVERSATION_TOOL_CALLS[index],
                     OnToolCallDetails.model_construct(
@@ -110,24 +110,24 @@ class TestChatPromptSync(TestCase):
                     ),
                 ),
             )
-            for index, _ in enumerate(actual_tool.call_args_list)
+            for index, _ in enumerate(actual_tool_mock.call_args_list)
         ]
-        self.assertEqual(actual_tool.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
-        other_tool.assert_not_awaited()
+        self.assertEqual(actual_tool_mock.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
+        other_tool_mock.assert_not_awaited()
 
     async def test_success_with_paused_tools(self):
         on_event_mock = Mock()
         on_finished_mock = Mock()
         on_error_mock = Mock()
-        actual_tool = AsyncMock(side_effect=OnToolCallPaused)
-        other_tool = AsyncMock()
+        actual_tool_mock = AsyncMock(side_effect=OnToolCallPaused)
+        other_tool_mock = AsyncMock()
         conversation_uuid = "conversation-uuid"
         messages = self.create_conversation(4)
         options = ChatPromptOptions(
             on_event=on_event_mock,
             on_finished=on_finished_mock,
             on_error=on_error_mock,
-            tools={"calculator": actual_tool, "other_tool": other_tool},
+            tools={"calculator": actual_tool_mock, "other_tool": other_tool_mock},
             stream=False,
         )
         endpoint = re.compile(r"/conversations/(?P<uuid>[a-zA-Z0-9-]+)/chat")
@@ -157,7 +157,7 @@ class TestChatPromptSync(TestCase):
         on_error_mock.assert_not_called()
         [
             self.assertEqual(
-                actual_tool.call_args_list[index][0],
+                actual_tool_mock.call_args_list[index][0],
                 (
                     fixtures.CONVERSATION_TOOL_CALLS[index],
                     OnToolCallDetails.model_construct(
@@ -168,10 +168,10 @@ class TestChatPromptSync(TestCase):
                     ),
                 ),
             )
-            for index, _ in enumerate(actual_tool.call_args_list)
+            for index, _ in enumerate(actual_tool_mock.call_args_list)
         ]
-        self.assertEqual(actual_tool.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
-        other_tool.assert_not_awaited()
+        self.assertEqual(actual_tool_mock.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
+        other_tool_mock.assert_not_awaited()
 
     async def test_fails_and_retries(self):
         on_event_mock = Mock()
@@ -321,15 +321,15 @@ class TestChatPromptStream(TestCase):
         on_event_mock = Mock()
         on_finished_mock = Mock()
         on_error_mock = Mock()
-        actual_tool = AsyncMock(side_effect=fixtures.CONVERSATION_TOOL_RESULTS)
-        other_tool = AsyncMock()
+        actual_tool_mock = AsyncMock(side_effect=fixtures.CONVERSATION_TOOL_RESULTS)
+        other_tool_mock = AsyncMock()
         conversation_uuid = "conversation-uuid"
         messages = self.create_conversation(4)
         options = ChatPromptOptions(
             on_event=on_event_mock,
             on_finished=on_finished_mock,
             on_error=on_error_mock,
-            tools={"calculator": actual_tool, "other_tool": other_tool},
+            tools={"calculator": actual_tool_mock, "other_tool": other_tool_mock},
             stream=True,
         )
         endpoint = re.compile(r"/conversations/(?P<uuid>[a-zA-Z0-9-]+)/chat")
@@ -377,7 +377,7 @@ class TestChatPromptStream(TestCase):
         on_error_mock.assert_not_called()
         [
             self.assertEqual(
-                actual_tool.call_args_list[index][0],
+                actual_tool_mock.call_args_list[index][0],
                 (
                     fixtures.CONVERSATION_TOOL_CALLS[index],
                     OnToolCallDetails.model_construct(
@@ -388,24 +388,24 @@ class TestChatPromptStream(TestCase):
                     ),
                 ),
             )
-            for index, _ in enumerate(actual_tool.call_args_list)
+            for index, _ in enumerate(actual_tool_mock.call_args_list)
         ]
-        self.assertEqual(actual_tool.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
-        other_tool.assert_not_awaited()
+        self.assertEqual(actual_tool_mock.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
+        other_tool_mock.assert_not_awaited()
 
     async def test_success_with_paused_tools(self):
         on_event_mock = Mock()
         on_finished_mock = Mock()
         on_error_mock = Mock()
-        actual_tool = AsyncMock(side_effect=OnToolCallPaused)
-        other_tool = AsyncMock()
+        actual_tool_mock = AsyncMock(side_effect=OnToolCallPaused)
+        other_tool_mock = AsyncMock()
         conversation_uuid = "conversation-uuid"
         messages = self.create_conversation(4)
         options = ChatPromptOptions(
             on_event=on_event_mock,
             on_finished=on_finished_mock,
             on_error=on_error_mock,
-            tools={"calculator": actual_tool, "other_tool": other_tool},
+            tools={"calculator": actual_tool_mock, "other_tool": other_tool_mock},
             stream=True,
         )
         endpoint = re.compile(r"/conversations/(?P<uuid>[a-zA-Z0-9-]+)/chat")
@@ -437,7 +437,7 @@ class TestChatPromptStream(TestCase):
         on_error_mock.assert_not_called()
         [
             self.assertEqual(
-                actual_tool.call_args_list[index][0],
+                actual_tool_mock.call_args_list[index][0],
                 (
                     fixtures.CONVERSATION_TOOL_CALLS[index],
                     OnToolCallDetails.model_construct(
@@ -448,10 +448,10 @@ class TestChatPromptStream(TestCase):
                     ),
                 ),
             )
-            for index, _ in enumerate(actual_tool.call_args_list)
+            for index, _ in enumerate(actual_tool_mock.call_args_list)
         ]
-        self.assertEqual(actual_tool.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
-        other_tool.assert_not_awaited()
+        self.assertEqual(actual_tool_mock.await_count, len(fixtures.CONVERSATION_TOOL_CALLS))
+        other_tool_mock.assert_not_awaited()
 
     async def test_fails_and_retries(self):
         on_event_mock = Mock()