ommlds 0.0.0.dev476__py3-none-any.whl → 0.0.0.dev478__py3-none-any.whl

ommlds/.omlish-manifests.json

@@ -198,7 +198,7 @@
     "module": ".minichain.backends.impls.groq.chat",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/groq/chat.py",
-    "line": 24,
+    "line": 26,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.groq.chat",
@@ -213,7 +213,7 @@
     "module": ".minichain.backends.impls.groq.names",
     "attr": "_BACKEND_STRINGS_MANIFEST",
     "file": "ommlds/minichain/backends/impls/groq/names.py",
-    "line": 27,
+    "line": 40,
     "value": {
       "!.minichain.backends.strings.manifests.BackendStringsManifest": {
         "service_cls_names": [
@@ -237,7 +237,7 @@
     "module": ".minichain.backends.impls.groq.stream",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/groq/stream.py",
-    "line": 31,
+    "line": 33,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.groq.stream",
@@ -533,8 +533,8 @@
             "gpt5-chat-latest": "gpt-5-chat-latest",
             "gpt5-mini": "gpt-5-mini",
             "gpt5-nano": "gpt-5-nano",
-            "gpt": "gpt-4o",
-            "gpt-mini": "gpt-4o-mini",
+            "gpt": "gpt-5",
+            "gpt-mini": "gpt-5-mini",
             "o3": null,
             "o3-mini": null,
             "o4-mini": null,
@@ -729,6 +729,18 @@
       }
     }
   },
+  {
+    "module": ".minichain.chat.choices.stream.services",
+    "attr": null,
+    "file": "ommlds/minichain/chat/choices/stream/services.py",
+    "line": 28,
+    "value": {
+      "!.minichain.registries.manifests.RegistryTypeManifest": {
+        "module": "ommlds.minichain.chat.choices.stream.services",
+        "attr": "ChatChoicesStreamService"
+      }
+    }
+  },
   {
     "module": ".minichain.chat.services",
     "attr": null,
@@ -749,7 +761,7 @@
     "value": {
       "!.minichain.registries.manifests.RegistryTypeManifest": {
         "module": "ommlds.minichain.chat.stream.services",
-        "attr": "ChatChoicesStreamService"
+        "attr": "ChatStreamService"
       }
     }
   },

ommlds/backends/groq/protocol.py

@@ -103,13 +103,41 @@ class ChatCompletionRequest(lang.Final):
     stream: bool | None = None
     stream_options: ta.Mapping[str, ta.Any] | None = None
     temperature: float | None = None
-    tool_choice: str | None = None
-    tools: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
+    ool_choice: str | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Tool(lang.Final):
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Function(lang.Final):
+            description: str | None = None
+            name: str
+            parameters: ta.Mapping[str, ta.Any] | None = None  # json schema
+            strict: bool | None = None
+
+        function: Function
+        type: ta.Literal['function', 'browser_search', 'code_interpreter'] = 'function'
+
+    tools: ta.Sequence[Tool] | None = None
+
     top_logprobs: int | None = None
     top_p: float | None = None
     user: str | None = None
 
 
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ExecutedTool(lang.Final):
+    arguments: str
+    index: int
+    type: str
+    browser_results: ta.Sequence[ta.Any] | None = None
+    code_results: ta.Sequence[ta.Any] | None = None
+    output: str | None = None
+    search_results: ta.Any | None = None
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 @_set_class_marshal_options
 class ChatCompletionResponse(lang.Final):
@@ -125,10 +153,27 @@ class ChatCompletionResponse(lang.Final):
         class Message(lang.Final):
             annotations: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
             content: str | None = None
-            executed_tools: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
+
+            executed_tools: ta.Sequence[ExecutedTool] | None = None
+
             reasoning: str | None = None
             role: ta.Literal['assistant'] = 'assistant'
