ommlds 0.0.0.dev487__py3-none-any.whl → 0.0.0.dev488__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,8 +9,6 @@ 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
@@ -45,11 +43,6 @@ def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
 
         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,28 @@
+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
+
+
+##
+
+
+def bind_bare(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=BareChatInterface, singleton=True),
+    ]
+
+    if cfg.interactive:
+        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/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,14 @@
+from omdev.tui import textual as tx
+
+
+##
+
+
+class ChatApp(tx.App):
+    def __init__(
+            self,
+    ) -> None:
+        super().__init__()
+
+    def compose(self) -> tx.ComposeResult:
+        yield tx.Static('app goes here lol')

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

@@ -0,0 +1,20 @@
+from omlish import inject as inj
+
+from ..base import ChatInterface
+from .app import ChatApp
+from .interface import TextualChatInterface
+
+
+##
+
+
+def bind_textual() -> inj.Elements:
+    els: list[inj.Elemental] = [
+        inj.bind(ChatInterface, to_ctor=TextualChatInterface, singleton=True),
+    ]
+
+    els.extend([
+        inj.bind(ChatApp, singleton=True),
+    ])
+
+    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/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))

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

@@ -0,0 +1,30 @@
+"""
+https://inference-docs.cerebras.ai/models/overview
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'llama3.1-8b': None,
+        'llama-3.3-70b': None,
+        'gpt-oss-120b': None,
+        'qwen-3-32b': None,
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'cerebras',
+    model_names=MODEL_NAMES,
+)

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

@@ -0,0 +1,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.cerebras import protocol as pt
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.types import AiChoice
+from ....chat.messages import AiMessage
+from ....chat.messages import AnyAiMessage
+from ....chat.messages import Chat
+from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
+from ....chat.messages import UserMessage
+from ....chat.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_cer_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    cer_msgs: list[pt.ChatCompletionRequest.Message] = []
+
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
+
+        if isinstance(mc_msgs[0], AnyAiMessage):
+            tups: list[tuple[AiMessage | None, list[ToolUseMessage]]] = []
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, AiMessage):
+                    tups.append((mc_msg, []))
+
+                elif isinstance(mc_msg, ToolUseMessage):
+                    if not tups:
+                        tups.append((None, []))
+                    tups[-1][1].append(mc_msg)
+
+                else:
+                    raise TypeError(mc_msg)
+
+            for mc_ai_msg, mc_tu_msgs in tups:
+                cer_msgs.append(pt.ChatCompletionRequest.AssistantMessage(
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.ChatCompletionRequest.AssistantMessage.ToolCall(
+                            function=pt.ChatCompletionRequest.AssistantMessage.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=check.not_none(mc_tu_msg.tu.raw_args),
+                            ),
+                            id=check.not_none(mc_tu_msg.tu.id),
+                        )
+                        for mc_tu_msg in mc_tu_msgs
+                    ] if mc_tu_msgs else None,
+                ))
+
+        else:
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, SystemMessage):
+                    cer_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    cer_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    cer_msgs.append(pt.ChatCompletionRequest.ToolMessage(
+                        tool_call_id=check.not_none(mc_msg.tur.id),
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return cer_msgs
+
+
+def build_cer_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
+    return pt.ChatCompletionRequest.Tool(
+        function=pt.ChatCompletionRequest.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc),
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(cer_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(cer_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        cer_msg = cer_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if cer_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(cer_msg.content, str),
+            ))
+
+        for cer_tc in cer_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=cer_tc.id,
+                name=cer_tc.function.name,
+                args=json.loads(cer_tc.function.arguments or '{}'),
+                raw_args=cer_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, cer_resp.choices)))
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if delta.content is not None:
+            lst.append(ContentAiDelta(delta.content))
+
+        for tc in delta.tool_calls or []:
+            tc_fn = check.not_none(tc.function)
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc_fn.name),
+                args=json.loads(tc_fn.arguments or '{}'),
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)