latitude-sdk 1.0.2__tar.gz → 1.1.0__tar.gz

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 1.0.2
+Version: 1.1.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
@@ -60,6 +60,28 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
+## Run only one test
+
+```python
+import pytest
+
+@pytest.mark.only
+async def my_test(self):
+    # ... your code
+```
+
+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.

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/README.md

@@ -41,6 +41,28 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
+## Run only one test
+
+```python
+import pytest
+
+@pytest.mark.only
+async def my_test(self):
+    # ... your code
+```
+
+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.

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "1.0.2"
+version = "1.1.0"
 description = "Latitude SDK for Python"
 authors = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
 maintainers = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/src/latitude_sdk/client/payloads.py

@@ -23,6 +23,10 @@ class GetPromptRequestParams(PromptRequestParams, Model):
     path: str
 
 
+class GetAllPromptRequestParams(PromptRequestParams, Model):
+    pass
+
+
 class GetOrCreatePromptRequestParams(PromptRequestParams, Model):
     pass
 
@@ -90,6 +94,7 @@ class CreateEvaluationResultRequestBody(Model):
 
 RequestParams = Union[
     GetPromptRequestParams,
+    GetAllPromptRequestParams,
     GetOrCreatePromptRequestParams,
     RunPromptRequestParams,
     ChatPromptRequestParams,
@@ -111,6 +116,7 @@ RequestBody = Union[
 
 class RequestHandler(StrEnum):
     GetPrompt = "GET_PROMPT"
+    GetAllPrompts = "GET_ALL_PROMPTS"
     GetOrCreatePrompt = "GET_OR_CREATE_PROMPT"
     RunPrompt = "RUN_PROMPT"
     ChatPrompt = "CHAT_PROMPT"

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/src/latitude_sdk/client/router.py

@@ -4,6 +4,7 @@ from latitude_sdk.client.payloads import (
     ChatPromptRequestParams,
     CreateEvaluationResultRequestParams,
     CreateLogRequestParams,
+    GetAllPromptRequestParams,
     GetOrCreatePromptRequestParams,
     GetPromptRequestParams,
     RequestHandler,
@@ -36,6 +37,14 @@ class Router:
                 version_uuid=params.version_uuid,
             ).prompt(params.path)
 
+        if handler == RequestHandler.GetAllPrompts:
+            assert isinstance(params, GetAllPromptRequestParams)
+
+            return "GET", self.prompts(
+                project_id=params.project_id,
+                version_uuid=params.version_uuid,
+            ).all_prompts
+
         elif handler == RequestHandler.GetOrCreatePrompt:
             assert isinstance(params, GetOrCreatePromptRequestParams)
 
@@ -94,6 +103,7 @@ class Router:
 
     class Prompts(Model):
         prompt: Callable[[str], str]
+        all_prompts: str
         get_or_create: str
         run: str
         logs: str
@@ -102,6 +112,7 @@ class Router:
         base_url = f"{self.commits_url(project_id, version_uuid)}/documents"
 
         return self.Prompts(
+            all_prompts=f"{base_url}",
             prompt=lambda path: f"{base_url}/{path}",
             get_or_create=f"{base_url}/get-or-create",
             run=f"{base_url}/run",

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/src/latitude_sdk/sdk/latitude.py

@@ -31,7 +31,7 @@ DEFAULT_INTERNAL_OPTIONS = InternalOptions(
         host=env.GATEWAY_HOSTNAME,
         port=env.GATEWAY_PORT,
         ssl=env.GATEWAY_SSL,
-        api_version="v2",
+        api_version="v3",
     ),
     source=LogSources.Api,
     retries=3,

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/src/latitude_sdk/sdk/prompts.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, AsyncGenerator, Dict, List, Optional, Sequence, Union
+from typing import Any, AsyncGenerator, List, Optional, Sequence, Union
 
 from promptl_ai import Adapter, Message, MessageLike, Promptl, ToolMessage, ToolResultContent
 from promptl_ai.bindings.types import _Message
@@ -9,6 +9,7 @@ from latitude_sdk.client import (
     ChatPromptRequestParams,
     Client,
     ClientEvent,
+    GetAllPromptRequestParams,
     GetOrCreatePromptRequestBody,
     GetOrCreatePromptRequestParams,
     GetPromptRequestParams,
@@ -18,12 +19,8 @@ from latitude_sdk.client import (
 )
 from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
 from latitude_sdk.sdk.types import (
-    ChainEventCompleted,
-    ChainEventError,
     ChainEvents,
-    ChainEventStep,
-    ChainEventStepCompleted,
-    FinishedEvent,
+    FinishedResult,
     OnStep,
     OnToolCall,
     OnToolCallDetails,
@@ -33,8 +30,11 @@ from latitude_sdk.sdk.types import (
     StreamCallbacks,
     StreamEvents,
     StreamTypes,
+    ToolCall,
     ToolResult,
+    _LatitudeEvent,
 )
+from latitude_sdk.util import Adapter as AdapterUtil
 from latitude_sdk.util import Model
 
 _PROVIDER_TO_ADAPTER = {
@@ -69,6 +69,13 @@ class GetPromptResult(Prompt, Model):
     pass
 
 
+_GetAllPromptResults = AdapterUtil[List[GetPromptResult]](List[GetPromptResult])
+
+
+class GetAllPromptOptions(PromptOptions, Model):
+    pass
+
+
 class GetOrCreatePromptOptions(PromptOptions, Model):
     prompt: Optional[str] = None
 
@@ -79,36 +86,36 @@ class GetOrCreatePromptResult(Prompt, Model):
 
 class RunPromptOptions(StreamCallbacks, PromptOptions, Model):
     custom_identifier: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
-    tools: Optional[Dict[str, OnToolCall]] = None
+    parameters: Optional[dict[str, Any]] = None
+    tools: Optional[dict[str, OnToolCall]] = None
     stream: Optional[bool] = None
 
 
-class RunPromptResult(FinishedEvent, Model):
+class RunPromptResult(FinishedResult, Model):
     pass
 
 
 class ChatPromptOptions(StreamCallbacks, Model):
-    tools: Optional[Dict[str, OnToolCall]] = None
+    tools: Optional[dict[str, OnToolCall]] = None
     stream: Optional[bool] = None
 
 
-class ChatPromptResult(FinishedEvent, Model):
+class ChatPromptResult(FinishedResult, Model):
     pass
 
 
 class RenderPromptOptions(Model):
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
     adapter: Optional[Adapter] = None
 
 
 class RenderPromptResult(Model):
-    messages: List[MessageLike]
-    config: Dict[str, Any]
+    messages: list[MessageLike]
+    config: dict[str, Any]
 
 
 class RenderChainOptions(Model):
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
     adapter: Optional[Adapter] = None
 
 
@@ -137,32 +144,27 @@ class Prompts:
 
     async def _handle_stream(
         self, stream: AsyncGenerator[ClientEvent, Any], on_event: Optional[StreamCallbacks.OnEvent]
-    ) -> FinishedEvent:
+    ) -> FinishedResult:
         uuid = None
-        conversation: List[Message] = []
+        conversation: list[Message] = []
         response = None
+        tool_requests: list[ToolCall] = []
 
         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)
+                event = _LatitudeEvent.validate_json(stream_event.data)
+                conversation = event.messages
+                uuid = event.uuid
 
-                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 [])
+                if event.type == ChainEvents.ProviderCompleted:
                     response = event.response
 
-                elif type == str(ChainEvents.Error):
-                    event = ChainEventError.model_validate_json(stream_event.data)
+                elif event.type == ChainEvents.ToolsRequested:
+                    tool_requests = event.tools
+
+                elif event.type == ChainEvents.ChainError:
                     raise ApiError(
                         status=400,
                         code=ApiErrorCodes.AIRunError,
@@ -170,14 +172,6 @@ class Prompts:
                         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
@@ -201,8 +195,7 @@ class Prompts:
                 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)
+        return FinishedResult(uuid=uuid, conversation=conversation, response=response, tool_requests=tool_requests)
 
     @staticmethod
     def _pause_tool_execution() -> Any:
@@ -210,9 +203,9 @@ class Prompts:
 
     @staticmethod
     async def _wrap_tool_handler(
-        handler: OnToolCall, arguments: Dict[str, Any], details: OnToolCallDetails
+        handler: OnToolCall, arguments: dict[str, Any], details: OnToolCallDetails
     ) -> ToolResult:
-        tool_result: Dict[str, Any] = {"id": details.id, "name": details.name}
+        tool_result: dict[str, Any] = {"id": details.id, "name": details.name}
 
         try:
             result = await handler(arguments, details)
@@ -225,10 +218,10 @@ class Prompts:
             return ToolResult(**tool_result, result=str(exception), is_error=True)
 
     async def _handle_tool_calls(
-        self, result: FinishedEvent, options: Union[RunPromptOptions, ChatPromptOptions]
-    ) -> Optional[FinishedEvent]:
+        self, result: FinishedResult, options: Union[RunPromptOptions, ChatPromptOptions]
+    ) -> Optional[FinishedResult]:
         # Seems Python cannot infer the type
-        assert result.response.type == StreamTypes.Text and result.response.tool_calls is not None
+        assert result.response.type == StreamTypes.Text and result.tool_requests is not None
 
         if not options.tools:
             raise ApiError(
@@ -238,7 +231,7 @@ class Prompts:
                 response="Tools not supplied",
             )
 
-        for tool_call in result.response.tool_calls:
+        for tool_call in result.tool_requests:
             if tool_call.name not in options.tools:
                 raise ApiError(
                     status=400,
@@ -258,10 +251,10 @@ class Prompts:
                         conversation_uuid=result.uuid,
                         messages=result.conversation,
                         pause_execution=self._pause_tool_execution,
-                        requested_tool_calls=result.response.tool_calls,
+                        requested_tool_calls=result.tool_requests,
                     ),
                 )
-                for tool_call in result.response.tool_calls
+                for tool_call in result.tool_requests
             ],
             return_exceptions=False,
         )