-            tool_calls: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None
+
+            @dc.dataclass(frozen=True, kw_only=True)
+            @_set_class_marshal_options
+            class ToolCall(lang.Final):
+                id: str
+
+                @dc.dataclass(frozen=True, kw_only=True)
+                @_set_class_marshal_options
+                class Function(lang.Final):
+                    arguments: str
+                    name: str
+
+                function: Function
+                type: ta.Literal['function'] = 'function'
+
+            tool_calls: ta.Sequence[ToolCall] | None = None
 
         message: Message
 
@@ -167,6 +212,26 @@ class ChatCompletionChunk(lang.Final):
             channel: str | None = None
             reasoning: str | None = None
 
+            @dc.dataclass(frozen=True, kw_only=True)
+            @_set_class_marshal_options
+            class ToolCall(lang.Final):
+                index: int
+                id: str | None = None
+
+                @dc.dataclass(frozen=True, kw_only=True)
+                @_set_class_marshal_options
+                class Function(lang.Final):
+                    arguments: str | None = None
+                    name: str | None = None
+
+                function: Function | None = None
+
+                type: ta.Literal['function'] = 'function'
+
+            tool_calls: ta.Sequence[ToolCall] | None = None
+
+            executed_tools: ta.Sequence[ExecutedTool] | None = None
+
         delta: Delta
         logprobs: ta.Mapping[str, ta.Any] | None = None
         finish_reason: ta.Literal['stop', 'length', 'tool_calls', 'function_call'] | None = None

ommlds/cli/sessions/chat/chat/ai/rendering.py

@@ -57,11 +57,11 @@ class RenderingStreamAiChatGenerator(StreamAiChatGenerator):
     async def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
     ) -> mc.Chat:
         async with self._renderer.create_context() as renderer:
-            async def inner(delta: mc.AiChoiceDelta) -> None:
-                if isinstance(delta, mc.ContentAiChoiceDelta):
+            async def inner(delta: mc.AiDelta) -> None:
+                if isinstance(delta, mc.ContentAiDelta):
                     await renderer.render_content(delta.c)
 
                 if delta_callback is not None:

ommlds/cli/sessions/chat/chat/ai/services.py

@@ -59,12 +59,12 @@ class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
     async def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
     ) -> mc.AiChat:
         opts = self._options() if self._options is not None else []
 
         async with self._service_provider.provide_backend() as service:
-            joiner = mc.AiChoiceDeltaJoiner()
+            joiner = mc.AiChoicesDeltaJoiner()
 
             async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).v as st_resp:
                 async for o in st_resp:

ommlds/cli/sessions/chat/chat/ai/types.py

@@ -23,6 +23,6 @@ class StreamAiChatGenerator(AiChatGenerator, lang.Abstract):
     def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
     ) -> ta.Awaitable['mc.Chat']:
         raise NotImplementedError

ommlds/cli/sessions/chat/tools/configs.py

@@ -1,6 +1,7 @@
 import typing as ta
 
 from omlish import dataclasses as dc
+from omlish import lang
 
 
 ##
@@ -11,3 +12,11 @@ class ToolsConfig:
     silent: bool = False
     dangerous_no_confirmation: bool = False
     enabled_tools: ta.Iterable[str] | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolSetConfig(lang.Abstract):
+    pass

ommlds/cli/sessions/chat/tools/fs/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FsToolSetConfig(ToolSetConfig, lang.Final):
+    pass

ommlds/cli/sessions/chat/tools/fs/inject.py

@@ -0,0 +1,35 @@
+import os
+
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import bind_tool_context_provider_to_key
+from ..injection import tool_catalog_entries
+from .configs import FsToolSetConfig
+
+
+##
+
+
+def bind_fs_tools(cfg: FsToolSetConfig) -> inj.Elements:
+    from ......minichain.lib.fs.context import FsContext
+    from ......minichain.lib.fs.tools.ls import ls_tool
+    from ......minichain.lib.fs.tools.read import read_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            ls_tool(),
+            read_tool(),
+        ),
+
+        inj.bind(FsContext(
+            root_dir=os.getcwd(),
+        )),
+        bind_tool_context_provider_to_key(FsContext),
+    )
+
+
+##
+
+
+FS_TOOL_SET_BINDER = ToolSetBinder(FsToolSetConfig, bind_fs_tools)

