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

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

@@ -0,0 +1,61 @@
+import typing as ta
+
+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
+
+
+with lang.auto_proxy_import(globals()):
+    from ..state import types as _state
+    from . import interactive as _interactive
+    from . import oneshot as _oneshot
+    from . import types as _types
+
+
+##
+
+
+def bind_user(
+        *,
+        initial_system_content: ta.Optional['mc.Content'] = None,
+        initial_user_content: ta.Optional['mc.Content'] = None,
+        interactive: bool = False,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    # FIXME: barf
+    if initial_system_content is not None:
+        async def add_initial_system_content(cm: '_state.ChatStateManager') -> None:
+            await cm.extend_chat([mc.SystemMessage(initial_system_content)])
+
+        els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
+            lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_system_content(cm)),
+        )))
+
+    if interactive:
+        if initial_user_content is not None:
+            async def add_initial_user_content(cm: '_state.ChatStateManager') -> None:
+                await cm.extend_chat([mc.UserMessage(initial_user_content)])
+
+            els.append(phase_callbacks().bind_item(to_fn=lang.typed_lambda(cm=_state.ChatStateManager)(
+                lambda cm: ChatPhaseCallback(ChatPhase.STARTED, lambda: add_initial_user_content(cm)),
+            )))
+
+            raise NotImplementedError
+
+        els.append(inj.bind(_types.UserChatInput, to_ctor=_interactive.InteractiveUserChatInput, singleton=True))
+
+    else:
+        if initial_user_content is None:
+            raise ValueError('Initial user content is required for non-interactive chat')
+
+        els.extend([
+            inj.bind(_oneshot.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(initial_user_content)]),
+            inj.bind(_types.UserChatInput, to_ctor=_oneshot.OneshotUserChatInput, singleton=True),
+        ])
+
+    return inj.as_elements(*els)

ommlds/cli/sessions/{chat2 → chat}/chat/user/interactive.py

@@ -21,7 +21,7 @@ class InteractiveUserChatInput(UserChatInput):
             string_input = lang.as_async(functools.partial(input, '> '))
         self._string_input = string_input
 
-    async def get_next_user_messages(self) -> mc.UserChat:
+    async def get_next_user_messages(self) -> 'mc.UserChat':
         try:
             s = await self._string_input()
         except EOFError:

ommlds/cli/sessions/{chat2 → chat}/chat/user/oneshot.py

@@ -19,7 +19,7 @@ class OneshotUserChatInput(UserChatInput):
 
         self._pending_chat: mc.UserChat | None = initial_chat
 
-    async def get_next_user_messages(self) -> mc.UserChat:
+    async def get_next_user_messages(self) -> 'mc.UserChat':
         ret = self._pending_chat
         self._pending_chat = None
         return ret or []

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

@@ -11,5 +11,5 @@ from ...... import minichain as mc
 
 class UserChatInput(lang.Abstract):
     @abc.abstractmethod
-    def get_next_user_messages(self) -> ta.Awaitable[mc.UserChat]:
+    def get_next_user_messages(self) -> ta.Awaitable['mc.UserChat']:
         raise NotImplementedError

ommlds/cli/sessions/{chat2 → chat}/configs.py

@@ -22,7 +22,8 @@ class ChatConfig:
 
     state: ta.Literal['new', 'continue', 'ephemeral'] = 'continue'
 
-    initial_content: mc.Content | None = None
+    initial_system_content: ta.Optional['mc.Content'] = None
+    initial_user_content: ta.Optional['mc.Content'] = None
     interactive: bool = False
 
     silent: bool = False
@@ -30,4 +31,6 @@ class ChatConfig:
 
     stream: bool = False
 
+    enable_tools: bool = False
+    enabled_tools: ta.AbstractSet[str] | None = None
     dangerous_no_tool_confirmation: bool = False

ommlds/cli/sessions/{chat2 → chat}/content/messages.py

@@ -1,4 +1,5 @@
 import abc