@@ -282,7 +275,7 @@ class Prompts:
 
         next_result = await self.chat(result.uuid, tool_messages, ChatPromptOptions(**dict(options)))
 
-        return FinishedEvent(**dict(next_result)) if next_result else None
+        return FinishedResult(**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 {})})
@@ -299,6 +292,20 @@ class Prompts:
         ) as response:
             return GetPromptResult.model_validate_json(response.content)
 
+    async def get_all(self, options: Optional[GetAllPromptOptions] = None) -> List[GetPromptResult]:
+        options = GetAllPromptOptions(**{**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.GetAllPrompts,
+            params=GetAllPromptRequestParams(
+                project_id=options.project_id,
+                version_uuid=options.version_uuid,
+            ),
+        ) as response:
+            return _GetAllPromptResults.validate_json(response.content)
+
     async def get_or_create(
         self, path: str, options: Optional[GetOrCreatePromptOptions] = None
     ) -> GetOrCreatePromptResult:
@@ -343,7 +350,7 @@ class Prompts:
                 else:
                     result = RunPromptResult.model_validate_json(response.content)
 
-            if options.tools and result.response.type == StreamTypes.Text and result.response.tool_calls:
+            if options.tools and result.response.type == StreamTypes.Text 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)
@@ -352,7 +359,7 @@ class Prompts:
                     pass
 
             if options.on_finished:
