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

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

@@ -11,6 +11,11 @@ from omlish.http import all as http
 from omlish.io.buffers import DelimitingBuffer
 
 from .....backends.google.protocol import types as pt
+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 ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
@@ -18,13 +23,8 @@ from ....chat.messages import SystemMessage
 from ....chat.messages import ToolUseMessage
 from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
-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 ToolUseAiChoiceDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....resources import UseResources
@@ -194,7 +194,7 @@ class GoogleChatChoicesStreamService:
                                     check.none(p.function_call)
                                     await sink.emit(AiChoicesDeltas([
                                         AiChoiceDeltas([
-                                            ContentAiChoiceDelta(check.not_none(txt)),
+                                            ContentAiDelta(check.not_none(txt)),
                                         ]),
                                     ]))
 
@@ -202,7 +202,7 @@ class GoogleChatChoicesStreamService:
                                     check.none(p.text)
                                     await sink.emit(AiChoicesDeltas([
                                         AiChoiceDeltas([
-                                            ToolUseAiChoiceDelta(
+                                            ToolUseAiDelta(
                                                 id=fc.id,
                                                 name=fc.name,
                                                 args=fc.args,

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

@@ -10,11 +10,13 @@ from .....backends.groq import protocol as pt
 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.tools.types import Tool
 from ....models.configs import ModelName
 from ....standard import ApiKey
 from ....standard import DefaultOptions
 from .names import MODEL_NAMES
-from .protocol import build_gq_request_message
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
 from .protocol import build_mc_choices_response
 
 
@@ -44,12 +46,16 @@ class GroqChatChoicesService:
             self._default_options: tv.TypedValues = DefaultOptions.pop(cc)
 
     async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
+
         gq_request = pt.ChatCompletionRequest(
-            messages=[
-                build_gq_request_message(m)
-                for m in request.v
-            ],
+            messages=build_gq_request_messages(request.v),
             model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
         )
 
         raw_request = msh.marshal(gq_request)

ommlds/minichain/backends/impls/groq/names.py

@@ -4,6 +4,19 @@ https://console.groq.com/docs/models
 curl -X GET "https://api.groq.com/openai/v1/models" \
      -H "Authorization: Bearer $GROQ_API_KEY" \
      -H "Content-Type: application/json"
+
+"compound-beta",
+"compound-beta-mini",
+"gemma2-9b-it",
+"llama-3.1-8b-instant",
+"llama-3.3-70b-versatile",
+"meta-llama/llama-4-maverick-17b-128e-instruct",
+"meta-llama/llama-4-scout-17b-16e-instruct",
+"meta-llama/llama-guard-4-12b",
+"moonshotai/kimi-k2-instruct",
+"openai/gpt-oss-120b",
+"openai/gpt-oss-20b",
+"qwen/qwen3-32b",
 """
 from ....models.names import ModelNameCollection
 from ...strings.manifests import BackendStringsManifest

ommlds/minichain/backends/impls/groq/protocol.py

@@ -1,46 +1,143 @@
+import itertools
+
 from omlish import check
+from omlish.formats import json
 
 from .....backends.groq import protocol as pt
 from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.stream.types import AiChoiceDeltas
 from ....chat.choices.types import AiChoice
 from ....chat.messages import AiMessage
-from ....chat.messages import Message
+from ....chat.messages import AnyAiMessage
+from ....chat.messages import Chat
 from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
-from ....chat.stream.types import AiChoiceDeltas
-from ....chat.stream.types import ContentAiChoiceDelta
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
 
 
 ##
 
 
-def build_gq_request_message(mc_msg: Message) -> pt.ChatCompletionRequest.Message:
-    if isinstance(mc_msg, SystemMessage):
-        return pt.ChatCompletionRequest.SystemMessage(
-            content=check.isinstance(mc_msg.c, str),
-        )
+def build_gq_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    gq_msgs: list[pt.ChatCompletionRequest.Message] = []
 
-    elif isinstance(mc_msg, UserMessage):
-        return pt.ChatCompletionRequest.UserMessage(
-            content=check.isinstance(mc_msg.c, str),
-        )
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
 
-    else:
-        raise TypeError(mc_msg)
+        if isinstance(mc_msgs[0], AnyAiMessage):
+            tups: list[tuple[AiMessage | None, list[ToolUseMessage]]] = []
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, AiMessage):
+                    tups.append((mc_msg, []))
+
+                elif isinstance(mc_msg, ToolUseMessage):
+                    if not tups:
+                        tups.append((None, []))
+                    tups[-1][1].append(mc_msg)
+
+                else:
+                    raise TypeError(mc_msg)
+
+            for mc_ai_msg, mc_tu_msgs in tups:
+                gq_msgs.append(pt.ChatCompletionRequest.AssistantMessage(
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.ChatCompletionRequest.AssistantMessage.ToolCall(
+                            function=pt.ChatCompletionRequest.AssistantMessage.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=check.not_none(mc_tu_msg.tu.raw_args),
+                            ),
+                            id=check.not_none(mc_tu_msg.tu.id),
+                        )
+                        for mc_tu_msg in mc_tu_msgs
+                    ] if mc_tu_msgs else None,
+                ))
+
+        else:
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, SystemMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.ToolMessage(
+                        tool_call_id=check.not_none(mc_msg.tur.id),
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return gq_msgs
+
+
+def build_gq_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
+    return pt.ChatCompletionRequest.Tool(
+        function=pt.ChatCompletionRequest.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc),
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
 
 
 def build_mc_choices_response(gq_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
-    return ChatChoicesResponse([
-        AiChoice([AiMessage(
-            check.isinstance(gq_choice.message.content, str),
-        )])
-        for gq_choice in gq_resp.choices
-    ])
+    def build_choice(gq_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        gq_msg = gq_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if gq_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(gq_msg.content, str),
+            ))
+
+        for gq_tc in gq_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=gq_tc.id,
+                name=gq_tc.function.name,
+                args=json.loads(gq_tc.function.arguments or '{}'),
+                raw_args=gq_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, gq_resp.choices)))
 
 
 def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
-    if delta.role in (None, 'assistant') and delta.content is not None:
-        return AiChoiceDeltas([ContentAiChoiceDelta(delta.content)])
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
 
-    else:
+        if delta.content is not None:
+            lst.append(ContentAiDelta(delta.content))
+
+        for tc in delta.tool_calls or []:
+            tc_fn = check.not_none(tc.function)
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc_fn.name),
+                args=json.loads(tc_fn.arguments or '{}'),
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
         return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)

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

@@ -10,10 +10,11 @@ from omlish.io.buffers import DelimitingBuffer
 
 from .....backends.groq import protocol as pt
 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 AiChoicesDeltas
+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 AiChoicesDeltas
+from ....chat.tools.types import Tool
 from ....configs import Config
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -21,7 +22,8 @@ from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .chat import GroqChatChoicesService
 from .names import MODEL_NAMES
-from .protocol import build_gq_request_message
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
 from .protocol import build_mc_ai_choice_deltas
 
 
@@ -50,14 +52,16 @@ class GroqChatChoicesStreamService:
     READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
     async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
-        # check.isinstance(request, ChatRequest)
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
 
         gq_request = pt.ChatCompletionRequest(
-            messages=[
-                build_gq_request_message(m)
-                for m in request.v
-            ],
+            messages=build_gq_request_messages(request.v),
             model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
             stream=True,
         )
 

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

@@ -10,12 +10,12 @@ from omlish import typedvalues as tv
 
 from .....backends import llamacpp as lcu
 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.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 ....configs import Config
 from ....models.configs import ModelPath
 from ....resources import UseResources
@@ -102,7 +102,7 @@ class LlamacppChatChoicesStreamService(lang.ExitStacked):
                     # FIXME: stop reason
 
                     if (content := delta.get('content', '')):
-                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(content)])]))
+                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(content)])]))
 
                 return None
 

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

@@ -10,18 +10,18 @@ from ....chat.choices.services import ChatChoicesOutputs
 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 ChatChoicesOptions
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
 from ....chat.messages import UserMessage
-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 ....configs import Config
 from ....llms.types import MaxTokens
 from ....models.configs import ModelPath
@@ -207,7 +207,7 @@ class MlxChatChoicesStreamService(BaseMlxChatChoicesService):
                 for go in gen:
                     if go.text:
                         await sink.emit(AiChoicesDeltas([AiChoiceDeltas([
-                            ContentAiChoiceDelta(go.text),
+                            ContentAiDelta(go.text),
                         ])]))
 
                 return []

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

@@ -13,18 +13,18 @@ from ....chat.choices.services import ChatChoicesOutputs
 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.messages import AiMessage
 from ....chat.messages import AnyAiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
 from ....chat.messages import UserMessage
-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 ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiUrl
@@ -189,7 +189,7 @@ class OllamaChatChoicesStreamService(BaseOllamaChatChoicesService):
                         check.state(not lp.message.tool_calls)
 
                         if (c := lp.message.content):
-                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
+                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
                                 c,
                             )])]))
 

ommlds/minichain/backends/impls/openai/format.py

@@ -17,9 +17,9 @@ from ....chat.messages import SystemMessage
 from ....chat.messages import ToolUseMessage
 from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
-from ....chat.stream.types import AiChoiceDelta
-from ....chat.stream.types import ContentAiChoiceDelta
-from ....chat.stream.types import PartialToolUseAiChoiceDelta
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....content.json import JsonContent
 from ....content.prepare import prepare_content_str
@@ -128,16 +128,16 @@ def build_mc_choices_response(oai_resp: pt.ChatCompletionResponse) -> ChatChoice
     )
 
 
-def build_mc_ai_choice_delta(delta: pt.ChatCompletionChunkChoiceDelta) -> AiChoiceDelta:
+def build_mc_ai_delta(delta: pt.ChatCompletionChunkChoiceDelta) -> AiDelta:
     if delta.content is not None:
         check.state(not delta.tool_calls)
-        return ContentAiChoiceDelta(delta.content)
+        return ContentAiDelta(delta.content)
 
     elif delta.tool_calls is not None:
         check.state(delta.content is None)
         tc = check.single(delta.tool_calls)
         tc_fn = check.not_none(tc.function)
-        return PartialToolUseAiChoiceDelta(
+        return PartialToolUseAiDelta(
             id=tc.id,
             name=tc_fn.name,
             raw_args=tc_fn.arguments,
@@ -166,8 +166,8 @@ class OpenaiChatRequestHandler:
         self._mandatory_kwargs = mandatory_kwargs
 
     DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
-        Temperature(0.),
-        MaxTokens(1024),
+        # Temperature(0.),
+        # MaxTokens(1024),
     )
 
     _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
@@ -182,8 +182,8 @@ class OpenaiChatRequestHandler:
     @cached.function
     def _process_options(self) -> _ProcessedOptions:
         kwargs: dict = dict(
-            temperature=0,
-            max_tokens=1024,
+            # temperature=0,
+            # max_tokens=1024,
         )
 
         tools_by_name: dict[str, ToolSpec] = {}

ommlds/minichain/backends/impls/openai/names.py

@@ -46,8 +46,8 @@ CHAT_MODEL_NAMES = ModelNameCollection(
             for n in _GPT_MODEL_NAMES
         },
 
-        'gpt': 'gpt-4o',
-        'gpt-mini': 'gpt-4o-mini',
+        'gpt': 'gpt-5',
+        'gpt-mini': 'gpt-5-mini',
 
         #
 

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

@@ -13,12 +13,12 @@ from omlish.io.buffers import DelimitingBuffer
 
 from .....backends.openai import protocol as pt
 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 ChatChoicesStreamOption
+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.stream.types import ChatChoicesStreamOption
 from ....configs import Config
 from ....resources import ResourcesOption
 from ....resources import UseResources
@@ -28,7 +28,7 @@ from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .chat import OpenaiChatChoicesService
 from .format import OpenaiChatRequestHandler
-from .format import build_mc_ai_choice_delta
+from .format import build_mc_ai_delta
 from .names import CHAT_MODEL_NAMES
 
 
@@ -122,7 +122,7 @@ class OpenaiChatChoicesStreamService:
                                     break
 
                                 await sink.emit(AiChoicesDeltas([
-                                    AiChoiceDeltas([build_mc_ai_choice_delta(choice.delta)])
+                                    AiChoiceDeltas([build_mc_ai_delta(choice.delta)])
                                     for choice in ccc.choices
                                 ]))
 

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

@@ -9,18 +9,18 @@ from ....chat.choices.services import ChatChoicesOptions
 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.messages import Chat
 from ....chat.messages import SystemMessage
 from ....chat.messages import UserMessage
-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 ....chat.types import ChatOption
 from ....llms.types import LlmOption
 from ....resources import UseResources
@@ -151,7 +151,7 @@ class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
                 for s in tgl3.run_llm(llm, toks):
                     await sink.emit(AiChoicesDeltas([
                         AiChoiceDeltas([
-                            ContentAiChoiceDelta(s),
+                            ContentAiDelta(s),
                         ]),
                     ]))
 

ommlds/minichain/backends/impls/transformers/transformers.py

@@ -19,6 +19,11 @@ from .....backends.transformers.streamers import CancellableTextStreamer
 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  # noqa
+from ....chat.choices.stream.types import AiChoicesDeltas  # noqa
 from ....chat.choices.types import AiChoice
 from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
@@ -27,12 +32,7 @@ from ....chat.messages import SystemMessage
 from ....chat.messages import ToolUseMessage
 from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
-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  # noqa
-from ....chat.stream.types import AiChoicesDeltas  # noqa
-from ....chat.stream.types import ContentAiChoiceDelta  # noqa
+from ....chat.stream.types import ContentAiDelta  # noqa
 from ....completion import CompletionRequest
 from ....completion import CompletionResponse
 from ....completion import static_check_is_completion_service
@@ -288,7 +288,7 @@ class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
                         end = False
 
                     if out:
-                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(out)])]))
+                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(out)])]))
 
                     if end:
                         break

ommlds/minichain/chat/{stream → choices/stream}/adapters.py

@@ -1,11 +1,11 @@
 from omlish import dataclasses as dc
 
-from ...services import Response
-from ..choices.services import ChatChoicesRequest
-from ..choices.services import static_check_is_chat_choices_service
-from ..choices.types import AiChoice
-from ..choices.types import AiChoices
-from .joining import AiChoiceDeltaJoiner
+from ....services import Response
+from ..services import ChatChoicesRequest
+from ..services import static_check_is_chat_choices_service
+from ..types import AiChoice
+from ..types import AiChoices
+from .joining import AiChoicesDeltaJoiner
 from .services import ChatChoicesOutputs
 from .services import ChatChoicesStreamOutputs
 from .services import ChatChoicesStreamService
@@ -23,7 +23,7 @@ class ChatChoicesStreamServiceChatChoicesService:
         AiChoices,
         ChatChoicesOutputs | ChatChoicesStreamOutputs,
     ]:
-        joiner = AiChoiceDeltaJoiner()
+        joiner = AiChoicesDeltaJoiner()
 
         async with (resp := await self.service.invoke(request)).v as it:  # noqa
             async for cs in it:

ommlds/minichain/chat/choices/stream/joining.py

@@ -0,0 +1,31 @@
+import typing as ta
+
+from omlish import check
+
+from ...messages import AiChat
+from ...stream.joining import AiDeltaJoiner
+from .types import AiChoiceDeltas
+
+
+##
+
+
+class AiChoicesDeltaJoiner:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._seq = 0
+        self._channels: list[AiDeltaJoiner] = []
+
+    def add(self, choices: ta.Sequence[AiChoiceDeltas]) -> None:
+        if not self._seq:
+            check.empty(self._channels)
+            self._channels.extend(AiDeltaJoiner() for _ in range(len(choices)))
+
+        for chan, c in zip(self._channels, choices, strict=True):
+            chan.add(c.deltas)
+
+        self._seq += 1
+
+    def build(self) -> list[AiChat]:
+        return [list(chan.build()) for chan in self._channels]