ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

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

@@ -1,5 +1,4 @@
-import dataclasses as dc
-
+from omlish import dataclasses as dc
 from omlish import lang
 
 from ...... import minichain as mc
@@ -21,10 +20,6 @@ class InMemoryChatStateManager(ChatStateManager):
     async def get_state(self) -> ChatState:
         return self._state
 
-    async def clear_state(self) -> ChatState:
-        self._state = ChatState()
-        return self._state
-
     async def extend_chat(self, chat_additions: 'mc.Chat') -> ChatState:
         self._state = dc.replace(
             self._state,

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

@@ -1,10 +1,11 @@
-import dataclasses as dc
-
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import lang
+from omlish import typedvalues as tv
 
 from ...... import minichain as mc
 from .....state.storage import StateStorage
+from .types import ChatId
 from .types import ChatState
 from .types import ChatStateManager
 
@@ -12,35 +13,40 @@ from .types import ChatStateManager
 ##
 
 
+class ChatStateStorageKey(tv.UniqueScalarTypedValue[str]):
+    pass
+
+
+def build_chat_storage_key(chat_id: ChatId) -> ChatStateStorageKey:
+    return ChatStateStorageKey(f'chat:{chat_id.v}')
+
+
+##
+
+
 class StateStorageChatStateManager(ChatStateManager):
     def __init__(
             self,
             *,
             storage: StateStorage,
-            key: str = 'chat',
+            key: ChatStateStorageKey,
     ) -> None:
         super().__init__()
 
         self._storage = storage
-        self._key = check.non_empty_str(key)
+        self._key = check.isinstance(key, ChatStateStorageKey)
 
         self._state: ChatState | None = None
 
     async def get_state(self) -> ChatState:
         if self._state is not None:
             return self._state
-        state: ChatState | None = await self._storage.load_state(self._key, ChatState)
+        state: ChatState | None = await self._storage.load_state(self._key.v, ChatState)
         if state is None:
             state = ChatState()
         self._state = state
         return state
 
-    async def clear_state(self) -> ChatState:
-        state = ChatState()
-        await self._storage.save_state(self._key, state, ChatState)
-        self._state = state
-        return state
-
     async def extend_chat(self, chat_additions: 'mc.Chat') -> ChatState:
         state = await self.get_state()
         state = dc.replace(
@@ -48,6 +54,6 @@ class StateStorageChatStateManager(ChatStateManager):
             chat=[*state.chat, *chat_additions],
             updated_at=lang.utcnow(),
         )
-        await self._storage.save_state(self._key, state, ChatState)
+        await self._storage.save_state(self._key.v, state, ChatState)
         self._state = state
         return state

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

@@ -1,9 +1,11 @@
 import abc
-import dataclasses as dc
 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/drivers/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:
+    enabled_tools: ta.Iterable[str] | None = None
+
+    verbose: bool = False
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ToolSetConfig(lang.Abstract):
+    pass

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

@@ -0,0 +1,83 @@
+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 errorhandling as _errorhandling
+    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))
+
+    els.append(exec_stack.push_bind(to_ctor=_errorhandling.ErrorHandlingToolUseExecutor, 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),
+    ])
+
+    #
+
+    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 → drivers/tools}/injection.py

@@ -1,14 +1,20 @@
 import typing as ta
 
+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
 
 
 with lang.auto_proxy_import(globals()):
     from . import execution as _execution
 
+
+ToolSetConfigT = ta.TypeVar('ToolSetConfigT', bound='ToolSetConfig')
+
+
 ##
 
 
@@ -23,7 +29,16 @@ 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,
+    )
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ToolSetBinder(lang.Final, ta.Generic[ToolSetConfigT]):
+    cfg_cls: type[ToolSetConfig]
+    fn: ta.Callable[[ToolSetConfigT], inj.Elements]

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/drivers/tools/todo/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 TodoToolSetConfig(ToolSetConfig, lang.Final):
+    pass

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

@@ -0,0 +1,31 @@
+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 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
+
+    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),
+    )
+
+
+##
+
+
+TODO_TOOL_SET_BINDER = ToolSetBinder(TodoToolSetConfig, bind_todo_tools)

ommlds/cli/sessions/chat/drivers/tools/weather/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 WeatherToolSetConfig(ToolSetConfig, lang.Final):
+    pass

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

@@ -0,0 +1,22 @@
+from omlish import inject as inj
+
+from ..injection import ToolSetBinder
+from ..injection import tool_catalog_entries
+from .configs import WeatherToolSetConfig
+
+
+##
+
+
+def bind_weather_tools(cfg: WeatherToolSetConfig) -> inj.Elements:
+    from .tools import WEATHER_TOOL
+
+    return inj.as_elements(
+        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
+    )
+
+
+##
+
+
+WEATHER_TOOL_SET_BINDER = ToolSetBinder(WeatherToolSetConfig, bind_weather_tools)

ommlds/cli/sessions/chat/{tools/weather.py → 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/drivers/user/configs.py

@@ -0,0 +1,14 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ...... import minichain as mc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class UserConfig:
+    initial_system_content: ta.Optional['mc.Content'] = None
+    initial_user_content: ta.Optional['mc.Content'] = None

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)