ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev503__py3-none-any.whl

ommlds/cli/sessions/chat/{chat → drivers}/state/types.py

@@ -1,9 +1,11 @@
 import abc
 import datetime
 import typing as ta
+import uuid
 
 from omlish import dataclasses as dc
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ...... import minichain as mc
 
@@ -11,6 +13,13 @@ from ...... import minichain as mc
 ##
 
 
+class ChatId(tv.UniqueScalarTypedValue[uuid.UUID]):
+    pass
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class ChatState:
     name: str | None = None
@@ -18,7 +27,7 @@ class ChatState:
     created_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
     updated_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
 
-    chat: mc.Chat = ()
+    chat: 'mc.Chat' = ()
 
 
 ##
@@ -29,10 +38,6 @@ class ChatStateManager(lang.Abstract):
     def get_state(self) -> ta.Awaitable[ChatState]:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    def clear_state(self) -> ta.Awaitable[ChatState]:
-        raise NotImplementedError
-
     @abc.abstractmethod
     def extend_chat(self, chat_additions: 'mc.Chat') -> ta.Awaitable[ChatState]:
         raise NotImplementedError

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

@@ -9,10 +9,10 @@ from omlish import lang
 
 @dc.dataclass(frozen=True, kw_only=True)
 class ToolsConfig:
-    silent: bool = False
-    dangerous_no_confirmation: bool = False
     enabled_tools: ta.Iterable[str] | None = None
 
+    verbose: bool = False
+
 
 ##
 

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/drivers/tools/errorhandling.py

