ommlds 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev480__py3-none-any.whl

ommlds/cli/rendering/types.py

@@ -0,0 +1,21 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ... import minichain as mc
+
+
+##
+
+
+class ContentRendering(lang.Abstract):
+    @abc.abstractmethod
+    def render_content(self, content: 'mc.Content') -> ta.Awaitable[None]:
+        raise NotImplementedError
+
+
+class StreamContentRendering(lang.Abstract):
+    @abc.abstractmethod
+    def create_context(self) -> ta.AsyncContextManager[ContentRendering]:
+        raise NotImplementedError

ommlds/cli/secrets.py

@@ -0,0 +1,21 @@
+import os
+
+from omdev.home.secrets import load_secrets
+
+
+##
+
+
+def install_secrets() -> None:
+    # FIXME: lol garbage
+    for key in [
+        'ANTHROPIC_API_KEY',
+        'GEMINI_API_KEY',
+        'GROQ_API_KEY',
+        'HUGGINGFACE_TOKEN',
+        'MISTRAL_API_KEY',
+        'OPENAI_API_KEY',
+        'TAVILY_API_KEY',
+    ]:
+        if (sec := load_secrets().try_get(key.lower())) is not None:
+            os.environ[key] = sec.reveal()

ommlds/cli/sessions/base.py

@@ -1,7 +1,7 @@
 import abc
-import dataclasses as dc
 import typing as ta
 
+from omlish import dataclasses as dc
 from omlish import lang
 from omlish.configs import all as cfgs
 

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

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

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

@@ -0,0 +1,74 @@
+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 rendering as _rendering
+    from . import services as _services
+    from . import tools as _tools
+    from . import types as _types
+
+
+##
+
+
+def bind_ai(cfg: AiConfig = AiConfig()) -> 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 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 cfg.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 cfg.silent:
+            els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, 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 cfg.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/chat/chat/ai/rendering.py

@@ -0,0 +1,70 @@
+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 .types import AiChatGenerator
+from .types import StreamAiChatGenerator
+
+
+##
+
+
+class RenderingAiChatGenerator(AiChatGenerator):
+    def __init__(
+            self,
+            *,
+            wrapped: AiChatGenerator,
+            extractor: MessageContentExtractor | None = None,
+            renderer: ContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        if extractor is None:
+            extractor = MessageContentExtractorImpl()
+        self._extractor = extractor
+        self._renderer = renderer
+
+    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:
+            if (c := self._extractor.extract_message_content(msg)) is not None:
+                await self._renderer.render_content(c)
+
+        return out
+
+
+class RenderingStreamAiChatGenerator(StreamAiChatGenerator):
+    def __init__(
+            self,
+            *,
+            wrapped: StreamAiChatGenerator,
+            extractor: MessageContentExtractor | None = None,
+            renderer: StreamContentRendering,
+    ) -> None:
+        super().__init__()
+
+        self._wrapped = wrapped
+        if extractor is None:
+            extractor = MessageContentExtractorImpl()
+        self._extractor = extractor
+        self._renderer = renderer
+
+    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 with self._renderer.create_context() as renderer:
+            async def inner(delta: mc.AiDelta) -> None:
+                if isinstance(delta, mc.ContentAiDelta):
+                    await renderer.render_content(delta.c)
+
+                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/ai/services.py

@@ -0,0 +1,79 @@
+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.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.AiChoicesDeltaJoiner()
+
+            async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).v as st_resp:
+                async for o in st_resp:
+                    joiner.add(o.choices)
+
+                    choice = check.single(o.choices)
+
+                    for delta in choice.deltas:
+                        if delta_callback is not None:
+                            await delta_callback(delta)
+
+        return check.single(joiner.build())

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/chat/chat/ai/types.py

@@ -0,0 +1,28 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ...... import minichain as mc
+
+
+##
+
+
+class AiChatGenerator(lang.Abstract):
+    @abc.abstractmethod
+    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.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.AiDelta'], ta.Awaitable[None]] | None = None,
+    ) -> ta.Awaitable['mc.Chat']:
+        raise NotImplementedError

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

@@ -0,0 +1,11 @@
+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'

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

@@ -0,0 +1,36 @@
+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 inmemory as _inmemory
+    from . import storage as _storage
+    from . import types as _types
+
+
+##
+
+
+def bind_state(cfg: StateConfig = StateConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    if cfg.state in ('continue', 'new'):
+        els.append(inj.bind(_types.ChatStateManager, to_ctor=_storage.StateStorageChatStateManager, singleton=True))
+
+        if cfg.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 cfg.state == 'ephemeral':
+        els.append(inj.bind(_types.ChatStateManager, to_ctor=_inmemory.InMemoryChatStateManager, singleton=True))
+
+    else:
+        raise TypeError(cfg.state)
+
+    return inj.as_elements(*els)

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

@@ -0,0 +1,33 @@
+from omlish 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,52 @@
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ...... import minichain as mc
+from .....state.storage 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 datetime
+import typing as ta
+
+from omlish import dataclasses as dc
+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/configs.py

@@ -0,0 +1,17 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+
+from ...... import minichain as mc
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class UserConfig:
+    initial_system_content: ta.Optional['mc.Content'] = None
+    initial_user_content: ta.Optional['mc.Content'] = None
+
+    interactive: bool = False
+    use_readline: bool | ta.Literal['auto'] = 'auto'

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

@@ -0,0 +1,62 @@
+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
+from .configs import UserConfig
+
+
+with lang.auto_proxy_import(globals()):
+    from .....inputs import asyncs as _inputs_asyncs
+    from .....inputs import sync as _inputs_sync
+    from ..state import types as _state
+    from . import interactive as _interactive
+    from . import oneshot as _oneshot
+    from . import types as _types
+
+
+##
+
+
+def bind_user(cfg: UserConfig = UserConfig()) -> inj.Elements:
+    els: list[inj.Elemental] = []
+
+    # FIXME: barf
+    if cfg.initial_system_content is not None:
+        async def add_initial_system_content(cm: '_state.ChatStateManager') -> None:
+            await cm.extend_chat([mc.SystemMessage(cfg.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 cfg.interactive:
+        if cfg.initial_user_content is not None:
+            async def add_initial_user_content(cm: '_state.ChatStateManager') -> None:
+                await cm.extend_chat([mc.UserMessage(cfg.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))
+
+        els.extend([
+            inj.bind(_inputs_sync.SyncStringInput, to_const=_inputs_sync.InputSyncStringInput(use_readline=cfg.use_readline)),  # noqa
+            inj.bind(_inputs_asyncs.AsyncStringInput, to_ctor=_inputs_asyncs.ThreadAsyncStringInput, singleton=True),
+        ])
+
+    else:
+        if cfg.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(cfg.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,31 @@
+import typing as ta
+
+from ...... import minichain as mc
+from .....inputs.asyncs import AsyncStringInput
+from .....inputs.asyncs import SyncAsyncStringInput
+from .....inputs.sync import InputSyncStringInput
+from .types import UserChatInput
+
+
+##
+
+
+class InteractiveUserChatInput(UserChatInput):
+    DEFAULT_STRING_INPUT: ta.ClassVar[AsyncStringInput] = SyncAsyncStringInput(InputSyncStringInput())
+
+    def __init__(
+            self,
+            string_input: AsyncStringInput | None = None,
+    ) -> None:
+        super().__init__()
+
+        if string_input is None:
+            string_input = self.DEFAULT_STRING_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)]