-                options.on_finished(FinishedEvent(**dict(result)))
+                options.on_finished(FinishedResult(**dict(result)))
 
             return RunPromptResult(**dict(result))
 
@@ -395,7 +402,7 @@ class Prompts:
                 else:
                     result = ChatPromptResult.model_validate_json(response.content)
 
-            if options.tools and result.response.type == StreamTypes.Text and result.response.tool_calls:
+            if options.tools and result.response.type == StreamTypes.Text 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)
@@ -404,7 +411,7 @@ class Prompts:
                     pass
 
             if options.on_finished:
-                options.on_finished(FinishedEvent(**dict(result)))
+                options.on_finished(FinishedResult(**dict(result)))
 
             return ChatPromptResult(**dict(result))
 
@@ -424,8 +431,8 @@ class Prompts:
 
             return None
 
-    def _adapt_prompt_config(self, config: Dict[str, Any], adapter: Adapter) -> Dict[str, Any]:
-        adapted_config: Dict[str, Any] = {}
+    def _adapt_prompt_config(self, config: dict[str, Any], adapter: Adapter) -> dict[str, Any]:
+        adapted_config: dict[str, Any] = {}
 
         # NOTE: Should we delete attributes not supported by the provider?
         for attr, value in config.items():

{latitude_sdk-1.0.2 → latitude_sdk-1.1.0}/src/latitude_sdk/sdk/types.py

