ommlds 0.0.0.dev462__py3-none-any.whl → 0.0.0.dev463__py3-none-any.whl

ommlds/cli/sessions/chat2/chat/user/oneshot.py

@@ -0,0 +1,25 @@
+import typing as ta
+
+from ...... import minichain as mc
+from .types import UserChatInput
+
+
+##
+
+
+OneshotUserChatInputInitialChat = ta.NewType('OneshotUserChatInputInitialChat', mc.UserChat)
+
+
+class OneshotUserChatInput(UserChatInput):
+    def __init__(
+            self,
+            initial_chat: OneshotUserChatInputInitialChat,
+    ) -> None:
+        super().__init__()
+
+        self._pending_chat: mc.UserChat | None = initial_chat
+
+    async def get_next_user_messages(self) -> mc.UserChat:
+        ret = self._pending_chat
+        self._pending_chat = None
+        return ret or []

ommlds/cli/sessions/chat2/chat/user/types.py

@@ -0,0 +1,15 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ...... import minichain as mc
+
+
+##
+
+
+class UserChatInput(lang.Abstract):
+    @abc.abstractmethod
+    def get_next_user_messages(self) -> ta.Awaitable[mc.UserChat]:
+        raise NotImplementedError

ommlds/cli/sessions/chat2/configs.py

@@ -0,0 +1,33 @@
+import dataclasses as dc
+import typing as ta
+
+from .... import minichain as mc
+
+
+##
+
+
+DEFAULT_CHAT_MODEL_BACKEND = 'openai'
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ChatConfig:
+    _: dc.KW_ONLY
+
+    backend: str | None = None
+    model_name: str | None = None
+
+    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
+
+    initial_content: mc.Content | None = None
+    interactive: bool = False
+
+    silent: bool = False
+    markdown: bool = False
+
+    stream: bool = False
+
+    dangerous_no_tool_confirmation: bool = False

ommlds/cli/sessions/chat2/content/messages.py

@@ -0,0 +1,30 @@
+import abc
+
+from omlish import check
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+##
+
+
+class MessageContentExtractor(lang.Abstract):
+    @abc.abstractmethod
+    def extract_message_content(self, message: mc.Message) -> mc.Content | None:
+        raise NotImplementedError
+
+
+class MessageContentExtractorImpl(MessageContentExtractor):
+    def extract_message_content(self, message: mc.Message) -> mc.Content | None:
+        if isinstance(message, (mc.SystemMessage, mc.UserMessage, mc.AiMessage)):
+            if message.c is not None:
+                return check.isinstance(message.c, str)
+            else:
+                return None
+
+        elif isinstance(message, mc.ToolUseResultMessage):
+            return check.isinstance(message.tur.c, str)
+
+        else:
+            raise TypeError(message)

ommlds/cli/sessions/chat2/content/strings.py

