ommlds 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev480__py3-none-any.whl

ommlds/minichain/chat/_marshal.py

@@ -5,6 +5,8 @@ TODO:
 from omlish import lang
 from omlish import marshal as msh
 
+from .messages import AnyAiMessage
+from .messages import AnyUserMessage
 from .messages import Message
 
 
@@ -12,13 +14,18 @@ from .messages import Message
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
-    msgs_poly = msh.polymorphism_from_subclasses(
+def _install_standard_marshaling() -> None:
+    for cls in [
+        AnyAiMessage,
+        AnyUserMessage,
         Message,
-        naming=msh.Naming.SNAKE,
-        strip_suffix=True,
-    )
-    msh.install_standard_factories(
-        msh.PolymorphismMarshalerFactory(msgs_poly),
-        msh.PolymorphismUnmarshalerFactory(msgs_poly),
-    )
+    ]:
+        cls_poly = msh.polymorphism_from_subclasses(
+            cls,
+            naming=msh.Naming.SNAKE,
+            strip_suffix='Message',
+        )
+        msh.install_standard_factories(
+            msh.PolymorphismMarshalerFactory(cls_poly),
+            msh.PolymorphismUnmarshalerFactory(cls_poly),
+        )

ommlds/minichain/chat/choices/adapters.py

@@ -2,7 +2,7 @@ from omlish import check
 from omlish import dataclasses as dc
 
 from ...services import Response
-from ..messages import AiMessage
+from ..messages import AiChat
 from ..services import ChatRequest
 from ..services import static_check_is_chat_service
 from .services import ChatChoicesService
@@ -17,6 +17,6 @@ from .types import ChatChoicesOutputs
 class ChatChoicesServiceChatService:
     service: ChatChoicesService
 
-    def invoke(self, request: ChatRequest) -> Response[AiMessage, ChatChoicesOutputs]:
-        resp = self.service.invoke(request)
-        return Response(check.single(resp.v).m, resp.outputs)
+    async def invoke(self, request: ChatRequest) -> Response[AiChat, ChatChoicesOutputs]:
+        resp = await self.service.invoke(request)
+        return Response(check.single(resp.v).ms, resp.outputs)

ommlds/minichain/chat/choices/services.py

@@ -36,5 +36,5 @@ def static_check_is_chat_choices_service[T: ChatChoicesService](t: type[T]) -> t
 @static_check_is_chat_choices_service
 class AbstractChatChoicesService(lang.Abstract):
     @abc.abstractmethod
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+    def invoke(self, request: ChatChoicesRequest) -> ta.Awaitable[ChatChoicesResponse]:
         raise NotImplementedError

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

@@ -0,0 +1,35 @@
+from omlish import dataclasses as dc
+
+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
+
+
+##
+
+
+@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 = AiChoicesDeltaJoiner()
+
+        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/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]

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

@@ -0,0 +1,45 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ....registries.globals import register_type
+from ....services import Request
+from ....services import Service
+from ....stream.services import StreamResponse
+from ...messages import Chat
+from ..types import ChatChoicesOutputs
+from .types import AiChoicesDeltas
+from .types import ChatChoicesStreamOptions
+from .types import ChatChoicesStreamOutputs
+
+
+##
+
+
+ChatChoicesStreamRequest: ta.TypeAlias = Request[Chat, ChatChoicesStreamOptions]
+
+ChatChoicesStreamResponse: ta.TypeAlias = StreamResponse[
+    AiChoicesDeltas,
+    ChatChoicesOutputs,
+    ChatChoicesStreamOutputs,
+]
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryTypeManifest
+ChatChoicesStreamService: ta.TypeAlias = Service[ChatChoicesStreamRequest, ChatChoicesStreamResponse]
+
+register_type(ChatChoicesStreamService, module=__name__)
+
+
+def static_check_is_chat_choices_stream_service[T: ChatChoicesStreamService](t: type[T]) -> type[T]:
+    return t
+
+
+##
+
+
+@static_check_is_chat_choices_stream_service
+class AbstractChatChoicesStreamService(lang.Abstract):
+    @abc.abstractmethod
+    def invoke(self, request: ChatChoicesStreamRequest) -> ta.Awaitable[ChatChoicesStreamResponse]:
+        raise NotImplementedError

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

