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

ommlds/minichain/chat/stream/joining.py

@@ -8,45 +8,45 @@ 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
+from .types import AiDelta
+from .types import AiDeltas
+from .types import ContentAiDelta
+from .types import PartialToolUseAiDelta
+from .types import ToolUseAiDelta
 
 
 ##
 
 
-class AiChoiceDeltaJoiner:
+class AiDeltaJoiner:
     def __init__(self) -> None:
         super().__init__()
 
-        self._seq = 0
-        self._channels: list[AiChoiceDeltaJoiner._Channel] = []
+        self._all: list[AiDelta] = []
+        self._queue: list[AiDelta] = []
+        self._out: list[AnyAiMessage] = []
 
-    class _Channel(ta.NamedTuple):
-        deltas: list[AiChoiceDelta]
-        messages: list[AnyAiMessage]
-
-    def _build_joined(self, deltas: ta.Sequence[AiChoiceDelta]) -> AnyAiMessage:
+    def _build_joined(self, deltas: ta.Sequence[AiDelta]) -> AnyAiMessage:
         dty = check.single(set(map(type, check.not_empty(deltas))))
 
-        if dty is ContentAiChoiceDelta:
-            cds = ta.cast(ta.Sequence[ContentAiChoiceDelta], deltas)
+        if dty is ContentAiDelta:
+            cds = ta.cast(ta.Sequence[ContentAiDelta], deltas)
             return AiMessage(''.join(check.isinstance(cd.c, str) for cd in cds))
 
-        elif dty is ToolUseAiChoiceDelta:
+        elif dty is ToolUseAiDelta:
             raise TypeError(dty)
 
-        elif dty is PartialToolUseAiChoiceDelta:
-            tds = ta.cast(ta.Sequence[PartialToolUseAiChoiceDelta], deltas)
-            for td in ta.cast(ta.Sequence[PartialToolUseAiChoiceDelta], deltas)[1:]:
+        elif dty is PartialToolUseAiDelta:
+            tds = ta.cast(ta.Sequence[PartialToolUseAiDelta], deltas)
+            for td in ta.cast(ta.Sequence[PartialToolUseAiDelta], deltas)[1:]:
                 check.none(td.id)
                 check.none(td.name)
 
             ra = ''.join(filter(None, (td.raw_args for td in tds)))
 