@@ -0,0 +1,42 @@
+import abc
+import typing as ta
+
+from omlish import lang
+from omlish.formats import json
+
+from ..... import minichain as mc
+
+
+##
+
+
+class ContentStringifier(lang.Abstract):
+    @abc.abstractmethod
+    def stringify_content(self, content: mc.Content) -> str | None:
+        raise NotImplementedError
+
+
+class ContentStringifierImpl(ContentStringifier):
+    def stringify_content(self, content: mc.Content) -> str | None:
+        if isinstance(content, str):
+            return content
+
+        elif isinstance(content, mc.JsonContent):
+            return json.dumps_pretty(content.v)
+
+        else:
+            raise TypeError(content)
+
+
+class HasContentStringifier(lang.Abstract):
+    def __init__(
+            self,
+            *args: ta.Any,
+            content_stringifier: ContentStringifier | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if content_stringifier is None:
+            content_stringifier = ContentStringifierImpl()
+        self._content_stringifier = content_stringifier

ommlds/cli/sessions/chat2/driver.py

@@ -0,0 +1,43 @@
+from .chat.ai.types import AiChatGenerator
+from .chat.state.types import ChatStateManager
+from .chat.user.types import UserChatInput
+from .phases import ChatPhase
+from .phases import ChatPhaseManager
+
+
+##
+
+
+class ChatDriver:
+    def __init__(
+            self,
+            *,
+            phases: ChatPhaseManager,
+            ai_chat_generator: AiChatGenerator,
+            user_chat_input: UserChatInput,
+            chat_state_manager: ChatStateManager,
+    ):
+        super().__init__()
+
+        self._phases = phases
+        self._ai_chat_generator = ai_chat_generator
+        self._user_chat_input = user_chat_input
+        self._chat_state_manager = chat_state_manager
+
+    async def run(self) -> None:
+        await self._phases.set_phase(ChatPhase.STARTING)
+        await self._phases.set_phase(ChatPhase.STARTED)
+
+        while True:
+            next_user_chat = await self._user_chat_input.get_next_user_messages()
+            if not next_user_chat:
+                break
+
+            prev_user_chat = (await self._chat_state_manager.get_state()).chat
+
+            next_ai_chat = await self._ai_chat_generator.get_next_ai_messages([*prev_user_chat, *next_user_chat])
+
+            await self._chat_state_manager.extend_chat([*next_user_chat, *next_ai_chat])
+
+        await self._phases.set_phase(ChatPhase.STOPPING)
+        await self._phases.set_phase(ChatPhase.STOPPED)

ommlds/cli/sessions/chat2/inject.py

@@ -0,0 +1,143 @@
+import typing as ta
+
+from omlish import inject as inj
+from omlish import lang
+
+from .... import minichain as mc
+from . import _inject as _inj
+from .configs import DEFAULT_CHAT_MODEL_BACKEND
+from .configs import ChatConfig
+
+
+ItemT = ta.TypeVar('ItemT')
+
+
+##
+
+
+CHAT_OPTIONS = inj.items_binder_helper[mc.ChatChoicesOption](_inj.ChatChoicesServiceOptions)
+BACKEND_CONFIGS = inj.items_binder_helper[mc.Config](_inj.BackendConfigs)
+PHASE_CALLBACKS = inj.items_binder_helper[_inj.ChatPhaseCallback](_inj.ChatPhaseCallbacks)
+
+
+##
+
+
+def bind_chat(cfg: ChatConfig) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.extend([
+        CHAT_OPTIONS.bind_items_provider(singleton=True),
+        BACKEND_CONFIGS.bind_items_provider(singleton=True),
+        PHASE_CALLBACKS.bind_items_provider(singleton=True),
+    ])
+
+    #
+
+    if cfg.state in ('continue', 'new'):
+        els.extend([
+            inj.bind(_inj.StateStorageChatStateManager, singleton=True),
+            inj.bind(_inj.ChatStateManager, to_key=_inj.StateStorageChatStateManager),
+        ])
+
+        if cfg.state == 'new':
+            els.append(PHASE_CALLBACKS.bind_item(to_fn=lang.typed_lambda(cm=_inj.ChatStateManager)(
+                lambda cm: _inj.ChatPhaseCallback(_inj.ChatPhase.STARTING, cm.clear_state),
+            )))
+
+    elif cfg.state == 'ephemeral':
+        els.extend([
+            inj.bind(_inj.InMemoryChatStateManager, singleton=True),
+            inj.bind(_inj.ChatStateManager, to_key=_inj.InMemoryChatStateManager),
+        ])
+
+    else:
+        raise TypeError(cfg.state)
+
+    #
+
+    if cfg.interactive:
+        if cfg.initial_content is not None:
+            async def add_initial_content(cm: '_inj.ChatStateManager') -> None:
+                await cm.extend_chat([mc.UserMessage(cfg.initial_content)])
+
+            els.append(PHASE_CALLBACKS.bind_item(to_fn=lang.typed_lambda(cm=_inj.ChatStateManager)(
+                lambda cm: _inj.ChatPhaseCallback(_inj.ChatPhase.STARTED, lambda: add_initial_content(cm)),
+            )))
+
+            raise NotImplementedError
+
+        els.extend([
+            inj.bind(_inj.InteractiveUserChatInput, singleton=True),
+            inj.bind(_inj.UserChatInput, to_key=_inj.InteractiveUserChatInput),
+        ])
+
+    else:
+        if cfg.initial_content is None:
+            raise ValueError('Initial content is required for non-interactive chat')
+
+        els.extend([
+            inj.bind(_inj.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(cfg.initial_content)]),
+            inj.bind(_inj.OneshotUserChatInput, singleton=True),
+            inj.bind(_inj.UserChatInput, to_key=_inj.OneshotUserChatInput),
+        ])
+
+    #
+
+    if cfg.stream:
+        raise NotImplementedError
+
+    else:
+        ai_stack = inj.wrapper_binder_helper(_inj.AiChatGenerator)
+
+        els.append(ai_stack.push_bind(to_ctor=_inj.ChatChoicesServiceAiChatGenerator, singleton=True))
+
+        if not cfg.silent:
+            if cfg.markdown:
+                els.extend([
+                    inj.bind(_inj.MarkdownContentRendering, singleton=True),
+                    inj.bind(_inj.ContentRendering, to_key=_inj.MarkdownContentRendering),
+                ])
+            else:
+                els.extend([
+                    inj.bind(_inj.RawContentRendering, singleton=True),
+                    inj.bind(_inj.ContentRendering, to_key=_inj.RawContentRendering),
+                ])
+
+            els.append(ai_stack.push_bind(to_ctor=_inj.RenderingAiChatGenerator, singleton=True))
+
+        els.append(inj.bind(_inj.AiChatGenerator, to_key=ai_stack.top))
+
+    #
+
+    els.append(inj.bind(_inj.BackendName, to_const=cfg.backend or DEFAULT_CHAT_MODEL_BACKEND))
+
+    els.extend([
+        inj.bind(_inj.CatalogChatChoicesServiceBackendProvider),
+        inj.bind(_inj.ChatChoicesServiceBackendProvider, to_key=_inj.CatalogChatChoicesServiceBackendProvider),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_inj.ToolUseExecutorImpl, singleton=True),
+        inj.bind(_inj.ToolUseExecutor, to_key=_inj.ToolUseExecutorImpl),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_inj.ChatPhaseManager, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_inj.ChatDriver, singleton=True),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat2/phases.py

