ommlds 0.0.0.dev465__tar.gz → 0.0.0.dev466__tar.gz

{ommlds-0.0.0.dev465/ommlds.egg-info → ommlds-0.0.0.dev466}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev465
+Version: 0.0.0.dev466
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev465
-Requires-Dist: omlish==0.0.0.dev465
+Requires-Dist: omdev==0.0.0.dev466
+Requires-Dist: omlish==0.0.0.dev466
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/.omlish-manifests.json

@@ -63,7 +63,7 @@
     "module": ".minichain.backends.impls.anthropic.stream",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/anthropic/stream.py",
-    "line": 35,
+    "line": 36,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.anthropic.stream",
@@ -137,7 +137,7 @@
     "module": ".minichain.backends.impls.google.stream",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/google/stream.py",
-    "line": 36,
+    "line": 41,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.google.stream",

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/backends/google/protocol/types.py

@@ -148,11 +148,14 @@ class Part(lang.Final):
     video_metadata: VideoMetadata | None = None
 
 
+ContentRole: ta.TypeAlias = ta.Literal['user', 'model']
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 @_set_class_marshal_options
 class Content(lang.Final):
     parts: ta.Sequence[Part] | None = None
-    role: ta.Literal['user', 'model'] | None = None
+    role: ContentRole | None = None
 
 
 ##

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/cli/sessions/chat/chat/ai/services.py

@@ -63,19 +63,17 @@ class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
     ) -> mc.AiChat:
         opts = self._options() if self._options is not None else []
 
-        lst: list[str] = []
-
         async with self._service_provider.provide_backend() as service:
+            joiner = mc.AiChoiceDeltaJoiner()
+
             async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).v as st_resp:
                 async for o in st_resp:
+                    joiner.add(o.choices)
+
                     choice = check.single(o.choices)
 
                     for delta in choice.deltas:
                         if delta_callback is not None:
                             await delta_callback(delta)
 
-                    c = check.isinstance(delta, mc.ContentAiChoiceDelta).c  # noqa
-                    if c is not None:
-                        lst.append(check.isinstance(c, str))
-
-        return [mc.AiMessage(''.join(lst))]
+        return check.single(joiner.build())

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/minichain/__init__.py

@@ -92,6 +92,10 @@ with _lang.auto_proxy_init(
         ChatChoicesStreamServiceChatChoicesService,
     )
 
+    from .chat.stream.joining import (  # noqa
+        AiChoiceDeltaJoiner,
+    )
+
     from .chat.stream.services import (  # noqa
         ChatChoicesStreamRequest,
         ChatChoicesStreamResponse,
@@ -109,7 +113,9 @@ with _lang.auto_proxy_init(
 
         AiChoiceDelta,
         ContentAiChoiceDelta,
+        AnyToolUseAiChoiceDelta,
         ToolUseAiChoiceDelta,
+        PartialToolUseAiChoiceDelta,
 
         AiChoiceDeltas,
         AiChoicesDeltas,

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/minichain/backends/impls/anthropic/stream.py

@@ -17,6 +17,7 @@ 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.tools.types import Tool
 from ....configs import Config
 from ....resources import UseResources
@@ -123,19 +124,35 @@ class AnthropicChatChoicesStreamService:
                                         check.not_none(msg_start)
                                         check.none(cbk_start)
                                         cbk_start = ae
+
                                         if isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Text):  # noqa
                                             await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
                                                 ae.content_block.text,
                                             )])]))
+
+                                        elif isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.ToolUse):  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiChoiceDelta(  # noqa
+                                                id=ae.content_block.id,
+                                                name=ae.content_block.name,
+                                                raw_args=ae.content_block.input,
+                                            )])]))
+
                                         else:
                                             raise TypeError(ae.content_block)
 
                                     case AnthropicSseDecoderEvents.ContentBlockDelta():
                                         check.not_none(cbk_start)
+
                                         if isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.TextDelta):
                                             await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
                                                 ae.delta.text,
                                             )])]))
+
+                                        elif isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.InputJsonDelta):  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiChoiceDelta(  # noqa
+                                                raw_args=ae.delta.partial_json,
+                                            )])]))
+
                                         else:
                                             raise TypeError(ae.delta)
 

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/minichain/backends/impls/google/stream.py

@@ -15,6 +15,8 @@ from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 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
@@ -22,12 +24,15 @@ 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.tools.types import Tool
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiKey
 from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .names import MODEL_NAMES
