ommlds 0.0.0.dev451__py3-none-any.whl → 0.0.0.dev452__py3-none-any.whl

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

@@ -68,6 +68,6 @@ class HistoryAddingChatService:
         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]

ommlds/minichain/chat/stream/_marshal.py

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

ommlds/minichain/chat/stream/adapters.py

@@ -1,19 +1,22 @@
-import typing as ta
-
 from omlish import check
 from omlish import dataclasses as dc
 from omlish import lang
 
 from ...services import Response
+from ...tools.types import ToolUse
 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 ..messages import AiMessage
-from ..messages import ToolExecRequest
+from ..messages import AnyAiMessage
+from ..messages import ToolUseMessage
 from .services import ChatChoicesOutputs
 from .services import ChatChoicesStreamOutputs
 from .services import ChatChoicesStreamService
+from .types import AiChoiceDelta
+from .types import ContentAiChoiceDelta
+from .types import ToolUseAiChoiceDelta
 
 
 ##
@@ -24,46 +27,54 @@ from .services import ChatChoicesStreamService
 class ChatChoicesStreamServiceChatChoicesService:
     service: ChatChoicesStreamService
 
-    class _Choice(ta.NamedTuple):
-        parts: list[str]
-        trs: list[ToolExecRequest]
-
     async def invoke(self, request: ChatChoicesRequest) -> Response[
         AiChoices,
         ChatChoicesOutputs | ChatChoicesStreamOutputs,
     ]:
-        lst: list[ChatChoicesStreamServiceChatChoicesService._Choice] = []
+        choice_lsts: list[list[list[str] | ToolUse]] = []
+
+        def add(l: list[list[str] | ToolUse], d: AiChoiceDelta) -> None:
+            if isinstance(d, ContentAiChoiceDelta):
+                s = check.isinstance(d.c, str)
+                if l and isinstance(l[-1], list):
+                    l[-1].append(s)
+                else:
+                    l.append([s])
+
+            elif isinstance(d, ToolUseAiChoiceDelta):
+                l.append(d.tu)
+
+            else:
+                raise TypeError(d)
 
         async with (resp := await self.service.invoke(request)).v as it:  # noqa
             i = -1  # noqa
+            l: list[list[str] | ToolUse]
             async for i, cs in lang.async_enumerate(it):
                 if i == 0:
-                    for c in cs:
-                        m = c.m
-                        lst.append(self._Choice(
-                            [check.isinstance(m.c, str)] if m.c is not None else [],
-                            # FIXME
-                            # list(m.tool_exec_requests or []),
-                            [],
-                        ))
+                    for c in cs.choices:
+                        choice_lsts.append(l := [])
+                        for d in c.deltas:
+                            add(l, d)
 
                 else:
-                    for ch, c in zip(lst, cs, strict=True):
-                        m = c.m
-                        if m.c is not None:
-                            ch.parts.append(check.isinstance(m.c, str))
-                        # FIXME
-                        # if m.tool_exec_requests:
-                        #     ch.trs.extend(m.tool_exec_requests)
+                    for l, c in zip(choice_lsts, cs.choices, strict=True):
+                        for d in c.deltas:
+                            add(l, d)
 
         # check.state(resp_v.is_done)
 
         ret: list[AiChoice] = []
-        for ch in lst:
-            ret.append(AiChoice(AiMessage(
-                ''.join(ch.parts) if ch.parts else None,
-                ch.trs or None,
-            )))
+        for cl in choice_lsts:
+            cc: list[AnyAiMessage] = []
+            for e in cl:
+                if isinstance(e, list):
+                    cc.append(AiMessage(''.join(e)))
+                elif isinstance(e, ToolUse):
+                    cc.append(ToolUseMessage(e))
+                else:
+                    raise TypeError(e)
+            ret.append(AiChoice(cc))
 
         # FIXME: outputs lol
         return Response(ret)

ommlds/minichain/chat/stream/services.py

@@ -9,7 +9,7 @@ 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 AiChoicesDeltas
 from .types import ChatChoicesStreamOptions
 from .types import ChatChoicesStreamOutputs
 
@@ -20,7 +20,7 @@ from .types import ChatChoicesStreamOutputs
 ChatChoicesStreamRequest: ta.TypeAlias = Request[Chat, ChatChoicesStreamOptions]
 
 ChatChoicesStreamResponse: ta.TypeAlias = StreamResponse[
-    AiChoiceDeltas,
+    AiChoicesDeltas,
     ChatChoicesOutputs,
     ChatChoicesStreamOutputs,
 ]

ommlds/minichain/chat/stream/types.py

@@ -1,4 +1,3 @@
-import operator
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -7,11 +6,15 @@ 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
 
 
+msh.register_global_module_import('._marshal', __package__)
+
+
 ##
 
 