@@ -0,0 +1,55 @@
+import enum
+import typing as ta
+
+from omlish import check
+from omlish import collections as col
+from omlish import dataclasses as dc
+
+
+##
+
+
+class ChatPhase(enum.Enum):
+    NEW = enum.auto()
+
+    STARTING = enum.auto()
+    STARTED = enum.auto()
+
+    STOPPING = enum.auto()
+    STOPPED = enum.auto()
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ChatPhaseCallback:
+    phase: ChatPhase = dc.xfield(validate=lambda v: v != ChatPhase.NEW)
+    fn: ta.Callable[[], ta.Awaitable[None]] = dc.xfield()
+
+
+ChatPhaseCallbacks = ta.NewType('ChatPhaseCallbacks', ta.Sequence[ChatPhaseCallback])
+
+
+##
+
+
+class ChatPhaseManager:
+    def __init__(self, callbacks: ChatPhaseCallbacks) -> None:
+        super().__init__()
+
+        self._callbacks = callbacks
+        self._callbacks_by_phase = col.multi_map_by(lambda cb: cb.phase, callbacks)
+
+        check.state(not self._callbacks_by_phase.get(ChatPhase.NEW))
+
+        self._phase = ChatPhase.NEW
+
+    @property
+    def phase(self) -> ChatPhase:
+        return self._phase
+
+    async def set_phase(self, phase: ChatPhase) -> None:
+        self._phase = phase
+        for cb in self._callbacks_by_phase.get(phase, ()):
+            await cb.fn()

