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

ommlds/cli/sessions/chat/interfaces/textual/widgets/messages.py

@@ -0,0 +1,207 @@
+import abc
+import asyncio
+import typing as ta
+
+from omdev.tui import textual as tx
+from omlish import lang
+
+
+##
+
+
+class MessagesContainer(tx.VerticalScroll):
+    pass
+
+
+##
+
+
+class MessageDivider(tx.Static):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.add_class('message-divider')
+
+
+##
+
+
+class Message(tx.Static, lang.Abstract):
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        self.add_class('message')
+
+
+#
+
+
+class WelcomeMessage(Message):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self.add_class('welcome-message')
+
+        self._content = content
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Vertical(classes='welcome-message-outer message-outer'):
+            yield tx.Static(self._content, classes='welcome-message-content')
+
+
+#
+
+
+class UserMessage(Message):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self.add_class('user-message')
+
+        self._content = content
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='user-message-outer message-outer'):
+            yield tx.Static('> ', classes='user-message-glyph message-glyph')
+            with tx.Vertical(classes='user-message-inner message-inner'):
+                yield tx.Static(self._content)
+
+
+#
+
+
+class AiMessage(Message, lang.Abstract):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.add_class('ai-message')
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='ai-message-outer message-outer'):
+            yield tx.Static('< ', classes='ai-message-glyph message-glyph')
+            with tx.Vertical(classes='ai-message-inner message-inner'):
+                yield from self._compose_content()
+
+    @abc.abstractmethod
+    def _compose_content(self) -> ta.Generator:
+        raise NotImplementedError
+
+
+class StaticAiMessage(AiMessage):
+    def __init__(
+            self,
+            content: str,
+            *,
+            markdown: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._content = content
+        self._markdown = markdown
+
+    def _compose_content(self) -> ta.Generator:
+        if self._markdown:
+            yield tx.Markdown(self._content)
+        else:
+            yield tx.Static(self._content)
+
+
+class StreamAiMessage(AiMessage):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self._content = content
+
+    def _compose_content(self) -> ta.Generator:
+        yield tx.Markdown('')
+
+    _stream_: tx.MarkdownStream | None = None
+
+    def _stream(self) -> tx.MarkdownStream:
+        if self._stream_ is None:
+            self._stream_ = tx.Markdown.get_stream(self.query_one(tx.Markdown))
+        return self._stream_
+
+    async def write_initial_content(self) -> None:
+        if self._content:
+            await self._stream().write(self._content)
+
+    async def append_content(self, content: str) -> None:
+        if not content:
+            return
+
+        self._content += content
+        await self._stream().write(content)
+
+    async def stop_stream(self) -> None:
+        if (stream := self._stream_) is None:
+            return
+
+        await stream.stop()
+        self._stream_ = None
+
+
+#
+
+
+class ToolConfirmationControls(tx.Static):
+    class Allowed(tx.Message):
+        pass
+
+    def compose(self) -> tx.ComposeResult:
+        yield tx.Button('Allow', action='allow')
+
+    def action_allow(self) -> None:
+        self.post_message(self.Allowed())
+
+
+class ToolConfirmationMessage(Message):
+    def __init__(
+            self,
+            outer_content: str,
+            inner_content: str,
+            fut: asyncio.Future[bool],
+    ) -> None:
+        super().__init__()
+
+        self.add_class('tool-confirmation-message')
+
+        self._outer_content = outer_content
+        self._inner_content = inner_content
+        self._fut = fut
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='tool-confirmation-message-outer message-outer'):
+            yield tx.Static('? ', classes='tool-confirmation-message-glyph message-glyph')
+            with tx.Vertical(classes='tool-confirmation-message-inner tool-confirmation-message-inner-open message-inner'):  # noqa
+                yield tx.Static(self._outer_content, classes='tool-confirmation-message-outer-content')
+                yield tx.Static(self._inner_content, classes='tool-confirmation-message-inner-content')
+                yield ToolConfirmationControls(classes='tool-confirmation-message-controls')
+
+    @tx.on(ToolConfirmationControls.Allowed)
+    async def on_allowed(self, event: ToolConfirmationControls.Allowed) -> None:
+        inner = self.query_one(tx.Vertical)
+        await inner.query_one(ToolConfirmationControls).remove()
+        inner.remove_class('tool-confirmation-message-inner-open')
+        inner.add_class('tool-confirmation-message-inner-closed')
+        inner.query_one('.tool-confirmation-message-outer-content', tx.Static).update('Tool use confirmed.')
+
+        self._fut.set_result(True)
+
+
+#
+
+
+class UiMessage(Message):
+    def __init__(self, content: str) -> None:
+        super().__init__()
+
+        self.add_class('ui-message')
+
+        self._content = content
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='ui-message-outer message-outer'):
+            yield tx.Static('~ ', classes='ui-message-glyph message-glyph')
+            with tx.Vertical(classes='ui-message-inner message-inner'):
+                yield tx.Static(self._content)