@@ -1,10 +1,10 @@
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Literal, Optional, Protocol, Sequence, Union, runtime_checkable
+from typing import Any, Callable, 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 Field, Model, StrEnum
+from latitude_sdk.util import Adapter, Field, Model, StrEnum
 
 
 class DbErrorRef(Model):
@@ -19,14 +19,27 @@ class Providers(StrEnum):
     Mistral = "mistral"
     Azure = "azure"
     Google = "google"
+    GoogleVertex = "google_vertex"
+    AnthropicVertex = "anthropic_vertex"
     Custom = "custom"
 
 
+class ParameterType(StrEnum):
+    Text = "text"
+    File = "file"
+    Image = "image"
+
+
+class PromptParameter(Model):
+    type: ParameterType
+
+
 class Prompt(Model):
     uuid: str
     path: str
     content: str
-    config: Dict[str, Any]
+    config: dict[str, Any]
+    parameters: dict[str, PromptParameter]
     provider: Optional[Providers] = None
 
 
@@ -49,7 +62,7 @@ class FinishReason(StrEnum):
 class ToolCall(Model):
     id: str
     name: str
-    arguments: Dict[str, Any]
+    arguments: dict[str, Any]
 
 
 class ToolResult(Model):
@@ -67,7 +80,7 @@ class StreamTypes(StrEnum):
 class ChainTextResponse(Model):
     type: Literal[StreamTypes.Text] = Field(default=StreamTypes.Text, alias=str("streamType"))
     text: str
-    tool_calls: Optional[List[ToolCall]] = Field(default=None, alias=str("toolCalls"))
+    tool_calls: list[ToolCall] = Field(alias=str("toolCalls"))
     usage: ModelUsage
 
 
@@ -89,66 +102,105 @@ class ChainError(Model):
 class StreamEvents(StrEnum):
     Latitude = "latitude-event"
     Provider = "provider-event"
-    Finished = "finished-event"
 
 
-ProviderEvent = Dict[str, Any]
+ProviderEvent = dict[str, Any]
 
 
 class ChainEvents(StrEnum):
-    Step = "chain-step"
-    StepCompleted = "chain-step-complete"
-    Completed = "chain-complete"
-    Error = "chain-error"
+    ChainStarted = "chain-started"
+    StepStarted = "step-started"
+    ProviderStarted = "provider-started"
+    ProviderCompleted = "provider-completed"
+    ToolsStarted = "tools-started"
+    ToolCompleted = "tool-completed"
+    StepCompleted = "step-completed"
+    ChainCompleted = "chain-completed"
+    ChainError = "chain-error"
+    ToolsRequested = "tools-requested"
+
+
+class GenericChainEvent(Model):
+    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
+    messages: list[Message]
+    uuid: str
 
 
-class ChainEventStep(Model):
-    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
-    type: Literal[ChainEvents.Step] = ChainEvents.Step
-    uuid: Optional[str] = None
-    is_last_step: bool = Field(alias=str("isLastStep"))
-    config: Dict[str, Any]
-    messages: List[Message]
+class ChainEventChainStarted(GenericChainEvent):
+    type: Literal[ChainEvents.ChainStarted] = ChainEvents.ChainStarted
 
 
-class ChainEventStepCompleted(Model):
-    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
-    type: Literal[ChainEvents.StepCompleted] = ChainEvents.StepCompleted
-    uuid: Optional[str] = None
-    response: ChainResponse
+class ChainEventStepStarted(GenericChainEvent):
+    type: Literal[ChainEvents.StepStarted] = ChainEvents.StepStarted
 
 
-class ChainEventCompleted(Model):
-    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
-    type: Literal[ChainEvents.Completed] = ChainEvents.Completed
-    uuid: Optional[str] = None
+class ChainEventProviderStarted(GenericChainEvent):
+    type: Literal[ChainEvents.ProviderStarted] = ChainEvents.ProviderStarted
+    config: dict[str, Any]
+
+
+class ChainEventProviderCompleted(GenericChainEvent):
+    type: Literal[ChainEvents.ProviderCompleted] = ChainEvents.ProviderCompleted
+    provider_log_uuid: str = Field(alias=str("providerLogUuid"))
+    token_usage: ModelUsage = Field(alias=str("tokenUsage"))
     finish_reason: FinishReason = Field(alias=str("finishReason"))
-    config: Dict[str, Any]
-    messages: Optional[List[Message]] = None
-    object: Optional[Any] = None
     response: ChainResponse
 
 
