ommlds 0.0.0.dev490__py3-none-any.whl → 0.0.0.dev492__py3-none-any.whl

ommlds/cli/sessions/chat/interfaces/textual/styles/messages.tcss

@@ -1,33 +1,155 @@
-#messages-scroll {
+/* Container */
+
+#messages-container {
     width: 100%;
     height: 1fr;
 
-    padding: 0 2 0 2;
+    scrollbar-gutter: stable;
+
+    background: $background-darken-3;
+
+    text-align: left;
+
+    scrollbar-size: 1 1;
 }
 
-#messages-container {
+
+/* Base */
+
+.message {
+    width: 1fr;
     height: auto;
-    width: 100%;
 
-    margin-top: 1;
-    margin-bottom: 0;
+    margin: 1 0 0 0;
+
+    padding-right: 1;
 
     layout: stream;
-    text-align: left;
 }
 
+
+/* Welcome */
+
 .welcome-message {
-    margin: 1;
+    padding: 1 2 1 1;
 
     border: round;
+}
 
-    padding: 1;
+.welcome-message-outer {
+    width: 1fr;
+    height: auto;
+}
 
+.welcome-message-content {
     text-align: center;
 }
 
+
+/* User */
+
 .user-message {
 }
 
+.user-message-outer {
+    width: 1fr;
+    height: auto;
+}
+
+.user-message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.user-message-inner {
+    width: 1fr;
+    height: auto;
+}
+
+
+/* Ai */
+
 .ai-message {
 }
+
+.ai-message-outer {
+    width: 1fr;
+    height: auto;
+
+    align: left top;
+}
+
+.ai-message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.ai-message-inner {
+    width: 1fr;
+    height: auto;
+
+    padding: 0;
+
+    Markdown {
+        width: 100%;
+        height: auto;
+
+        margin: 0;
+        padding: 0;
+    }
+}
+
+
+/* Tool Confirmation */
+
+.tool-confirmation-message {
+}
+
+.tool-confirmation-message-outer {
+    width: 1fr;
+    height: auto;
+
+    align: left top;
+}
+
+.tool-confirmation-message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.tool-confirmation-message-inner {
+    width: 1fr;
+    height: auto;
+
+    padding: 1;
+}
+
+.tool-confirmation-message-inner-open {
+    background: $warning-lighten-3 15%;
+}
+
+.tool-confirmation-message-inner-closed {
+}
+
+.tool-confirmation-message-content {
+    background: $background;
+}
+
+.tool-confirmation-message-controls {
+    margin-top: 1;
+}

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

@@ -0,0 +1,37 @@
+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),
+        )
+
+        msg = f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}'  # noqa
+
+        if not await self._app().confirm_tool_use(msg):
+            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,164 @@
+import abc
+import asyncio
+import typing as ta
+
+from omdev.tui import textual as tx
+from omlish import lang
+
+
+##
+
+
+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'):
+            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'):
+            yield tx.Static('> ', classes='user-message-glyph')
+            with tx.Vertical(classes='user-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'):
+            yield tx.Static('< ', classes='ai-message-glyph')
+            with tx.Vertical(classes='ai-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, content: str, fut: asyncio.Future[bool]) -> None:
+        super().__init__()
+
+        self.add_class('tool-confirmation-message')
+
+        self._content = content
+        self._fut = fut
+
+    def compose(self) -> tx.ComposeResult:
+        with tx.Horizontal(classes='tool-confirmation-message-outer'):
+            yield tx.Static('? ', classes='tool-confirmation-message-glyph')
+            with tx.Vertical(classes='tool-confirmation-message-inner tool-confirmation-message-inner-open'):
+                yield tx.Static(self._content, classes='tool-confirmation-message-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')
+
+        self._fut.set_result(True)

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

@@ -1,3 +1,29 @@
+"""
+devstral-small-2:24b      24277f07f62d    15 GB     15 hours ago
+
+dolphin3:latest           d5ab9ae8e1f2    4.9 GB    11 months ago (no tools)
+
+gemma3:27b                a418f5838eaf    17 GB     7 weeks ago (no tools)
+gemma3:4b                 a2af6cc3eb7f    3.3 GB    7 weeks ago (no tools)
+
+llama3.2:1b               baf6a787fdff    1.3 GB    13 months ago (too stupid for tools)
+llama3.2:latest           a80c4f17acd5    2.0 GB    13 months ago
+
+ministral-3:14b           4760c35aeb9d    9.1 GB    11 hours ago
+mistral:latest            6577803aa9a0    4.4 GB    3 seconds ago
+
+nemotron-3-nano:30b       b725f1117407    24 GB     15 hours ago
+
+olmo-3.1:32b-instruct     a16b6a5be6cf    19 GB     11 hours ago (no tools)
+olmo-3.1:32b-think        223d4ec84d91    19 GB     11 hours ago (no tools)
+
+phi4-mini:latest          78fad5d182a7    2.5 GB    8 months ago (no tools)
+
+qwen3-coder:30b           06c1097efce0    18 GB     11 hours ago
+qwen3-next:80b            b2ebb986e4e9    50 GB     11 hours ago
+qwen3:30b                 ad815644918f    18 GB     11 hours ago
+qwen3:32b                 030ee887880f    20 GB     11 hours ago
+"""
 import typing as ta
 
 from omlish import check
@@ -16,20 +42,17 @@ from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.stream.services import ChatChoicesStreamRequest
 from ....chat.choices.stream.services import ChatChoicesStreamResponse
 from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.choices.stream.types import AiChoiceDeltas
 from ....chat.choices.stream.types import AiChoicesDeltas
-from ....chat.choices.types import AiChoice
-from ....chat.messages import AiMessage
-from ....chat.messages import AnyAiMessage
-from ....chat.messages import Message
-from ....chat.messages import SystemMessage
-from ....chat.messages import UserMessage
-from ....chat.stream.types import ContentAiDelta
+from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiUrl
 from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
+from .protocol import build_mc_ai_choice_deltas
+from .protocol import build_mc_choices_response
+from .protocol import build_ol_request_messages
+from .protocol import build_ol_request_tool
 
 
 ##
@@ -64,31 +87,6 @@ class BaseOllamaChatChoicesService(lang.Abstract):
             self._api_url = cc.pop(self.DEFAULT_API_URL)
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
 
-    #
-
-    ROLE_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.Role]] = {  # noqa
-        SystemMessage: 'system',
-        UserMessage: 'user',
-        AiMessage: 'assistant',
-    }
-
-    @classmethod
-    def _get_message_content(cls, m: Message) -> str | None:
-        if isinstance(m, (AiMessage, UserMessage, SystemMessage)):
-            return check.isinstance(m.c, str)
-        else:
-            raise TypeError(m)
-
-    @classmethod
-    def _build_request_messages(cls, mc_msgs: ta.Iterable[Message]) -> ta.Sequence[pt.Message]:
-        messages: list[pt.Message] = []
-        for m in mc_msgs:
-            messages.append(pt.Message(
-                role=cls.ROLE_MAP[type(m)],
-                content=cls._get_message_content(m),
-            ))
-        return messages
-
 
 ##
 