ommlds/cli/sessions/chat/tools/inject.py

@@ -1,13 +1,10 @@
-import os
-import typing as ta
-
 from omlish import check
 from omlish import inject as inj
 from omlish import lang
 
 from ..... import minichain as mc
 from .configs import ToolsConfig
-from .injection import bind_tool_context_provider_to_key
+from .injection import ToolSetBinder
 from .injection import tool_catalog_entries
 from .injection import tool_context_providers
 
@@ -21,65 +18,6 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-_TOOL_BINDERS: dict[str, ta.Callable[[], inj.Elements]] = {}
-
-
-def _tool_binder(name: str) -> ta.Callable[[ta.Callable[[], inj.Elements]], ta.Callable[[], inj.Elements]]:
-    def inner(fn):
-        check.not_in(name, _TOOL_BINDERS)
-        _TOOL_BINDERS[name] = fn
-        return fn
-    return inner
-
-
-#
-
-
-@_tool_binder('weather')
-def _bind_weather_tool() -> inj.Elements:
-    from .weather import WEATHER_TOOL
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
-    )
-
-
-@_tool_binder('todo')
-def _bind_todo_tools() -> inj.Elements:
-    from .....minichain.lib.todo.context import TodoContext
-    from .....minichain.lib.todo.tools.read import todo_read_tool
-    from .....minichain.lib.todo.tools.write import todo_write_tool
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(
-            todo_read_tool(),
-            todo_write_tool(),
-        ),
-
-        inj.bind(TodoContext()),
-        bind_tool_context_provider_to_key(TodoContext),
-    )
-
-
-@_tool_binder('fs')
-def _bind_fs_tools() -> inj.Elements:
-    from .....minichain.lib.fs.context import FsContext
-    from .....minichain.lib.fs.tools.ls import ls_tool
-    from .....minichain.lib.fs.tools.read import read_tool
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(
-            ls_tool(),
-            read_tool(),
-        ),
-
-        inj.bind(FsContext(
-            root_dir=os.getcwd(),
-        )),
-        bind_tool_context_provider_to_key(FsContext),
-    )
-
-
 # if tools_config.enable_unsafe_tools_do_not_use_lol:
 #     from ...minichain.lib.bash import bash_tool
 #     els.append(bind_tool(bash_tool()))
@@ -103,7 +41,16 @@ def bind_tools(cfg: ToolsConfig = ToolsConfig()) -> inj.Elements:
     els.append(tool_catalog_entries().bind_items_provider(singleton=True))
 
     for etn in check.not_isinstance(cfg.enabled_tools or [], str):
-        els.append(_TOOL_BINDERS[etn]())
+        from .fs.inject import FS_TOOL_SET_BINDER
+        from .todo.inject import TODO_TOOL_SET_BINDER
+        from .weather.inject import WEATHER_TOOL_SET_BINDER
+        ts_binder: ToolSetBinder = {  # type: ignore[assignment]  # FIXME: placeholder obviously lol
+            'fs': FS_TOOL_SET_BINDER,
+            'todo': TODO_TOOL_SET_BINDER,
+            'weather': WEATHER_TOOL_SET_BINDER,
+        }[etn]
+
+        els.append(ts_binder.fn(ts_binder.cfg_cls()))
 
     #
 

ommlds/cli/sessions/chat/tools/injection.py

@@ -1,15 +1,20 @@
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
 from ..... import minichain as mc
+from .configs import ToolSetConfig
 
 
 with lang.auto_proxy_import(globals()):
     from . import execution as _execution
 
 
+ToolSetConfigT = ta.TypeVar('ToolSetConfigT', bound='ToolSetConfig')
+
+
 ##
 
 