@@ -0,0 +1,43 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ....stream.services import StreamOptions
+from ....types import Option
+from ....types import Output
+from ...stream.types import AiDeltas
+from ..types import ChatChoicesOptions
+
+
+##
+
+
+class ChatChoicesStreamOption(Option, lang.Abstract, lang.PackageSealed):
+    pass
+
+
+ChatChoicesStreamOptions: ta.TypeAlias = ChatChoicesStreamOption | StreamOptions | ChatChoicesOptions
+
+
+##
+
+
+class ChatChoicesStreamOutput(Output, lang.Abstract, lang.PackageSealed):
+    pass
+
+
+ChatChoicesStreamOutputs: ta.TypeAlias = ChatChoicesStreamOutput
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class AiChoiceDeltas(lang.Final):
+    deltas: AiDeltas
+
+
+@dc.dataclass(frozen=True)
+class AiChoicesDeltas(lang.Final):
+    choices: ta.Sequence[AiChoiceDeltas]

ommlds/minichain/chat/choices/types.py

@@ -9,7 +9,7 @@ from omlish import lang
 
 from ...types import Option
 from ...types import Output
-from ..messages import AiMessage
+from ..messages import AiChat
 from ..types import ChatOptions
 from ..types import ChatOutputs
 
@@ -39,7 +39,7 @@ ChatChoicesOutputs: ta.TypeAlias = ChatChoicesOutput | ChatOutputs
 
 @dc.dataclass(frozen=True)
 class AiChoice(lang.Final):
-    m: AiMessage
+    ms: AiChat
 
 
 AiChoices: ta.TypeAlias = ta.Sequence[AiChoice]

ommlds/minichain/chat/history.py

@@ -63,11 +63,11 @@ class HistoryAddingChatService:
         self._inner = inner
         self._history = history
 
-    def invoke(self, request: ChatRequest) -> ChatResponse:
+    async def invoke(self, request: ChatRequest) -> ChatResponse:
         new_req = dc.replace(request, v=[*self._history.get(), *request.v])
-        response = self._inner.invoke(new_req)
+        response = await self._inner.invoke(new_req)
         self._history.add(
             *request.v,
-            response.v,
+            *response.v,
         )
         return response

ommlds/minichain/chat/messages.py

@@ -13,7 +13,8 @@ from ..content.materialize import CanContent
 from ..content.transforms.base import ContentTransform
 from ..content.types import Content
 from ..metadata import MetadataContainer
-from ..tools.types import ToolExecRequest
+from ..tools.types import ToolUse
+from ..tools.types import ToolUseResult
 from .metadata import MessageMetadatas
 
 
