ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/minichain/_typedvalues.py

@@ -23,14 +23,21 @@ def _tv_field_coercer(
 ) -> ta.Callable[[ta.Sequence], tv.TypedValues]:
     if isinstance(tvc, tuple):
         check.arg(all(issubclass(e, tv.TypedValue) for e in tvc))
+
     else:
         check.issubclass(tvc, tv.TypedValue)
 
     def inner(seq):
-        return tv.TypedValues(*[
-            check.isinstance(e, tvc)
-            for e in check.isinstance(seq, ta.Sequence)
-        ])
+        if isinstance(seq, tv.TypedValues):
+            for e in seq:
+                check.isinstance(e, tvc)
+            return seq
+
+        else:
+            return tv.TypedValues(*[
+                check.isinstance(e, tvc)
+                for e in check.isinstance(seq, ta.Sequence)
+            ])
 
     return inner
 
@@ -68,11 +75,11 @@ def _tv_field_metadata(
             repr_fn=_tv_field_repr,
         ),
 
-        msh.FieldMetadata: msh.FieldMetadata(
+        msh.FieldOptions: msh.FieldOptions(
             name=marshal_name,
-            options=msh.FieldOptions(
-                omit_if=operator.not_,
-            ),
+
+            omit_if=operator.not_,
+
             marshaler_factory=msh.FuncMarshalerFactory(
                 lambda ctx, rty: _marshal._TypedValuesFieldMarshalerFactory(tvs_rty).make_marshaler(ctx, rty),  # noqa
             ),

ommlds/minichain/backends/catalogs/base.py

@@ -3,15 +3,34 @@ import typing as ta
 
 from omlish import lang
 
+from ...configs import Config
+
+
+T = ta.TypeVar('T')
+
 
 ##
 
 
 class BackendCatalog(lang.Abstract):
+    class Backend(ta.NamedTuple):
+        factory: ta.Callable[..., ta.Any]
+        configs: ta.Sequence[Config] | None
+
     @abc.abstractmethod
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: type[T], name: str) -> Backend:
         raise NotImplementedError
 
+    def new_backend(
+            self,
+            service_cls: ta.Any,
+            name: str,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Any:
+        be = self.get_backend(service_cls, name)
+        return be.factory(*be.configs or [], *args, **kwargs)
+
     # #
     #
     # class Bound(lang.Final, ta.Generic[T]):

ommlds/minichain/backends/catalogs/simple.py

@@ -40,9 +40,9 @@ class SimpleBackendCatalog(BackendCatalog):
             sc_dct[e.name] = e
         self._dct = dct
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         e = self._dct[service_cls][name]
-        return e.factory_fn(*args, **kwargs)
+        return BackendCatalog.Backend(e.factory_fn, None)
 
 
 ##

ommlds/minichain/backends/catalogs/strings.py

@@ -5,7 +5,7 @@ from omlish import check
 from ...models.configs import ModelPath
 from ...models.configs import ModelRepo
 from ...models.repos.resolving import ModelRepoResolver
-from ...registries.globals import registry_new
+from ...registries.globals import get_registry_cls
 from ..strings.parsing import parse_backend_string
 from ..strings.resolving import BackendStringResolver
 from ..strings.resolving import ResolveBackendStringArgs
@@ -30,26 +30,29 @@ class BackendStringBackendCatalog(BackendCatalog):
         self._string_resolver = string_resolver
         self._model_repo_resolver = model_repo_resolver
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         ps = parse_backend_string(name)
-        rs = check.not_none(self._string_resolver.resolve_backend_string(ResolveBackendStringArgs(
+        rba = ResolveBackendStringArgs(
             service_cls,
             ps,
-        )))
+        )
+        rs = check.not_none(self._string_resolver.resolve_backend_string(rba))
 
-        al = list(rs.args or [])
+        al: list = list(rs.args or [])
 
-        # FIXME: lol
+        # FIXME: lol - move *into* local model classes as an injected dep?
         if al and isinstance(al[0], ModelRepo):
             [mr] = al
             mrr = check.not_none(self._model_repo_resolver)
             mrp = check.not_none(mrr.resolve(mr))
             al = [ModelPath(mrp.path), *al[1:]]
 
-        return registry_new(
+        cls = get_registry_cls(
             service_cls,
             rs.name,
-            *al,
-            *args,
-            **kwargs,
+        )
+
+        return BackendCatalog.Backend(
+            cls,
+            al,
         )

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

@@ -17,6 +17,7 @@ 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.types import AiChoice
+from ....chat.choices.types import ChatChoicesOptions
 from ....chat.messages import AiMessage
 from ....chat.messages import AnyAiMessage
 from ....chat.messages import Message
@@ -24,9 +25,12 @@ from ....chat.messages import SystemMessage
 from ....chat.messages import ToolUseMessage
 from ....chat.messages import UserMessage
 from ....chat.tools.types import Tool
+from ....llms.types import MaxTokens
+from ....llms.types import Temperature
 from ....models.configs import ModelName
 from ....standard import ApiKey
 from ....tools.types import ToolUse
+from ....types import Option
 from .names import MODEL_NAMES
 from .protocol import build_protocol_chat_messages
 from .protocol import build_protocol_tool
@@ -46,9 +50,12 @@ class AnthropicChatChoicesService:
     def __init__(
             self,
             *configs: ApiKey | ModelName,
+            http_client: http.AsyncHttpClient | None = None,
     ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._api_key = check.not_none(ApiKey.pop_secret(cc, env='ANTHROPIC_API_KEY'))
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
@@ -64,16 +71,31 @@ class AnthropicChatChoicesService:
         else:
             raise TypeError(m)
 
+    DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
+        MaxTokens(4096),
+    )
+
+    _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
+        temperature=Temperature,
+        max_tokens=MaxTokens,
+    )
+
     async def invoke(
             self,
             request: ChatChoicesRequest,
-            *,
-            max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
         messages, system = build_protocol_chat_messages(request.v)
 
+        kwargs: dict = dict()
+
         tools: list[pt.ToolSpec] = []
-        with tv.TypedValues(*request.options).consume() as oc:
+        with tv.TypedValues(
+            *self.DEFAULT_OPTIONS,
+                *request.options,
+                override=True,
+        ).consume() as oc:
+            kwargs.update(oc.pop_scalar_kwargs(**self._OPTION_KWARG_NAMES_MAP))
+
             t: Tool
             for t in oc.pop(Tool, []):
                 tools.append(build_protocol_tool(t))
@@ -83,12 +105,12 @@ class AnthropicChatChoicesService:
             system=system,
             messages=messages,
             tools=tools or None,
-            max_tokens=max_tokens,
+            **kwargs,
         )
 
         raw_request = msh.marshal(a_req)
 
-        raw_response = http.request(
+        raw_response = await http.async_request(
             'https://api.anthropic.com/v1/messages',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
@@ -96,6 +118,7 @@ class AnthropicChatChoicesService:
                 b'anthropic-version': b'2023-06-01',
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))

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

@@ -14,9 +14,9 @@ from ...strings.manifests import BackendStringsManifest
 MODEL_NAMES = ModelNameCollection(
     default='claude',
     aliases={
-        'claude-opus-4-1-20250805': None,
-        'claude-opus-4-1': 'claude-opus-4-1-20250805',
-        'claude-opus': 'claude-opus-4-1',
+        'claude-opus-4-5-20251101': None,
+        'claude-opus-4-5': 'claude-opus-4-5-20251101',
+        'claude-opus': 'claude-opus-4-5',
 
         'claude-sonnet-4-5-20250929': None,
         'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',

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

@@ -12,7 +12,7 @@ from ....chat.messages import ToolUseMessage
 from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
 from ....chat.tools.types import Tool
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 
 
@@ -104,6 +104,6 @@ def build_protocol_chat_messages(msgs: ta.Iterable[Message]) -> BuiltChatMessage
 def build_protocol_tool(t: Tool) -> pt.ToolSpec:
     return pt.ToolSpec(
         name=check.not_none(t.spec.name),
-        description=prepare_content_str(t.spec.desc),
+        description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else '',
         input_schema=build_tool_spec_params_json_schema(t.spec),
     )

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
@@ -39,14 +39,20 @@ from .protocol import build_protocol_tool
 # )
 @static_check_is_chat_choices_stream_service
 class AnthropicChatChoicesStreamService:
-    def __init__(self, *configs: Config) -> None:
+    def __init__(
+            self,
+            *configs: Config,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._model_name = cc.pop(AnthropicChatChoicesService.DEFAULT_MODEL_NAME)
             self._api_key = check.not_none(ApiKey.pop_secret(cc, env='ANTHROPIC_API_KEY'))
 
-    READ_CHUNK_SIZE = 64 * 1024
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
     async def invoke(
             self,
@@ -84,8 +90,8 @@ class AnthropicChatChoicesStreamService:
         )
 
         async with UseResources.or_new(request.options) as rs:
-            http_client = rs.enter_context(http.client())
-            http_response = rs.enter_context(http_client.stream_request(http_request))
+            http_client = await rs.enter_async_context(http.manage_async_client(self._http_client))
+            http_response = await rs.enter_async_context(await http_client.stream_request(http_request))
 
             async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
                 msg_start: AnthropicSseDecoderEvents.MessageStart | None = None
@@ -95,12 +101,11 @@ class AnthropicChatChoicesStreamService:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 sd = sse.SseDecoder()
                 while True:
-                    # FIXME: read1 not on response stream protocol
-                    b = http_response.stream.read1(self.READ_CHUNK_SIZE)  # type: ignore[attr-defined]
+                    b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
                     for l in db.feed(b):
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(l)
 
                         # FIXME: https://docs.anthropic.com/en/docs/build-with-claude/streaming
                         for so in sd.process_line(l):
@@ -126,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,
@@ -144,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/cerebras/chat.py

@@ -0,0 +1,82 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish import typedvalues as tv
+from omlish.formats import json
+from omlish.http import all as http
+
+from .....backends.cerebras import protocol as pt
+from .....backends.cerebras.clients import REQUIRED_HTTP_HEADERS
+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_cer_request_messages
+from .protocol import build_cer_request_tool
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='cerebras',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class CerebrasChatChoicesService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName | DefaultOptions,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._http_client = http_client
+
+        with tv.consume(*configs) as cc:
+            self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='CEREBRAS_API_KEY')
+            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_cer_request_tool(t))
+
+        cer_request = pt.ChatCompletionRequest(
+            messages=build_cer_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+        )
+
+        raw_request = msh.marshal(cer_request)
+
+        # TODO: headers:
+        #  - CF-RAY
+        #  - X-Amz-Cf-Id
+        #  - X-delay-time
+
+        http_response = await http.async_request(
+            'https://api.cerebras.ai/v1/chat/completions',
+            headers={
+                http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
+                http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
+                **REQUIRED_HTTP_HEADERS,
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
+        )
+
+        raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))

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

@@ -0,0 +1,45 @@
+"""
+https://inference-docs.cerebras.ai/models/overview
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'llama3.1-8b': None,
+
+        'llama-3.3-70b': None,
+        'llama3': 'llama-3.3-70b',
+
+        'gpt-oss-120b': None,
+        'gpt-oss': 'gpt-oss-120b',
+
+        'qwen-3-32b': None,
+        'qwen3': 'qwen-3-32b',
+
+        ##
+        # preview
+
+        'qwen-3-235b-a22b-instruct-2507': None,
+        'qwen-3-235b': 'qwen-3-235b-a22b-instruct-2507',
+
+        'zai-glm-4.7': None,
+        'glm': 'zai-glm-4.7',
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'cerebras',
+    model_names=MODEL_NAMES,
+)

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

@@ -0,0 +1,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.cerebras 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 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 AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import PartialToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.transform.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_cer_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    cer_msgs: list[pt.ChatCompletionRequest.Message] = []
+
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
+
+        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:
+                cer_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):
+                    cer_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    cer_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    cer_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 cer_msgs
+
+
+def build_cer_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) if t.spec.desc is not None else None,
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(cer_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(cer_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        cer_msg = cer_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if cer_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(cer_msg.content, str),
+            ))
+
+        for cer_tc in cer_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=cer_tc.id,
+                name=cer_tc.function.name,
+                args=json.loads(cer_tc.function.arguments or '{}'),
+                raw_args=cer_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, cer_resp.choices)))
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        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(PartialToolUseAiDelta(
+                id=tc.id,
+                name=tc_fn.name,
+                raw_args=tc_fn.arguments,
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)