ommlds 0.0.0.dev487__py3-none-any.whl → 0.0.0.dev489__py3-none-any.whl

ommlds/cli/main.py

@@ -77,31 +77,47 @@ class ChatProfile(Profile):
 
     #
 
-    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
-        ap.arg('message', nargs='*', group='input'),
-        ap.arg('-i', '--interactive', action='store_true', group='input'),
-        ap.arg('-e', '--editor', action='store_true', group='input'),
+    INTERFACE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('-i', '--interactive', action='store_true', group='interface'),
+        ap.arg('-T', '--textual', action='store_true', group='interface'),
+        ap.arg('-e', '--editor', action='store_true', group='interface'),
     ]
 
-    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+    def configure_interface(self, cfg: ChatConfig) -> ChatConfig:
         if self._args.editor:
             check.arg(not self._args.interactive)
             check.arg(not self._args.message)
             raise NotImplementedError
 
-        elif self._args.interactive:
-            check.arg(not self._args.message)
-            return dc.replace(
+        if self._args.interactive:
+            cfg = dc.replace(
                 cfg,
+                interface=dc.replace(
+                    cfg.interface,
+                    interactive=True,
+                    use_textual=self._args.textual,
+                ),
                 user=dc.replace(
                     cfg.user,
                     interactive=True,
                 ),
             )
 
+        return cfg
+
+    #
+
+    INPUT_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
+        ap.arg('message', nargs='*', group='input'),
+    ]
+
+    def configure_input(self, cfg: ChatConfig) -> ChatConfig:
+        if self._args.interactive:
+            check.arg(not self._args.message)
+
         elif self._args.message:
             # TODO: '-' -> stdin