@@ -36,24 +39,28 @@ ChatChoicesStreamOutputs: ta.TypeAlias = ChatChoicesStreamOutput
 
 
 @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 AiChoiceDelta(lang.Sealed, lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class ContentAiChoiceDelta(AiChoiceDelta, lang.Final):
+    c: Content
 
 
 @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)
+class ToolUseAiChoiceDelta(AiChoiceDelta, lang.Final):
+    tu: ToolUse
 
-    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 AiChoiceDeltas(lang.Final):
+    deltas: ta.Sequence[AiChoiceDelta]
 
 
-AiChoiceDeltas: ta.TypeAlias = ta.Sequence[AiChoiceDelta]
+@dc.dataclass(frozen=True)
+class AiChoicesDeltas(lang.Final):
+    choices: ta.Sequence[AiChoiceDeltas]

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,
-    )
+    ))

ommlds/minichain/chat/tools/ids.py

@@ -3,31 +3,25 @@ import uuid
 
 from omlish import dataclasses as dc
 
-from ..messages import AiMessage
+from ..messages import Chat
 from ..messages import Message
-from ..messages import ToolExecRequest
+from ..messages import ToolUseMessage
 from ..transforms.base import MessageTransform
 
 
 ##
 
 
-def simple_uuid_tool_exec_request_id_factory(m: AiMessage, ter: ToolExecRequest) -> str:  # noqa
+def simple_uuid_tool_exec_request_id_factory(m: ToolUseMessage) -> str:  # noqa
     return str(uuid.uuid4())
 
 
 @dc.dataclass(frozen=True)
-class ToolExecRequestIdAddingMessageTransform(MessageTransform):
-    id_factory: ta.Callable[[AiMessage, ToolExecRequest], str] = dc.field(default=simple_uuid_tool_exec_request_id_factory)  # noqa
+class ToolUseIdAddingMessageTransform(MessageTransform):
+    id_factory: ta.Callable[[ToolUseMessage], str] = dc.field(default=simple_uuid_tool_exec_request_id_factory)  # noqa
 
-    def transform_message(self, m: Message) -> Message:
-        if not isinstance(m, AiMessage) or not m.tool_exec_requests:
-            return m
+    def transform_message(self, m: Message) -> Chat:
+        if not isinstance(m, ToolUseMessage) or m.tu.id is not None:
+            return [m]
 
-        lst: list[ToolExecRequest] = []
-        for ter in m.tool_exec_requests:
-            if ter.id is None:
-                ter = dc.replace(ter, id=self.id_factory(m, ter))
-            lst.append(ter)
-
-        return dc.replace(m, tool_exec_requests=lst)
+        return [dc.replace(m, tu=dc.replace(m.tu, id=self.id_factory(m)))]

ommlds/minichain/chat/tools/parsing.py

@@ -1,54 +1,45 @@
+import typing as ta
+
 from omlish import check
 from omlish import dataclasses as dc
 
-from ...content.types import Content
 from ...text.toolparsing.base import ParsedToolExec
 from ...text.toolparsing.base import ToolExecParser
 from ..messages import AiMessage
-from ..messages import ToolExecRequest
-from ..transforms.base import MessageTransform
+from ..messages import AnyAiMessage
+from ..messages import ToolUse
+from ..messages import ToolUseMessage
+from ..transforms.base import AiMessageTransform
 
 
 ##
 
 
 @dc.dataclass(frozen=True)
-class ToolExecParsingMessageTransform(MessageTransform[AiMessage]):
+class ToolExecParsingMessageTransform(AiMessageTransform):
     parser: ToolExecParser
 
-    def transform_message(self, message: AiMessage) -> AiMessage:
+    def transform_message(self, message: AnyAiMessage) -> ta.Sequence[AnyAiMessage]:
+        if not isinstance(message, AiMessage):
+            return [message]
+
         pts = self.parser.parse_tool_execs_(check.isinstance(message.c or '', str))
 
-        sl: list[str] = []
-        xl: list[ToolExecRequest] = []
+        out: list[AnyAiMessage] = []
+
         for pt in pts:
             if isinstance(pt, ParsedToolExec):
-                xl.append(ToolExecRequest(
+                out.append(ToolUseMessage(ToolUse(
                     id=pt.id,
                     name=pt.name,
                     args=pt.args,
                     raw_args=pt.raw_body,
-                ))
+                )))
 
             elif isinstance(pt, str):
-                sl.append(pt)
+                out.append(AiMessage(pt))
 
             else:
                 raise TypeError(pt)
 
