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

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)

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

@@ -0,0 +1,34 @@
+import dataclasses as dc
+
+from omlish import lang
+
+from ...... import minichain as mc
+from .types import ChatState
+from .types import ChatStateManager
+
+
+##
+
+
+class InMemoryChatStateManager(ChatStateManager):
+    def __init__(self, initial_state: ChatState | None = None) -> None:
+        super().__init__()
+
+        if initial_state is None:
+            initial_state = ChatState()
+        self._state = initial_state
+
+    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,
+            chat=[*self._state.chat, *chat_additions],
+            updated_at=lang.utcnow(),
+        )
+        return self._state

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

@@ -0,0 +1,53 @@
+import dataclasses as dc
+
+from omlish import check
+from omlish import lang
+
+from ...... import minichain as mc
+from .....state import StateStorage
+from .types import ChatState
+from .types import ChatStateManager
+
+
+##
+
+
+class StateStorageChatStateManager(ChatStateManager):
+    def __init__(
+            self,
+            *,
+            storage: StateStorage,
+            key: str = 'chat',
+    ) -> None:
+        super().__init__()
+
+        self._storage = storage
+        self._key = check.non_empty_str(key)
+
+        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)
+        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(
+            state,
+            chat=[*state.chat, *chat_additions],
+            updated_at=lang.utcnow(),
+        )
+        await self._storage.save_state(self._key, state, ChatState)
+        self._state = state
+        return state

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

@@ -0,0 +1,38 @@
+import abc
+import dataclasses as dc
+import datetime
+import typing as ta
+
+from omlish import lang
+
+from ...... import minichain as mc
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ChatState:
+    name: str | None = None
+
+    created_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
+    updated_at: datetime.datetime = dc.field(default_factory=lang.utcnow)
+
+    chat: mc.Chat = ()
+
+
+##
+
+
+class ChatStateManager(lang.Abstract):
+    @abc.abstractmethod
+    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/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/chat/chat/user/interactive.py

@@ -0,0 +1,29 @@
+import functools
+import typing as ta
+
+from omlish import lang
+
+from ...... import minichain as mc
+from .types import UserChatInput
+
+
+##
+
+
+class InteractiveUserChatInput(UserChatInput):
+    def __init__(
+            self,
+            string_input: ta.Callable[[], ta.Awaitable[str]] | None = None,
+    ) -> None:
+        super().__init__()
+
+        if string_input is None:
+            string_input = lang.as_async(functools.partial(input, '> '))
+        self._string_input = string_input
+
+    async def get_next_user_messages(self) -> 'mc.UserChat':
+        try:
+            s = await self._string_input()
+        except EOFError:
+            return []
+        return [mc.UserMessage(s)]

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

@@ -0,0 +1,25 @@
+import typing as ta
+
+from ...... import minichain as mc
+from .types import UserChatInput
+
+
+##
+
+
+OneshotUserChatInputInitialChat = ta.NewType('OneshotUserChatInputInitialChat', mc.UserChat)
+
+
+class OneshotUserChatInput(UserChatInput):
+    def __init__(
+            self,
+            initial_chat: OneshotUserChatInputInitialChat,
+    ) -> None:
+        super().__init__()
+
+        self._pending_chat: mc.UserChat | None = initial_chat
+
+    async def get_next_user_messages(self) -> 'mc.UserChat':
+        ret = self._pending_chat
+        self._pending_chat = None
+        return ret or []

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

@@ -0,0 +1,15 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ...... import minichain as mc
+
+
+##
+
+
+class UserChatInput(lang.Abstract):
+    @abc.abstractmethod
+    def get_next_user_messages(self) -> ta.Awaitable['mc.UserChat']:
+        raise NotImplementedError

ommlds/cli/sessions/chat/configs.py

@@ -0,0 +1,36 @@
+import dataclasses as dc
+import typing as ta
+
+from .... import minichain as mc
+
+
+##
+
+
+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

ommlds/cli/sessions/chat/content/messages.py

@@ -0,0 +1,34 @@
+import abc
+import typing as ta
+
+from omlish import check
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+##
+
+
+class MessageContentExtractor(lang.Abstract):
+    @abc.abstractmethod
+    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') -> 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)
+
+        else:
+            raise TypeError(message)

ommlds/cli/sessions/chat/content/strings.py

@@ -0,0 +1,42 @@
+import abc
+import typing as ta
+
+from omlish import lang
+from omlish.formats import json
+
+from ..... import minichain as mc
+
+
+##
+
+
+class ContentStringifier(lang.Abstract):
+    @abc.abstractmethod
+    def stringify_content(self, content: 'mc.Content') -> str | None:
+        raise NotImplementedError
+
+
+class ContentStringifierImpl(ContentStringifier):
+    def stringify_content(self, content: 'mc.Content') -> str | None:
+        if isinstance(content, str):
+            return content
+
+        elif isinstance(content, mc.JsonContent):
+            return json.dumps_pretty(content.v)
+
+        else:
+            raise TypeError(content)
+
+
+class HasContentStringifier(lang.Abstract):
+    def __init__(
+            self,
+            *args: ta.Any,
+            content_stringifier: ContentStringifier | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        if content_stringifier is None:
+            content_stringifier = ContentStringifierImpl()
+        self._content_stringifier = content_stringifier

ommlds/cli/sessions/chat/driver.py

@@ -0,0 +1,43 @@
+from .chat.ai.types import AiChatGenerator
+from .chat.state.types import ChatStateManager
+from .chat.user.types import UserChatInput
+from .phases.manager import ChatPhaseManager
+from .phases.types import ChatPhase
+
+
+##
+
+
+class ChatDriver:
+    def __init__(
+            self,
+            *,
+            phases: ChatPhaseManager,
+            ai_chat_generator: AiChatGenerator,
+            user_chat_input: UserChatInput,
+            chat_state_manager: ChatStateManager,
+    ):
+        super().__init__()
+
+        self._phases = phases
+        self._ai_chat_generator = ai_chat_generator
+        self._user_chat_input = user_chat_input
+        self._chat_state_manager = chat_state_manager
+
+    async def run(self) -> None:
+        await self._phases.set_phase(ChatPhase.STARTING)
+        await self._phases.set_phase(ChatPhase.STARTED)
+
+        while True:
+            next_user_chat = await self._user_chat_input.get_next_user_messages()
+            if not next_user_chat:
+                break
+
+            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])
+
+        await self._phases.set_phase(ChatPhase.STOPPING)
+        await self._phases.set_phase(ChatPhase.STOPPED)

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/chat/phases/manager.py

@@ -0,0 +1,29 @@
+from omlish import check
+from omlish import collections as col
+
+from .types import ChatPhase
+from .types import ChatPhaseCallbacks
+
+
+##
+
+
+class ChatPhaseManager:
+    def __init__(self, callbacks: ChatPhaseCallbacks) -> None:
+        super().__init__()
+
+        self._callbacks = callbacks
+        self._callbacks_by_phase = col.multi_map_by(lambda cb: cb.phase, callbacks)
+
+        check.state(not self._callbacks_by_phase.get(ChatPhase.NEW))
+
+        self._phase = ChatPhase.NEW
+
+    @property
+    def phase(self) -> ChatPhase:
+        return self._phase
+
+    async def set_phase(self, phase: ChatPhase) -> None:
+        self._phase = phase
+        for cb in self._callbacks_by_phase.get(phase, ()):
+            await cb.fn()