-            return dc.replace(
+            cfg = dc.replace(
                 cfg,
                 user=dc.replace(
                     cfg.user,
@@ -112,6 +128,8 @@ class ChatProfile(Profile):
         else:
             raise ValueError('Must specify input')
 
+        return cfg
+
     #
 
     STATE_ARGS: ta.ClassVar[ta.Sequence[ap.Arg]] = [
@@ -220,6 +238,7 @@ class ChatProfile(Profile):
 
         for grp_name, grp_args in [
             ('backend', self.BACKEND_ARGS),
+            ('interface', self.INTERFACE_ARGS),
             ('input', self.INPUT_ARGS),
             ('state', self.STATE_ARGS),
             ('output', self.OUTPUT_ARGS),
@@ -234,6 +253,7 @@ class ChatProfile(Profile):
 
         cfg = ChatConfig()
         cfg = self.configure_backend(cfg)
+        cfg = self.configure_interface(cfg)
         cfg = self.configure_input(cfg)
         cfg = self.configure_state(cfg)
         cfg = self.configure_output(cfg)

ommlds/cli/secrets.py

@@ -10,6 +10,7 @@ def install_secrets() -> None:
     # FIXME: lol garbage
     for key in [
         'ANTHROPIC_API_KEY',
+        'CEREBRAS_API_KEY',
         'GEMINI_API_KEY',
         'GROQ_API_KEY',
         'HUGGINGFACE_TOKEN',

ommlds/cli/sessions/chat/chat/user/configs.py

@@ -14,4 +14,3 @@ class UserConfig:
     initial_user_content: ta.Optional['mc.Content'] = None
 
     interactive: bool = False
-    use_readline: bool | ta.Literal['auto'] = 'auto'

ommlds/cli/sessions/chat/chat/user/inject.py

@@ -9,10 +9,7 @@ from .configs import UserConfig
 
 
 with lang.auto_proxy_import(globals()):
-    from .....inputs import asyncs as _inputs_asyncs
-    from .....inputs import sync as _inputs_sync
     from ..state import types as _state
-    from . import interactive as _interactive
     from . import oneshot as _oneshot
     from . import types as _types
 
@@ -43,13 +40,6 @@ def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
 
             raise NotImplementedError
 
-        els.append(inj.bind(_types.UserChatInput, to_ctor=_interactive.InteractiveUserChatInput, singleton=True))
-
-        els.extend([
-            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
-            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
-        ])
-
     else:
         if cfg.initial_user_content is None:
             raise ValueError('Initial user content is required for non-interactive chat')

ommlds/cli/sessions/chat/configs.py

@@ -5,6 +5,7 @@ from ...rendering.configs import RenderingConfig
 from .chat.ai.configs import AiConfig
 from .chat.state.configs import StateConfig
 from .chat.user.configs import UserConfig
+from .interface.configs import InterfaceConfig
 from .tools.configs import ToolsConfig
 
 
@@ -24,4 +25,5 @@ class ChatConfig:
     state: StateConfig = StateConfig()
     user: UserConfig = UserConfig()
     rendering: RenderingConfig = RenderingConfig()
+    interface: InterfaceConfig = InterfaceConfig()
     tools: ToolsConfig = ToolsConfig()

ommlds/cli/sessions/chat/inject.py

@@ -16,6 +16,7 @@ with lang.auto_proxy_import(globals()):
     from .chat.ai import inject as _chat_ai
     from .chat.state import inject as _chat_state
     from .chat.user import inject as _chat_user
+    from .interface import inject as _interface
     from .phases import inject as _phases
     from .tools import inject as _tools
 
@@ -37,6 +38,8 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
 
         _chat_state.bind_state(cfg.state),
 
+        _interface.bind_interface(cfg.interface),
+
         _phases.bind_phases(),
 
         _rendering.bind_rendering(cfg.rendering),

ommlds/cli/sessions/chat/interface/bare/inject.py

@@ -0,0 +1,32 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ..base import ChatInterface
+from ..configs import InterfaceConfig
+from .interface import BareChatInterface
+
+
+with lang.auto_proxy_import(globals()):
+    from .....inputs import asyncs as _inputs_asyncs
+    from .....inputs import sync as _inputs_sync
+    from ...chat.user import types as _user_types
+    from . import user as _user
+
+
+##
+
+
+def bind_bare(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=BareChatInterface, singleton=True),
+    ]
+
+    if cfg.interactive:
+        els.append(inj.bind(_user_types.UserChatInput, to_ctor=_user.InteractiveUserChatInput, singleton=True))
+
+        els.extend([
+            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
+            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
+        ])
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interface/bare/interface.py

@@ -0,0 +1,19 @@
+from ...driver import ChatDriver
+from ..base import ChatInterface
+
+
+##
+
+
+class BareChatInterface(ChatInterface):
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+
+    async def run(self) -> None:
+        await self._driver.run()

ommlds/cli/sessions/chat/{chat/user/interactive.py → interface/bare/user.py}

@@ -4,7 +4,7 @@ from ...... import minichain as mc
 from .....inputs.asyncs import AsyncStringInput
 from .....inputs.asyncs import SyncAsyncStringInput
 from .....inputs.sync import InputSyncStringInput
-from .types import UserChatInput
+from ...chat.user.types import UserChatInput
 
 
 ##

ommlds/cli/sessions/chat/interface/base.py

@@ -0,0 +1,13 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class ChatInterface(lang.Abstract):
+    @abc.abstractmethod
+    def run(self) -> ta.Awaitable[None]:
+        raise NotImplementedError

ommlds/cli/sessions/chat/interface/configs.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class InterfaceConfig:
+    interactive: bool = False
+
+    use_textual: bool = False
+
+    use_readline: bool | ta.Literal['auto'] = 'auto'

ommlds/cli/sessions/chat/interface/inject.py

@@ -0,0 +1,24 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .configs import InterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .bare import inject as _bare
+    from .textual import inject as _textual
+
+
+##
+
+
+def bind_interface(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if cfg.use_textual:
+        els.append(_textual.bind_textual())
+
+    else:
+        els.append(_bare.bind_bare(cfg))
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interface/textual/app.py

@@ -0,0 +1,191 @@
+import asyncio
+import dataclasses as dc
+import typing as ta
+
+from omdev.tui import textual as tx
+from omlish import check
+
+from ...... import minichain as mc
+from ...driver import ChatDriver
+from .user import QueueUserChatInput
+
+
+##
+
+
+class UserMessage(tx.Static):
+    pass
+
+
+class AiMessage(tx.Static):
+    pass
+
+
+##
+
+
+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 ChatApp(tx.App):
+    def __init__(
+            self,
+            *,
+            chat_driver: ChatDriver,
+            queue_user_chat_input: QueueUserChatInput,
+    ) -> None:
+        super().__init__()
+
+        self._chat_driver = chat_driver
+        self._queue_user_chat_input = queue_user_chat_input
+
+    CSS: ta.ClassVar[str] = """
+        #messages-scroll {
+            width: 100%;
+            height: 1fr;
+
+            padding: 0 2 0 2;
+        }
+
+        #messages-container {
+            height: auto;
+            width: 100%;
+
+            margin-top: 1;
+            margin-bottom: 0;
+
+            layout: stream;
+            text-align: left;
+        }
+
+        #input-outer {
+            width: 100%;
+            height: auto;
+        }
+
+        #input-vertical {
+            width: 100%;
+            height: auto;
+
+            margin: 0 2 1 2;
+
+            padding: 0;
+        }
+
+        #input-vertical2 {
+            width: 100%;
+            height: auto;
+
+            border: round $foreground-muted;
+
+            padding: 0 1;
+        }
+
+        #input-horizontal {
+            width: 100%;
+            height: auto;
+        }
+
+        #input-glyph {
+            width: auto;
+
+            padding: 0 1 0 0;
+
+            background: transparent;
+            color: $primary;
+
+            text-style: bold;
+        }
+
+        #input {
+            width: 1fr;
+            height: auto;
+            max-height: 16;
+
+            border: none;
+
+            padding: 0;
+
+            background: transparent;
+            color: $text;
+        }
+    """
+
+    ENABLE_COMMAND_PALETTE: ta.ClassVar[bool] = False
+
+    #
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.VerticalScroll(id='messages-scroll'):
+            yield tx.Static(id='messages-container')
+
+        with tx.Static(id='input-outer'):
+            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')
+
+    #
+
+    def _get_input_text_area(self) -> InputTextArea:
+        return self.query_one('#input', InputTextArea)
+
+    def _get_messages_container(self) -> tx.Static:
+        return self.query_one('#messages-container', tx.Static)
+
+    #
+
+    async def _mount_message(self, *messages: tx.Widget) -> None:
+        msg_ctr = self._get_messages_container()
+
+        for msg in messages:
+            await msg_ctr.mount(msg)
+
+        self.call_after_refresh(lambda: msg_ctr.scroll_end(animate=False))
+
+    #
+
+    _chat_driver_task: asyncio.Task | None = None
+
+    async def on_mount(self) -> None:
+        check.none(self._chat_driver_task)
+        self._chat_driver_task = asyncio.create_task(self._chat_driver.run())
+
+        self._get_input_text_area().focus()
+
+        await self._mount_message(UserMessage('Hello!'))
+
+    async def on_unmount(self) -> None:
+        await self._queue_user_chat_input.push_next_user_messages([])
+        await check.not_none(self._chat_driver_task)
+
+    async def on_input_text_area_submitted(self, event: InputTextArea.Submitted) -> None:
+        self._get_input_text_area().clear()
+
+        await self._mount_message(
+            UserMessage(event.text),
+            # AiMessage(f'You said: {event.text}!'),
+        )
+
+        await self._queue_user_chat_input.push_next_user_messages([mc.UserMessage(event.text)])

ommlds/cli/sessions/chat/interface/textual/inject.py

@@ -0,0 +1,27 @@
+from omlish import inject as inj
+
+from ...chat.user.types import UserChatInput
+from ..base import ChatInterface
+from .app import ChatApp
+from .interface import TextualChatInterface
+from .user import QueueUserChatInput
+
+
+##
+
+
+def bind_textual() -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=TextualChatInterface, singleton=True),
+    ]
+
+    els.extend([
+        inj.bind(ChatApp, singleton=True),
+    ])
+
+    els.extend([
+        inj.bind(QueueUserChatInput, singleton=True),
+        inj.bind(UserChatInput, to_key=QueueUserChatInput),
+    ])
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interface/textual/interface.py

@@ -0,0 +1,22 @@
+from ...driver import ChatDriver
+from ..base import ChatInterface
+from .app import ChatApp
+
+
+##
+
+
+class TextualChatInterface(ChatInterface):
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            app: ChatApp,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+        self._app = app
+
+    async def run(self) -> None:
+        await self._app.run_async()

ommlds/cli/sessions/chat/interface/textual/user.py

@@ -0,0 +1,20 @@
+import asyncio
+
+from ...... import minichain as mc
+from ...chat.user.types import UserChatInput
+
+
+##
+
+
+class QueueUserChatInput(UserChatInput):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._queue: asyncio.Queue[mc.UserChat] = asyncio.Queue()
+
+    async def push_next_user_messages(self, chat: 'mc.UserChat') -> None:
+        await self._queue.put(chat)
+
+    async def get_next_user_messages(self) -> 'mc.UserChat':
+        return await self._queue.get()

ommlds/cli/sessions/chat/session.py

@@ -1,14 +1,22 @@
+import typing as ta
+
 from omlish import dataclasses as dc
 
 from ..base import Session
 from .configs import ChatConfig
-from .driver import ChatDriver
+from .interface.base import ChatInterface
 
 
 ##
 
 
+@ta.final
 class ChatSession(Session['ChatSession.Config']):
+    """
+    An adapter to the lower level, dumber, non-chat-specific cli 'session' layer. Nothing else takes the kitchen-sink
+    'ChatConfig' object, it's only here for type dispatch in lower layers.
+    """
+
     @dc.dataclass(frozen=True)
     class Config(Session.Config, ChatConfig):
         pass
@@ -17,11 +25,11 @@ class ChatSession(Session['ChatSession.Config']):
             self,
             config: Config,
             *,
-            driver: ChatDriver,
+            interface: ChatInterface,
     ) -> None:
         super().__init__(config)
 
-        self._driver = driver
+        self._interface = interface
 
     async def run(self) -> None:
-        await self._driver.run()
+        await self._interface.run()

ommlds/minichain/backends/impls/cerebras/chat.py

@@ -0,0 +1,80 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish import typedvalues as tv
+from omlish.formats import json
+from omlish.http import all as http
+
+from .....backends.cerebras import protocol as pt
+from ....chat.choices.services import ChatChoicesRequest
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.services import static_check_is_chat_choices_service
+from ....chat.tools.types import Tool
+from ....models.configs import ModelName
+from ....standard import ApiKey
+from ....standard import DefaultOptions
+from .names import MODEL_NAMES
+from .protocol import build_cer_request_messages
+from .protocol import build_cer_request_tool
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='cerebras',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class CerebrasChatChoicesService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName | DefaultOptions,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._http_client = http_client
+
+        with tv.consume(*configs) as cc:
+            self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='CEREBRAS_API_KEY')
+            self._default_options: tv.TypedValues = DefaultOptions.pop(cc)
+
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_cer_request_tool(t))
+
+        cer_request = pt.ChatCompletionRequest(
+            messages=build_cer_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+        )
+
+        raw_request = msh.marshal(cer_request)
+
+        # TODO: headers:
+        #  - CF-RAY
+        #  - X-Amz-Cf-Id
+        #  - X-delay-time
+
+        http_response = await http.async_request(
+            'https://api.cerebras.ai/v1/chat/completions',
+            headers={
+                http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
+                http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
+        )
+
+        raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))