ommlds 0.0.0.dev456__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

ommlds/cli/sessions/chat/code.py

@@ -1,129 +0,0 @@
-import dataclasses as dc
-import itertools
-import os.path
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from ....minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
-from ...tools.config import ToolsConfig
-from .base import DEFAULT_CHAT_MODEL_BACKEND
-from .base import ChatOptions
-from .base import ChatSession
-from .printing import ChatSessionPrinter
-from .state import ChatStateManager
-from .tools import ToolUseExecutor
-
-
-with lang.auto_proxy_import(globals()):
-    from omdev import ptk
-
-
-##
-
-
-class CodeChatSession(ChatSession['CodeChatSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(ChatSession.Config):
-        _: dc.KW_ONLY
-
-        new: bool = False
-
-        backend: str | None = None
-        model_name: str | None = None
-
-        initial_message: mc.Content | None = None
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            state_manager: ChatStateManager,
-            chat_options: ChatOptions | None = None,
-            printer: ChatSessionPrinter,
-            backend_catalog: mc.BackendCatalog,
-            tool_exec_request_executor: ToolUseExecutor,
-            tools_config: ToolsConfig | None = None,
-    ) -> 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
-        self._tools_config = tools_config
-
-    async def run(self) -> None:
-        if self._config.new:
-            self._state_manager.clear_state()
-            state = self._state_manager.extend_chat([
-                mc.SystemMessage(CODE_AGENT_SYSTEM_PROMPT),
-            ])
-
-        else:
-            state = self._state_manager.get_state()
-
-        backend = self._config.backend
-        if backend is None:
-            backend = DEFAULT_CHAT_MODEL_BACKEND
-
-        # FIXME: lol
-        from ....minichain.lib.fs.context import FsContext
-        fs_tool_context = FsContext(
-            root_dir=os.getcwd(),
-            writes_permitted=self._tools_config is not None and self._tools_config.enable_unsafe_tools_do_not_use_lol,
-        )
-
-        from ....minichain.lib.todo.context import TodoContext
-        todo_tool_context = TodoContext()
-
-        mdl: mc.ChatChoicesService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-                mc.ChatChoicesService,
-                backend,
-                *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            for i in itertools.count():
-                if not i and self._config.initial_message is not None:
-                    req_msg = mc.UserMessage(self._config.initial_message)
-                else:
-                    try:
-                        prompt = await ptk.prompt('> ')
-                    except EOFError:
-                        break
-                    req_msg = mc.UserMessage(prompt)
-
-                state = self._state_manager.extend_chat([req_msg])
-
-                while True:
-                    response = await mdl.invoke(mc.ChatChoicesRequest(
-                        state.chat,
-                        (self._chat_options or []),
-                    ))
-
-                    tool_resp_lst = []
-                    for resp_msg in check.single(response.v).ms:
-                        state = self._state_manager.extend_chat([resp_msg])
-
-                        if isinstance(resp_msg, mc.AiMessage):
-                            self._printer.print(resp_msg)
-
-                        elif isinstance(resp_msg, mc.ToolUseMessage):
-                            trm = await self._tool_exec_request_executor.execute_tool_use(
-                                resp_msg.tu,
-                                fs_tool_context,
-                                todo_tool_context,
-                            )
-
-                            self._printer.print(trm.tur.c)
-                            tool_resp_lst.append(trm)
-
-                        else:
-                            raise TypeError(resp_msg)
-
-                    if not tool_resp_lst:
-                        break
-
-                    state = self._state_manager.extend_chat(tool_resp_lst)

ommlds/cli/sessions/chat/interactive.py

@@ -1,71 +0,0 @@
-import dataclasses as dc
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from .base import DEFAULT_CHAT_MODEL_BACKEND
-from .base import ChatSession
-from .printing import ChatSessionPrinter
-from .state import ChatStateManager
-
-
-with lang.auto_proxy_import(globals()):
-    from omdev import ptk
-
-
-##
-
-
-class InteractiveChatSession(ChatSession['InteractiveChatSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(ChatSession.Config):
-        _: dc.KW_ONLY
-
-        new: bool = False
-
-        backend: str | None = None
-        model_name: str | None = None
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            state_manager: ChatStateManager,
-            printer: ChatSessionPrinter,
-            backend_catalog: mc.BackendCatalog,
-    ) -> None:
-        super().__init__(config)
-
-        self._state_manager = state_manager
-        self._printer = printer
-        self._backend_catalog = backend_catalog
-
-    async def run(self) -> None:
-        if self._config.new:
-            state = self._state_manager.clear_state()
-        else:
-            state = self._state_manager.get_state()
-
-        backend = self._config.backend
-        if backend is None:
-            backend = DEFAULT_CHAT_MODEL_BACKEND
-
-        mdl: mc.ChatChoicesService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-                mc.ChatChoicesService,
-                backend,
-                *([mc.ModelName(mn)] if (mn := self._config.model_name) is not None else []),
-        )) as mdl:
-            while True:
-                prompt = await ptk.prompt('> ')
-
-                req_msg = mc.UserMessage(prompt)
-
-                response = await mdl.invoke(mc.ChatChoicesRequest([*state.chat, req_msg]))
-
-                resp_msg = check.isinstance(check.single(response.v[0].ms), mc.AiMessage)
-
-                self._printer.print(resp_msg)
-
-                state = self._state_manager.extend_chat([req_msg, resp_msg])