+from .tools import build_tool_spec_schema
 
 
 ##
@@ -48,22 +53,70 @@ class GoogleChatChoicesStreamService:
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
             self._api_key = ApiKey.pop_secret(cc, env='GEMINI_API_KEY')
 
-    def _get_msg_content(self, m: Message) -> str | None:
-        if isinstance(m, AiMessage):
-            return check.isinstance(m.c, str)
+    def _make_str_content(
+            self,
+            s: str | None,
+            *,
+            role: pt.ContentRole | None = None,
+    ) -> pt.Content | None:
+        if s is None:
+            return None
+
+        return pt.Content(
+            parts=[pt.Part(
+                text=check.not_none(s),
+            )],
+            role=role,
+        )
 
-        elif isinstance(m, (SystemMessage, UserMessage)):
-            return check.isinstance(m.c, str)
+    def _make_msg_content(self, m: Message) -> pt.Content:
+        if isinstance(m, (AiMessage, SystemMessage, UserMessage)):
+            return check.not_none(self._make_str_content(
+                check.isinstance(m.c, str),
+                role=self.ROLES_MAP[type(m)],
+            ))
+
+        elif isinstance(m, ToolUseResultMessage):
+            tr_resp_val: pt.Value
+            if m.tur.c is None:
+                tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
+            elif isinstance(m.tur.c, str):
+                tr_resp_val = pt.StringValue(m.tur.c)
+            else:
+                raise TypeError(m.tur.c)
+            return pt.Content(
+                parts=[pt.Part(
+                    function_response=pt.FunctionResponse(
+                        id=m.tur.id,
+                        name=m.tur.name,
+                        response={
+                            'value': tr_resp_val,
+                        },
+                    ),
+                )],
+            )
+
+        elif isinstance(m, ToolUseMessage):
+            return pt.Content(
+                parts=[pt.Part(
+                    function_call=pt.FunctionCall(
+                        id=m.tu.id,
+                        name=m.tu.name,
+                        args=m.tu.args,
+                    ),
+                )],
+                role='model',
+            )
 
         else:
             raise TypeError(m)
 
     BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
+    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.ContentRole | None]] = {  # noqa
+        SystemMessage: None,
         UserMessage: 'user',
-        AiMessage: 'assistant',
+        AiMessage: 'model',
     }
 
     READ_CHUNK_SIZE = 64 * 1024
@@ -74,16 +127,28 @@ class GoogleChatChoicesStreamService:
     ) -> ChatChoicesStreamResponse:
         key = check.not_none(self._api_key).reveal()
 
+        msgs = list(request.v)
+
+        system_inst: pt.Content | None = None
+        if msgs and isinstance(m0 := msgs[0], SystemMessage):
+            system_inst = self._make_msg_content(m0)
+            msgs.pop(0)
+
+        g_tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                g_tools.append(pt.Tool(
+                    function_declarations=[build_tool_spec_schema(t.spec)],
+                ))
+
         g_req = pt.GenerateContentRequest(
             contents=[
-                pt.Content(
-                    parts=[pt.Part(
-                        text=check.not_none(self._get_msg_content(m)),
-                    )],
-                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
-                )
-                for m in request.v
+                self._make_msg_content(m)
+                for m in msgs
             ],
+            tools=g_tools or None,
+            system_instruction=system_inst,
         )
 
         req_dct = msh.marshal(g_req)
@@ -110,18 +175,38 @@ class GoogleChatChoicesStreamService:
                         if isinstance(bl, DelimitingBuffer.Incomplete):
                             # FIXME: handle
                             return []
+
                         l = bl.decode('utf-8')
                         if not l:
                             continue
+
                         if l.startswith('data: '):
                             gcr = msh.unmarshal(json.loads(l[6:]), pt.GenerateContentResponse)  # noqa
                             cnd = check.single(check.not_none(gcr.candidates))
+
                             for p in check.not_none(cnd.content).parts or []:
-                                await sink.emit(AiChoicesDeltas([
-                                    AiChoiceDeltas([
-                                        ContentAiChoiceDelta(check.not_none(p.text)),
-                                    ]),
-                                ]))
+                                if (txt := p.text) is not None:
+                                    check.none(p.function_call)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ContentAiChoiceDelta(check.not_none(txt)),
+                                        ]),
+                                    ]))
+
+                                elif (fc := p.function_call) is not None:
+                                    check.none(p.text)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ToolUseAiChoiceDelta(
+                                                id=fc.id,
+                                                name=fc.name,
+                                                args=fc.args,
+                                            ),
+                                        ]),
+                                    ]))
+
+                                else:
+                                    raise ValueError(p)
 
                     if not b:
                         return []

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/minichain/backends/impls/openai/format.py

