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

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 []

ommlds/minichain/chat/transforms/metadata.py

@@ -3,13 +3,20 @@ import typing as ta
 import uuid
 
 from omlish import dataclasses as dc
+from omlish import lang
+from omlish import typedvalues as tv
 
 from ...metadata import CreatedAt
 from ...metadata import Uuid
+from ..messages import Chat
 from ..messages import Message
+from ..metadata import MessageMetadata
 from .base import MessageTransform
 
 
+MessageT = ta.TypeVar('MessageT', bound=Message)
+
+
 ##
 
 
@@ -17,17 +24,36 @@ from .base import MessageTransform
 class UuidAddingMessageTransform(MessageTransform):
     uuid_factory: ta.Callable[[], uuid.UUID] = dc.field(default_factory=lambda: uuid.uuid4)
 
-    def transform_message(self, m: Message) -> Message:
+    def transform_message(self, m: Message) -> Chat:
         if Uuid not in m.metadata:
             m = m.with_metadata(Uuid(self.uuid_factory()))
-        return m
+        return [m]
 
 
 @dc.dataclass(frozen=True)
 class CreatedAtAddingMessageTransform(MessageTransform):
     clock: ta.Callable[[], datetime.datetime] = dc.field(default=datetime.datetime.now)
 
-    def transform_message(self, m: Message) -> Message:
+    def transform_message(self, m: Message) -> Chat:
         if CreatedAt not in m.metadata:
             m = m.with_metadata(CreatedAt(self.clock()))