@@ -28,3 +33,12 @@ def bind_tool_context_provider_to_key(key: ta.Any) -> inj.Elements:
         lambda v: _execution.ToolContextProvider(lambda: [v]),
         v=key,
     ), singleton=True)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ToolSetBinder(lang.Final, ta.Generic[ToolSetConfigT]):
+    cfg_cls: type[ToolSetConfig]
+    fn: ta.Callable[[ToolSetConfigT], inj.Elements]

ommlds/cli/sessions/chat/tools/todo/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class TodoToolSetConfig(ToolSetConfig, lang.Final):
+    pass

ommlds/cli/sessions/chat/tools/todo/inject.py

@@ -0,0 +1,31 @@
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import bind_tool_context_provider_to_key
+from ..injection import tool_catalog_entries
+from .configs import TodoToolSetConfig
+
+
+##
+
+
+def bind_todo_tools(cfg: TodoToolSetConfig) -> inj.Elements:
+    from ......minichain.lib.todo.context import TodoContext
+    from ......minichain.lib.todo.tools.read import todo_read_tool
+    from ......minichain.lib.todo.tools.write import todo_write_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            todo_read_tool(),
+            todo_write_tool(),
+        ),
+
+        inj.bind(TodoContext()),
+        bind_tool_context_provider_to_key(TodoContext),
+    )
+
+
+##
+
+
+TODO_TOOL_SET_BINDER = ToolSetBinder(TodoToolSetConfig, bind_todo_tools)

ommlds/cli/sessions/chat/tools/weather/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class WeatherToolSetConfig(ToolSetConfig, lang.Final):
+    pass

ommlds/cli/sessions/chat/tools/weather/inject.py

@@ -0,0 +1,22 @@
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import tool_catalog_entries
+from .configs import WeatherToolSetConfig
+
+
+##
+
+
+def bind_weather_tools(cfg: WeatherToolSetConfig) -> inj.Elements:
+    from .tools import WEATHER_TOOL
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
+    )
+
+
+##
+
+
+WEATHER_TOOL_SET_BINDER = ToolSetBinder(WeatherToolSetConfig, bind_weather_tools)

ommlds/cli/sessions/chat/tools/{weather.py → weather/tools.py}

@@ -1,4 +1,4 @@
-from ..... import minichain as mc
+from ...... import minichain as mc
 
 
 ##

ommlds/minichain/__init__.py