@@ -18,7 +18,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.tools.types import Tool
 from ....content.json import JsonContent
 from ....content.prepare import prepare_content_str
@@ -212,17 +214,20 @@ class OpenaiChatRequestHandler:
             ),
         )
 
-    def build_ai_choice_delta(self, delta: ta.Mapping[str, ta.Any]) -> ContentAiChoiceDelta:
-        return ContentAiChoiceDelta(
-            check.not_none(delta.get('content')),
-            # FIXME:
-            # tool_exec_requests=[
-            #     ToolUse(
-            #         id=tc['id'],
-            #         spec=self._process_options().tools_by_name[tc['function']['name']],
-            #         args=json.loads(tc['function']['arguments'] or '{}'),
-            #         raw_args=tc['function']['arguments'],
-            #     )
-            #     for tc in message_or_delta.get('tool_calls', [])
-            # ] or None,
-        )
+    def build_ai_choice_delta(self, delta: ta.Mapping[str, ta.Any]) -> AiChoiceDelta:
+        if (c := delta.get('content')) is not None:
+            check.state(not delta.get('tool_calls'))
+            return ContentAiChoiceDelta(c)
+
+        elif (tcs := delta.get('tool_calls')) is not None:  # noqa
+            check.state(delta.get('content') is None)
+            tc = check.single(tcs)
+            tc_fn = tc['function']
+            return PartialToolUseAiChoiceDelta(
+                id=tc.get('id'),
+                name=tc_fn.get('name'),
+                raw_args=tc_fn.get('arguments'),
+            )
+
+        else:
+            raise ValueError(delta)

ommlds-0.0.0.dev466/ommlds/minichain/chat/stream/adapters.py

@@ -0,0 +1,35 @@
+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 ChatChoicesOutputs
+from .services import ChatChoicesStreamOutputs
+from .services import ChatChoicesStreamService
+
+
+##
+
+
+@static_check_is_chat_choices_service
+@dc.dataclass(frozen=True)
+class ChatChoicesStreamServiceChatChoicesService:
+    service: ChatChoicesStreamService
+
+    async def invoke(self, request: ChatChoicesRequest) -> Response[
+        AiChoices,
+        ChatChoicesOutputs | ChatChoicesStreamOutputs,
+    ]:
+        joiner = AiChoiceDeltaJoiner()
+
+        async with (resp := await self.service.invoke(request)).v as it:  # noqa
+            async for cs in it:
+                joiner.add(cs.choices)
+
+        # check.state(resp_v.is_done)
+
+        # FIXME: outputs lol
+        return Response([AiChoice(ms) for ms in joiner.build()])

ommlds-0.0.0.dev466/ommlds/minichain/chat/stream/joining.py