+import typing as ta
 
 from omlish import check
 from omlish import lang
@@ -11,18 +12,21 @@ from ..... import minichain as mc
 
 class MessageContentExtractor(lang.Abstract):
     @abc.abstractmethod
-    def extract_message_content(self, message: mc.Message) -> mc.Content | None:
+    def extract_message_content(self, message: 'mc.Message') -> ta.Optional['mc.Content']:
         raise NotImplementedError
 
 
 class MessageContentExtractorImpl(MessageContentExtractor):
-    def extract_message_content(self, message: mc.Message) -> mc.Content | None:
+    def extract_message_content(self, message: 'mc.Message') -> ta.Optional['mc.Content']:
         if isinstance(message, (mc.SystemMessage, mc.UserMessage, mc.AiMessage)):
             if message.c is not None:
                 return check.isinstance(message.c, str)
             else:
                 return None
 
+        elif isinstance(message, mc.ToolUseMessage):
+            return None
+
         elif isinstance(message, mc.ToolUseResultMessage):
             return check.isinstance(message.tur.c, str)
 

ommlds/cli/sessions/{chat2 → chat}/content/strings.py

@@ -12,12 +12,12 @@ from ..... import minichain as mc
 
 class ContentStringifier(lang.Abstract):
     @abc.abstractmethod
-    def stringify_content(self, content: mc.Content) -> str | None:
+    def stringify_content(self, content: 'mc.Content') -> str | None:
         raise NotImplementedError
 
 
 class ContentStringifierImpl(ContentStringifier):
-    def stringify_content(self, content: mc.Content) -> str | None:
+    def stringify_content(self, content: 'mc.Content') -> str | None:
         if isinstance(content, str):
             return content
 

ommlds/cli/sessions/{chat2 → chat}/driver.py

@@ -1,8 +1,8 @@
 from .chat.ai.types import AiChatGenerator
 from .chat.state.types import ChatStateManager
 from .chat.user.types import UserChatInput
-from .phases import ChatPhase
-from .phases import ChatPhaseManager
+from .phases.manager import ChatPhaseManager
+from .phases.types import ChatPhase
 
 
 ##

ommlds/cli/sessions/chat/inject.py

@@ -1,96 +1,70 @@
-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 ToolExecutionConfirmation
-from .tools import ToolUseExecutor
-from .tools import ToolUseExecutorImpl
-
-
-##
-
+from .configs import DEFAULT_CHAT_MODEL_BACKEND
+from .configs import ChatConfig
 
-@dc.dataclass(frozen=True, eq=False)
-class _InjectedChatOptions:
-    v: ChatOptions
 
-
-def bind_chat_options(*cos: ChatOption) -> inj.Elements:
-    return inj.bind_set_entry_const(ta.AbstractSet[_InjectedChatOptions], _InjectedChatOptions(ChatOptions(cos)))
+with lang.auto_proxy_import(globals()):
+    from . import driver as _driver
+    from .backends import inject as _backends
+    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 .rendering import inject as _rendering
+    from .tools import inject as _tools
 
 
 ##
 
 
-def bind_chat_session(cfg: ChatSession.Config) -> inj.Elements:
+def bind_chat(cfg: ChatConfig) -> inj.Elements:
     els: list[inj.Elemental] = []
 
     #
 
     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,
+        _backends.bind_backends(
+            backend=cfg.backend or DEFAULT_CHAT_MODEL_BACKEND,
         ),
-    ])
 
-    #
+        _chat_ai.bind_ai(
+            stream=cfg.stream,
+            silent=cfg.silent,
+            enable_tools=cfg.enable_tools,
+        ),
 
-    els.extend([
-        inj.bind(StateStorageChatStateManager, singleton=True),
-        inj.bind(ChatStateManager, to_key=StateStorageChatStateManager),
-    ])
+        _chat_user.bind_user(
+            initial_system_content=cfg.initial_system_content,
+            initial_user_content=cfg.initial_user_content,
+            interactive=cfg.interactive,
+        ),
 
