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

ommlds/cli/sessions/chat/drivers/tools/confirmation.py

@@ -0,0 +1,44 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+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 AlwaysDenyToolExecutionConfirmation(ToolExecutionConfirmation):
+    async def confirm_tool_execution_or_raise(
+            self,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
+    ) -> None:
+        raise ToolExecutionRequestDeniedError
+
+
+class UnsafeAlwaysAllowToolExecutionConfirmation(ToolExecutionConfirmation):
+    async def confirm_tool_execution_or_raise(
+            self,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
+    ) -> None:
+        pass

ommlds/cli/sessions/chat/{tools → drivers/tools}/execution.py

@@ -4,7 +4,7 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from ..... import minichain as mc
+from ...... import minichain as mc
 from .confirmation import ToolExecutionConfirmation
 
 
@@ -37,7 +37,7 @@ class ToolUseExecutorImpl(ToolUseExecutor):
             *,
             catalog: 'mc.ToolCatalog',
             ctx_provider: ToolContextProvider,
-            confirmation: ToolExecutionConfirmation | None = None,
+            confirmation: ToolExecutionConfirmation,
     ) -> None:
         super().__init__()
 
@@ -52,8 +52,7 @@ class ToolUseExecutorImpl(ToolUseExecutor):
     ) -> '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)
+        await self._confirmation.confirm_tool_execution_or_raise(use, tce)
 
         return await mc.execute_tool_use(
             mc.ToolContext(

ommlds/cli/sessions/chat/{tools → drivers/tools}/fs/inject.py

@@ -12,9 +12,9 @@ from .configs import FsToolSetConfig
 
 
 def bind_fs_tools(cfg: FsToolSetConfig) -> 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
+    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(

ommlds/cli/sessions/chat/{tools → drivers/tools}/inject.py

@@ -2,15 +2,14 @@ from omlish import check
 from omlish import inject as inj
 from omlish import lang
 
-from ..... import minichain as mc
-from .configs import ToolsConfig
+from ...... import minichain as mc
+from ..configs import ToolsConfig
 from .injection import ToolSetBinder
 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
 
@@ -58,23 +57,16 @@ def bind_tools(cfg: ToolsConfig = ToolsConfig()) -> inj.Elements:
 
     els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
 
-    if not cfg.silent:
+    if cfg.verbose:
+        els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
         els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
 
-        if cfg.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 cfg.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),
 

ommlds/cli/sessions/chat/{tools → drivers/tools}/injection.py

@@ -4,7 +4,7 @@ from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
-from ..... import minichain as mc
+from ...... import minichain as mc
 from .configs import ToolSetConfig
 
 

ommlds/cli/sessions/chat/{tools → drivers/tools}/rendering.py

@@ -1,8 +1,8 @@
 import typing as ta
 
-from ..... import minichain as mc
-from ....rendering.types import ContentRendering
-from .execution import ToolUseExecutor
+from ...... import minichain as mc
+from .....rendering.types import ContentRendering
+from ...drivers.tools.execution import ToolUseExecutor
 
 
 ##

ommlds/cli/sessions/chat/{tools → drivers/tools}/todo/inject.py

@@ -10,9 +10,9 @@ from .configs import TodoToolSetConfig
 
 
 def bind_todo_tools(cfg: TodoToolSetConfig) -> 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
+    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(

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

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

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

@@ -0,0 +1,10 @@
+import uuid
+
+from omlish import typedvalues as tv
+
+
+##
+
+
+class ChatDriverId(tv.UniqueScalarTypedValue[uuid.UUID]):
+    pass

ommlds/cli/sessions/chat/{chat → drivers}/user/configs.py

@@ -12,5 +12,3 @@ from ...... import minichain as mc
 class UserConfig:
     initial_system_content: ta.Optional['mc.Content'] = None
     initial_user_content: ta.Optional['mc.Content'] = None
-
-    interactive: bool = False

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

@@ -0,0 +1,40 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ...... import minichain as mc
+from ..phases.injection import phase_callbacks
+from ..phases.types import ChatPhase
+from ..phases.types import ChatPhaseCallback
+from .configs import UserConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .. import driver as _driver
+    from ..state import types as _state
+
+
+##
+
+
+def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if cfg.initial_system_content is not None:
+        async def add_initial_system_content(cm: '_state.ChatStateManager') -> None:
+            await cm.extend_chat([mc.SystemMessage(cfg.initial_system_content)])
+
+        els.append(phase_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
+            lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_system_content(cm)),
+            cm=_state.ChatStateManager,
+        )))
+
+    if cfg.initial_user_content is not None:
+        async def add_initial_user_content(ca: '_driver.ChatDriver') -> None:
+            await ca.send_user_messages([mc.UserMessage(cfg.initial_user_content)])
+
+        els.append(phase_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
+            lambda ca: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(ca())),
+            ca=inj.Late[_driver.ChatDriver],
+        )))
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/inject.py

@@ -2,23 +2,15 @@ from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
-from ...backends.types import DefaultBackendName
 from ..base import Session
-from .configs import DEFAULT_BACKEND
 from .configs import ChatConfig
 
 
 with lang.auto_proxy_import(globals()):
-    from ...backends import inject as _backends
     from ...rendering import inject as _rendering
-    from . import driver as _driver
     from . import session as _session
