ommlds 0.0.0.dev462__py3-none-any.whl → 0.0.0.dev464__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 = 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()
-        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(),
-        )
-        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/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

ommlds/cli/tools/inject.py

@@ -1,75 +0,0 @@
-import dataclasses as dc
-import typing as ta
-
-from omlish import inject as inj
-from omlish import lang
-
-from ... import minichain as mc
-from ..sessions.chat.inject import bind_chat_options
-from .config import ToolsConfig
-from .weather import WEATHER_TOOL
-
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
-class _InjectedTool:
-    tce: mc.ToolCatalogEntry
-
-
-def bind_tool(tce: mc.ToolCatalogEntry) -> inj.Element | inj.Elements:
-    return inj.as_elements(
-        inj.bind_set_entry_const(ta.AbstractSet[_InjectedTool], _InjectedTool(tce)),
-
-        bind_chat_options(mc.Tool(tce.spec)),
-    )
-
-
-##
-
-
-def bind_tools(tools_config: ToolsConfig) -> inj.Elements:
-    els: list[inj.Elemental] = [
-        inj.bind(tools_config),
-
-        inj.bind(mc.ToolCatalog, singleton=True),
-
-        inj.set_binder[_InjectedTool](),
-        inj.bind(
-            lang.typed_lambda(mc.ToolCatalogEntries, s=ta.AbstractSet[_InjectedTool])(
-                lambda s: [it.tce for it in s],
-            ),
-            singleton=True,
-        ),
-    ]
-
-    #
-
-    if tools_config.enable_fs_tools:
-        from ...minichain.lib.fs.tools.ls import ls_tool
-        els.append(bind_tool(ls_tool()))
-
-        from ...minichain.lib.fs.tools.read import read_tool
-        els.append(bind_tool(read_tool()))
-
-    if tools_config.enable_todo_tools:
-        from ...minichain.lib.todo.tools.read import todo_read_tool
-        els.append(bind_tool(todo_read_tool()))
-
-        from ...minichain.lib.todo.tools.write import todo_write_tool
-        els.append(bind_tool(todo_write_tool()))
-
-    if tools_config.enable_unsafe_tools_do_not_use_lol:
-        from ...minichain.lib.bash import bash_tool
-        els.append(bind_tool(bash_tool()))
-
-        from ...minichain.lib.fs.tools.edit import edit_tool
-        els.append(bind_tool(edit_tool()))
-
-    if tools_config.enable_test_weather_tool:
-        els.append(bind_tool(WEATHER_TOOL))
-
-    #
-
-    return inj.as_elements(*els)