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

ommlds/cli/sessions/chat/configs.py

@@ -1,36 +1,19 @@
-import dataclasses as dc
-import typing as ta
+from omlish import dataclasses as dc
 
-from .... import minichain as mc
+from ...rendering.configs import RenderingConfig
+from ..configs import SessionConfig
+from .drivers.configs import DriverConfig
+from .facades.configs import FacadeConfig
+from .interfaces.bare.configs import BareInterfaceConfig
+from .interfaces.configs import InterfaceConfig
 
 
 ##
 
 
-DEFAULT_CHAT_MODEL_BACKEND = 'openai'
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class ChatConfig:
-    _: dc.KW_ONLY
-
-    backend: str | None = None
-    model_name: str | None = None
-
-    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
-
-    initial_system_content: ta.Optional['mc.Content'] = None
-    initial_user_content: ta.Optional['mc.Content'] = None
-    interactive: bool = False
-
-    silent: bool = False
-    markdown: bool = False
-
-    stream: bool = False
-
-    enable_tools: bool = False
-    enabled_tools: ta.AbstractSet[str] | None = None
-    dangerous_no_tool_confirmation: bool = False
+@dc.dataclass(frozen=True, kw_only=True)
+class ChatConfig(SessionConfig):
+    driver: DriverConfig = DriverConfig()
+    facade: FacadeConfig = FacadeConfig()
+    interface: InterfaceConfig = BareInterfaceConfig()
+    rendering: RenderingConfig = RenderingConfig()

ommlds/cli/sessions/chat/drivers/ai/configs.py

@@ -0,0 +1,13 @@
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AiConfig:
+    stream: bool = False
+
+    verbose: bool = False
+
+    enable_tools: bool = False

ommlds/cli/sessions/chat/drivers/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 → drivers}/ai/inject.py

@@ -2,10 +2,12 @@ from omlish import inject as inj
 from omlish import lang
 
 from ...... import minichain as mc
+from .configs import AiConfig
 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
@@ -15,12 +17,7 @@ with lang.auto_proxy_import(globals()):
 ##
 
 
-def bind_ai(
-        *,
-        stream: bool = False,
-        silent: bool = False,
-        enable_tools: bool = False,
-) -> inj.Elements:
+def bind_ai(cfg: AiConfig = AiConfig()) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
@@ -38,14 +35,16 @@ def bind_ai(
 
     ai_stack = inj.wrapper_binder_helper(_types.AiChatGenerator)
 
-    if stream:
+    if cfg.stream:
         stream_ai_stack = inj.wrapper_binder_helper(_types.StreamAiChatGenerator)
 
         els.append(stream_ai_stack.push_bind(to_ctor=_services.ChatChoicesStreamServiceStreamAiChatGenerator, singleton=True))  # noqa
 
-        if not 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),
@@ -54,18 +53,22 @@ def bind_ai(
     else:
         els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
 
-        if not silent:
+        if cfg.verbose:
             els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
 
-    if enable_tools:
+        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))
 
     els.append(inj.bind(_types.AiChatGenerator, to_key=ai_stack.top))
 
     #
 
-    if enable_tools:
-        def _provide_tools_chat_choices_options_provider(tc: mc.ToolCatalog) -> _services.ChatChoicesServiceOptionsProvider:  # noqa
+    if cfg.enable_tools:
+        def _provide_tools_chat_choices_options_provider(
+                tc: mc.ToolCatalog,
+        ) -> _services.ChatChoicesServiceOptionsProvider:
             return _services.ChatChoicesServiceOptionsProvider(lambda: [
                 mc.Tool(tce.spec)
                 for tce in tc.by_name.values()

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

@@ -1,10 +1,10 @@
 import typing as ta
 
 from ...... import minichain as mc
-from ...content.messages import MessageContentExtractor
-from ...content.messages import MessageContentExtractorImpl
-from ...rendering.types import ContentRendering
-from ...rendering.types import StreamContentRendering
+from .....content.messages import MessageContentExtractor
+from .....content.messages import MessageContentExtractorImpl
+from .....rendering.types import ContentRendering
+from .....rendering.types import StreamContentRendering
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 
@@ -57,11 +57,11 @@ class RenderingStreamAiChatGenerator(StreamAiChatGenerator):
     async def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
-    ) -> mc.Chat:
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
+    ) -> 'mc.Chat':
         async with self._renderer.create_context() as renderer:
-            async def inner(delta: mc.AiChoiceDelta) -> None:
-                if isinstance(delta, mc.ContentAiChoiceDelta):
+            async def inner(delta: mc.AiDelta) -> None:
+                if isinstance(delta, mc.ContentAiDelta):
                     await renderer.render_content(delta.c)
 
                 if delta_callback is not None:

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

@@ -4,8 +4,8 @@ from omlish import check
 from omlish import lang
 
 from ...... import minichain as mc
-from ...backends.types import ChatChoicesServiceBackendProvider
-from ...backends.types import ChatChoicesStreamServiceBackendProvider
+from .....backends.types import ChatChoicesServiceBackendProvider
+from .....backends.types import ChatChoicesStreamServiceBackendProvider
 from .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 
@@ -59,12 +59,12 @@ class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
     async def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
-    ) -> mc.AiChat:
+            delta_callback: ta.Callable[['mc.AiDelta'], ta.Awaitable[None]] | None = None,
+    ) -> 'mc.AiChat':
         opts = self._options() if self._options is not None else []
 
         async with self._service_provider.provide_backend() as service:
-            joiner = mc.AiChoiceDeltaJoiner()
+            joiner = mc.AiChoicesDeltaJoiner()
 
             async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).v as st_resp:
                 async for o in st_resp:

ommlds/cli/sessions/chat/{chat → drivers}/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
 
 
@@ -24,17 +24,13 @@ class ToolExecutingAiChatGenerator(AiChatGenerator):
         while True:
             new = await self._wrapped.get_next_ai_messages([*chat, *out])
 
-            out.extend(new)
-
             cont = False
 
             for msg in new:
+                out.append(msg)
+
                 if isinstance(msg, mc.ToolUseMessage):
-                    trm = await self._executor.execute_tool_use(
-                        msg.tu,
-                        # fs_tool_context,
-                        # todo_tool_context,  # noqa
-                    )
+                    trm = await self._executor.execute_tool_use(msg.tu)
 
                     out.append(trm)
 

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

@@ -23,6 +23,15 @@ class StreamAiChatGenerator(AiChatGenerator, lang.Abstract):
     def get_next_ai_messages_streamed(
             self,
             chat: 'mc.Chat',
-            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+            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/drivers/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 DriverConfig:
+    ai: AiConfig = AiConfig()
+    backend: BackendConfig = BackendConfig()
+    state: StateConfig = StateConfig()
+    tools: ToolsConfig = ToolsConfig()
+    user: UserConfig = UserConfig()

ommlds/cli/sessions/chat/drivers/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/drivers/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/drivers/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/drivers/events/types.py

@@ -0,0 +1,44 @@
+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'
+
+
+@dc.dataclass(frozen=True)
+class ErrorChatEvent(ChatEvent, lang.Final):
+    message: str | None = None
+    error: BaseException | None = None

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

@@ -0,0 +1,50 @@
+"""
+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
+from .types import ChatDriver
+
+
+##
+
+
+class ChatDriverImpl(ChatDriver):
+    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/drivers/inject.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - private + expose(ChatDriver)
+"""
+import uuid
+
+from omlish import inject as inj
+from omlish import lang
+
+from ....backends.types import DefaultBackendName
+from .configs import DEFAULT_BACKEND
+from .configs import DriverConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from ....backends import inject as _backends
+    from . import impl as _impl
+    from . import types as _types
+    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_driver(cfg: DriverConfig = DriverConfig()) -> 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(_impl.ChatDriverImpl, singleton=True),
+        inj.bind(_types.ChatDriver, to_key=_impl.ChatDriverImpl),
+
+        inj.bind_async_late(_types.ChatDriver, _types.ChatDriverGetter),
+    ])
+
+    #
+
+    els.append(inj.bind(DefaultBackendName, to_const=DEFAULT_BACKEND))
+
+    #
+
+    els.append(inj.bind(_types.ChatDriverId(uuid.uuid4())))
+
+    #
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/chat/drivers/state/configs.py

@@ -0,0 +1,13 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class StateConfig:
+    state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
+
+    chat_id: str | None = None

ommlds/cli/sessions/chat/drivers/state/ids.py

@@ -0,0 +1,25 @@
+from .storage import StateStorage
+from .types import ChatId
+
+
+##
+
+
+_LAST_CHAT_ID_STATE_KEY: str = 'last_chat_id'
+
+
+class LastChatIdManager:
+    def __init__(
+            self,
+            *,
+            state_storage: StateStorage,
+    ) -> None:
+        super().__init__()
+
+        self._state_storage = state_storage
+
+    async def get_last_chat_id(self) -> ChatId | None:
+        return await self._state_storage.load_state(_LAST_CHAT_ID_STATE_KEY, ChatId)
+
+    async def set_last_chat_id(self, chat_id: ChatId | None) -> None:
+        await self._state_storage.save_state(_LAST_CHAT_ID_STATE_KEY, chat_id, ChatId)

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

@@ -0,0 +1,83 @@
+"""
+TODO:
+ - given chat-id + ephemeral = continue in mem
+ - fork chats
+"""
+import uuid
+
+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 .configs import StateConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from . import ids as _ids
+    from . import inmemory as _inmemory
+    from . import storage as _storage
+    from . import types as _types
+
+
+##
+
+
+def _new_chat_id() -> '_types.ChatId':
+    return _types.ChatId(uuid.uuid4())
+
+
+async def _get_last_or_new_chat_id(lcim: '_ids.LastChatIdManager') -> '_types.ChatId':
+    return lcid if (lcid := await lcim.get_last_chat_id()) is not None else _new_chat_id()
+
+
+##
+
+
+def bind_state(cfg: StateConfig = StateConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if cfg.state in ('continue', 'new'):
+        if cfg.state == 'new':
+            els.append(inj.bind(_types.ChatId(uuid.UUID(cfg.chat_id)) if cfg.chat_id is not None else _new_chat_id()))
+
+        elif cfg.chat_id is not None:
+            els.append(inj.bind(_types.ChatId(uuid.UUID(cfg.chat_id))))
+
+        else:
+            els.append(inj.bind(_types.ChatId, to_async_fn=_get_last_or_new_chat_id, singleton=True))
+
+        els.extend([
+            inj.bind(_storage.build_chat_storage_key),
+
+            inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True),
+        ])
+
+        #
+
+        els.extend([
+            inj.bind(_ids.LastChatIdManager, singleton=True),
+
+            phase_callbacks().bind_item(to_fn=inj.target(
+                lcim=_ids.LastChatIdManager,
+                cid=_types.ChatId,
+            )(lambda lcim, cid: ChatPhaseCallback(ChatPhase.STARTED, lambda: lcim.set_last_chat_id(cid)))),
+        ])
+
+    elif cfg.state == 'ephemeral':
+        if cfg.chat_id is not None:
+            raise ValueError('chat-id is not allowed for ephemeral state')
+
+        els.extend([
+            inj.bind(_new_chat_id()),
+
+            inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True),
+        ])
+
+    else:
+        raise TypeError(cfg.state)
+
+    #
+
+    return inj.as_elements(*els)