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

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

@@ -0,0 +1,27 @@
+from omlish import dataclasses as dc
+
+from ...backends.configs import BackendConfig
+from ...rendering.configs import RenderingConfig
+from .chat.ai.configs import AiConfig
+from .chat.state.configs import StateConfig
+from .chat.user.configs import UserConfig
+from .tools.configs import ToolsConfig
+
+
+##
+
+
+DEFAULT_BACKEND = 'openai'
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatConfig:
+    backend: BackendConfig = BackendConfig()
+    ai: AiConfig = AiConfig()
+    state: StateConfig = StateConfig()
+    user: UserConfig = UserConfig()
+    rendering: RenderingConfig = RenderingConfig()
+    tools: ToolsConfig = ToolsConfig()

ommlds/cli/sessions/chat/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.manager import ChatPhaseManager
+from .phases.types import ChatPhase
+
+
+##
+
+
+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/chat/inject.py

@@ -1,97 +1,65 @@
-import typing as ta
-
 from omlish import dataclasses as dc
 from omlish import inject as inj
 from omlish import lang
 
-from .base import ChatOption
-from .base import ChatOptions
-from .base import ChatSession
-from .printing import ChatSessionPrinter
-from .printing import MarkdownStringChatSessionPrinter
-from .printing import SimpleStringChatSessionPrinter
-from .state import ChatStateManager
-from .state import StateStorageChatStateManager
-from .tools import AskingToolExecutionConfirmation
-from .tools import NopToolExecutionConfirmation
-from .tools import ToolExecRequestExecutor
-from .tools import ToolExecRequestExecutorImpl
-from .tools import ToolExecutionConfirmation
+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 .phases import inject as _phases
+    from .tools import inject as _tools
 
 
 ##
 
 
-@dc.dataclass(frozen=True, eq=False)
-class _InjectedChatOptions:
-    v: ChatOptions
+def bind_chat(cfg: ChatConfig) -> inj.Elements:
+    els: list[inj.Elemental] = []
 
+    #
 
-def bind_chat_options(*cos: ChatOption) -> inj.Elements:
-    return inj.bind_set_entry_const(ta.AbstractSet[_InjectedChatOptions], _InjectedChatOptions(ChatOptions(cos)))
+    els.extend([
+        _backends.bind_backends(cfg.backend),
 
+        _chat_ai.bind_ai(cfg.ai),
 
-##
+        _chat_user.bind_user(cfg.user),
 
+        _chat_state.bind_state(cfg.state),
 
-def bind_chat_session(cfg: ChatSession.Config) -> inj.Elements:
-    els: list[inj.Elemental] = []
+        _phases.bind_phases(),
 
-    #
+        _rendering.bind_rendering(cfg.rendering),
 
-    els.extend([
-        inj.set_binder[_InjectedChatOptions](),
-        inj.bind(
-            lang.typed_lambda(ChatOptions, s=ta.AbstractSet[_InjectedChatOptions])(
-                lambda s: ChatOptions([
-                    co
-                    for ico in s
-                    for co in ico.v
-                ]),
-            ),
-            singleton=True,
-        ),
+        _tools.bind_tools(cfg.tools),
     ])
 
     #
 
     els.extend([
-        inj.bind(StateStorageChatStateManager, singleton=True),
-        inj.bind(ChatStateManager, to_key=StateStorageChatStateManager),
+        inj.bind(_driver.ChatDriver, singleton=True),
     ])
 
     #
 
-    if cfg.markdown:
-        els.extend([
-            inj.bind(MarkdownStringChatSessionPrinter, singleton=True),
-            inj.bind(ChatSessionPrinter, to_key=MarkdownStringChatSessionPrinter),
-        ])
-    else:
-        els.extend([
-            inj.bind(SimpleStringChatSessionPrinter, singleton=True),
-            inj.bind(ChatSessionPrinter, to_key=SimpleStringChatSessionPrinter),
-        ])
-
-    #
-
-    if cfg.dangerous_no_tool_confirmation:
-        els.extend([
-            inj.bind(NopToolExecutionConfirmation, singleton=True),
-            inj.bind(ToolExecutionConfirmation, to_key=NopToolExecutionConfirmation),
-        ])
-    else:
-        els.extend([
-            inj.bind(AskingToolExecutionConfirmation, singleton=True),
-            inj.bind(ToolExecutionConfirmation, to_key=AskingToolExecutionConfirmation),
-        ])
+    els.extend([
+        inj.bind(_session.ChatSession.Config(**dc.asdict(cfg))),
+        inj.bind(Session, to_ctor=_session.ChatSession, singleton=True),
+    ])
 
     #
 
-    els.extend([
-        inj.bind(ToolExecRequestExecutorImpl, singleton=True),
-        inj.bind(ToolExecRequestExecutor, to_key=ToolExecRequestExecutorImpl),
-    ])
+    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
 
     #
 

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

@@ -0,0 +1,27 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .injection import phase_callbacks
+
+
+with lang.auto_proxy_import(globals()):
+    from . import manager as _manager
+
+
+##
+
+
+def bind_phases() -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(phase_callbacks().bind_items_provider(singleton=True))
+
+    #
+
+    els.append(inj.bind(_manager.ChatPhaseManager, singleton=True))
+
+    #
+
+    return inj.as_elements(*els)

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

@@ -0,0 +1,14 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def phase_callbacks() -> 'inj.ItemsBinderHelper[_types.ChatPhaseCallback]':
+    return inj.items_binder_helper[_types.ChatPhaseCallback](_types.ChatPhaseCallbacks)

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

@@ -0,0 +1,29 @@
+from omlish import check
+from omlish import collections as col
+
+from .types import ChatPhase
+from .types import ChatPhaseCallbacks
+
+
+##
+
+
+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/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/session.py

@@ -0,0 +1,27 @@
+from omlish 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/configs.py

@@ -0,0 +1,22 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+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
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolSetConfig(lang.Abstract):
+    pass

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/fs/configs.py

@@ -0,0 +1,12 @@
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ..configs import ToolSetConfig
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FsToolSetConfig(ToolSetConfig, lang.Final):
+    pass

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

@@ -0,0 +1,35 @@
+import os
+
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import bind_tool_context_provider_to_key
+from ..injection import tool_catalog_entries
+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
+
+    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),
+    )
+
+
+##
+
+
+FS_TOOL_SET_BINDER = ToolSetBinder(FsToolSetConfig, bind_fs_tools)

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

@@ -0,0 +1,88 @@
+from omlish import check
+from omlish import inject as inj
+from omlish import lang
+
+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
+
+
+##
+
+
+# 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(cfg: ToolsConfig = ToolsConfig()) -> 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(cfg.enabled_tools or [], str):
+        from .fs.inject import FS_TOOL_SET_BINDER
+        from .todo.inject import TODO_TOOL_SET_BINDER
+        from .weather.inject import WEATHER_TOOL_SET_BINDER
+        ts_binder: ToolSetBinder = {  # type: ignore[assignment]  # FIXME: placeholder obviously lol
+            'fs': FS_TOOL_SET_BINDER,
+            'todo': TODO_TOOL_SET_BINDER,
+            'weather': WEATHER_TOOL_SET_BINDER,
+        }[etn]
+
+        els.append(ts_binder.fn(ts_binder.cfg_cls()))
+
+    #
+
+    exec_stack = inj.wrapper_binder_helper(_execution.ToolUseExecutor)
+
+    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))
+
+        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),
+
+        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)