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

ommlds/cli/sessions/chat/prompt.py

@@ -1,161 +0,0 @@
-import dataclasses as dc
-import os
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from .base import DEFAULT_CHAT_MODEL_BACKEND
-from .base import ChatOptions
-from .base import ChatSession
-from .printing import ChatSessionPrinter
-from .printing import MarkdownStreamPrinter
-from .printing import SimpleStreamPrinter
-from .printing import StreamPrinter
-from .state import ChatStateManager
-from .tools import ToolUseExecutor
-
-
-##
-
-
-class ToolExecutionRequestDeniedError(Exception):
-    pass
-
-
-class PromptChatSession(ChatSession['PromptChatSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(ChatSession.Config):  # noqa
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        new: bool = False
-
-        backend: str | None = None
-        model_name: str | None = None
-
-        stream: bool = False
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            state_manager: ChatStateManager,
-            chat_options: ChatOptions | None = None,
-            printer: ChatSessionPrinter,
-            backend_catalog: mc.BackendCatalog,
-            tool_exec_request_executor: ToolUseExecutor,
-    ) -> None:
-        super().__init__(config)
-
-        self._state_manager = state_manager
-        self._chat_options = chat_options
-        self._printer = printer
-        self._backend_catalog = backend_catalog
-        self._tool_exec_request_executor = tool_exec_request_executor
-
-    async def run(self) -> None:
-        if self._config.stream:
-            await self._run_stream()
-        else:
-            await self._run_immediate()
-
-    async def _run_stream(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        if self._config.new:
-            state = self._state_manager.clear_state()
-        else:
-            state = self._state_manager.get_state()
-
-        new_chat: list[mc.Message] = [
-            mc.UserMessage(prompt),
-        ]
-
-        mdl: mc.ChatChoicesStreamService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.ChatChoicesStreamService,
-            self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
-            *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            async with (await mdl.invoke(mc.ChatChoicesStreamRequest(
-                    [*state.chat, *new_chat],
-                    (self._chat_options or []),
-            ))).v as st_resp:
-                lst: list[str] = []
-
-                sp_cls: type[StreamPrinter]
-                if self._config.markdown:
-                    sp_cls = MarkdownStreamPrinter
-                else:
-                    sp_cls = SimpleStreamPrinter
-                with sp_cls() as sp:
-                    async for o in st_resp:
-                        if o:
-                            c = check.isinstance(check.single(check.single(o.choices).deltas), mc.ContentAiChoiceDelta).c  # noqa
-                            if c is not None:
-                                s = check.isinstance(c, str)
-                                sp.feed(s)
-                                lst.append(s)
-
-            resp_m = mc.AiMessage(''.join(lst))
-            new_chat.append(resp_m)
-
-        self._state_manager.extend_chat(new_chat)
-
-    async def _run_immediate(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        if self._config.new:
-            state = self._state_manager.clear_state()
-        else:
-            state = self._state_manager.get_state()
-
-        new_chat: list[mc.Message] = [
-            mc.UserMessage(prompt),
-        ]
-
-        mdl: mc.ChatChoicesService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-            mc.ChatChoicesService,
-                self._config.backend or DEFAULT_CHAT_MODEL_BACKEND,
-                *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            response: mc.ChatChoicesResponse = await mdl.invoke(mc.ChatChoicesRequest(
-                [*state.chat, *new_chat],
-                (self._chat_options or []),
-            ))
-
-            for resp_m in response.v[0].ms:
-                new_chat.append(resp_m)
-
-                if isinstance(resp_m, mc.AiMessage):
-                    self._printer.print(resp_m)
-
-                elif isinstance(resp_m, mc.ToolUseMessage):
-                    tr: mc.ToolUse = resp_m.tu
-
-                    # FIXME: lol
-                    from ....minichain.lib.fs.context import FsContext
-
-                    trm = await self._tool_exec_request_executor.execute_tool_use(
-                        tr,
-                        FsContext(root_dir=os.getcwd()),
-                    )
-
-                    print(trm.tur.c)
-                    new_chat.append(trm)
-
-                    response = await mdl.invoke(mc.ChatChoicesRequest(
-                        [*state.chat, *new_chat],
-                        (self._chat_options or []),
-                    ))
-
-                    resp_m = check.isinstance(check.single(response.v[0].ms), mc.AiMessage)
-                    new_chat.append(resp_m)
-
-                else:
-                    raise TypeError(resp_m)
-
-        self._state_manager.extend_chat(new_chat)

ommlds/cli/sessions/chat/state.py

@@ -1,110 +0,0 @@
-import abc
-import dataclasses as dc
-import datetime
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from ...state import StateStorage
-
-
-##
-
-
-@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) -> ChatState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def clear_state(self) -> ChatState:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def extend_chat(self, chat_additions: mc.Chat) -> ChatState:
-        raise NotImplementedError
-
-
-##
-
-
-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
-
-    def get_state(self) -> ChatState:
-        return self._state
-
-    def clear_state(self) -> ChatState:
-        self._state = ChatState()
-        return self._state
-
-    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
-
-
-##
-
-
-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
-
-    def get_state(self) -> ChatState:
-        if self._state is not None:
-            return self._state
-        state: ChatState | None = lang.sync_await(self._storage.load_state(self._key, ChatState))
-        if state is None:
-            state = ChatState()
-        self._state = state
-        return state
-
-    def clear_state(self) -> ChatState:
-        state = ChatState()
-        lang.sync_await(self._storage.save_state(self._key, state, ChatState))
-        self._state = state
-        return state
-
-    def extend_chat(self, chat_additions: mc.Chat) -> ChatState:
-        state = self.get_state()
-        state = dc.replace(
-            state,
-            chat=[*state.chat, *chat_additions],
-            updated_at=lang.utcnow(),
-        )
-        lang.sync_await(self._storage.save_state(self._key, state, ChatState))
-        self._state = state
-        return state

ommlds/cli/sessions/chat/tools.py

@@ -1,97 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import check
-from omlish import lang
-from omlish.formats import json
-from omlish.term.confirm import confirm_action
-
-from .... import minichain as mc
-
-
-##
-
-
-class ToolExecutionRequestDeniedError(Exception):
-    pass
-
-
-class ToolExecutionConfirmation(lang.Abstract):
-    @abc.abstractmethod
-    def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> ta.Awaitable[None]:
-        raise NotImplementedError
-
-
-class NopToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        pass
-
-
-class AskingToolExecutionConfirmation(ToolExecutionConfirmation):
-    async def confirm_tool_execution_or_raise(
-            self,
-            tr: mc.ToolUse,
-            tce: mc.ToolCatalogEntry,
-    ) -> None:
-        tr_dct = dict(
-            id=tr.id,
-            name=tce.spec.name,
-            args=tr.args,
-            # spec=msh.marshal(tce.spec),
-        )
-        cr = confirm_action(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}')  # FIXME: async lol
-
-        if not cr:
-            raise ToolExecutionRequestDeniedError
-
-
-##
-
-
-class ToolUseExecutor(lang.Abstract):
-    @abc.abstractmethod
-    def execute_tool_use(
-            self,
-            tr: mc.ToolUse,
-            *ctx_items: ta.Any,
-    ) -> ta.Awaitable[mc.ToolUseResultMessage]:
-        raise NotImplementedError
-
-
-class ToolUseExecutorImpl(ToolUseExecutor):
-    def __init__(
-            self,
-            *,
-            catalog: mc.ToolCatalog,
-            confirmation: ToolExecutionConfirmation,
-    ) -> None:
-        super().__init__()
-
-        self._catalog = catalog
-        self._confirmation = confirmation
-
-    async def execute_tool_use(
-            self,
-            tr: mc.ToolUse,
-            *ctx_items: ta.Any,
-    ) -> mc.ToolUseResultMessage:
-        tce = self._catalog.by_name[check.non_empty_str(tr.name)]
-
-        await self._confirmation.confirm_tool_execution_or_raise(tr, tce)
-
-        return await mc.execute_tool_use(
-            mc.ToolContext(
-                tr,
-                *ctx_items,
-            ),
-            tce.executor(),
-            tr,
-        )

ommlds/cli/sessions/chat2/_inject.py

@@ -1,105 +0,0 @@
-from omlish import lang
-
-
-with lang.auto_proxy_init(globals()):
-    from .backends.catalog import (  # noqa
-        CatalogChatChoicesServiceBackendProvider,
-        CatalogChatChoicesStreamServiceBackendProvider,
-    )
-
-    from .backends.types import (  # noqa
-        BackendName,
-        BackendConfigs,
-        BackendProvider,
-        ChatChoicesServiceBackendProvider,
-        ChatChoicesStreamServiceBackendProvider,
-    )
-
-    from .chat.ai.rendering import (  # noqa
-        RenderingAiChatGenerator,
-        RenderingStreamAiChatGenerator,
-    )
-
-    from .chat.ai.services import (  # noqa
-        ChatChoicesServiceOptions,
-        ChatChoicesServiceAiChatGenerator,
-        ChatChoicesStreamServiceStreamAiChatGenerator,
-    )
-
-    from .chat.ai.types import (  # noqa
-        AiChatGenerator,
-        StreamAiChatGenerator,
-    )
-
-    from .chat.state.inmemory import (  # noqa
-        InMemoryChatStateManager,
-    )
-
-    from .chat.state.storage import (  # noqa
-        StateStorageChatStateManager,
-    )
-
-    from .chat.state.types import (  # noqa
-        ChatState,
-        ChatStateManager,
-    )
-
-    from .chat.user.interactive import (  # noqa
-        InteractiveUserChatInput,
-    )
-
-    from .chat.user.oneshot import (  # noqa
-        OneshotUserChatInputInitialChat,
-        OneshotUserChatInput,
-    )
-
-    from .chat.user.types import (  # noqa
-        UserChatInput,
-    )
-
-    from .content.messages import (  # noqa
-        MessageContentExtractor,
-        MessageContentExtractorImpl,
-    )
-
-    from .content.strings import (  # noqa
-        ContentStringifier,
-        ContentStringifierImpl,
-    )
-
-    from .rendering.markdown import (  # noqa
-        MarkdownContentRendering,
-        MarkdownStreamContentRendering,
-    )
-
-    from .rendering.raw import (  # noqa
-        RawContentRendering,
-        RawContentStreamRendering,
-    )
-
-    from .rendering.types import (  # noqa
-        ContentRendering,
-        StreamContentRendering,
-    )
-
-    from .tools.confirmation import (  # noqa
-        ToolExecutionRequestDeniedError,
-        ToolExecutionConfirmation,
-        InteractiveToolExecutionConfirmation,
-    )
-
-    from .tools.execution import (  # noqa
-        ToolUseExecutor,
-        ToolUseExecutorImpl,
-    )
-
-    from .driver import (  # noqa
-        ChatDriver,
-    )
-
-    from .phases import (  # noqa
-        ChatPhase,
-        ChatPhaseCallback,
-        ChatPhaseCallbacks,
-        ChatPhaseManager,
-    )

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

@@ -1,70 +0,0 @@
-import typing as ta
-
-from omlish import check
-
-from ...... import minichain as mc
-from ...backends.types import ChatChoicesServiceBackendProvider
-from .types import AiChatGenerator
-from .types import StreamAiChatGenerator
-
-
-##
-
-
-ChatChoicesServiceOptions = ta.NewType('ChatChoicesServiceOptions', ta.Sequence[mc.ChatChoicesOptions])
-
-
-##
-
-
-class ChatChoicesServiceAiChatGenerator(AiChatGenerator):
-    def __init__(
-            self,
-            service_provider: ChatChoicesServiceBackendProvider,
-            *,
-            options: ChatChoicesServiceOptions | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._service_provider = service_provider
-        self._options = options
-
-    async def get_next_ai_messages(self, chat: mc.Chat) -> mc.AiChat:
-        async with self._service_provider.provide_backend() as service:
-            resp = await service.invoke(mc.ChatChoicesRequest(chat, self._options or []))
-
-        return check.single(resp.v).ms
-
-
-class ChatChoicesStreamServiceStreamAiChatGenerator(StreamAiChatGenerator):
-    def __init__(
-            self,
-            service: mc.ChatChoicesStreamService,
-            *,
-            options: ChatChoicesServiceOptions | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._service = service
-        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:
-        lst: list[str] = []
-
-        async with (await self._service.invoke(mc.ChatChoicesStreamRequest(chat, self._options or []))).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/chat2/inject.py

@@ -1,143 +0,0 @@
-import typing as ta
-
-from omlish import inject as inj
-from omlish import lang
-
-from .... import minichain as mc
-from . import _inject as _inj
-from .configs import DEFAULT_CHAT_MODEL_BACKEND
-from .configs import ChatConfig
-
-
-ItemT = ta.TypeVar('ItemT')
-
-
-##
-
-
-CHAT_OPTIONS = inj.items_binder_helper[mc.ChatChoicesOption](_inj.ChatChoicesServiceOptions)
-BACKEND_CONFIGS = inj.items_binder_helper[mc.Config](_inj.BackendConfigs)
-PHASE_CALLBACKS = inj.items_binder_helper[_inj.ChatPhaseCallback](_inj.ChatPhaseCallbacks)
-
-
-##
-
-
-def bind_chat(cfg: ChatConfig) -> inj.Elements:
-    els: list[inj.Elemental] = []
-
-    #
-
-    els.extend([
-        CHAT_OPTIONS.bind_items_provider(singleton=True),
-        BACKEND_CONFIGS.bind_items_provider(singleton=True),
-        PHASE_CALLBACKS.bind_items_provider(singleton=True),
-    ])
-
-    #
-
-    if cfg.state in ('continue', 'new'):
-        els.extend([
-            inj.bind(_inj.StateStorageChatStateManager, singleton=True),
-            inj.bind(_inj.ChatStateManager, to_key=_inj.StateStorageChatStateManager),
-        ])
-
-        if cfg.state == 'new':
-            els.append(PHASE_CALLBACKS.bind_item(to_fn=lang.typed_lambda(cm=_inj.ChatStateManager)(
-                lambda cm: _inj.ChatPhaseCallback(_inj.ChatPhase.STARTING, cm.clear_state),
-            )))
-
-    elif cfg.state == 'ephemeral':
-        els.extend([
-            inj.bind(_inj.InMemoryChatStateManager, singleton=True),
-            inj.bind(_inj.ChatStateManager, to_key=_inj.InMemoryChatStateManager),
-        ])
-
-    else:
-        raise TypeError(cfg.state)
-
-    #
-
-    if cfg.interactive:
-        if cfg.initial_content is not None:
-            async def add_initial_content(cm: '_inj.ChatStateManager') -> None:
-                await cm.extend_chat([mc.UserMessage(cfg.initial_content)])
-
-            els.append(PHASE_CALLBACKS.bind_item(to_fn=lang.typed_lambda(cm=_inj.ChatStateManager)(
-                lambda cm: _inj.ChatPhaseCallback(_inj.ChatPhase.STARTED, lambda: add_initial_content(cm)),
-            )))
-
-            raise NotImplementedError
-
-        els.extend([
-            inj.bind(_inj.InteractiveUserChatInput, singleton=True),
-            inj.bind(_inj.UserChatInput, to_key=_inj.InteractiveUserChatInput),
-        ])
-
-    else:
-        if cfg.initial_content is None:
-            raise ValueError('Initial content is required for non-interactive chat')
-
-        els.extend([
-            inj.bind(_inj.OneshotUserChatInputInitialChat, to_const=[mc.UserMessage(cfg.initial_content)]),
-            inj.bind(_inj.OneshotUserChatInput, singleton=True),
-            inj.bind(_inj.UserChatInput, to_key=_inj.OneshotUserChatInput),
-        ])
-
-    #
-
-    if cfg.stream:
-        raise NotImplementedError
-
-    else:
-        ai_stack = inj.wrapper_binder_helper(_inj.AiChatGenerator)
-
-        els.append(ai_stack.push_bind(to_ctor=_inj.ChatChoicesServiceAiChatGenerator, singleton=True))
-
-        if not cfg.silent:
-            if cfg.markdown:
-                els.extend([
-                    inj.bind(_inj.MarkdownContentRendering, singleton=True),
-                    inj.bind(_inj.ContentRendering, to_key=_inj.MarkdownContentRendering),
-                ])
-            else:
-                els.extend([
-                    inj.bind(_inj.RawContentRendering, singleton=True),
-                    inj.bind(_inj.ContentRendering, to_key=_inj.RawContentRendering),
-                ])
-
-            els.append(ai_stack.push_bind(to_ctor=_inj.RenderingAiChatGenerator, singleton=True))
-
-        els.append(inj.bind(_inj.AiChatGenerator, to_key=ai_stack.top))
-
-    #
-
-    els.append(inj.bind(_inj.BackendName, to_const=cfg.backend or DEFAULT_CHAT_MODEL_BACKEND))
-
-    els.extend([
-        inj.bind(_inj.CatalogChatChoicesServiceBackendProvider),
-        inj.bind(_inj.ChatChoicesServiceBackendProvider, to_key=_inj.CatalogChatChoicesServiceBackendProvider),
-    ])
-
-    #
-
-    els.extend([
-        inj.bind(_inj.ToolUseExecutorImpl, singleton=True),
-        inj.bind(_inj.ToolUseExecutor, to_key=_inj.ToolUseExecutorImpl),
-    ])
-
-    #
-
-    els.extend([
-        inj.bind(_inj.ChatPhaseManager, singleton=True),
-    ])
-
-    #
-
-    els.extend([
-        inj.bind(_inj.ChatDriver, singleton=True),
-    ])
-
-    #
-
-    return inj.as_elements(*els)

ommlds/cli/tools/config.py

@@ -1,14 +0,0 @@
-from omlish import dataclasses as dc
-
-
-##
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class ToolsConfig:
-    enable_fs_tools: bool = False
-    enable_todo_tools: bool = False
-
-    enable_unsafe_tools_do_not_use_lol: bool = False
-
-    enable_test_weather_tool: bool = False