@@ -47,11 +48,48 @@ class Message(  # noqa
         return dc.replace(self, _metadata=tv.TypedValues(*self._metadata, *mds, override=override))
 
 
+Chat: ta.TypeAlias = ta.Sequence[Message]
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class AnyUserMessage(Message, lang.Abstract):
+    pass
+
+
+UserChat: ta.TypeAlias = ta.Sequence[AnyUserMessage]
+
+
+def check_user_chat(chat: Chat) -> UserChat:
+    for m in chat:
+        check.isinstance(m, AnyUserMessage)
+    return ta.cast(UserChat, chat)
+
+
 #
 
 
 @dc.dataclass(frozen=True)
-class SystemMessage(Message, lang.Final):
+class AnyAiMessage(Message, lang.Abstract):
+    pass
+
+
+AiChat: ta.TypeAlias = ta.Sequence[AnyAiMessage]
+
+
+def check_ai_chat(chat: Chat) -> AiChat:
+    for m in chat:
+        check.isinstance(m, AnyAiMessage)
+    return ta.cast(AiChat, chat)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SystemMessage(AnyUserMessage, lang.Final):
     c: CanContent
 
 
@@ -60,7 +98,7 @@ class SystemMessage(Message, lang.Final):
 
 @dc.dataclass(frozen=True)
 @msh.update_fields_metadata(['name'], omit_if=operator.not_)
-class UserMessage(Message, lang.Final):
+class UserMessage(AnyUserMessage, lang.Final):
     c: CanContent
 
     name: str | None = dc.xfield(None, repr_fn=dc.opt_repr)
@@ -70,27 +108,21 @@ class UserMessage(Message, lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['tool_exec_requests'], omit_if=operator.not_)
-class AiMessage(Message, lang.Final):
-    c: Content | None = dc.xfield(None, repr_fn=dc.opt_repr)
-
-    tool_exec_requests: ta.Sequence[ToolExecRequest] | None = dc.xfield(None, repr_fn=dc.opt_repr)
+class AiMessage(AnyAiMessage, lang.Final):
+    c: Content = dc.xfield(None, repr_fn=dc.opt_repr)  # TODO: non-null?
 
 
 #
 
 
-@dc.dataclass(frozen=True, kw_only=True)
-class ToolExecResultMessage(Message, lang.Final):
-    id: str | None = None
-    name: str
-    c: Content
-
-
-##
+@dc.dataclass(frozen=True)
+class ToolUseMessage(AnyAiMessage, lang.Final):
+    tu: ToolUse
 
 
-Chat: ta.TypeAlias = ta.Sequence[Message]
+@dc.dataclass(frozen=True)
+class ToolUseResultMessage(AnyUserMessage, lang.Final):
+    tur: ToolUseResult
 
 
 ##
@@ -110,5 +142,9 @@ class _MessageContentTransform(ContentTransform, lang.Final, lang.NotInstantiabl
         return dc.replace(m, c=self.apply(m.c))
 
     @dispatch.install_method(ContentTransform.apply)
-    def apply_tool_exec_result_message(self, m: ToolExecResultMessage) -> ToolExecResultMessage:
-        return m
+    def apply_tool_use_message(self, m: ToolUseMessage) -> ToolUseMessage:
+        return dc.replace(m, tu=self.apply(m.tu))
+
+    @dispatch.install_method(ContentTransform.apply)
+    def apply_tool_use_result_message(self, m: ToolUseResultMessage) -> ToolUseResultMessage:
+        return dc.replace(m, tur=self.apply(m.tur))

ommlds/minichain/chat/services.py

@@ -7,7 +7,7 @@ from ..registries.globals import register_type
 from ..services import Request
 from ..services import Response
 from ..services import Service
-from .messages import AiMessage
+from .messages import AiChat
 from .messages import Chat
 from .types import ChatOptions
 from .types import ChatOutputs
@@ -18,7 +18,7 @@ from .types import ChatOutputs
 
 ChatRequest: ta.TypeAlias = Request[Chat, ChatOptions]
 
-ChatResponse: ta.TypeAlias = Response[AiMessage, ChatOutputs]
+ChatResponse: ta.TypeAlias = Response[AiChat, ChatOutputs]
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryTypeManifest
 ChatService: ta.TypeAlias = Service[ChatRequest, ChatResponse]
@@ -36,5 +36,5 @@ def static_check_is_chat_service[T: ChatService](t: type[T]) -> type[T]:
 @static_check_is_chat_service
 class AbstractChatService(lang.Abstract):
     @abc.abstractmethod
-    def invoke(self, request: ChatRequest) -> ChatResponse:
+    def invoke(self, request: ChatRequest) -> ta.Awaitable[ChatResponse]:
         raise NotImplementedError

ommlds/minichain/chat/stream/_marshal.py

@@ -0,0 +1,16 @@
+from omlish import lang
+from omlish import marshal as msh
+
+from .types import AiDelta
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    ad_poly = msh.polymorphism_from_subclasses(AiDelta, naming=msh.Naming.SNAKE)
+    msh.install_standard_factories(
+        msh.PolymorphismMarshalerFactory(ad_poly),
+        msh.PolymorphismUnmarshalerFactory(ad_poly),
+    )

ommlds/minichain/chat/stream/joining.py

@@ -0,0 +1,85 @@
+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 AiDelta
+from .types import AiDeltas
+from .types import ContentAiDelta
+from .types import PartialToolUseAiDelta
+from .types import ToolUseAiDelta
+
+
+##
+
+
+class AiDeltaJoiner:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._deltas: list[AiDelta] = []
+        self._messages: list[AnyAiMessage] = []
+
+    def _build_joined(self, deltas: ta.Sequence[AiDelta]) -> AnyAiMessage:
+        dty = check.single(set(map(type, check.not_empty(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 ToolUseAiDelta:
+            raise TypeError(dty)
+
+        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)))
+
+            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 _maybe_join(self) -> None:
+        if not self._deltas:
+            return
+
+        self._messages.append(self._build_joined(self._deltas))
+        self._deltas.clear()
+
+    def _add_one(self, d: AiDelta) -> None:
+        if self._deltas and type(self._deltas[0]) is not type(d):
+            self._maybe_join()
+
+        if isinstance(d, ToolUseAiDelta):
+            self._messages.append(ToolUseMessage(ToolUse(
+                id=d.id,
+                name=check.not_none(d.name),
+                args=d.args or {},
+                raw_args=json.dumps_compact(d.args),
+            )))
+
+        else:
+            self._deltas.append(d)
+
+    def add(self, deltas: AiDeltas) -> None:
+        for d in deltas:
+            self._add_one(d)
+
+    def build(self) -> AiChat:
+        self._maybe_join()
+
+        return list(self._messages)

ommlds/minichain/chat/stream/services.py

@@ -7,45 +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 AiChoiceDeltas
-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[
-    AiChoiceDeltas,
-    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) -> ChatChoicesStreamResponse:
+    def invoke(self, request: ChatStreamRequest) -> ta.Awaitable[ChatStreamResponse]:
         raise NotImplementedError
-
-
-##
-
-
-ChatChoicesStreamGenerator: ta.TypeAlias = ta.Generator[AiChoiceDeltas, None, ta.Sequence[ChatChoicesOutputs] | None]

ommlds/minichain/chat/stream/types.py

@@ -1,4 +1,3 @@
-import operator
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -9,51 +8,65 @@ from ...content.types 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__)
 
 
 ##
 
 
-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 ToolExecRequestDelta(lang.Final):
-    index: int | None = None
-    id: str | None = None
-    name: str | None = None
-    args: str | None = None
+class AiDelta(lang.Sealed, lang.Abstract):
+    pass
 
 
-@dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['tool_exec_requests'], omit_if=operator.not_)
-class AiMessageDelta(lang.Final):
-    c: Content | None = dc.xfield(None, repr_fn=dc.opt_repr)
+AiDeltas: ta.TypeAlias = ta.Sequence[AiDelta]
 
-    tool_exec_requests: ta.Sequence[ToolExecRequestDelta] | None = dc.xfield(None, repr_fn=dc.opt_repr)
+
+#
 
 
 @dc.dataclass(frozen=True)
-class AiChoiceDelta(lang.Final):
-    m: AiMessageDelta
+class ContentAiDelta(AiDelta, lang.Final):
+    c: Content
+
+
+#
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AnyToolUseAiDelta(AiDelta, lang.Abstract):
+    id: str | None = None
+    name: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
+    args: ta.Mapping[str, ta.Any] | None = None
 
 
-AiChoiceDeltas: ta.TypeAlias = ta.Sequence[AiChoiceDelta]
+@dc.dataclass(frozen=True, kw_only=True)
+class PartialToolUseAiDelta(AnyToolUseAiDelta, lang.Final):
+    raw_args: ta.Any | None = None

ommlds/minichain/chat/tools/execution.py

@@ -1,25 +1,26 @@
 from ...tools.execution.context import ToolContext
 from ...tools.execution.executors import ToolExecutor
-from ..messages import ToolExecRequest
-from ..messages import ToolExecResultMessage
+from ...tools.types import ToolUseResult
+from ..messages import ToolUse
+from ..messages import ToolUseResultMessage
 
 
 ##
 
 
-async def execute_tool_request(
+async def execute_tool_use(
         ctx: ToolContext,
         tex: ToolExecutor,
-        ter: ToolExecRequest,
-) -> ToolExecResultMessage:
+        ter: ToolUse,
+) -> ToolUseResultMessage:
     result_str = await tex.execute_tool(
         ctx,
         ter.name,
         ter.args,
     )
 
-    return ToolExecResultMessage(
+    return ToolUseResultMessage(ToolUseResult(
         id=ter.id,
         name=ter.name,
         c=result_str,
-    )
+    ))