@@ -0,0 +1,39 @@
+import typing as ta
+
+from omlish import check
+
+from ...... import minichain as mc
+from .execution import ToolUseExecutor
+
+
+##
+
+
+class ErrorHandlingToolUseExecutor(ToolUseExecutor):
+    def __init__(
+            self,
+            *,
+            wrapped: ToolUseExecutor,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+
+    async def execute_tool_use(
+            self,
+            use: 'mc.ToolUse',
+            *ctx_items: ta.Any,
+    ) -> 'mc.ToolUseResultMessage':
+        try:
+            return await self._wrapped.execute_tool_use(use, *ctx_items)
+
+        except mc.ToolExecutionError as txe:  # noqa
+            s = check.non_empty_str(check.isinstance(txe.content, str))
+
+            return mc.ToolUseResultMessage(
+                mc.ToolUseResult(
+                    id=use.id,
+                    name=use.name,
+                    c=s,
+                ),
+            )

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,15 @@ 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 errorhandling as _errorhandling
     from . import execution as _execution
     from . import rendering as _rendering
 
@@ -58,11 +58,11 @@ def bind_tools(cfg: ToolsConfig = ToolsConfig()) -> inj.Elements:
 
     els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
 
-    if not cfg.silent:
-        els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
+    els.append(exec_stack.push_bind(to_ctor=_errorhandling.ErrorHandlingToolUseExecutor, singleton=True))
 
-        if cfg.dangerous_no_confirmation:
-            els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
+    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))
 
     els.extend([
         inj.bind(_execution.ToolUseExecutor, to_key=exec_stack.top),
@@ -70,11 +70,6 @@ def bind_tools(cfg: ToolsConfig = ToolsConfig()) -> inj.Elements:
 
     #
 
-    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
 
 
@@ -29,10 +29,10 @@ def tool_context_providers() -> 'inj.ItemsBinderHelper[_execution.ToolContextPro
 
 
 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)
+    return tool_context_providers().bind_item(
+        to_fn=inj.target(v=key)(lambda v: _execution.ToolContextProvider(lambda: [v])),
+        singleton=True,
+    )
 
 
 ##

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,31 @@
+import abc
+import typing as ta
+import uuid
+
+from omlish import lang
+from omlish import typedvalues as tv
+
+from ..... import minichain as mc
+
+
+##
+
+
+class ChatDriverId(tv.UniqueScalarTypedValue[uuid.UUID]):
+    pass
+
+
+class ChatDriverGetter(lang.Func0[ta.Awaitable['ChatDriver']]):
+    pass
+
+
+class ChatDriver(lang.Abstract):
+    async def start(self) -> None:
+        pass
+
+    async def stop(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def send_user_messages(self, next_user_chat: 'mc.UserChat') -> ta.Awaitable[None]:
+        raise NotImplementedError

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

@@ -12,6 +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
-    use_readline: bool | ta.Literal['auto'] = 'auto'

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

@@ -0,0 +1,41 @@
+from omlish import check
+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 types 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(check.not_none(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(cdg: '_driver.ChatDriverGetter') -> None:
+            await (await cdg()).send_user_messages([mc.UserMessage(check.not_none(cfg.initial_user_content))])
+
+        els.append(phase_callbacks().bind_item(to_fn=inj.KwargsTarget.of(
+            lambda cdg: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cdg)),
+            cdg=_driver.ChatDriverGetter,
+        )))
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/facades/commands/base.py

@@ -0,0 +1,83 @@
+import abc
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish.argparse import all as argparse
+
+
+##
+
+
+class CommandError(Exception):
+    pass
+
+
+@dc.dataclass()
+class ArgsCommandError(CommandError):
+    command: 'Command'
+    argv: ta.Sequence[str]
+    help: str
+
+    arg_error: argparse.ArgumentError | None = None
+
+
+##
+
+
+class Command(lang.Abstract):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.__parser: argparse.ArgumentParser = argparse.NoExitArgumentParser(
+            prog=self.name,
+            description=self.description,
+            formatter_class=self._HelpFormatter,
+        )
+        self._configure_parser(self.__parser)
+
+    #
+
+    @property
+    def name(self) -> str:
+        return lang.camel_to_snake(type(self).__name__.removesuffix('Command'))
+
+    @property
+    def description(self) -> str | None:
+        return None
+
+    class _HelpFormatter(argparse.HelpFormatter):
+        def start_section(self, heading):
+            return super().start_section(heading.title())
+
+        def add_usage(self, usage, actions, groups, prefix=None):
+            if prefix is None:
+                prefix = 'Usage: '
+            return super().add_usage(usage, actions, groups, prefix)
+
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        pass
+
+    #
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Context:
+        print: ta.Callable[[str], ta.Awaitable[None]]
+
+    @ta.final
+    async def run(self, ctx: Context, argv: list[str]) -> None:
+        try:
+            args = self.__parser.parse_args(argv)
+        except argparse.ArgumentError as ae:
+            raise ArgsCommandError(
+                self,
+                argv,
+                self.__parser.format_help(),
+                ae,
+            ) from ae
+
+        await self._run_args(ctx, args)
+
+    @abc.abstractmethod
+    def _run_args(self, ctx: Context, args: argparse.Namespace) -> ta.Awaitable[None]:
+        raise NotImplementedError

ommlds/cli/sessions/chat/facades/commands/configs.py

@@ -0,0 +1,9 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CommandsConfig:
+    pass

ommlds/cli/sessions/chat/facades/commands/inject.py

@@ -0,0 +1,41 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .configs import CommandsConfig
+from .injection import commands
+
+
+with lang.auto_proxy_import(globals()):
+    from . import manager as _manager
+    from . import simple as _simple
+
+
+##
+
+
+def bind_commands(cfg: CommandsConfig = CommandsConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(commands().bind_items_provider(singleton=True))
+
+    #
+
+    els.extend([
+        inj.bind(_manager.CommandsManager, singleton=True),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_simple.EchoCommand, singleton=True),
+        commands().bind_item(to_key=_simple.EchoCommand),
+
+        inj.bind(_simple.QuitCommand, singleton=True),
+        commands().bind_item(to_key=_simple.QuitCommand),
+    ])
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/facades/commands/injection.py

@@ -0,0 +1,15 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import base as _base
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def commands() -> 'inj.ItemsBinderHelper[_base.Command]':
+    return inj.items_binder_helper[_base.Command](_types.Commands)

ommlds/cli/sessions/chat/facades/commands/manager.py

@@ -0,0 +1,59 @@
+import enum
+import shlex
+
+from omlish import collections as col
+
+from ..ui import UiMessageDisplayer
+from .base import Command
+from .types import Commands
+
+
+##
+
+
+class RunCommandResult(enum.StrEnum):
+    SUCCESS = 'success'
+    FAILURE = 'failure'
+
+
+class CommandsManager:
+    def __init__(
+            self,
+            *,
+            commands: Commands,
+            ui_message_displayer: UiMessageDisplayer,
+    ) -> None:
+        super().__init__()
+
+        self._commands = commands
+        self._ui_message_displayer = ui_message_displayer
+
+        self._commands_by_name = col.make_map((
+            (c.name, c) for c in commands
+        ), strict=True)
+
+    async def run_command_text(self, text: str) -> RunCommandResult:
+        try:
+            parts = shlex.split(text)
+        except ValueError as e:
+            await self._ui_message_displayer.display_ui_message(f'Invalid command syntax: {e}')
+            return RunCommandResult.FAILURE
+
+        if not parts:
+            return RunCommandResult.FAILURE
+
+        cmd = parts[0].lstrip('/').lower()
+        argv = parts[1:]
+
+        command = self._commands_by_name.get(cmd)
+        if not command:
+            await self._ui_message_displayer.display_ui_message(f'Unknown command: {cmd}')
+            return RunCommandResult.FAILURE
+
+        ctx = Command.Context(
+            print=self._ui_message_displayer.display_ui_message,
+        )
+
+        await command.run(ctx, argv)
+
+        return RunCommandResult.SUCCESS

ommlds/cli/sessions/chat/facades/commands/simple.py

@@ -0,0 +1,34 @@
+from omlish.argparse import all as argparse
+
+from ..ui import UiQuitSignal
+from .base import Command
+
+
+##
+
+
+class EchoCommand(Command):
+    def _configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        super()._configure_parser(parser)
+
+        parser.add_argument('message', help='Message to echo')
+
+    async def _run_args(self, ctx: Command.Context, args: argparse.Namespace) -> None:
+        await ctx.print(args.message)
+
+
+##
+
+
+class QuitCommand(Command):
+    def __init__(
+            self,
+            *,
+            quit_signal: UiQuitSignal,
+    ) -> None:
+        super().__init__()
+
+        self._quit_signal = quit_signal
+
+    async def _run_args(self, ctx: Command.Context, args: argparse.Namespace) -> None:
+        await self._quit_signal()

ommlds/cli/sessions/chat/facades/commands/types.py

@@ -0,0 +1,13 @@
+import typing as ta
+
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import base as _base
+
+
+##
+
+
+Commands = ta.NewType('Commands', ta.Sequence['_base.Command'])

ommlds/cli/sessions/chat/facades/configs.py

@@ -0,0 +1,11 @@
+from omlish import dataclasses as dc
+
+from .commands.configs import CommandsConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FacadeConfig:
+    commands: CommandsConfig = CommandsConfig()

ommlds/cli/sessions/chat/facades/facade.py

@@ -0,0 +1,26 @@
+from ..... import minichain as mc
+from ..drivers.types import ChatDriver
+from .commands.manager import CommandsManager
+
+
+##
+
+
+class ChatFacade:
+    def __init__(
+            self,
+            *,
+            driver: ChatDriver,
+            commands: CommandsManager,
+    ) -> None:
+        super().__init__()
+
+        self._driver = driver
+        self._commands = commands
+
+    async def handle_user_input(self, text: str) -> None:
+        if text.startswith('/'):
+            await self._commands.run_command_text(text[1:])
+
+        else:
+            await self._driver.send_user_messages([mc.UserMessage(text)])