-    #
+        _chat_state.bind_state(
+            state=cfg.state,
+        ),
+
+        _phases.bind_phases(),
 
-    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),
-        ])
+        _rendering.bind_rendering(
+            markdown=cfg.markdown,
+        ),
+    ])
 
     #
 
-    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),
-        ])
+    if cfg.enable_tools:
+        els.append(_tools.bind_tools(
+            silent=cfg.silent,
+            dangerous_no_confirmation=cfg.dangerous_no_tool_confirmation,
+            enabled_tools=cfg.enabled_tools,
+        ))
 
     #
 
     els.extend([
-        inj.bind(ToolUseExecutorImpl, singleton=True),
-        inj.bind(ToolUseExecutor, to_key=ToolUseExecutorImpl),
+        inj.bind(_driver.ChatDriver, singleton=True),
     ])
 
     #

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/{chat2/phases.py → chat/phases/manager.py}

@@ -1,34 +1,8 @@
-import enum
-import typing as ta
-
 from omlish import check
 from omlish import collections as col
-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])
+from .types import ChatPhase
+from .types import ChatPhaseCallbacks
 
 
 ##

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

@@ -0,0 +1,32 @@
+from omlish import inject as inj
+from omlish import lang
+
+
+with lang.auto_proxy_import(globals()):
+    from . import markdown as _markdown
+    from . import raw as _raw
+    from . import types as _types
+
+
+##
+
+
+def bind_rendering(
+        *,
+        markdown: bool = False,
+) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if markdown:
+        els.extend([
+            inj.bind(_types.ContentRendering, to_ctor=_markdown.MarkdownContentRendering, singleton=True),
+            inj.bind(_types.StreamContentRendering, to_ctor=_markdown.MarkdownStreamContentRendering, singleton=True),
+        ])
+
+    else:
+        els.extend([
+            inj.bind(_types.ContentRendering, to_ctor=_raw.RawContentRendering, singleton=True),
+            inj.bind(_types.StreamContentRendering, to_ctor=_raw.RawStreamContentRendering, singleton=True),
+        ])
+
+    return inj.as_elements(*els)

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

@@ -21,7 +21,7 @@ class MarkdownContentRendering(ContentRendering, HasContentStringifier):
     ) -> None:
         super().__init__(content_stringifier=content_stringifier)
 
-    async def render_content(self, content: mc.Content) -> None:
+    async def render_content(self, content: 'mc.Content') -> None:
         if (s := self._content_stringifier.stringify_content(content)) is not None and (s := s.strip()):
             rich.Console().print(rich.Markdown(s))
 