ommlds/cli/sessions/chat2/rendering/markdown.py

@@ -0,0 +1,52 @@
+import typing as ta
+
+from omdev.tui import rich
+from omlish import lang
+
+from ..... import minichain as mc
+from ..content.strings import ContentStringifier
+from ..content.strings import HasContentStringifier
+from .types import ContentRendering
+from .types import StreamContentRendering
+
+
+##
+
+
+class MarkdownContentRendering(ContentRendering, HasContentStringifier):
+    def __init__(
+            self,
+            *,
+            content_stringifier: ContentStringifier | None = None,
+    ) -> None:
+        super().__init__(content_stringifier=content_stringifier)
+
+    async def render_content(self, content: mc.Content) -> None:
+        if (s := self._content_stringifier.stringify_content(content)) is not None and (s := s.strip()):
+            rich.Console().print(rich.Markdown(s))
+
+
+class MarkdownStreamContentRendering(StreamContentRendering, HasContentStringifier):
+    def __init__(
+            self,
+            *,
+            content_stringifier: ContentStringifier | None = None,
+    ) -> None:
+        super().__init__(content_stringifier=content_stringifier)
+
+    @ta.final
+    class _ContextInstance(ContentRendering, lang.AsyncExitStacked):
+        def __init__(self, owner: 'MarkdownStreamContentRendering') -> None:
+            self._owner = owner
+
+        _ir: rich.MarkdownLiveStream
+
+        async def _async_enter_contexts(self) -> None:
+            self._ir = self._enter_context(rich.IncrementalMarkdownLiveStream())
+
+        async def render_content(self, content: mc.Content) -> None:
+            if (s := self._owner._content_stringifier.stringify_content(content)) is not None:  # noqa: SLF001
+                self._ir.feed(s)
+
+    def create_context(self) -> ta.AsyncContextManager[ContentRendering]:
+        return MarkdownStreamContentRendering._ContextInstance(self)

ommlds/cli/sessions/chat2/rendering/raw.py

@@ -0,0 +1,73 @@
+import typing as ta
+
+from omlish import lang
+
+from ..... import minichain as mc
+from ..content.strings import ContentStringifier
+from ..content.strings import HasContentStringifier
+from .types import ContentRendering
+from .types import StreamContentRendering
+
+
+##
+
+
+class RawContentRendering(ContentRendering, HasContentStringifier):
+    def __init__(
+            self,
+            *,
+            printer: ta.Callable[[str], ta.Awaitable[None]] | None = None,
+            content_stringifier: ContentStringifier | None = None,
+    ) -> None:
+        super().__init__(content_stringifier=content_stringifier)
+
+        if printer is None:
+            printer = lang.as_async(print)
+        self._printer = printer
+
+    async def render_content(self, content: mc.Content) -> None:
+        if (s := self._content_stringifier.stringify_content(content)) is not None:
+            await self._printer(s)
+
+
+class RawContentStreamRendering(StreamContentRendering, HasContentStringifier):
+    class Output(ta.Protocol):
+        def write(self, s: str) -> ta.Awaitable[None]: ...
+        def flush(self) -> ta.Awaitable[None]: ...
+
+    class PrintOutput:
+        async def write(self, s: str) -> None:
+            print(s, end='', flush=True)
+
+        async def flush(self) -> None:
+            print(flush=True)
+
+    def __init__(
+            self,
+            *,
+            output: Output | None = None,
+            content_stringifier: ContentStringifier | None = None,
+    ) -> None:
+        super().__init__(content_stringifier=content_stringifier)
+
+        if output is None:
+            output = RawContentStreamRendering.PrintOutput()
+        self._output = output
+
+    @ta.final
+    class _ContextInstance(ContentRendering, ta.AsyncContextManager):
+        def __init__(self, owner: 'RawContentStreamRendering') -> None:
+            self._owner = owner
+
+        async def __aenter__(self) -> ta.Self:
+            return self
+
+        async def __aexit__(self, *exc_info) -> None:
+            await self._owner._output.flush()  # noqa: SLF001
+
+        async def render_content(self, content: mc.Content) -> None:
+            if (s := self._owner._content_stringifier.stringify_content(content)) is not None:  # noqa: SLF001
+                await self._owner._output.write(s)  # noqa: SLF001
+
+    def create_context(self) -> ta.AsyncContextManager[ContentRendering]:
+        return RawContentStreamRendering._ContextInstance(self)