@@ -0,0 +1,96 @@
+import typing as ta
+
+from omlish import check
+from omlish.formats import json
+
+from ...tools.types import ToolUse
+from ..messages import AiChat
+from ..messages import AiMessage
+from ..messages import AnyAiMessage
+from ..messages import ToolUseMessage
+from .types import AiChoiceDelta
+from .types import AiChoiceDeltas
+from .types import ContentAiChoiceDelta
+from .types import PartialToolUseAiChoiceDelta
+from .types import ToolUseAiChoiceDelta
+
+
+##
+
+
+class AiChoiceDeltaJoiner:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._seq = 0
+        self._channels: list[AiChoiceDeltaJoiner._Channel] = []
+
+    class _Channel(ta.NamedTuple):
+        deltas: list[AiChoiceDelta]
+        messages: list[AnyAiMessage]
+
+    def _build_joined(self, deltas: ta.Sequence[AiChoiceDelta]) -> AnyAiMessage:
+        dty = check.single(set(map(type, check.not_empty(deltas))))
+
+        if dty is ContentAiChoiceDelta:
+            cds = ta.cast(ta.Sequence[ContentAiChoiceDelta], deltas)
+            return AiMessage(''.join(check.isinstance(cd.c, str) for cd in cds))
+
+        elif dty is ToolUseAiChoiceDelta:
+            raise TypeError(dty)
+
+        elif dty is PartialToolUseAiChoiceDelta:
+            tds = ta.cast(ta.Sequence[PartialToolUseAiChoiceDelta], deltas)
+            for td in ta.cast(ta.Sequence[PartialToolUseAiChoiceDelta], deltas)[1:]:
+                check.none(td.id)
+                check.none(td.name)
+
+            ra = ''.join(filter(None, (td.raw_args for td in tds)))
+
+            return ToolUseMessage(ToolUse(
+                id=tds[0].id,
+                name=check.non_empty_str(tds[0].name),
+                args=json.loads(ra),
+                raw_args=ra,
+            ))
+
+        else:
+            raise TypeError(dty)
+
+    def _join_one(self, chan: _Channel) -> None:
+        if not chan.deltas:
+            return
+
+        chan.messages.append(self._build_joined(chan.deltas))
+        chan.deltas.clear()
+
+    def _add_to(self, chan: _Channel, d: AiChoiceDelta) -> None:
+        if chan.deltas and type(chan.deltas[0]) is not type(d):
+            self._join_one(chan)
+
+        if isinstance(d, ToolUseAiChoiceDelta):
+            chan.messages.append(ToolUseMessage(ToolUse(
+                id=d.id,
+                name=check.not_none(d.name),
+                args=d.args or {},
+            )))
+
+        else:
+            chan.deltas.append(d)
+
+    def add(self, choices: ta.Sequence[AiChoiceDeltas]) -> None:
+        if not self._seq:
+            check.empty(self._channels)
+            self._channels.extend(self._Channel([], []) for _ in range(len(choices)))
+
+        for chan, c in zip(self._channels, choices, strict=True):
+            for d in c.deltas:
+                self._add_to(chan, d)
+
+        self._seq += 1
+
+    def build(self) -> list[AiChat]:
+        for chan in self._channels:
+            self._join_one(chan)
+
+        return [list(chan.messages) for chan in self._channels]

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds/minichain/chat/stream/types.py

@@ -6,7 +6,6 @@ from omlish import marshal as msh
 
 from ...content.types import Content
 from ...stream.services import StreamOptions
-from ...tools.types import ToolUse
 from ...types import Option
 from ...types import Output
 from ..choices.types import ChatChoicesOptions
@@ -48,9 +47,23 @@ class ContentAiChoiceDelta(AiChoiceDelta, lang.Final):
     c: Content
 
 
-@dc.dataclass(frozen=True)
-class ToolUseAiChoiceDelta(AiChoiceDelta, lang.Final):
-    tu: ToolUse
+#
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AnyToolUseAiChoiceDelta(AiChoiceDelta, lang.Abstract):
+    id: str | None = None
+    name: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolUseAiChoiceDelta(AnyToolUseAiChoiceDelta, lang.Final):
+    args: ta.Mapping[str, ta.Any] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class PartialToolUseAiChoiceDelta(AnyToolUseAiChoiceDelta, lang.Final):
+    raw_args: ta.Any | None = None
 
 
 #

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466/ommlds.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev465
+Version: 0.0.0.dev466
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev465
-Requires-Dist: omlish==0.0.0.dev465
+Requires-Dist: omdev==0.0.0.dev466
+Requires-Dist: omlish==0.0.0.dev466
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds.egg-info/SOURCES.txt

@@ -239,6 +239,7 @@ ommlds/minichain/chat/choices/types.py
 ommlds/minichain/chat/stream/__init__.py
 ommlds/minichain/chat/stream/_marshal.py
 ommlds/minichain/chat/stream/adapters.py
+ommlds/minichain/chat/stream/joining.py
 ommlds/minichain/chat/stream/services.py
 ommlds/minichain/chat/stream/types.py
 ommlds/minichain/chat/tools/__init__.py

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/ommlds.egg-info/requires.txt

@@ -1,5 +1,5 @@
-omdev==0.0.0.dev465
-omlish==0.0.0.dev465
+omdev==0.0.0.dev466
+omlish==0.0.0.dev466
 
 [all]
 llama-cpp-python~=0.3

{ommlds-0.0.0.dev465 → ommlds-0.0.0.dev466}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev465'
+version = '0.0.0.dev466'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',
@@ -24,8 +24,8 @@ classifiers = [
 ]
 description = 'ommlds'
 dependencies = [
-    'omdev == 0.0.0.dev465',
-    'omlish == 0.0.0.dev465',
+    'omdev == 0.0.0.dev466',
+    'omlish == 0.0.0.dev466',
 ]
 
 [project.optional-dependencies]