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

ommlds/cli/sessions/chat/interfaces/textual/tools.py

@@ -0,0 +1,38 @@
+from omlish.formats import json
+
+from ...... import minichain as mc
+from ...drivers.tools.confirmation import ToolExecutionConfirmation
+from ...drivers.tools.confirmation import ToolExecutionRequestDeniedError
+from .app import ChatAppGetter
+
+
+##
+
+
+class ChatAppToolExecutionConfirmation(ToolExecutionConfirmation):
+    def __init__(
+            self,
+            *,
+            app: ChatAppGetter,
+    ) -> None:
+        super().__init__()
+
+        self._app = app
+
+    async def confirm_tool_execution_or_raise(
+            self,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
+    ) -> None:
+        tr_dct = dict(
+            id=use.id,
+            name=entry.spec.name,
+            args=use.args,
+            # spec=msh.marshal(tce.spec),
+        )
+
+        if not await (await self._app()).confirm_tool_use(
+                'Execute requested tool?',
+                json.dumps_pretty(tr_dct),
+        ):
+            raise ToolExecutionRequestDeniedError

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

@@ -0,0 +1,36 @@
+import dataclasses as dc
+import typing as ta
+
+from omdev.tui import textual as tx
+
+
+##
+
+
+class InputTextArea(tx.TextArea):
+    @dc.dataclass()
+    class Submitted(tx.Message):
+        text: str
+
+    def __init__(self, **kwargs: ta.Any) -> None:
+        super().__init__(**kwargs)
+
+    async def _on_key(self, event: tx.Key) -> None:
+        if event.key == 'enter':
+            event.prevent_default()
+            event.stop()
+
+            if text := self.text.strip():
+                self.post_message(self.Submitted(text))
+
+        else:
+            await super()._on_key(event)
+
+
+class InputOuter(tx.Static):
+    def compose(self) -> tx.ComposeResult:
+        with tx.Vertical(id='input-vertical'):
+            with tx.Vertical(id='input-vertical2'):
+                with tx.Horizontal(id='input-horizontal'):
+                    yield tx.Static('>', id='input-glyph')
+                    yield InputTextArea(placeholder='...', id='input')

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

@@ -0,0 +1,197 @@
+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 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 @@
-from omlish 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,6 +1,7 @@
 from omlish import dataclasses as dc
 
 from .... import minichain as mc
+from ..configs import SessionConfig
 
 
 ##
@@ -12,10 +13,8 @@ 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,4 +1,3 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
@@ -23,7 +22,7 @@ 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),
     ])
 

ommlds/cli/sessions/completion/session.py

@@ -1,5 +1,4 @@
 from omlish import check
-from omlish import dataclasses as dc
 
 from .... import minichain as mc
 from ...backends.types import CompletionServiceBackendProvider
@@ -10,19 +9,16 @@ 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,
             *,
             service_provider: CompletionServiceBackendProvider,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
+        self._config = config
         self._service_provider = service_provider
 
     async def run(self) -> None:

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,6 +1,7 @@
 from omlish import dataclasses as dc
 
 from .... import minichain as mc
+from ..configs import SessionConfig
 
 
 ##
@@ -12,10 +13,8 @@ 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,4 +1,3 @@
-from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
@@ -23,7 +22,7 @@ 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),
     ])
 

ommlds/cli/sessions/embedding/session.py

@@ -1,4 +1,3 @@
-from omlish import dataclasses as dc
 from omlish.formats import json
 
 from .... import minichain as mc
@@ -10,19 +9,16 @@ 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,
             *,
             service_provider: EmbeddingServiceBackendProvider,
     ) -> None:
-        super().__init__(config)
+        super().__init__()
 
+        self._config = config
         self._service_provider = service_provider
 
     async def run(self) -> None:

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,4 +1,5 @@
 import abc
+import datetime
 import os.path
 import typing as ta
 
@@ -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)