-    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
+    from .drivers import inject as _drivers
+    from .interfaces import inject as _interfaces
 
 
 ##
@@ -30,27 +22,11 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
     #
 
     els.extend([
-        _backends.bind_backends(cfg.backend),
+        _drivers.bind_driver(cfg.driver),
 
-        _chat_ai.bind_ai(cfg.ai),
-
-        _chat_user.bind_user(cfg.user),
-
-        _chat_state.bind_state(cfg.state),
-
-        _interface.bind_interface(cfg.interface),
-
-        _phases.bind_phases(),
+        _interfaces.bind_interface(cfg.interface),
 
         _rendering.bind_rendering(cfg.rendering),
-
-        _tools.bind_tools(cfg.tools),
-    ])
-
-    #
-
-    els.extend([
-        inj.bind(_driver.ChatDriver, singleton=True),
     ])
 
     #
@@ -62,8 +38,4 @@ def bind_chat(cfg: ChatConfig) -> inj.Elements:
 
     #
 
-    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
-
-    #
-
     return inj.as_elements(*els)

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

@@ -0,0 +1,61 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ..base import ChatInterface
+from ..configs import InterfaceConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .....inputs import asyncs as _inputs_asyncs
+    from .....inputs import sync as _inputs_sync
+    from ...drivers.tools import confirmation as _tools_confirmation
+    from . import interactive as _interactive
+    from . import oneshot as _oneshot
+    from . import tools as _tools
+
+
+##
+
+
+def bind_bare(cfg: InterfaceConfig = InterfaceConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    if cfg.interactive:
+        els.extend([
+            inj.bind(_interactive.InteractiveBareChatInterface, singleton=True),
+            inj.bind(ChatInterface, to_key=_interactive.InteractiveBareChatInterface),
+        ])
+
+        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:
+        els.extend([
+            inj.bind(_oneshot.OneshotBareChatInterface, singleton=True),
+            inj.bind(ChatInterface, to_key=_oneshot.OneshotBareChatInterface),
+        ])
+
+    #
+
+    if cfg.enable_tools:
+        if cfg.dangerous_no_tool_confirmation:
+            els.append(inj.bind(
+                _tools_confirmation.ToolExecutionConfirmation,
+                to_ctor=_tools_confirmation.UnsafeAlwaysAllowToolExecutionConfirmation,
+                singleton=True,
+            ))
+
+        else:
+            els.append(inj.bind(
+                _tools_confirmation.ToolExecutionConfirmation,
+                to_ctor=_tools.InteractiveToolExecutionConfirmation,
+                singleton=True,
+            ))
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/interfaces/bare/interactive.py

@@ -0,0 +1,41 @@
+import typing as ta
+
+from ...... import minichain as mc
+from .....inputs.asyncs import AsyncStringInput
+from .....inputs.asyncs import SyncAsyncStringInput
+from .....inputs.sync import InputSyncStringInput
+from ...drivers.driver import ChatDriver
+from ..base import ChatInterface
+
+
+##
+
+
+class InteractiveBareChatInterface(ChatInterface):
+    DEFAULT_STRING_INPUT: ta.ClassVar[AsyncStringInput] = SyncAsyncStringInput(InputSyncStringInput())
+
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            string_input: AsyncStringInput | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+        if string_input is None:
+            string_input = self.DEFAULT_STRING_INPUT
+        self._string_input = string_input
+
+    async def run(self) -> None:
+        await self._driver.start()
+
+        while True:
+            try:
+                s = await self._string_input()
+            except EOFError:
+                break
+
+            await self._driver.send_user_messages([mc.UserMessage(s)])
+
+        await self._driver.stop()

ommlds/cli/sessions/chat/{interface/bare/interface.py → interfaces/bare/oneshot.py}

@@ -1,11 +1,11 @@
-from ...driver import ChatDriver
+from ...drivers.driver import ChatDriver
 from ..base import ChatInterface
 
 
 ##
 
 
-class BareChatInterface(ChatInterface):
+class OneshotBareChatInterface(ChatInterface):
     def __init__(
             self,
             *,
@@ -16,4 +16,6 @@ class BareChatInterface(ChatInterface):
         self._driver = driver
 
     async def run(self) -> None:
-        await self._driver.run()
+        await self._driver.start()
+
+        await self._driver.stop()

ommlds/cli/sessions/chat/{tools/confirmation.py → interfaces/bare/tools.py}

@@ -1,28 +1,9 @@
-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
+from ...... import minichain as mc
+from ...drivers.tools.confirmation import ToolExecutionConfirmation
+from ...drivers.tools.confirmation import ToolExecutionRequestDeniedError
 
 
 ##

ommlds/cli/sessions/chat/{interface → interfaces}/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 ...chat.user.types import UserChatInput
+from ...drivers.user.types import UserChatInput
 
 
 ##

ommlds/cli/sessions/chat/{interface → interfaces}/configs.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - obviously, subclasses of InterfaceConfig
+  - this is really just another instance of the whole `argparse -> config -> inject` flow
+"""
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -13,3 +18,6 @@ class InterfaceConfig:
     use_textual: bool = False
 
     use_readline: bool | ta.Literal['auto'] = 'auto'
+
+    enable_tools: bool = False
+    dangerous_no_tool_confirmation: bool = False