+            if not ra:
+                ra = '{}'
+
             return ToolUseMessage(ToolUse(
                 id=tds[0].id,
                 name=check.non_empty_str(tds[0].name),
@@ -57,40 +57,53 @@ class AiChoiceDeltaJoiner:
         else:
             raise TypeError(dty)
 
-    def _join_one(self, chan: _Channel) -> None:
-        if not chan.deltas:
+    def _join(self) -> None:
+        if not self._queue:
             return
 
-        chan.messages.append(self._build_joined(chan.deltas))
-        chan.deltas.clear()
+        self._out.append(self._build_joined(self._queue))
+        self._queue.clear()
+
+    def _should_join(self, *, new: AiDelta | None = None) -> bool:
+        if not self._queue:
+            return False
+
+        if new is not None and type(self._queue[0]) is not type(new):
+            return True
+
+        if (
+                isinstance(d0 := self._queue[0], PartialToolUseAiDelta) and
+                isinstance(new, PartialToolUseAiDelta) and
+                d0.id is not None and
+                new.id is not None and
+                d0.id != new.id
+        ):
+            return True
 
-    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)
+        return False
 
-        if isinstance(d, ToolUseAiChoiceDelta):
-            chan.messages.append(ToolUseMessage(ToolUse(
+    def _add_one(self, d: AiDelta) -> None:
+        if self._should_join(new=d):
+            self._join()
+
+        self._all.append(d)
+
+        if isinstance(d, ToolUseAiDelta):
+            self._out.append(ToolUseMessage(ToolUse(
                 id=d.id,
                 name=check.not_none(d.name),
                 args=d.args or {},
+                raw_args=json.dumps_compact(d.args),
             )))
 
         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._queue.append(d)
 
-        self._seq += 1
+    def add(self, deltas: AiDeltas) -> None:
+        for d in deltas:
+            self._add_one(d)
 
-    def build(self) -> list[AiChat]:
-        for chan in self._channels:
-            self._join_one(chan)
+    def build(self) -> AiChat:
+        self._join()
 
-        return [list(chan.messages) for chan in self._channels]
+        return list(self._out)

ommlds/minichain/chat/stream/services.py

@@ -7,39 +7,39 @@ from ...registries.globals import register_type
 from ...services import Request
 from ...services import Service
 from ...stream.services import StreamResponse
-from ..choices.types import ChatChoicesOutputs
 from ..messages import Chat
-from .types import AiChoicesDeltas
-from .types import ChatChoicesStreamOptions
-from .types import ChatChoicesStreamOutputs
+from ..types import ChatOutputs
+from .types import AiDeltas
+from .types import ChatStreamOptions
+from .types import ChatStreamOutputs
 
 
 ##
 
 
-ChatChoicesStreamRequest: ta.TypeAlias = Request[Chat, ChatChoicesStreamOptions]
+ChatStreamRequest: ta.TypeAlias = Request[Chat, ChatStreamOptions]
 
-ChatChoicesStreamResponse: ta.TypeAlias = StreamResponse[
-    AiChoicesDeltas,
-    ChatChoicesOutputs,
-    ChatChoicesStreamOutputs,
+ChatStreamResponse: ta.TypeAlias = StreamResponse[
+    AiDeltas,
+    ChatOutputs,
+    ChatStreamOutputs,
 ]
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryTypeManifest
-ChatChoicesStreamService: ta.TypeAlias = Service[ChatChoicesStreamRequest, ChatChoicesStreamResponse]
+ChatStreamService: ta.TypeAlias = Service[ChatStreamRequest, ChatStreamResponse]
 
-register_type(ChatChoicesStreamService, module=__name__)
+register_type(ChatStreamService, module=__name__)
 
 
-def static_check_is_chat_choices_stream_service[T: ChatChoicesStreamService](t: type[T]) -> type[T]:
+def static_check_is_chat_stream_service[T: ChatStreamService](t: type[T]) -> type[T]:
     return t
 
 
 ##
 
 
-@static_check_is_chat_choices_stream_service
-class AbstractChatChoicesStreamService(lang.Abstract):
+@static_check_is_chat_stream_service
+class AbstractChatStreamService(lang.Abstract):
     @abc.abstractmethod
-    def invoke(self, request: ChatChoicesStreamRequest) -> ta.Awaitable[ChatChoicesStreamResponse]:
+    def invoke(self, request: ChatStreamRequest) -> ta.Awaitable[ChatStreamResponse]:
         raise NotImplementedError

ommlds/minichain/chat/stream/types.py

@@ -4,11 +4,11 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 
-from ...content.types import Content
+from ...content.content import Content
 from ...stream.services import StreamOptions
 from ...types import Option
 from ...types import Output
-from ..choices.types import ChatChoicesOptions
+from ..types import ChatOptions
 
 
 msh.register_global_module_import('._marshal', __package__)
@@ -17,33 +17,39 @@ msh.register_global_module_import('._marshal', __package__)
 ##
 
 
-class ChatChoicesStreamOption(Option, lang.Abstract, lang.PackageSealed):
+class ChatStreamOption(Option, lang.Abstract, lang.PackageSealed):
     pass
 
 
-ChatChoicesStreamOptions: ta.TypeAlias = ChatChoicesStreamOption | StreamOptions | ChatChoicesOptions
+ChatStreamOptions: ta.TypeAlias = ChatStreamOption | StreamOptions | ChatOptions
 
 
 ##
 
 
-class ChatChoicesStreamOutput(Output, lang.Abstract, lang.PackageSealed):
+class ChatStreamOutput(Output, lang.Abstract, lang.PackageSealed):
     pass
 
 
-ChatChoicesStreamOutputs: ta.TypeAlias = ChatChoicesStreamOutput
+ChatStreamOutputs: ta.TypeAlias = ChatStreamOutput
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class AiChoiceDelta(lang.Sealed, lang.Abstract):
+class AiDelta(lang.Sealed, lang.Abstract):
     pass
 
 
+AiDeltas: ta.TypeAlias = ta.Sequence[AiDelta]
+
+
+#
+
+
 @dc.dataclass(frozen=True)
-class ContentAiChoiceDelta(AiChoiceDelta, lang.Final):
+class ContentAiDelta(AiDelta, lang.Final):
     c: Content
 
 
@@ -51,29 +57,16 @@ class ContentAiChoiceDelta(AiChoiceDelta, lang.Final):
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class AnyToolUseAiChoiceDelta(AiChoiceDelta, lang.Abstract):
+class AnyToolUseAiDelta(AiDelta, lang.Abstract):
     id: str | None = None
     name: str | None = None
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class ToolUseAiChoiceDelta(AnyToolUseAiChoiceDelta, lang.Final):
+class ToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
     args: ta.Mapping[str, ta.Any] | None = None
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-class PartialToolUseAiChoiceDelta(AnyToolUseAiChoiceDelta, lang.Final):
+class PartialToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
     raw_args: ta.Any | None = None
-
-
-#
-
-
-@dc.dataclass(frozen=True)
-class AiChoiceDeltas(lang.Final):
-    deltas: ta.Sequence[AiChoiceDelta]
-
-
-@dc.dataclass(frozen=True)
-class AiChoicesDeltas(lang.Final):
-    choices: ta.Sequence[AiChoiceDeltas]

ommlds/minichain/chat/templating.py

@@ -10,9 +10,9 @@ from omlish import dataclasses as dc
 from omlish import lang
 from omlish.text import templating as tpl
 
-from ..content.transforms.strings import transform_content_strings
 from ..envs import Env
 from ..envs import EnvKey
+from .content import transform_message_content_strings
 from .messages import Chat
 from .messages import Message
 
@@ -81,7 +81,7 @@ class ChatTemplater:
                 t = self.d[s]
                 return t.render(tpl.Templater.Context(env))
 
-            return [transform_content_strings(render_content_str, self.m)]
+            return [transform_message_content_strings(render_content_str, self.m)]
 
     @dc.dataclass(frozen=True)
     class _PlaceholderStep(_Step):
@@ -110,7 +110,7 @@ class ChatTemplater:
                 content_strs.add(s)
                 return s
 
-            transform_content_strings(visit_content_str, p.v)
+            transform_message_content_strings(visit_content_str, p.v)
 
             d: dict[str, tpl.Templater] = {
                 s: self._template_factory(s)

ommlds/minichain/content/__init__.py

@@ -8,11 +8,28 @@ _msh.register_global_module_import('._marshal', __package__)
 ##
 
 
-# This is everything _marshal.py references - it must all be imported before the conditional import.
+# These are all of the Content subtypes - it must all be imported before the conditional import.
+
 from . import (  # noqa
+    code as _code,
+    composite as _composite,
+    content as _content,
+    dynamic as _dynamic,
+    emphasis as _emphasis,
     images as _images,
-    materialize as _materialize,
+    json as _json,
+    link as _link,
+    markdown as _markdown,
+    namespaces as _namespaces,
+    placeholders as _placeholders,
+    quote as _quote,
+    raw as _raw,
+    recursive as _recursive,
+    resources as _resources,
+    section as _section,
     sequence as _sequence,
+    standard as _standard,
+    tag as _tag,
+    templates as _templates,
     text as _text,
-    types as _types,
 )