-        return m
+        return [m]
+
+
+##
+
+
+# FIXME: Unique?
+class TransformedMessageOrigin(tv.ScalarTypedValue[Message], MessageMetadata, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class OriginAddingMessageTransform(MessageTransform):
+    child: MessageTransform
+
+    def transform_message(self, m: Message) -> Chat:
+        return [
+            o.with_metadata(TransformedMessageOrigin(m)) if TransformedMessageOrigin not in o.metadata else m
+            for o in self.child.transform_message(m)
+        ]

ommlds/minichain/chat/transforms/services.py

@@ -1,13 +1,11 @@
-from omlish import check
 from omlish import dataclasses as dc
 
-from ..messages import AiMessage
+from ..messages import check_ai_chat
 from ..services import ChatRequest
 from ..services import ChatResponse
 from ..services import ChatService
 from ..services import static_check_is_chat_service
 from .base import ChatTransform
-from .base import MessageTransform
 
 
 ##
@@ -19,10 +17,10 @@ class RequestChatTransformingChatService:
     ct: ChatTransform
     svc: ChatService
 
-    def invoke(self, request: ChatRequest) -> ChatResponse:
+    async def invoke(self, request: ChatRequest) -> ChatResponse:
         new_chat = self.ct.transform_chat(request.v)
         new_req = dc.replace(request, v=new_chat)
-        return self.svc.invoke(new_req)
+        return await self.svc.invoke(new_req)
 
 
 #
@@ -30,11 +28,11 @@ class RequestChatTransformingChatService:
 
 @static_check_is_chat_service
 @dc.dataclass(frozen=True)
-class ResponseMessageTransformingChatService:
-    mt: MessageTransform[AiMessage]
+class ResponseChatTransformingChatService:
+    ct: ChatTransform
     svc: ChatService
 
-    def invoke(self, request: ChatRequest) -> ChatResponse:
-        orig_resp = self.svc.invoke(request)
-        new_msg = self.mt.transform_message(orig_resp.v)
-        return dc.replace(orig_resp, v=check.isinstance(new_msg, AiMessage))
+    async def invoke(self, request: ChatRequest) -> ChatResponse:
+        orig_resp = await self.svc.invoke(request)
+        new_chat = check_ai_chat(self.ct.transform_chat(orig_resp.v))
+        return dc.replace(orig_resp, v=new_chat)

ommlds/minichain/content/_marshal.py

@@ -6,9 +6,9 @@ from omlish import check
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .images import ImageContent  # noqa
+from .json import JsonContent  # noqa
 from .materialize import CanContent
 from .materialize import _InnerCanContent
 from .sequence import BlockContent  # noqa
@@ -52,10 +52,11 @@ class _ContentMarshaler(msh.Marshaler):
             raise TypeError(o)
 
 
-class _ContentMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _ContentMarshaler(ctx.make(ExtendedContent))
+class _ContentMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
+            return None
+        return lambda: _ContentMarshaler(ctx.make_marshaler(ExtendedContent))
 
 
 @dc.dataclass(frozen=True)
@@ -73,10 +74,11 @@ class _ContentUnmarshaler(msh.Unmarshaler):
             raise TypeError(v)
 
 
-class _ContentUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _ContentUnmarshaler(ctx.make(ExtendedContent))
+class _ContentUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
+            return None
+        return lambda: _ContentUnmarshaler(ctx.make_unmarshaler(ExtendedContent))
 
 
 ##
@@ -103,10 +105,11 @@ class _CanContentMarshaler(msh.Marshaler):
         return self.c.marshal(ctx, check.isinstance(o, CONTENT_RUNTIME_TYPES))
 
 
-class _CanContentMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _CanContentMarshaler(ctx.make(Content))
+class _CanContentMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+            return None
+        return lambda: _CanContentMarshaler(ctx.make_marshaler(Content))
 
 
 @dc.dataclass(frozen=True)
@@ -117,10 +120,11 @@ class _CanContentUnmarshaler(msh.Unmarshaler):
         return self.c.unmarshal(ctx, v)
 
 
-class _CanContentUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _CanContentUnmarshaler(ctx.make(Content))
+class _CanContentUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalFactoryContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:  # noqa
+        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+            return None
+        return lambda: _CanContentUnmarshaler(ctx.make_unmarshaler(Content))
 
 
 ##
@@ -139,28 +143,48 @@ class _ImageContentUnmarshaler(msh.Unmarshaler):
 ##
 
 
+class _JsonContentMarshaler(msh.Marshaler):
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return ta.cast(msh.Value, check.isinstance(o, JsonContent).v)
+
+
+class _JsonContentUnmarshaler(msh.Unmarshaler):
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return JsonContent(v)
+
+
+##
+
+
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     extended_content_poly = msh.Polymorphism(
         ExtendedContent,
         [
             msh.Impl(InlineContent, 'inline'),
             msh.Impl(BlockContent, 'block'),
             msh.Impl(ImageContent, 'image'),
+            msh.Impl(JsonContent, 'json'),
             msh.Impl(TextContent, 'text'),
         ],
     )
 
     msh.install_standard_factories(
         msh.PolymorphismMarshalerFactory(extended_content_poly),
-        msh.TypeMapMarshalerFactory({ImageContent: _ImageContentMarshaler()}),
+        msh.TypeMapMarshalerFactory({
+            ImageContent: _ImageContentMarshaler(),
+            JsonContent: _JsonContentMarshaler(),
+        }),
         _ContentMarshalerFactory(),
         _CanContentMarshalerFactory(),
     )
 
     msh.install_standard_factories(
         msh.PolymorphismUnmarshalerFactory(extended_content_poly),
-        msh.TypeMapUnmarshalerFactory({ImageContent: _ImageContentUnmarshaler()}),
+        msh.TypeMapUnmarshalerFactory({
+            ImageContent: _ImageContentUnmarshaler(),
+            JsonContent: _JsonContentUnmarshaler(),
+        }),
         _ContentUnmarshalerFactory(),
         _CanContentUnmarshalerFactory(),
     )

ommlds/minichain/content/json.py

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..json import JsonValue
+from .simple import SimpleSingleExtendedContent
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class JsonContent(SimpleSingleExtendedContent, lang.Final):
+    v: JsonValue

ommlds/minichain/content/materialize.py

@@ -112,7 +112,7 @@ class ContentMaterializer:
         finally:
             self._cur_depth -= 1
 
-    @dispatch.method
+    @dispatch.method()
     def _materialize(self, o: CanContent) -> Content:
         raise TypeError(o)
 
@@ -130,7 +130,13 @@ class ContentMaterializer:
 
     @_materialize.register
     def _materialize_iterable(self, o: ta.Iterable) -> Content:
-        return [self.materialize(e) for e in o]
+        # `collections.abc.Iterable` appears as a virtual base in the dispatch c3.mro for ContentNamespace before `type`
+        # does (due to NamespaceMeta having `__iter__`), so handle that here too.
+        if isinstance(o, type) and issubclass(o, ContentNamespace):
+            return self._materialize_namespace_type(o)
+
+        else:
+            return [self.materialize(e) for e in o]
 
     @_materialize.register
     def _materialize_none(self, o: None) -> Content:
@@ -151,25 +157,12 @@ class ContentMaterializer:
     def _materialize_namespace_type(self, o: type[ContentNamespace]) -> Content:
         check.issubclass(o, ContentNamespace)
 
-        def rec(v: ta.Any) -> ta.Generator[Content]:
-            if isinstance(v, (bytes, bytearray, ta.Mapping)):
-                return
-
-            elif isinstance(v, type):
-                if issubclass(v, ContentNamespace):
-                    for n, e in v:
-                        if n.startswith('_'):
-                            continue
-                        yield from rec(e)
-
-            elif isinstance(v, ta.Iterable):
-                for e in v:
-                    yield from rec(e)
-
-            else:
-                yield self.materialize(v)
-
-        return list(rec(o))
+        out: list[Content] = []
+        for n, e in o:
+            if n.startswith('_'):
+                continue
+            out.append(self.materialize(e))
+        return out
 
     #
 

ommlds/minichain/content/prepare.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - re-softwrap
+"""
 import abc
 import dataclasses as dc
 import typing as ta

ommlds/minichain/content/transforms/interleave.py

@@ -33,7 +33,7 @@ class ContentInterleaver:
             cs = lang.interleave(cs, separator)
         return list(cs)
 
-    @dispatch.method
+    @dispatch.method()
     def interleave(self, c: Content) -> Content:
         return c
 

ommlds/minichain/content/transforms/squeeze.py

@@ -22,7 +22,7 @@ class ContentSqueezer:
 
         self._strip_strings = strip_strings
 
-    @dispatch.method
+    @dispatch.method()
     def squeeze(self, c: Content) -> ta.Iterable[SingleContent]:
         raise TypeError(c)
 

ommlds/minichain/content/transforms/stringify.py

@@ -24,7 +24,7 @@ class ContentStringWriter:
 
         self._out = out
 
-    @dispatch.method
+    @dispatch.method()
     def write(self, c: Content) -> None:
         raise TypeError(c)
 

ommlds/minichain/json.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP007
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -11,3 +12,22 @@ from omlish import lang
 class JsonSchema(lang.Final):
     name: str
     root: ta.Any
+
+
+##
+
+
+JsonValue: ta.TypeAlias = ta.Union[
+    ta.Mapping[str, 'JsonValue'],
+
+    ta.Sequence['JsonValue'],
+
+    str,
+
+    int,
+    float,
+
+    bool,
+
+    None,
+]

ommlds/minichain/lib/code/prompts.py

@@ -0,0 +1,6 @@
+CODE_AGENT_SYSTEM_PROMPT = """
+You are an interactive assistant specializing in programming tasks.
+
+Your goal is to assist the user by accomplishing the tasks and answering the questions given to you by the user using
+your available tools.
+"""