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

ommlds/cli/sessions/chat/phases/types.py

@@ -0,0 +1,29 @@
+import enum
+import typing as ta
+
+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])

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

@@ -0,0 +1,32 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import markdown as _markdown
+    from . import raw as _raw
+    from . import types as _types
+
+
+##
+
+
+def bind_rendering(
+        *,
+        markdown: bool = False,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if markdown:
+        els.extend([
+            inj.bind(_types.ContentRendering, to_ctor=_markdown.MarkdownContentRendering, singleton=True),
+            inj.bind(_types.StreamContentRendering, to_ctor=_markdown.MarkdownStreamContentRendering, singleton=True),
+        ])
+
+    else:
+        els.extend([
+            inj.bind(_types.ContentRendering, to_ctor=_raw.RawContentRendering, singleton=True),
+            inj.bind(_types.StreamContentRendering, to_ctor=_raw.RawStreamContentRendering, singleton=True),
+        ])
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/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/chat/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 RawStreamContentRendering(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 = RawStreamContentRendering.PrintOutput()
+        self._output = output
+
+    @ta.final
+    class _ContextInstance(ContentRendering, ta.AsyncContextManager):
+        def __init__(self, owner: 'RawStreamContentRendering') -> 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 RawStreamContentRendering._ContextInstance(self)

ommlds/cli/sessions/chat/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/chat/session.py

@@ -0,0 +1,27 @@
+import dataclasses as dc
+
+from ..base import Session
+from .configs import ChatConfig
+from .driver import ChatDriver
+
+
+##
+
+
+class ChatSession(Session['ChatSession.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/chat/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/chat/tools/execution.py

@@ -0,0 +1,66 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ..... import minichain as mc
+from .confirmation import ToolExecutionConfirmation
+
+
+##
+
+
+class ToolContextProvider(lang.Func0[ta.Sequence[ta.Any]]):
+    pass
+
+
+ToolContextProviders = ta.NewType('ToolContextProviders', ta.Sequence[ToolContextProvider])
+
+
+##
+
+
+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',
+            ctx_provider: ToolContextProvider,
+            confirmation: ToolExecutionConfirmation | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._catalog = catalog
+        self._ctx_provider = ctx_provider
+        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,
+                *self._ctx_provider(),
+                *ctx_items,
+            ),
+            tce.executor(),
+            use,
+        )

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

@@ -0,0 +1,145 @@
+import os
+import typing as ta
+
+from omlish import check
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+from .injection import bind_tool_context_provider_to_key
+from .injection import tool_catalog_entries
+from .injection import tool_context_providers
+
+
+with lang.auto_proxy_import(globals()):
+    from . import confirmation as _confirmation
+    from . import execution as _execution
+    from . import rendering as _rendering
+
+
+##
+
+
+_TOOL_BINDERS: dict[str, ta.Callable[[], inj.Elements]] = {}
+
+
+def _tool_binder(name: str) -> ta.Callable[[ta.Callable[[], inj.Elements]], ta.Callable[[], inj.Elements]]:
+    def inner(fn):
+        check.not_in(name, _TOOL_BINDERS)
+        _TOOL_BINDERS[name] = fn
+        return fn
+    return inner
+
+
+#
+
+
+@_tool_binder('weather')
+def _bind_weather_tool() -> inj.Elements:
+    from .weather import WEATHER_TOOL
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
+    )
+
+
+@_tool_binder('todo')
+def _bind_todo_tools() -> inj.Elements:
+    from .....minichain.lib.todo.context import TodoContext
+    from .....minichain.lib.todo.tools.read import todo_read_tool
+    from .....minichain.lib.todo.tools.write import todo_write_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            todo_read_tool(),
+            todo_write_tool(),
+        ),
+
+        inj.bind(TodoContext()),
+        bind_tool_context_provider_to_key(TodoContext),
+    )
+
+
+@_tool_binder('fs')
+def _bind_fs_tools() -> inj.Elements:
+    from .....minichain.lib.fs.context import FsContext
+    from .....minichain.lib.fs.tools.ls import ls_tool
+    from .....minichain.lib.fs.tools.read import read_tool
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(
+            ls_tool(),
+            read_tool(),
+        ),
+
+        inj.bind(FsContext(
+            root_dir=os.getcwd(),
+        )),
+        bind_tool_context_provider_to_key(FsContext),
+    )
+
+
+# if tools_config.enable_unsafe_tools_do_not_use_lol:
+#     from ...minichain.lib.bash import bash_tool
+#     els.append(bind_tool(bash_tool()))
+#
+#     from ...minichain.lib.fs.tools.edit import edit_tool
+#     els.append(bind_tool(edit_tool()))
+
+
+##
+
+
+def bind_tools(
+        *,
+        silent: bool = False,
+        dangerous_no_confirmation: bool = False,
+        enabled_tools: ta.Iterable[str] | None = None,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(inj.bind(mc.ToolCatalog, singleton=True))
+
+    #
+
+    els.append(tool_catalog_entries().bind_items_provider(singleton=True))
+
+    for etn in check.not_isinstance(enabled_tools or [], str):
+        els.append(_TOOL_BINDERS[etn]())
+
+    #
+
+    exec_stack = inj.wrapper_binder_helper(_execution.ToolUseExecutor)
+
+    els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
+
+    if not silent:
+        els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
+
+        if dangerous_no_confirmation:
+            els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
+
+    els.extend([
+        inj.bind(_execution.ToolUseExecutor, to_key=exec_stack.top),
+    ])
+
+    #
+
+    if not dangerous_no_confirmation:
+        els.append(inj.bind(_confirmation.ToolExecutionConfirmation, to_ctor=_confirmation.InteractiveToolExecutionConfirmation, singleton=True))  # noqa
+
+    #
+
+    els.extend([
+        tool_context_providers().bind_items_provider(singleton=True),
+
+        inj.bind(_execution.ToolContextProvider, to_fn=lang.typed_lambda(tcps=_execution.ToolContextProviders)(
+            lambda tcps: _execution.ToolContextProvider(lambda: [tc for tcp in tcps for tc in tcp()]),
+        ), singleton=True),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/tools/injection.py

@@ -0,0 +1,29 @@
+import typing as ta
+
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+with lang.auto_proxy_import(globals()):
+    from . import execution as _execution
+
+##
+
+
+@lang.cached_function
+def tool_catalog_entries() -> 'inj.ItemsBinderHelper[mc.ToolCatalogEntry]':
+    return inj.items_binder_helper[mc.ToolCatalogEntry](mc.ToolCatalogEntries)
+
+
+@lang.cached_function
+def tool_context_providers() -> 'inj.ItemsBinderHelper[_execution.ToolContextProvider]':
+    return inj.items_binder_helper[_execution.ToolContextProvider](_execution.ToolContextProviders)
+
+
+def bind_tool_context_provider_to_key(key: ta.Any) -> inj.Elements:
+    return tool_context_providers().bind_item(to_fn=inj.KwargsTarget.of(
+        lambda v: _execution.ToolContextProvider(lambda: [v]),
+        v=key,
+    ), singleton=True)

ommlds/cli/sessions/chat/tools/rendering.py

@@ -0,0 +1,58 @@
+import typing as ta
+
+from ..... import minichain as mc
+from ..rendering.types import ContentRendering
+from .execution import ToolUseExecutor
+
+
+##
+
+
+class ArgsRenderingToolUseExecutor(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolUseExecutor,
+            renderer: ContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._renderer = renderer
+
+    async def execute_tool_use(
+            self,
+            use: 'mc.ToolUse',
+            *ctx_items: ta.Any,
+    ) -> 'mc.ToolUseResultMessage':
+        await self._renderer.render_content(mc.JsonContent(dict(
+            id=use.id,
+            name=use.name,
+            args=use.args,
+        )))
+
+        return await self._wrapped.execute_tool_use(use, *ctx_items)
+
+
+class ResultRenderingToolUseExecutor(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolUseExecutor,
+            renderer: ContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._renderer = renderer
+
+    async def execute_tool_use(
+            self,
+            use: 'mc.ToolUse',
+            *ctx_items: ta.Any,
+    ) -> 'mc.ToolUseResultMessage':
+        out = await self._wrapped.execute_tool_use(use, *ctx_items)
+
+        await self._renderer.render_content(out.tur.c)
+
+        return out

ommlds/cli/{tools → sessions/chat/tools}/weather.py

@@ -1,4 +1,4 @@
-from ... import minichain as mc
+from ..... import minichain as mc
 
 
 ##

ommlds/cli/sessions/inject.py

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