@@ -65,6 +65,33 @@ with _lang.auto_proxy_init(
 
     ##
 
+    from .chat.choices.stream.adapters import (  # noqa
+        ChatChoicesStreamServiceChatChoicesService,
+    )
+
+    from .chat.choices.stream.joining import (  # noqa
+        AiChoicesDeltaJoiner,
+    )
+
+    from .chat.choices.stream.services import (  # noqa
+        ChatChoicesStreamRequest,
+        ChatChoicesStreamResponse,
+        ChatChoicesStreamService,
+        AbstractChatChoicesStreamService,
+        static_check_is_chat_choices_stream_service,
+    )
+
+    from .chat.choices.stream.types import (  # noqa
+        ChatChoicesStreamOption,
+        ChatChoicesStreamOptions,
+
+        ChatChoicesStreamOutput,
+        ChatChoicesStreamOutputs,
+
+        AiChoiceDeltas,
+        AiChoicesDeltas,
+    )
+
     from .chat.choices.adapters import (  # noqa
         ChatChoicesServiceChatService,
     )
@@ -88,37 +115,27 @@ with _lang.auto_proxy_init(
         AiChoices,
     )
 
-    from .chat.stream.adapters import (  # noqa
-        ChatChoicesStreamServiceChatChoicesService,
-    )
-
     from .chat.stream.joining import (  # noqa
-        AiChoiceDeltaJoiner,
+        AiDeltaJoiner,
     )
 
     from .chat.stream.services import (  # noqa
-        ChatChoicesStreamRequest,
-        ChatChoicesStreamResponse,
-        ChatChoicesStreamService,
-        AbstractChatChoicesStreamService,
-        static_check_is_chat_choices_stream_service,
+        ChatStreamRequest,
+        ChatStreamResponse,
+        ChatStreamService,
+        AbstractChatStreamService,
+        static_check_is_chat_stream_service,
     )
 
     from .chat.stream.types import (  # noqa
-        ChatChoicesStreamOption,
-        ChatChoicesStreamOptions,
+        AiDelta,
+        AiDeltas,
 
-        ChatChoicesStreamOutput,
-        ChatChoicesStreamOutputs,
-
-        AiChoiceDelta,
-        ContentAiChoiceDelta,
-        AnyToolUseAiChoiceDelta,
-        ToolUseAiChoiceDelta,
-        PartialToolUseAiChoiceDelta,
+        ContentAiDelta,
 
-        AiChoiceDeltas,
-        AiChoicesDeltas,
+        AnyToolUseAiDelta,
+        ToolUseAiDelta,
+        PartialToolUseAiDelta,
     )
 
     from .chat.tools.execution import (  # noqa

ommlds/minichain/backends/impls/anthropic/stream.py

@@ -11,13 +11,13 @@ from omlish.io.buffers import DelimitingBuffer
 from .....backends.anthropic.protocol import types as pt
 from .....backends.anthropic.protocol.sse.events import AnthropicSseDecoderEvents
 from ....chat.choices.services import ChatChoicesOutputs
-from ....chat.stream.services import ChatChoicesStreamRequest
-from ....chat.stream.services import ChatChoicesStreamResponse
-from ....chat.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.stream.types import AiChoiceDeltas
-from ....chat.stream.types import AiChoicesDeltas
-from ....chat.stream.types import ContentAiChoiceDelta
-from ....chat.stream.types import PartialToolUseAiChoiceDelta
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.stream.types import AiChoicesDeltas
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....configs import Config
 from ....resources import UseResources
@@ -131,12 +131,12 @@ class AnthropicChatChoicesStreamService:
                                         cbk_start = ae
 
                                         if isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Text):  # noqa
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
                                                 ae.content_block.text,
                                             )])]))
 
                                         elif isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.ToolUse):  # noqa
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiChoiceDelta(  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiDelta(  # noqa
                                                 id=ae.content_block.id,
                                                 name=ae.content_block.name,
                                                 raw_args=ae.content_block.input,
@@ -149,12 +149,12 @@ class AnthropicChatChoicesStreamService:
                                         check.not_none(cbk_start)
 
                                         if isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.TextDelta):
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
                                                 ae.delta.text,
                                             )])]))
 
                                         elif isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.InputJsonDelta):  # noqa
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiChoiceDelta(  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiDelta(  # noqa
                                                 raw_args=ae.delta.partial_json,
                                             )])]))
 

ommlds/minichain/backends/impls/dummy/chat.py

@@ -6,15 +6,15 @@ from omlish.text.lorem import LOREM
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
+from ....chat.choices.stream.services import ChatChoicesStreamRequest
+from ....chat.choices.stream.services import ChatChoicesStreamResponse
+from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.stream.types import AiChoicesDeltas
 from ....chat.choices.types import AiChoice
 from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
-from ....chat.stream.services import ChatChoicesStreamRequest
-from ....chat.stream.services import ChatChoicesStreamResponse
-from ....chat.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.stream.types import AiChoiceDeltas
-from ....chat.stream.types import AiChoicesDeltas
-from ....chat.stream.types import ContentAiChoiceDelta
+from ....chat.stream.types import ContentAiDelta
 from ....resources import UseResources
 from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
@@ -48,7 +48,7 @@ class DummyChatChoicesStreamService:
                 for s in LOREM:
                     await sink.emit(AiChoicesDeltas([
                         AiChoiceDeltas([
-                            ContentAiChoiceDelta(s),
+                            ContentAiDelta(s),
                         ]),
                     ]))