ommlds/cli/sessions/chat/printing.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 .... import minichain as mc
-
-
-with lang.auto_proxy_import(globals()):
-    from omdev import ptk
-    from omdev.ptk import markdown as ptk_md
-
-
-##
-
-
-class ChatSessionPrinter(lang.Abstract):
-    @abc.abstractmethod
-    def print(self, obj: mc.Message | mc.Content) -> None:
-        raise NotImplementedError
-
-
-##
-
-
-class StringChatSessionPrinter(ChatSessionPrinter, lang.Abstract):
-    @abc.abstractmethod
-    def _print_str(self, s: str) -> None:
-        raise NotImplementedError
-
-    def print(self, obj: mc.Message | mc.Content) -> None:
-        if obj is None:
-            pass
-
-        elif isinstance(obj, mc.Message):
-            if isinstance(obj, mc.SystemMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.UserMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.AiMessage):
-                if obj.c is not None:
-                    self._print_str(check.isinstance(obj.c, str))
-            elif isinstance(obj, mc.ToolUseResultMessage):
-                self._print_str(check.isinstance(obj.tur.c, str))
-            else:
-                raise TypeError(obj)
-
-        elif isinstance(obj, mc.JsonContent):
-            self._print_str(json.dumps_pretty(obj.v))
-
-        elif isinstance(obj, str):
-            self._print_str(obj)
-
-        else:
-            raise TypeError(obj)
-
-
-##
-
-
-class SimpleStringChatSessionPrinter(StringChatSessionPrinter):
-    def __init__(
-            self,
-            *,
-            str_printer: ta.Callable[[str], None] | None = None,
-    ) -> None:
-        super().__init__()
-
-        if str_printer is None:
-            str_printer = print
-        self._str_printer = str_printer
-
-    def _print_str(self, s: str) -> None:
-        s = s.strip()
-        if not s:
-            return
-
-        self._str_printer(s)
-
-
-##
-
-
-class MarkdownStringChatSessionPrinter(StringChatSessionPrinter):
-    def _print_str(self, s: str) -> None:
-        s = s.strip()
-        if not s:
-            return
-
-        ptk.print_formatted_text(
-            ptk_md.Markdown(s),
-            style=ptk.Style(list(ptk_md.MARKDOWN_STYLE)),
-        )

ommlds/cli/sessions/chat/prompt.py

@@ -1,151 +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 .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] = []
-                async for o in st_resp:
-                    if o:
-                        c = check.isinstance(check.single(check.single(o.choices).deltas), mc.ContentAiChoiceDelta).c
-                        if c is not None:
-                            print(check.isinstance(c, str), end='', flush=True)
-                            lst.append(check.isinstance(c, str))
-                print()
-
-            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,100 +0,0 @@
-import abc
-import typing as ta
-
-from omlish import check
-from omlish import lang
-from omlish.formats import json
-
-from .... import minichain as mc
-
-
-with lang.auto_proxy_import(globals()):
-    from omdev import ptk
-
-
-##
-
-
-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 = await ptk.strict_confirm(f'Execute requested tool?\n\n{json.dumps_pretty(tr_dct)}\n\n')
-
-        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/completion/completion.py

@@ -1,44 +0,0 @@
-import dataclasses as dc
-
-from omlish import check
-from omlish import lang
-
-from .... import minichain as mc
-from ..base import Session
-
-
-##
-
-
-DEFAULT_COMPLETION_MODEL_BACKEND = 'openai'
-
-
-class CompletionSession(Session['CompletionSession.Config']):
-    @dc.dataclass(frozen=True)
-    class Config(Session.Config):
-        content: mc.Content
-
-        _: dc.KW_ONLY
-
-        backend: str | None = None
-
-    def __init__(
-            self,
-            config: Config,
-            *,
-            backend_catalog: mc.BackendCatalog,
-    ) -> None:
-        super().__init__(config)
-
-        self._backend_catalog = backend_catalog
-
-    async def run(self) -> None:
-        prompt = check.isinstance(self._config.content, str)
-
-        mdl: mc.CompletionService
-        async with lang.async_maybe_managing(self._backend_catalog.get_backend(
-                mc.CompletionService,
-                self._config.backend or DEFAULT_COMPLETION_MODEL_BACKEND,
-        )) as mdl:
-            response = await mdl.invoke(mc.CompletionRequest(prompt))
-            print(response.v.strip())