ommlds/cli/sessions/chat2/rendering/types.py

@@ -0,0 +1,21 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+##
+
+
+class ContentRendering(lang.Abstract):
+    @abc.abstractmethod
+    def render_content(self, content: mc.Content) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+class StreamContentRendering(lang.Abstract):
+    @abc.abstractmethod
+    def create_context(self) -> ta.AsyncContextManager[ContentRendering]:
+        raise NotImplementedError

ommlds/cli/sessions/chat2/session.py

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

ommlds/cli/sessions/chat2/tools/confirmation.py

@@ -0,0 +1,46 @@
+import abc
+import typing as ta
+
+from omlish import lang
+from omlish.formats import json
+from omlish.term.confirm import confirm_action
+
+from ..... import minichain as mc
+
+
+##
+
+
+class ToolExecutionRequestDeniedError(Exception):
+    pass
+
+
+class ToolExecutionConfirmation(lang.Abstract):
+    @abc.abstractmethod
+    def confirm_tool_execution_or_raise(
+            self,
+            use: mc.ToolUse,
+            entry: mc.ToolCatalogEntry,
+    ) -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+##
+
+
+class InteractiveToolExecutionConfirmation(ToolExecutionConfirmation):
+    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),
+        )
+        cr = confirm_action(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}')  # FIXME: async lol
+
+        if not cr:
+            raise ToolExecutionRequestDeniedError

ommlds/cli/sessions/chat2/tools/execution.py

@@ -0,0 +1,53 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ..... import minichain as mc
+from .confirmation import ToolExecutionConfirmation
+
+
+##
+
+
+class ToolUseExecutor(lang.Abstract):
+    @abc.abstractmethod
+    def execute_tool_use(
+            self,
+            use: mc.ToolUse,
+            *ctx_items: ta.Any,
+    ) -> ta.Awaitable[mc.ToolUseResultMessage]:
+        raise NotImplementedError
+
+
+class ToolUseExecutorImpl(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            catalog: mc.ToolCatalog,
+            confirmation: ToolExecutionConfirmation | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._catalog = catalog
+        self._confirmation = confirmation
+
+    async def execute_tool_use(
+            self,
+            use: mc.ToolUse,
+            *ctx_items: ta.Any,
+    ) -> mc.ToolUseResultMessage:
+        tce = self._catalog.by_name[check.non_empty_str(use.name)]
+
+        if self._confirmation is not None:
+            await self._confirmation.confirm_tool_execution_or_raise(use, tce)
+
+        return await mc.execute_tool_use(
+            mc.ToolContext(
+                use,
+                *ctx_items,
+            ),
+            tce.executor(),
+            use,
+        )

ommlds/cli/sessions/inject.py

@@ -2,7 +2,7 @@ from omlish import inject as inj
 
 from .base import Session
 from .chat.base import ChatSession
-from .chat.inject import bind_chat_session
+from .chat2.session import Chat2Session
 
 
 ##
@@ -16,6 +16,11 @@ def bind_sessions(session_cfg: Session.Config) -> inj.Elements:
     ]
 
     if isinstance(session_cfg, ChatSession.Config):
+        from .chat.inject import bind_chat_session
         els.append(bind_chat_session(session_cfg))
 
+    elif isinstance(session_cfg, Chat2Session.Config):
+        from .chat2.inject import bind_chat
+        els.append(bind_chat(session_cfg))  # noqa
+
     return inj.as_elements(*els)