ommlds/cli/sessions/chat/session.py

@@ -1,27 +1,22 @@
-import dataclasses as dc
+import typing as ta
 
 from ..base import Session
-from .configs import ChatConfig
-from .driver import ChatDriver
+from .interfaces.base import ChatInterface
 
 
 ##
 
 
-class ChatSession(Session['ChatSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config, ChatConfig):
-        pass
-
+@ta.final
+class ChatSession(Session):
     def __init__(
             self,
-            config: Config,
             *,
-            driver: ChatDriver,
+            interface: ChatInterface,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
-        self._driver = driver
+        self._interface = interface
 
     async def run(self) -> None:
-        await self._driver.run()
+        await self._interface.run()

ommlds/cli/sessions/completion/configs.py

@@ -1,21 +1,20 @@
-import dataclasses as dc
+from omlish import dataclasses as dc
 
 from .... import minichain as mc
+from ..configs import SessionConfig
 
 
 ##
 
 
-DEFAULT_COMPLETION_MODEL_BACKEND = 'openai'
+DEFAULT_BACKEND = 'openai'
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class CompletionConfig:
+@dc.dataclass(frozen=True, kw_only=True)
+class CompletionConfig(SessionConfig):
     content: 'mc.Content'
 
-    _: dc.KW_ONLY
-
     backend: str | None = None

ommlds/cli/sessions/completion/inject.py

@@ -1,12 +1,15 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
+from ...backends.configs import BackendConfig
+from ...backends.types import DefaultBackendName
 from ..base import Session
+from .configs import DEFAULT_BACKEND
 from .configs import CompletionConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
     from . import session as _session
 
 
@@ -19,10 +22,20 @@ def bind_completion(cfg: CompletionConfig) -> inj.Elements:
     #
 
     els.extend([
-        inj.bind(_session.CompletionSession.Config(**dc.asdict(cfg))),
+        inj.bind(cfg),
         inj.bind(Session, to_ctor=_session.CompletionSession, singleton=True),
     ])
 
     #
 
+    els.extend([
+        _backends.bind_backends(BackendConfig(
+            backend=cfg.backend,
+        )),
+
+        inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND),
+    ])
+
+    #
+
     return inj.as_elements(*els)

ommlds/cli/sessions/completion/session.py

@@ -1,39 +1,31 @@
-import dataclasses as dc
-
 from omlish import check
-from omlish import lang
 
 from .... import minichain as mc
+from ...backends.types import CompletionServiceBackendProvider
 from ..base import Session
-from .configs import DEFAULT_COMPLETION_MODEL_BACKEND
 from .configs import CompletionConfig
 
 
 ##
 
 
-class CompletionSession(Session['CompletionSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config, CompletionConfig):
-        pass
-
+class CompletionSession(Session):
     def __init__(
             self,
-            config: Config,
+            config: CompletionConfig,
             *,
-            backend_catalog: mc.BackendCatalog,
+            service_provider: CompletionServiceBackendProvider,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
-        self._backend_catalog = backend_catalog
+        self._config = config
+        self._service_provider = service_provider
 
     async def run(self) -> None:
         prompt = check.isinstance(self._config.content, str)
 
         mdl: mc.CompletionService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-                mc.CompletionService,
-                self._config.backend or DEFAULT_COMPLETION_MODEL_BACKEND,
-        )) as mdl:
+        async with self._service_provider.provide_backend() as mdl:
             response = await mdl.invoke(mc.CompletionRequest(prompt))
-            print(response.v.strip())
+
+        print(response.v.strip())

ommlds/cli/sessions/configs.py

@@ -0,0 +1,10 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class SessionConfig(lang.Abstract):
+    pass

ommlds/cli/sessions/embedding/configs.py

@@ -1,21 +1,20 @@
-import dataclasses as dc
+from omlish import dataclasses as dc
 
 from .... import minichain as mc
+from ..configs import SessionConfig
 
 
 ##
 
 
-DEFAULT_EMBEDDING_MODEL_BACKEND = 'openai'
+DEFAULT_BACKEND = 'openai'
 
 
 ##
 
 
-@dc.dataclass(frozen=True)
-class EmbeddingConfig:
+@dc.dataclass(frozen=True, kw_only=True)
+class EmbeddingConfig(SessionConfig):
     content: 'mc.Content'
 
-    _: dc.KW_ONLY
-
     backend: str | None = None

ommlds/cli/sessions/embedding/inject.py

@@ -1,12 +1,15 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
+from ...backends.configs import BackendConfig
+from ...backends.types import DefaultBackendName
 from ..base import Session
+from .configs import DEFAULT_BACKEND
 from .configs import EmbeddingConfig
 
 
 with lang.auto_proxy_import(globals()):
+    from ...backends import inject as _backends
     from . import session as _session
 
 
@@ -19,10 +22,20 @@ def bind_embedding(cfg: EmbeddingConfig) -> inj.Elements:
     #
 
     els.extend([
-        inj.bind(_session.EmbeddingSession.Config(**dc.asdict(cfg))),
+        inj.bind(cfg),
         inj.bind(Session, to_ctor=_session.EmbeddingSession, singleton=True),
     ])
 
     #
 
+    els.extend([
+        _backends.bind_backends(BackendConfig(
+            backend=cfg.backend,
+        )),
+
+        inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND),
+    ])
+
+    #
+
     return inj.as_elements(*els)

ommlds/cli/sessions/embedding/session.py

@@ -1,37 +1,29 @@
-import dataclasses as dc
-
-from omlish import lang
 from omlish.formats import json
 
 from .... import minichain as mc
+from ...backends.types import EmbeddingServiceBackendProvider
 from ..base import Session
-from .configs import DEFAULT_EMBEDDING_MODEL_BACKEND
 from .configs import EmbeddingConfig
 
 
 ##
 
 
-class EmbeddingSession(Session['EmbeddingSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config, EmbeddingConfig):
-        pass
-
+class EmbeddingSession(Session):
     def __init__(
             self,
-            config: Config,
+            config: EmbeddingConfig,
             *,
-            backend_catalog: mc.BackendCatalog,
+            service_provider: EmbeddingServiceBackendProvider,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
-        self._backend_catalog = backend_catalog
+        self._config = config
+        self._service_provider = service_provider
 
     async def run(self) -> None:
         mdl: mc.EmbeddingService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.EmbeddingService,
-            self._config.backend or DEFAULT_EMBEDDING_MODEL_BACKEND,
-        )) as mdl:
+        async with self._service_provider.provide_backend() as mdl:
             response = await mdl.invoke(mc.EmbeddingRequest(self._config.content))
-            print(json.dumps_compact(list(map(float, response.v))))
+
+        print(json.dumps_compact(list(map(float, response.v))))

ommlds/cli/sessions/inject.py

@@ -1,34 +1,34 @@
-import typing as ta
-
 from omlish import inject as inj
 from omlish import lang
 
+from .chat.configs import ChatConfig
+from .completion.configs import CompletionConfig
+from .configs import SessionConfig
+from .embedding.configs import EmbeddingConfig
+
 
 with lang.auto_proxy_import(globals()):
-    from .chat import configs as _chat_cfgs
-    from .chat import inject as _chat_inj
-    from .completion import configs as _completion_cfgs
-    from .completion import inject as _completion_inj
-    from .embedding import configs as _embedding_cfgs
-    from .embedding import inject as _embedding_inj
+    from .chat import inject as _chat
+    from .completion import inject as _completion
+    from .embedding import inject as _embedding
 
 
 ##
 
 
-def bind_sessions(cfg: ta.Any) -> inj.Elements:
+def bind_sessions(cfg: SessionConfig) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
-    if isinstance(cfg, _chat_cfgs.ChatConfig):
-        els.append(_chat_inj.bind_chat(cfg))
+    if isinstance(cfg, ChatConfig):
+        els.append(_chat.bind_chat(cfg))
 
-    elif isinstance(cfg, _completion_cfgs.CompletionConfig):
-        els.append(_completion_inj.bind_completion(cfg))
+    elif isinstance(cfg, CompletionConfig):
+        els.append(_completion.bind_completion(cfg))
 
-    elif isinstance(cfg, _embedding_cfgs.EmbeddingConfig):
-        els.append(_embedding_inj.bind_embedding(cfg))
+    elif isinstance(cfg, EmbeddingConfig):
+        els.append(_embedding.bind_embedding(cfg))
 
     else:
         raise TypeError(cfg)

ommlds/cli/state/storage.py

@@ -1,8 +1,9 @@
 import abc
-import dataclasses as dc
+import datetime
 import os.path
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish import marshal as msh
 from omlish.formats import json
@@ -52,8 +53,12 @@ STATE_VERSION = 0
 @dc.dataclass(frozen=True)
 class MarshaledState:
     version: int
+
     payload: ta.Any
 
+    created_at: datetime.datetime | None = dc.field(default_factory=lang.utcnow)
+    updated_at: datetime.datetime | None = dc.field(default_factory=lang.utcnow)
+
 
 class MarshalStateStorage(StateStorage, lang.Abstract):
     def __init__(
@@ -75,6 +80,7 @@ class MarshalStateStorage(StateStorage, lang.Abstract):
         ms = MarshaledState(
             version=self._version,
             payload=msh.marshal(obj, ty),
+            updated_at=lang.utcnow(),
         )
         return msh.marshal(ms)
 
@@ -102,7 +108,7 @@ class JsonFileStateStorage(MarshalStateStorage):
         return json.loads(data)
 
     def _save_file_data(self, data: ta.Any) -> None:
-        data = json.dumps_pretty(data)
+        data = json.dumps_compact(data)
         with open(self._file, 'w') as f:
             f.write(data)