-        c: Content | None
-        if len(sl) == 1:
-            [c] = sl
-        elif sl:
-            c = sl
-        else:
-            c = None
-
-        return dc.replace(
-            message,
-            c=c,
-            tool_exec_requests=[
-                *(message.tool_exec_requests or []),
-                *xl,
-            ],
-        )
+        return out

ommlds/minichain/chat/transforms/base.py

@@ -1,76 +1,67 @@
+"""
+Mirrors omlish.funcs.pairs.
+
+TODO:
+ - MessagesTransform ? MessageTransformMessagesTransform? :| ...
+"""
 import abc
 import typing as ta
 
 from omlish import dataclasses as dc
 from omlish import lang
 
+from ..messages import AnyAiMessage
+from ..messages import AnyUserMessage
 from ..messages import Chat
 from ..messages import Message
 
 
+MessageF = ta.TypeVar('MessageF', bound=Message)
 MessageT = ta.TypeVar('MessageT', bound=Message)
 
 
 ##
 
 
-class MessageTransform(lang.Abstract, ta.Generic[MessageT]):
+class MessageTransform(lang.Abstract, ta.Generic[MessageF, MessageT]):
     @abc.abstractmethod
-    def transform_message(self, message: MessageT) -> MessageT:
+    def transform_message(self, message: MessageF) -> ta.Sequence[MessageT]:
         raise NotImplementedError
 
 
+AiMessageTransform: ta.TypeAlias = MessageTransform[AnyAiMessage, AnyAiMessage]
+UserMessageTransform: ta.TypeAlias = MessageTransform[AnyUserMessage, AnyUserMessage]
+
+
 @dc.dataclass(frozen=True)
 class CompositeMessageTransform(MessageTransform):
     mts: ta.Sequence[MessageTransform]
 
-    def transform_message(self, message: Message) -> Message:
+    def transform_message(self, message: Message) -> Chat:
+        chat: Chat = [message]
         for mt in self.mts:
-            message = mt.transform_message(message)
-        return message
+            chat = [o for i in chat for o in mt.transform_message(i)]
+        return chat
 
 
 @dc.dataclass(frozen=True)
-class FnMessageTransform(MessageTransform, ta.Generic[MessageT]):
-    fn: ta.Callable[[MessageT], MessageT]
+class FnMessageTransform(MessageTransform, ta.Generic[MessageF, MessageT]):
+    fn: ta.Callable[[MessageF], ta.Sequence[MessageT]]
 
-    def transform_message(self, message: MessageT) -> MessageT:
+    def transform_message(self, message: MessageF) -> ta.Sequence[MessageT]:
         return self.fn(message)
 
 
 @dc.dataclass(frozen=True)
-class TypeFilteredMessageTransform(MessageTransform[Message], ta.Generic[MessageT]):
+class TypeFilteredMessageTransform(MessageTransform, ta.Generic[MessageF, MessageT]):
     ty: type | tuple[type, ...]
-    mt: MessageTransform[MessageT]
+    mt: MessageTransform[MessageF, MessageT]
 
-    def transform_message(self, message: Message) -> Message:
+    def transform_message(self, message: Message) -> Chat:
         if isinstance(message, self.ty):
-            return self.mt.transform_message(ta.cast(MessageT, message))
+            return self.mt.transform_message(ta.cast(MessageF, message))
         else:
-            return message
-
-
-@ta.overload
-def fn_message_transform(
-        fn: ta.Callable[[MessageT], MessageT],
-        ty: type[MessageT],
-) -> MessageTransform[MessageT]:
-    ...
-
-
-@ta.overload
-def fn_message_transform(
-        fn: ta.Callable[[Message], Message],
-        ty: type | tuple[type, ...] | None = None,
-) -> MessageTransform:
-    ...
-
-
-def fn_message_transform(fn, ty=None) -> MessageTransform[MessageT]:
-    mt: MessageTransform = FnMessageTransform(fn)
-    if ty is not None:
-        mt = TypeFilteredMessageTransform(ty, mt)
-    return mt
+            return [message]
 
 
 ##
@@ -108,7 +99,7 @@ class MessageTransformChatTransform(ChatTransform):
     mt: MessageTransform
 
     def transform_chat(self, chat: Chat) -> Chat:
-        return [self.mt.transform_message(m) for m in chat]
+        return [o for i in chat for o in self.mt.transform_message(i)]
 
 
 @dc.dataclass(frozen=True)
@@ -117,6 +108,6 @@ class LastMessageTransformChatTransform(ChatTransform):
 
     def transform_chat(self, chat: Chat) -> Chat:
         if chat:
-            return [*chat[:-1], self.mt.transform_message(chat[-1])]
+            return [*chat[:-1], *self.mt.transform_message(chat[-1])]
         else:
             return []