ommlds 0.0.0.dev463__py3-none-any.whl → 0.0.0.dev465__py3-none-any.whl

ommlds/.omlish-manifests.json

@@ -18,7 +18,7 @@
     "module": ".minichain.backends.impls.anthropic.chat",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/anthropic/chat.py",
-    "line": 39,
+    "line": 38,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.anthropic.chat",
@@ -63,7 +63,7 @@
     "module": ".minichain.backends.impls.anthropic.stream",
     "attr": null,
     "file": "ommlds/minichain/backends/impls/anthropic/stream.py",
-    "line": 33,
+    "line": 35,
     "value": {
       "!.minichain.registries.manifests.RegistryManifest": {
         "module": "ommlds.minichain.backends.impls.anthropic.stream",

ommlds/cli/inject.py

@@ -1,30 +1,13 @@
-import os.path
+import typing as ta
 
-from omdev.home.paths import get_home_paths
 from omlish import inject as inj
 from omlish import lang
 
 
 with lang.auto_proxy_import(globals()):
-    from . import state
-    from .backends import inject as backends_inj
-    from .sessions import base as sessions_base
-    from .sessions import inject as sessions_inj
-    from .tools import config as tools_cfg
-    from .tools import inject as tools_inj
-
-
-##
-
-
-def _provide_state_storage() -> 'state.StateStorage':
-    state_dir = os.path.join(get_home_paths().state_dir, 'minichain', 'cli')
-    if not os.path.exists(state_dir):
-        os.makedirs(state_dir, exist_ok=True)
-        os.chmod(state_dir, 0o770)  # noqa
-
-    state_file = os.path.join(state_dir, 'state.json')
-    return state.JsonFileStateStorage(state_file)
+    from .backends import inject as _backends
+    from .sessions import inject as _sessions
+    from .state import inject as _state
 
 
 ##
@@ -32,23 +15,22 @@ def _provide_state_storage() -> 'state.StateStorage':
 
 def bind_main(
         *,
-        session_cfg: 'sessions_base.Session.Config',
-        tools_config: 'tools_cfg.ToolsConfig',
+        session_cfg: ta.Any,
         enable_backend_strings: bool = False,
 ) -> inj.Elements:
-    els: list[inj.Elemental] = [
-        backends_inj.bind_backends(
-            enable_backend_strings=enable_backend_strings,
-        ),
+    els: list[inj.Elemental] = []
 
-        sessions_inj.bind_sessions(session_cfg),
+    #
 
-        tools_inj.bind_tools(tools_config),
-    ]
+    els.extend([
+        _backends.bind_backends(
+            enable_backend_strings=enable_backend_strings,
+        ),
 
-    #
+        _sessions.bind_sessions(session_cfg),
 
-    els.append(inj.bind(_provide_state_storage, singleton=True))
+        _state.bind_state(),
+    ])
 
     #
 

ommlds/cli/main.py

@@ -24,13 +24,9 @@ from omlish.subprocesses.sync import subprocesses
 from .. import minichain as mc
 from .inject import bind_main
 from .sessions.base import Session
-from .sessions.chat.code import CodeChatSession
-from .sessions.chat.interactive import InteractiveChatSession
-from .sessions.chat.prompt import PromptChatSession
-from .sessions.chat2.session import Chat2Session
-from .sessions.completion.completion import CompletionSession
-from .sessions.embedding.embedding import EmbeddingSession
-from .tools.config import ToolsConfig
+from .sessions.chat.configs import ChatConfig
+from .sessions.completion.configs import CompletionConfig
+from .sessions.embedding.configs import EmbeddingConfig
 
 
 if ta.TYPE_CHECKING:
@@ -57,6 +53,7 @@ async def _a_main(args: ta.Any = None) -> None:
     parser.add_argument('-C', '--completion', action='store_true')
 
     parser.add_argument('-n', '--new', action='store_true')
+    parser.add_argument('--ephemeral', action='store_true')
 
     parser.add_argument('-e', '--editor', action='store_true')
     parser.add_argument('-i', '--interactive', action='store_true')
@@ -67,8 +64,6 @@ async def _a_main(args: ta.Any = None) -> None:
     parser.add_argument('-E', '--embed', action='store_true')
     parser.add_argument('-j', '--image', action='store_true')
 
-    parser.add_argument('-2', '--two', action='store_true')
-
     parser.add_argument('--enable-fs-tools', action='store_true')
     parser.add_argument('--enable-todo-tools', action='store_true')
     parser.add_argument('--enable-unsafe-tools-do-not-use-lol', action='store_true')
@@ -93,6 +88,7 @@ async def _a_main(args: ta.Any = None) -> None:
     elif args.interactive:
         if args.prompt:
             raise ValueError('Must not provide prompt')
+        content = None
 
     elif args.code:
         if args.prompt:
@@ -129,77 +125,56 @@ async def _a_main(args: ta.Any = None) -> None:
 
     #
 
-    session_cfg: Session.Config
+    session_cfg: ta.Any
 
-    if args.two:
-        session_cfg = Chat2Session.Config(
-            backend=args.backend,
-            model_name=args.model_name,
-            state='ephemeral',
-            initial_content=content,  # noqa
-            # dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
-        )
-
-    elif args.interactive:
-        session_cfg = InteractiveChatSession.Config(
-            backend=args.backend,
-            model_name=args.model_name,
-            new=bool(args.new),
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
-        )
-
-    elif args.code:
-        session_cfg = CodeChatSession.Config(
-            backend=args.backend,
-            model_name=args.model_name,
-            new=bool(args.new),
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
-            initial_message=content,  # noqa
-            markdown=bool(args.markdown),
-        )
-
-    elif args.embed:
-        session_cfg = EmbeddingSession.Config(
+    if args.embed:
+        session_cfg = EmbeddingConfig(
             check.not_none(content),  # noqa
             backend=args.backend,
         )
 
     elif args.completion:
-        session_cfg = CompletionSession.Config(
+        session_cfg = CompletionConfig(
             check.not_none(content),  # noqa
             backend=args.backend,
         )
 
     else:
-        session_cfg = PromptChatSession.Config(
-            check.not_none(content),  # noqa
+        system_content: mc.Content | None = None
+        if (args.new or args.ephemeral) and args.code:
+            from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
+            system_content = CODE_AGENT_SYSTEM_PROMPT
+
+        session_cfg = ChatConfig(
             backend=args.backend,
             model_name=args.model_name,
-            new=bool(args.new),
-            stream=bool(args.stream),
+            state='ephemeral' if args.ephemeral else 'new' if args.new else 'continue',
+            initial_system_content=system_content,
+            initial_user_content=content,  # noqa
+            interactive=bool(args.interactive),
             markdown=bool(args.markdown),
+            stream=bool(args.stream),
+            enable_tools=(
+                args.enable_fs_tools or
+                args.enable_todo_tools or
+                args.enable_unsafe_tools_do_not_use_lol or
+                args.enable_test_weather_tool or
+                args.code
+            ),
+            enabled_tools={
+                *(['fs'] if args.enable_fs_tools else []),
+                *(['todo'] if args.enable_todo_tools else []),
+                *(['weather'] if args.enable_test_weather_tool else []),
+                # FIXME: enable_unsafe_tools_do_not_use_lol
+            },
             dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
         )
 
     #
 
-    tools_config = ToolsConfig(
-        enable_fs_tools=args.enable_fs_tools or args.code,
-        enable_todo_tools=args.enable_todo_tools or args.code,
-        enable_unsafe_tools_do_not_use_lol=args.enable_unsafe_tools_do_not_use_lol,
-        enable_test_weather_tool=args.enable_test_weather_tool,
-    )
-
-    #
-
     with inj.create_managed_injector(bind_main(
             session_cfg=session_cfg,
-            tools_config=tools_config,
-            enable_backend_strings=isinstance(session_cfg, (
-                Chat2Session.Config,
-                CodeChatSession.Config,
-                PromptChatSession.Config,
-            )),
+            enable_backend_strings=isinstance(session_cfg, ChatConfig),
     )) as injector:
         await injector[Session].run()
 

ommlds/cli/sessions/{chat2 → chat}/backends/catalog.py

@@ -20,7 +20,7 @@ class _CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
             self,
             *,
             name: BackendName,
-            catalog: mc.BackendCatalog,
+            catalog: 'mc.BackendCatalog',
             configs: BackendConfigs | None = None,
     ) -> None:
         super().__init__()
@@ -41,16 +41,16 @@ class _CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
 
 
 class CatalogChatChoicesServiceBackendProvider(
-    _CatalogBackendProvider[mc.ChatChoicesService],
+    _CatalogBackendProvider['mc.ChatChoicesService'],
     ChatChoicesServiceBackendProvider,
 ):
-    def provide_backend(self) -> ta.AsyncContextManager[mc.ChatChoicesService]:
+    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesService']:
         return self._provide_backend(mc.ChatChoicesService)  # type: ignore[type-abstract]
 
 
 class CatalogChatChoicesStreamServiceBackendProvider(
-    _CatalogBackendProvider[mc.ChatChoicesStreamService],
+    _CatalogBackendProvider['mc.ChatChoicesStreamService'],
     ChatChoicesStreamServiceBackendProvider,
 ):
-    def provide_backend(self) -> ta.AsyncContextManager[mc.ChatChoicesStreamService]:
+    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesStreamService']:
         return self._provide_backend(mc.ChatChoicesStreamService)  # type: ignore[type-abstract]

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

@@ -0,0 +1,37 @@
+from omlish import inject as inj
+from omlish import lang
+
+from .injection import backend_configs
+
+
+with lang.auto_proxy_import(globals()):
+    from . import catalog as _catalog
+    from . import types as _types
+
+
+##
+
+
+def bind_backends(
+        *,
+        backend: str | None = None,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(backend_configs().bind_items_provider(singleton=True))
+
+    #
+
+    if backend is not None:
+        els.append(inj.bind(_types.BackendName, to_const=backend))
+
+    els.extend([
+        inj.bind(_types.ChatChoicesServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesServiceBackendProvider, singleton=True),  # noqa
+        inj.bind(_types.ChatChoicesStreamServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesStreamServiceBackendProvider, singleton=True),  # noqa
+    ])
+
+    #
+
+    return inj.as_elements(*els)

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

@@ -0,0 +1,16 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+with lang.auto_proxy_import(globals()):
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def backend_configs() -> 'inj.ItemsBinderHelper[mc.Config]':
+    return inj.items_binder_helper[mc.Config](_types.BackendConfigs)

ommlds/cli/sessions/{chat2 → chat}/backends/types.py

@@ -13,7 +13,7 @@ ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
 
 
 BackendName = ta.NewType('BackendName', str)
-BackendConfigs = ta.NewType('BackendConfigs', ta.Sequence[mc.Config])
+BackendConfigs = ta.NewType('BackendConfigs', ta.Sequence['mc.Config'])
 
 
 ##
@@ -28,9 +28,9 @@ class BackendProvider(lang.Abstract, ta.Generic[ServiceT]):
 ##
 
 
-class ChatChoicesServiceBackendProvider(BackendProvider[mc.ChatChoicesService], lang.Abstract):
+class ChatChoicesServiceBackendProvider(BackendProvider['mc.ChatChoicesService'], lang.Abstract):
     pass
 
 
-class ChatChoicesStreamServiceBackendProvider(BackendProvider[mc.ChatChoicesStreamService], lang.Abstract):
+class ChatChoicesStreamServiceBackendProvider(BackendProvider['mc.ChatChoicesStreamService'], lang.Abstract):
     pass

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

@@ -0,0 +1,78 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ...... import minichain as mc
+from .injection import chat_options_providers
+
+
+with lang.auto_proxy_import(globals()):
+    from . import rendering as _rendering
+    from . import services as _services
+    from . import tools as _tools
+    from . import types as _types
+
+
+##
+
+
+def bind_ai(
+        *,
+        stream: bool = False,
+        silent: bool = False,
+        enable_tools: bool = False,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    #
+
+    els.append(chat_options_providers().bind_items_provider(singleton=True))
+
+    def _provide_chat_choices_options_provider(
+            ps: _services.ChatChoicesServiceOptionsProviders,
+    ) -> _services.ChatChoicesServiceOptionsProvider:
+        return _services.ChatChoicesServiceOptionsProvider(lambda: [o for p in ps for o in p()])
+
+    els.append(inj.bind(_provide_chat_choices_options_provider, singleton=True))
+
+    #
+
+    ai_stack = inj.wrapper_binder_helper(_types.AiChatGenerator)
+
+    if 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:
+            els.append(stream_ai_stack.push_bind(to_ctor=_rendering.RenderingStreamAiChatGenerator, singleton=True))
+
+        els.extend([
+            inj.bind(_types.StreamAiChatGenerator, to_key=stream_ai_stack.top),
+            ai_stack.push_bind(to_key=_types.StreamAiChatGenerator),
+        ])
+
+    else:
+        els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
+
+        if not silent:
+            els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
+
+    if 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
+            return _services.ChatChoicesServiceOptionsProvider(lambda: [
+                mc.Tool(tce.spec)
+                for tce in tc.by_name.values()
+            ])
+
+        els.append(chat_options_providers().bind_item(to_fn=_provide_tools_chat_choices_options_provider, singleton=True))  # noqa
+
+    #
+
+    return inj.as_elements(*els)

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

@@ -0,0 +1,14 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import services as _services
+
+
+##
+
+
+@lang.cached_function
+def chat_options_providers() -> 'inj.ItemsBinderHelper[_services.ChatChoicesServiceOptionsProvider]':
+    return inj.items_binder_helper[_services.ChatChoicesServiceOptionsProvider](_services.ChatChoicesServiceOptionsProviders)  # noqa

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

@@ -4,6 +4,7 @@ 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 .types import AiChatGenerator
 from .types import StreamAiChatGenerator
 
@@ -27,7 +28,7 @@ class RenderingAiChatGenerator(AiChatGenerator):
         self._extractor = extractor
         self._renderer = renderer
 
-    async def get_next_ai_messages(self, chat: mc.Chat) -> mc.AiChat:
+    async def get_next_ai_messages(self, chat: 'mc.Chat') -> 'mc.Chat':
         out = await self._wrapped.get_next_ai_messages(chat)
 
         for msg in out:
@@ -43,7 +44,7 @@ class RenderingStreamAiChatGenerator(StreamAiChatGenerator):
             *,
             wrapped: StreamAiChatGenerator,
             extractor: MessageContentExtractor | None = None,
-            renderer: ContentRendering,
+            renderer: StreamContentRendering,
     ) -> None:
         super().__init__()
 
@@ -55,13 +56,15 @@ 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.AiChat:
-        async def inner(delta: mc.AiChoiceDelta) -> None:
-            # FIXME: render lol
+            chat: 'mc.Chat',
+            delta_callback: ta.Callable[['mc.AiChoiceDelta'], 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):
+                    await renderer.render_content(delta.c)
 
-            if delta_callback is not None:
-                await delta_callback(delta)
+                if delta_callback is not None:
+                    await delta_callback(delta)
 
-        return await self._wrapped.get_next_ai_messages_streamed(chat, delta_callback=inner)
+            return await self._wrapped.get_next_ai_messages_streamed(chat, delta_callback=inner)

ommlds/cli/sessions/chat/chat/ai/services.py

@@ -0,0 +1,81 @@
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ...... import minichain as mc
+from ...backends.types import ChatChoicesServiceBackendProvider
+from ...backends.types import ChatChoicesStreamServiceBackendProvider
+from .types import AiChatGenerator
+from .types import StreamAiChatGenerator
+
+
+##
+
+
+class ChatChoicesServiceOptionsProvider(lang.Func0[ta.Sequence['mc.ChatChoicesOptions']]):
+    pass
+
+
+ChatChoicesServiceOptionsProviders = ta.NewType('ChatChoicesServiceOptionsProviders', ta.Sequence[ChatChoicesServiceOptionsProvider])  # noqa
+
+
+##
+
+
+class ChatChoicesServiceAiChatGenerator(AiChatGenerator):
+    def __init__(
+            self,
+            service_provider: ChatChoicesServiceBackendProvider,
+            *,
+            options: ChatChoicesServiceOptionsProvider | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._service_provider = service_provider
+        self._options = options
+
+    async def get_next_ai_messages(self, chat: 'mc.Chat') -> 'mc.Chat':
+        opts = self._options() if self._options is not None else []
+
+        async with self._service_provider.provide_backend() as service:
+            resp = await service.invoke(mc.ChatChoicesRequest(chat, opts))
+
+        return check.single(resp.v).ms
+
+
+class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
+    def __init__(
+            self,
+            service_provider: ChatChoicesStreamServiceBackendProvider,
+            *,
+            options: ChatChoicesServiceOptionsProvider | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._service_provider = service_provider
+        self._options = options
+
+    async def get_next_ai_messages_streamed(
+            self,
+            chat: 'mc.Chat',
+            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+    ) -> mc.AiChat:
+        opts = self._options() if self._options is not None else []
+
+        lst: list[str] = []
+
+        async with self._service_provider.provide_backend() as service:
+            async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).v as st_resp:
+                async for o in st_resp:
+                    choice = check.single(o.choices)
+
+                    for delta in choice.deltas:
+                        if delta_callback is not None:
+                            await delta_callback(delta)
+
+                    c = check.isinstance(delta, mc.ContentAiChoiceDelta).c  # noqa
+                    if c is not None:
+                        lst.append(check.isinstance(c, str))
+
+        return [mc.AiMessage(''.join(lst))]

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

@@ -0,0 +1,44 @@
+from ...... import minichain as mc
+from ...tools.execution import ToolUseExecutor
+from .types import AiChatGenerator
+
+
+##
+
+
+class ToolExecutingAiChatGenerator(AiChatGenerator):
+    def __init__(
+            self,
+            *,
+            wrapped: AiChatGenerator,
+            executor: ToolUseExecutor,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        self._executor = executor
+
+    async def get_next_ai_messages(self, chat: 'mc.Chat') -> 'mc.Chat':
+        out: list[mc.Message] = []
+
+        while True:
+            new = await self._wrapped.get_next_ai_messages([*chat, *out])
+
+            out.extend(new)
+
+            cont = False
+
+            for msg in new:
+                if isinstance(msg, mc.ToolUseMessage):
+                    trm = await self._executor.execute_tool_use(
+                        msg.tu,
+                        # fs_tool_context,
+                        # todo_tool_context,  # noqa
+                    )
+
+                    out.append(trm)
+
+                    cont = True
+
+            if not cont:
+                return out

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

@@ -11,18 +11,18 @@ from ...... import minichain as mc
 
 class AiChatGenerator(lang.Abstract):
     @abc.abstractmethod
-    def get_next_ai_messages(self, chat: mc.Chat) -> ta.Awaitable[mc.AiChat]:
+    def get_next_ai_messages(self, chat: 'mc.Chat') -> ta.Awaitable['mc.Chat']:
         raise NotImplementedError
 
 
 class StreamAiChatGenerator(AiChatGenerator, lang.Abstract):
-    def get_next_ai_messages(self, chat: mc.Chat) -> ta.Awaitable[mc.AiChat]:
+    def get_next_ai_messages(self, chat: 'mc.Chat') -> ta.Awaitable['mc.Chat']:
         return self.get_next_ai_messages_streamed(chat)
 
     @abc.abstractmethod
     def get_next_ai_messages_streamed(
             self,
-            chat: mc.Chat,
-            delta_callback: ta.Callable[[mc.AiChoiceDelta], ta.Awaitable[None]] | None = None,
-    ) -> ta.Awaitable[mc.AiChat]:
+            chat: 'mc.Chat',
+            delta_callback: ta.Callable[['mc.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+    ) -> ta.Awaitable['mc.Chat']:
         raise NotImplementedError

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

@@ -0,0 +1,40 @@
+import typing as ta
+
+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
+
+
+with lang.auto_proxy_import(globals()):
+    from . import inmemory as _inmemory
+    from . import storage as _storage
+    from . import types as _types
+
+
+##
+
+
+def bind_state(
+        *,
+        state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue',
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if state in ('continue', 'new'):
+        els.append(inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True))
+
+        if state == 'new':
+            els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_types.ChatStateManager)(
+                lambda cm: ChatPhaseCallback(ChatPhase.STARTING, cm.clear_state),
+            )))
+
+    elif state == 'ephemeral':
+        els.append(inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True))
+
+    else:
+        raise TypeError(state)
+
+    return inj.as_elements(*els)