@@ -103,12 +101,18 @@ class OllamaChatChoicesService(BaseOllamaChatChoicesService):
             self,
             request: ChatChoicesRequest,
     ) -> ChatChoicesResponse:
-        messages = self._build_request_messages(request.v)
+        messages = build_ol_request_messages(request.v)
+
+        tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_ol_request_tool(t))
 
         a_req = pt.ChatRequest(
             model=self._model_name.v,
             messages=messages,
-            # tools=tools or None,
+            tools=tools or None,
             stream=False,
         )
 
@@ -124,17 +128,7 @@ class OllamaChatChoicesService(BaseOllamaChatChoicesService):
 
         resp = msh.unmarshal(json_response, pt.ChatResponse)
 
-        out: list[AnyAiMessage] = []
-        if resp.message.role == 'assistant':
-            out.append(AiMessage(
-                check.not_none(resp.message.content),
-            ))
-        else:
-            raise TypeError(resp.message.role)
-
-        return ChatChoicesResponse([
-            AiChoice(out),
-        ])
+        return build_mc_choices_response(resp)
 
 
 ##
@@ -152,12 +146,18 @@ class OllamaChatChoicesStreamService(BaseOllamaChatChoicesService):
             self,
             request: ChatChoicesStreamRequest,
     ) -> ChatChoicesStreamResponse:
-        messages = self._build_request_messages(request.v)
+        messages = build_ol_request_messages(request.v)
+
+        tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_ol_request_tool(t))
 
         a_req = pt.ChatRequest(
             model=self._model_name.v,
             messages=messages,
-            # tools=tools or None,
+            tools=tools or None,
             stream=True,
         )
 
@@ -184,14 +184,8 @@ class OllamaChatChoicesStreamService(BaseOllamaChatChoicesService):
                         lj = json.loads(l.decode('utf-8'))
                         lp: pt.ChatResponse = msh.unmarshal(lj, pt.ChatResponse)
 
-                        check.state(lp.message.role == 'assistant')
-                        check.none(lp.message.tool_name)
-                        check.state(not lp.message.tool_calls)
-
-                        if (c := lp.message.content):
-                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
-                                c,
-                            )])]))
+                        if (ds := build_mc_ai_choice_deltas(lp)).deltas:
+                            await sink.emit(AiChoicesDeltas([ds]))
 
                     if not b:
                         return []

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

@@ -0,0 +1,144 @@
+import itertools
+
+from omlish import check
+
+from .....backends.ollama 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_ol_request_messages(chat: Chat) -> list[pt.Message]:
+    ol_msgs: list[pt.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:
+                ol_msgs.append(pt.Message(
+                    role='assistant',
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.Message.ToolCall(
+                            function=pt.Message.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=mc_tu_msg.tu.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):
+                    ol_msgs.append(pt.Message(
+                        role='system',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    ol_msgs.append(pt.Message(
+                        role='user',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    ol_msgs.append(pt.Message(
+                        role='tool',
+                        tool_name=mc_msg.tur.name,
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return ol_msgs
+
+
+def build_ol_request_tool(t: Tool) -> pt.Tool:
+    return pt.Tool(
+        function=pt.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(ol_resp: pt.ChatResponse) -> ChatChoicesResponse:
+    ol_msg = ol_resp.message
+
+    lst: list[AnyAiMessage] = []
+
+    if ol_msg.role in (None, 'assistant'):
+        if ol_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(ol_msg.content, str),
+            ))
+
+        for ol_tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=ol_tc.id,
+                name=ol_tc.function.name,
+                args=ol_tc.function.arguments,
+            )))
+
+    else:
+        raise ValueError(ol_msg)
+
+    return ChatChoicesResponse([AiChoice(lst)])
+
+
+def build_mc_ai_choice_deltas(ol_resp: pt.ChatResponse) -> AiChoiceDeltas:
+    ol_msg = ol_resp.message
+
+    if ol_msg.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if ol_msg.content is not None:
+            lst.append(ContentAiDelta(ol_msg.content))
+
+        for tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc.function.name),
+                args=tc.function.arguments,
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    else:
+        raise ValueError(ol_msg)