-class ChainEventError(Model):
-    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
-    type: Literal[ChainEvents.Error] = ChainEvents.Error
+class ChainEventToolsStarted(GenericChainEvent):
+    type: Literal[ChainEvents.ToolsStarted] = ChainEvents.ToolsStarted
+    tools: list[ToolCall]
+
+
+class ChainEventToolCompleted(GenericChainEvent):
+    type: Literal[ChainEvents.ToolCompleted] = ChainEvents.ToolCompleted
+
+
+class ChainEventStepCompleted(GenericChainEvent):
+    type: Literal[ChainEvents.StepCompleted] = ChainEvents.StepCompleted
+
+
+class ChainEventChainCompleted(GenericChainEvent):
+    type: Literal[ChainEvents.ChainCompleted] = ChainEvents.ChainCompleted
+    token_usage: ModelUsage = Field(alias=str("tokenUsage"))
+    finish_reason: FinishReason = Field(alias=str("finishReason"))
+
+
+class ChainEventChainError(GenericChainEvent):
+    type: Literal[ChainEvents.ChainError] = ChainEvents.ChainError
     error: ChainError
 
 
-ChainEvent = Union[ChainEventStep, ChainEventStepCompleted, ChainEventCompleted, ChainEventError]
+class ChainEventToolsRequested(GenericChainEvent):
+    type: Literal[ChainEvents.ToolsRequested] = ChainEvents.ToolsRequested
+    tools: list[ToolCall]
+
 
+ChainEvent = Union[
+    ChainEventChainStarted,
+    ChainEventStepStarted,
+    ChainEventProviderStarted,
+    ChainEventProviderCompleted,
+    ChainEventToolsStarted,
+    ChainEventToolCompleted,
+    ChainEventStepCompleted,
+    ChainEventChainCompleted,
+    ChainEventChainError,
+    ChainEventToolsRequested,
+]
 
 LatitudeEvent = ChainEvent
+_LatitudeEvent = Adapter[LatitudeEvent](LatitudeEvent)
 
 
-class FinishedEvent(Model):
-    event: Literal[StreamEvents.Finished] = StreamEvents.Finished
+class FinishedResult(Model):
     uuid: str
-    conversation: List[Message]
+    conversation: list[Message]
     response: ChainResponse
+    tool_requests: list[ToolCall] = Field(alias=str("toolRequests"))
 
 
-StreamEvent = Union[ProviderEvent, LatitudeEvent, FinishedEvent]
+StreamEvent = Union[ProviderEvent, LatitudeEvent]
 
 
 class LogSources(StrEnum):
@@ -166,7 +218,7 @@ class Log(Model):
     commit_id: int = Field(alias=str("commitId"))
     resolved_content: str = Field(alias=str("resolvedContent"))
     content_hash: str = Field(alias=str("contentHash"))
-    parameters: Dict[str, Any]
+    parameters: dict[str, Any]
     custom_identifier: Optional[str] = Field(default=None, alias=str("customIdentifier"))
     duration: Optional[int] = None
     created_at: datetime = Field(alias=str("createdAt"))
@@ -204,7 +256,7 @@ class StreamCallbacks(Model):
 
     @runtime_checkable
     class OnFinished(Protocol):
-        def __call__(self, event: FinishedEvent): ...
+        def __call__(self, result: FinishedResult): ...
 
     on_finished: Optional[OnFinished] = None
 
@@ -219,27 +271,27 @@ class OnToolCallDetails(Model):
     id: str
     name: str
     conversation_uuid: str
-    messages: List[Message]
+    messages: list[Message]
     pause_execution: Callable[[], ToolResult]
-    requested_tool_calls: List[ToolCall]
+    requested_tool_calls: list[ToolCall]
 
 
 @runtime_checkable
 class OnToolCall(Protocol):
-    async def __call__(self, arguments: Dict[str, Any], details: OnToolCallDetails) -> Any: ...
+    async def __call__(self, arguments: dict[str, Any], details: OnToolCallDetails) -> Any: ...
 
 
 @runtime_checkable
 class OnStep(Protocol):
     async def __call__(
-        self, messages: List[MessageLike], config: Dict[str, Any]
+        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
-    tools: Optional[Dict[str, OnToolCall]] = None
+    tools: Optional[dict[str, OnToolCall]] = None
 
 
 class GatewayOptions(Model):