@@ -44,7 +44,7 @@ class MarkdownStreamContentRendering(StreamContentRendering, HasContentStringifi
         async def _async_enter_contexts(self) -> None:
             self._ir = self._enter_context(rich.IncrementalMarkdownLiveStream())
 
-        async def render_content(self, content: mc.Content) -> None:
+        async def render_content(self, content: 'mc.Content') -> None:
             if (s := self._owner._content_stringifier.stringify_content(content)) is not None:  # noqa: SLF001
                 self._ir.feed(s)
 

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

@@ -25,12 +25,12 @@ class RawContentRendering(ContentRendering, HasContentStringifier):
             printer = lang.as_async(print)
         self._printer = printer
 
-    async def render_content(self, content: mc.Content) -> None:
+    async def render_content(self, content: 'mc.Content') -> None:
         if (s := self._content_stringifier.stringify_content(content)) is not None:
             await self._printer(s)
 
 
-class RawContentStreamRendering(StreamContentRendering, HasContentStringifier):
+class RawStreamContentRendering(StreamContentRendering, HasContentStringifier):
     class Output(ta.Protocol):
         def write(self, s: str) -> ta.Awaitable[None]: ...
         def flush(self) -> ta.Awaitable[None]: ...
@@ -51,12 +51,12 @@ class RawContentStreamRendering(StreamContentRendering, HasContentStringifier):
         super().__init__(content_stringifier=content_stringifier)
 
         if output is None:
-            output = RawContentStreamRendering.PrintOutput()
+            output = RawStreamContentRendering.PrintOutput()
         self._output = output
 
     @ta.final
     class _ContextInstance(ContentRendering, ta.AsyncContextManager):
-        def __init__(self, owner: 'RawContentStreamRendering') -> None:
+        def __init__(self, owner: 'RawStreamContentRendering') -> None:
             self._owner = owner
 
         async def __aenter__(self) -> ta.Self:
@@ -65,9 +65,9 @@ class RawContentStreamRendering(StreamContentRendering, HasContentStringifier):
         async def __aexit__(self, *exc_info) -> None:
             await self._owner._output.flush()  # noqa: SLF001
 
-        async def render_content(self, content: mc.Content) -> None:
+        async def render_content(self, content: 'mc.Content') -> None:
             if (s := self._owner._content_stringifier.stringify_content(content)) is not None:  # noqa: SLF001
                 await self._owner._output.write(s)  # noqa: SLF001
 
     def create_context(self) -> ta.AsyncContextManager[ContentRendering]:
-        return RawContentStreamRendering._ContextInstance(self)
+        return RawStreamContentRendering._ContextInstance(self)

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

@@ -11,7 +11,7 @@ from ..... import minichain as mc
 
 class ContentRendering(lang.Abstract):
     @abc.abstractmethod
-    def render_content(self, content: mc.Content) -> ta.Awaitable[None]:
+    def render_content(self, content: 'mc.Content') -> ta.Awaitable[None]:
         raise NotImplementedError
 
 

ommlds/cli/sessions/{chat2 → chat}/session.py

@@ -8,7 +8,7 @@ from .driver import ChatDriver
 ##
 
 
-class Chat2Session(Session['Chat2Session.Config']):
+class ChatSession(Session['ChatSession.Config']):
     @dc.dataclass(frozen=True)
     class Config(Session.Config, ChatConfig):
         pass

ommlds/cli/sessions/{chat2 → chat}/tools/confirmation.py

@@ -19,8 +19,8 @@ class ToolExecutionConfirmation(lang.Abstract):
     @abc.abstractmethod
     def confirm_tool_execution_or_raise(
             self,
-            use: mc.ToolUse,
-            entry: mc.ToolCatalogEntry,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
     ) -> ta.Awaitable[None]:
         raise NotImplementedError
 
@@ -31,8 +31,8 @@ class ToolExecutionConfirmation(lang.Abstract):
 class InteractiveToolExecutionConfirmation(ToolExecutionConfirmation):
     async def confirm_tool_execution_or_raise(
             self,
-            use: mc.ToolUse,
-            entry: mc.ToolCatalogEntry,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
     ) -> None:
         tr_dct = dict(
             id=use.id,

ommlds/cli/sessions/{chat2 → chat}/tools/execution.py

@@ -11,13 +11,23 @@ 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,
+            use: 'mc.ToolUse',
             *ctx_items: ta.Any,
-    ) -> ta.Awaitable[mc.ToolUseResultMessage]:
+    ) -> ta.Awaitable['mc.ToolUseResultMessage']:
         raise NotImplementedError
 
 
@@ -25,19 +35,21 @@ class ToolUseExecutorImpl(ToolUseExecutor):
     def __init__(
             self,
             *,
-            catalog: mc.ToolCatalog,
+            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,
+            use: 'mc.ToolUse',
             *ctx_items: ta.Any,
-    ) -> mc.ToolUseResultMessage:
+    ) -> 'mc.ToolUseResultMessage':
         tce = self._catalog.by_name[check.non_empty_str(use.name)]
 
         if self._confirmation is not None:
@@ -46,6 +58,7 @@ class ToolUseExecutorImpl(ToolUseExecutor):
         return await mc.execute_tool_use(
             mc.ToolContext(
                 use,
+                *self._ctx_provider(),
                 *ctx_items,
             ),
             tce.executor(),