ommlds 0.0.0.dev488__py3-none-any.whl → 0.0.0.dev490__py3-none-any.whl

ommlds/cli/main.py

@@ -69,9 +69,12 @@ class ChatProfile(Profile):
     def configure_backend(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            backend=dc.replace(
-                cfg.backend,
-                backend=self._args.backend,
+            agent=dc.replace(
+                cfg.agent,
+                backend=dc.replace(
+                    cfg.agent.backend,
+                    backend=self._args.backend,
+                ),
             ),
         )
 
@@ -89,17 +92,28 @@ class ChatProfile(Profile):
             check.arg(not self._args.message)
             raise NotImplementedError
 
-        if self._args.interactive:
+        if self._args.textual:
             cfg = dc.replace(
                 cfg,
                 interface=dc.replace(
                     cfg.interface,
-                    interactive=True,
-                    use_textual=self._args.textual,
+                    use_textual=True,
+                ),
+            )
+
+        else:
+            cfg = dc.replace(
+                cfg,
+                agent=dc.replace(
+                    cfg.agent,
+                    ai=dc.replace(
+                        cfg.agent.ai,
+                        verbose=True,
+                    ),
                 ),
-                user=dc.replace(
-                    cfg.user,
-                    interactive=True,
+                interface=dc.replace(
+                    cfg.interface,
+                    interactive=self._args.interactive,
                 ),
             )
 
@@ -112,16 +126,19 @@ class ChatProfile(Profile):
     ]
 
     def configure_input(self, cfg: ChatConfig) -> ChatConfig:
-        if self._args.interactive:
+        if self._args.interactive or self._args.textual:
             check.arg(not self._args.message)
 
         elif self._args.message:
             # TODO: '-' -> stdin
             cfg = dc.replace(
                 cfg,
-                user=dc.replace(
-                    cfg.user,
-                    initial_user_content=' '.join(self._args.message),
+                agent=dc.replace(
+                    cfg.agent,
+                    user=dc.replace(
+                        cfg.agent.user,
+                        initial_user_content=' '.join(self._args.message),
+                    ),
                 ),
             )
 
@@ -140,9 +157,12 @@ class ChatProfile(Profile):
     def configure_state(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            state=dc.replace(
-                cfg.state,
-                state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+            agent=dc.replace(
+                cfg.agent,
+                state=dc.replace(
+                    cfg.agent.state,
+                    state='ephemeral' if self._args.ephemeral else 'new' if self._args.new else 'continue',
+                ),
             ),
         )
 
@@ -156,9 +176,12 @@ class ChatProfile(Profile):
     def configure_output(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                stream=bool(self._args.stream),
+            agent=dc.replace(
+                cfg.agent,
+                ai=dc.replace(
+                    cfg.agent.ai,
+                    stream=bool(self._args.stream),
+                ),
             ),
             rendering=dc.replace(
                 cfg.rendering,
@@ -178,24 +201,27 @@ class ChatProfile(Profile):
     def configure_tools(self, cfg: ChatConfig) -> ChatConfig:
         return dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                enable_tools=(
-                    self._args.enable_fs_tools or
-                    self._args.enable_todo_tools or
-                    # self._args.enable_unsafe_tools_do_not_use_lol or
-                    self._args.enable_test_weather_tool or
-                    self._args.code
+            agent=dc.replace(
+                cfg.agent,
+                ai=dc.replace(
+                    cfg.agent.ai,
+                    enable_tools=(
+                        self._args.enable_fs_tools or
+                        self._args.enable_todo_tools or
+                        # self._args.enable_unsafe_tools_do_not_use_lol or
+                        self._args.enable_test_weather_tool or
+                        self._args.code
+                    ),
+                ),
+                tools=dc.replace(
+                    cfg.agent.tools,
+                    enabled_tools={  # noqa
+                        *(cfg.agent.tools.enabled_tools or []),
+                        *(['fs'] if self._args.enable_fs_tools else []),
+                        *(['todo'] if self._args.enable_todo_tools else []),
+                        *(['weather'] if self._args.enable_test_weather_tool else []),
+                    },
                 ),
-            ),
-            tools=dc.replace(
-                cfg.tools,
-                enabled_tools={  # noqa
-                    *(cfg.tools.enabled_tools or []),
-                    *(['fs'] if self._args.enable_fs_tools else []),
-                    *(['todo'] if self._args.enable_todo_tools else []),
-                    *(['weather'] if self._args.enable_test_weather_tool else []),
-                },
             ),
         )
 
@@ -211,9 +237,12 @@ class ChatProfile(Profile):
 
         cfg = dc.replace(
             cfg,
-            ai=dc.replace(
-                cfg.ai,
-                enable_tools=True,
+            agent=dc.replace(
+                cfg.agent,
+                ai=dc.replace(
+                    cfg.agent.ai,
+                    enable_tools=True,
+                ),
             ),
         )
 
@@ -223,9 +252,12 @@ class ChatProfile(Profile):
 
             cfg = dc.replace(
                 cfg,
-                user=dc.replace(
-                    cfg.user,
-                    initial_system_content=system_content,
+                agent=dc.replace(
+                    cfg.agent,
+                    user=dc.replace(
+                        cfg.agent.user,
+                        initial_system_content=system_content,
+                    ),
                 ),
             )
 

ommlds/cli/sessions/chat/agents/agent.py

@@ -0,0 +1,49 @@
+"""
+TODO:
+ - lifecycles
+ - StreamService
+"""
+from ..... import minichain as mc
+from .ai.types import AiChatGenerator
+from .events.manager import ChatEventsManager
+from .events.types import UserMessagesChatEvent
+from .phases.manager import ChatPhaseManager
+from .phases.types import ChatPhase
+from .state.types import ChatStateManager
+
+
+##
+
+
+class ChatAgent:
+    def __init__(
+            self,
+            *,
+            phases: ChatPhaseManager,
+            ai_chat_generator: AiChatGenerator,
+            chat_state_manager: ChatStateManager,
+            events: ChatEventsManager,
+    ) -> None:
+        super().__init__()
+
+        self._phases = phases
+        self._ai_chat_generator = ai_chat_generator
+        self._chat_state_manager = chat_state_manager
+        self._events = events
+
+    async def start(self) -> None:
+        await self._phases.set_phase(ChatPhase.STARTING)
+        await self._phases.set_phase(ChatPhase.STARTED)
+
+    async def stop(self) -> None:
+        await self._phases.set_phase(ChatPhase.STOPPING)
+        await self._phases.set_phase(ChatPhase.STOPPED)
+
+    async def send_user_messages(self, next_user_chat: 'mc.UserChat') -> None:
+        await self._events.emit_event(UserMessagesChatEvent(next_user_chat))
+
+        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])

ommlds/cli/sessions/chat/{chat → agents}/ai/configs.py

@@ -7,5 +7,7 @@ from omlish import dataclasses as dc
 @dc.dataclass(frozen=True, kw_only=True)
 class AiConfig:
     stream: bool = False
-    silent: bool = False
+
+    verbose: bool = False
+
     enable_tools: bool = False

ommlds/cli/sessions/chat/agents/ai/events.py

@@ -0,0 +1,57 @@
+import typing as ta
+
+from ...... import minichain as mc
+from ..events.manager import ChatEventsManager
+from ..events.types import AiDeltaChatEvent
+from ..events.types import AiMessagesChatEvent
+from .types import AiChatGenerator
+from .types import StreamAiChatGenerator
+
+
+##
+
+
+class EventEmittingAiChatGenerator(AiChatGenerator):
+    def __init__(
+            self,
+            *,
+            wrapped: AiChatGenerator,
+            events: ChatEventsManager,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._events = events
+
+    async def get_next_ai_messages(self, chat: 'mc.Chat') -> 'mc.Chat':
+        out = await self._wrapped.get_next_ai_messages(chat)
+
+        await self._events.emit_event(AiMessagesChatEvent(out))
+
+        return out
+
+
+class EventEmittingStreamAiChatGenerator(StreamAiChatGenerator):
+    def __init__(
+            self,
+            *,
+            wrapped: StreamAiChatGenerator,
+            events: ChatEventsManager,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._events = events
+
+    async def get_next_ai_messages_streamed(
+            self,
+            chat: 'mc.Chat',
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
+    ) -> 'mc.Chat':
+        async def inner(delta: mc.AiDelta) -> None:
+            await self._events.emit_event(AiDeltaChatEvent(delta))
+
+            if delta_callback is not None:
+                await delta_callback(delta)
+
+        return await self._wrapped.get_next_ai_messages_streamed(chat, delta_callback=inner)

ommlds/cli/sessions/chat/{chat → agents}/ai/inject.py

@@ -7,6 +7,7 @@ from .injection import chat_options_providers
 
 
 with lang.auto_proxy_import(globals()):
+    from . import events as _events
     from . import rendering as _rendering
     from . import services as _services
     from . import tools as _tools
@@ -39,9 +40,11 @@ def bind_ai(cfg: AiConfig = AiConfig()) -> inj.Elements:
 
         els.append(stream_ai_stack.push_bind(to_ctor=_services.ChatChoicesStreamServiceStreamAiChatGenerator, singleton=True))  # noqa
 
-        if not cfg.silent:
+        if cfg.verbose:
             els.append(stream_ai_stack.push_bind(to_ctor=_rendering.RenderingStreamAiChatGenerator, singleton=True))
 
+        els.append(stream_ai_stack.push_bind(to_ctor=_events.EventEmittingStreamAiChatGenerator, singleton=True))
+
         els.extend([
             inj.bind(_types.StreamAiChatGenerator, to_key=stream_ai_stack.top),
             ai_stack.push_bind(to_key=_types.StreamAiChatGenerator),
@@ -50,9 +53,11 @@ def bind_ai(cfg: AiConfig = AiConfig()) -> inj.Elements:
     else:
         els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
 
-        if not cfg.silent:
+        if cfg.verbose:
             els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
 
+        els.append(ai_stack.push_bind(to_ctor=_events.EventEmittingAiChatGenerator, singleton=True))
+
     if cfg.enable_tools:
         els.append(ai_stack.push_bind(to_ctor=_tools.ToolExecutingAiChatGenerator, singleton=True))
 

ommlds/cli/sessions/chat/{chat → agents}/ai/rendering.py

@@ -58,7 +58,7 @@ class RenderingStreamAiChatGenerator(StreamAiChatGenerator):
             self,
             chat: 'mc.Chat',
             delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
-    ) -> mc.Chat:
+    ) -> 'mc.Chat':
         async with self._renderer.create_context() as renderer:
             async def inner(delta: mc.AiDelta) -> None:
                 if isinstance(delta, mc.ContentAiDelta):

ommlds/cli/sessions/chat/{chat → agents}/ai/services.py

@@ -60,7 +60,7 @@ class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
             self,
             chat: 'mc.Chat',
             delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
-    ) -> mc.AiChat:
+    ) -> 'mc.AiChat':
         opts = self._options() if self._options is not None else []
 
         async with self._service_provider.provide_backend() as service:

ommlds/cli/sessions/chat/{chat → agents}/ai/tools.py

@@ -1,5 +1,5 @@
 from ...... import minichain as mc
-from ...tools.execution import ToolUseExecutor
+from ..tools.execution import ToolUseExecutor
 from .types import AiChatGenerator
 
 

ommlds/cli/sessions/chat/{chat → agents}/ai/types.py

@@ -26,3 +26,12 @@ class StreamAiChatGenerator(AiChatGenerator, lang.Abstract):
             delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
     ) -> ta.Awaitable['mc.Chat']:
         raise NotImplementedError
+
+
+##
+
+
+class AiChatOutput(lang.Abstract):
+    @abc.abstractmethod
+    def output_ai_chat(self, chat: 'mc.Chat') -> ta.Awaitable[None]:
+        raise NotImplementedError

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

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

ommlds/cli/sessions/chat/agents/events/inject.py

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

ommlds/cli/sessions/chat/agents/events/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 event_callbacks() -> 'inj.ItemsBinderHelper[_types.ChatEventCallback]':
+    return inj.items_binder_helper[_types.ChatEventCallback](_types.ChatEventCallbacks)

ommlds/cli/sessions/chat/agents/events/manager.py

@@ -0,0 +1,16 @@
+from .types import ChatEvent
+from .types import ChatEventCallbacks
+
+
+##
+
+
+class ChatEventsManager:
+    def __init__(self, callbacks: ChatEventCallbacks) -> None:
+        super().__init__()
+
+        self._callbacks = callbacks
+
+    async def emit_event(self, event: ChatEvent) -> None:
+        for cb in self._callbacks:
+            await cb(event)

ommlds/cli/sessions/chat/agents/events/types.py

@@ -0,0 +1,38 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ...... import minichain as mc
+
+
+##
+
+
+class ChatEvent(lang.Abstract, lang.Sealed):
+    pass
+
+
+class ChatEventCallback(lang.Func1[ChatEvent, ta.Awaitable[None]]):
+    pass
+
+
+ChatEventCallbacks = ta.NewType('ChatEventCallbacks', ta.Sequence[ChatEventCallback])
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class UserMessagesChatEvent(ChatEvent, lang.Final):
+    chat: 'mc.UserChat'
+
+
+@dc.dataclass(frozen=True)
+class AiMessagesChatEvent(ChatEvent, lang.Final):
+    chat: 'mc.Chat'
+
+
+@dc.dataclass(frozen=True)
+class AiDeltaChatEvent(ChatEvent, lang.Final):
+    delta: 'mc.AiDelta'

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

@@ -0,0 +1,62 @@
+"""
+TODO:
+ - private + expose(ChatAgent)
+"""
+from omlish import inject as inj
+from omlish import lang
+
+from ....backends.types import DefaultBackendName
+from .configs import DEFAULT_BACKEND
+from .configs import AgentConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from ....backends import inject as _backends
+    from . import agent as _agent
+    from .ai import inject as _ai
+    from .events import inject as _events
+    from .phases import inject as _phases
+    from .state import inject as _state
+    from .tools import inject as _tools
+    from .user import inject as _user
+
+
+##
+
+
+def bind_agent(cfg: AgentConfig) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.extend([
+        _backends.bind_backends(cfg.backend),
+
+        _ai.bind_ai(cfg.ai),
+
+        _events.bind_events(),
+
+        _phases.bind_phases(),
+
+        _state.bind_state(cfg.state),
+
+        _tools.bind_tools(cfg.tools),
+
+        _user.bind_user(cfg.user),
+    ])
+
+    #
+
+    els.extend([
+        inj.bind(_agent.ChatAgent, singleton=True),
+
+        inj.bind_late(_agent.ChatAgent),
+    ])
+
+    #
+
+    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/{chat → agents}/state/inject.py

@@ -1,9 +1,9 @@
 from omlish import inject as inj
 from omlish import lang
 
-from ...phases.injection import phase_callbacks
-from ...phases.types import ChatPhase
-from ...phases.types import ChatPhaseCallback
+from ..phases.injection import phase_callbacks
+from ..phases.types import ChatPhase
+from ..phases.types import ChatPhaseCallback
 from .configs import StateConfig
 
 

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

@@ -18,7 +18,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' = ()
 
 
 ##

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

@@ -9,10 +9,12 @@ 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/{tools → agents/tools}/confirmation.py

@@ -5,7 +5,7 @@ from omlish import lang
 from omlish.formats import json
 from omlish.term.confirm import confirm_action
 
-from ..... import minichain as mc
+from ...... import minichain as mc
 
 
 ##

ommlds/cli/sessions/chat/{tools → agents/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
 
 

ommlds/cli/sessions/chat/{tools → agents/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 → agents/tools}/inject.py

@@ -2,8 +2,8 @@ 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
@@ -58,7 +58,7 @@ 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.ResultRenderingToolUseExecutor, singleton=True))
 
         if cfg.dangerous_no_confirmation:
@@ -71,7 +71,11 @@ 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.append(inj.bind(
+            _confirmation.ToolExecutionConfirmation,
+            to_ctor=_confirmation.InteractiveToolExecutionConfirmation,
+            singleton=True,
+        ))
 
     #
 

ommlds/cli/sessions/chat/{tools → agents/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