ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/cli/sessions/chat/backends/catalog.py

@@ -1,56 +0,0 @@
-import contextlib
-import typing as ta
-
-from omlish import lang
-
-from ..... import minichain as mc
-from .types import BackendConfigs
-from .types import BackendName
-from .types import BackendProvider
-from .types import ChatChoicesServiceBackendProvider
-from .types import ChatChoicesStreamServiceBackendProvider
-from .types import ServiceT
-
-
-##
-
-
-class _CatalogBackendProvider(BackendProvider[ServiceT], lang.Abstract):
-    def __init__(
-            self,
-            *,
-            name: BackendName,
-            catalog: 'mc.BackendCatalog',
-            configs: BackendConfigs | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._name = name
-        self._catalog = catalog
-        self._configs = configs
-
-    @contextlib.asynccontextmanager
-    async def _provide_backend(self, cls: type[ServiceT]) -> ta.AsyncIterator[ServiceT]:
-        service: ServiceT
-        async with lang.async_maybe_managing(self._catalog.get_backend(
-                cls,
-                self._name,
-                *(self._configs or []),
-        )) as service:
-            yield service
-
-
-class CatalogChatChoicesServiceBackendProvider(
-    _CatalogBackendProvider['mc.ChatChoicesService'],
-    ChatChoicesServiceBackendProvider,
-):
-    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesService']:
-        return self._provide_backend(mc.ChatChoicesService)  # type: ignore[type-abstract]
-
-
-class CatalogChatChoicesStreamServiceBackendProvider(
-    _CatalogBackendProvider['mc.ChatChoicesStreamService'],
-    ChatChoicesStreamServiceBackendProvider,
-):
-    def provide_backend(self) -> ta.AsyncContextManager['mc.ChatChoicesStreamService']:
-        return self._provide_backend(mc.ChatChoicesStreamService)  # type: ignore[type-abstract]

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

@@ -1,37 +0,0 @@
-from omlish import inject as inj
-from omlish import lang
-
-from .injection import backend_configs
-
-
-with lang.auto_proxy_import(globals()):
-    from . import catalog as _catalog
-    from . import types as _types
-
-
-##
-
-
-def bind_backends(
-        *,
-        backend: str | None = None,
-) -> inj.Elements:
-    els: list[inj.Elemental] = []
-
-    #
-
-    els.append(backend_configs().bind_items_provider(singleton=True))
-
-    #
-
-    if backend is not None:
-        els.append(inj.bind(_types.BackendName, to_const=backend))
-
-    els.extend([
-        inj.bind(_types.ChatChoicesServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesServiceBackendProvider, singleton=True),  # noqa
-        inj.bind(_types.ChatChoicesStreamServiceBackendProvider, to_ctor=_catalog.CatalogChatChoicesStreamServiceBackendProvider, singleton=True),  # noqa
-    ])
-
-    #
-
-    return inj.as_elements(*els)

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

@@ -1,40 +0,0 @@
-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/user/inject.py

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

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

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

@@ -1,15 +0,0 @@
-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/driver.py

@@ -1,43 +0,0 @@
-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/tools/inject.py

@@ -1,145 +0,0 @@
-import os
-import typing as ta
-
-from omlish import check
-from omlish import inject as inj
-from omlish import lang
-
-from ..... import minichain as mc
-from .injection import bind_tool_context_provider_to_key
-from .injection import tool_catalog_entries
-from .injection import tool_context_providers
-
-
-with lang.auto_proxy_import(globals()):
-    from . import confirmation as _confirmation
-    from . import execution as _execution
-    from . import rendering as _rendering
-
-
-##
-
-
-_TOOL_BINDERS: dict[str, ta.Callable[[], inj.Elements]] = {}
-
-
-def _tool_binder(name: str) -> ta.Callable[[ta.Callable[[], inj.Elements]], ta.Callable[[], inj.Elements]]:
-    def inner(fn):
-        check.not_in(name, _TOOL_BINDERS)
-        _TOOL_BINDERS[name] = fn
-        return fn
-    return inner
-
-
-#
-
-
-@_tool_binder('weather')
-def _bind_weather_tool() -> inj.Elements:
-    from .weather import WEATHER_TOOL
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(WEATHER_TOOL),
-    )
-
-
-@_tool_binder('todo')
-def _bind_todo_tools() -> inj.Elements:
-    from .....minichain.lib.todo.context import TodoContext
-    from .....minichain.lib.todo.tools.read import todo_read_tool
-    from .....minichain.lib.todo.tools.write import todo_write_tool
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(
-            todo_read_tool(),
-            todo_write_tool(),
-        ),
-
-        inj.bind(TodoContext()),
-        bind_tool_context_provider_to_key(TodoContext),
-    )
-
-
-@_tool_binder('fs')
-def _bind_fs_tools() -> inj.Elements:
-    from .....minichain.lib.fs.context import FsContext
-    from .....minichain.lib.fs.tools.ls import ls_tool
-    from .....minichain.lib.fs.tools.read import read_tool
-
-    return inj.as_elements(
-        tool_catalog_entries().bind_item_consts(
-            ls_tool(),
-            read_tool(),
-        ),
-
-        inj.bind(FsContext(
-            root_dir=os.getcwd(),
-        )),
-        bind_tool_context_provider_to_key(FsContext),
-    )
-
-
-# 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()))
-
-
-##
-
-
-def bind_tools(
-        *,
-        silent: bool = False,
-        dangerous_no_confirmation: bool = False,
-        enabled_tools: ta.Iterable[str] | None = None,
-) -> inj.Elements:
-    els: list[inj.Elemental] = []
-
-    #
-
-    els.append(inj.bind(mc.ToolCatalog, singleton=True))
-
-    #
-
-    els.append(tool_catalog_entries().bind_items_provider(singleton=True))
-
-    for etn in check.not_isinstance(enabled_tools or [], str):
-        els.append(_TOOL_BINDERS[etn]())
-
-    #
-
-    exec_stack = inj.wrapper_binder_helper(_execution.ToolUseExecutor)
-
-    els.append(exec_stack.push_bind(to_ctor=_execution.ToolUseExecutorImpl, singleton=True))
-
-    if not silent:
-        els.append(exec_stack.push_bind(to_ctor=_rendering.ResultRenderingToolUseExecutor, singleton=True))
-
-        if dangerous_no_confirmation:
-            els.append(exec_stack.push_bind(to_ctor=_rendering.ArgsRenderingToolUseExecutor, singleton=True))
-
-    els.extend([
-        inj.bind(_execution.ToolUseExecutor, to_key=exec_stack.top),
-    ])
-
-    #
-
-    if not dangerous_no_confirmation:
-        els.append(inj.bind(_confirmation.ToolExecutionConfirmation, to_ctor=_confirmation.InteractiveToolExecutionConfirmation, singleton=True))  # noqa
-
-    #
-
-    els.extend([
-        tool_context_providers().bind_items_provider(singleton=True),
-
-        inj.bind(_execution.ToolContextProvider, to_fn=lang.typed_lambda(tcps=_execution.ToolContextProviders)(
-            lambda tcps: _execution.ToolContextProvider(lambda: [tc for tcp in tcps for tc in tcp()]),
-        ), singleton=True),
-    ])
-
-    #
-
-    return inj.as_elements(*els)

ommlds/minichain/backends/impls/openai/format2.py

@@ -1,210 +0,0 @@
-import typing as ta
-
-from omlish import cached
-from omlish import check
-from omlish import typedvalues as tv
-from omlish.formats import json
-
-from .....backends.openai import protocol as pt
-from ....chat.choices.services import ChatChoicesResponse
-from ....chat.choices.types import AiChoice
-from ....chat.choices.types import AiChoices
-from ....chat.choices.types import ChatChoicesOptions
-from ....chat.messages import AiMessage
-from ....chat.messages import AnyAiMessage
-from ....chat.messages import Chat
-from ....chat.messages import SystemMessage
-from ....chat.messages import ToolUseMessage
-from ....chat.messages import ToolUseResultMessage
-from ....chat.messages import UserMessage
-from ....chat.tools.types import Tool
-from ....content.json import JsonContent
-from ....content.prepare import prepare_content_str
-from ....llms.types import MaxTokens
-from ....llms.types import Temperature
-from ....llms.types import TokenUsage
-from ....llms.types import TokenUsageOutput
-from ....tools.jsonschema import build_tool_spec_params_json_schema
-from ....tools.types import ToolSpec
-from ....tools.types import ToolUse
-from ....types import Option
-
-
-##
-
-
-def build_oai_request_msgs(mc_chat: Chat) -> ta.Sequence[pt.ChatCompletionMessage]:
-    oai_msgs: list[pt.ChatCompletionMessage] = []
-
-    for mc_msg in mc_chat:
-        if isinstance(mc_msg, SystemMessage):
-            oai_msgs.append(pt.SystemChatCompletionMessage(
-                content=check.isinstance(mc_msg.c, str),
-            ))
-
-        elif isinstance(mc_msg, AiMessage):
-            oai_msgs.append(pt.AssistantChatCompletionMessage(
-                content=check.isinstance(mc_msg.c, (str, None)),
-            ))
-
-        elif isinstance(mc_msg, ToolUseMessage):
-            oai_msgs.append(pt.AssistantChatCompletionMessage(
-                tool_calls=[pt.AssistantChatCompletionMessage.ToolCall(
-                    id=check.not_none(mc_msg.tu.id),
-                    function=pt.AssistantChatCompletionMessage.ToolCall.Function(
-                        arguments=check.not_none(mc_msg.tu.raw_args),
-                        name=mc_msg.tu.name,
-                    ),
-                )],
-            ))
-
-        elif isinstance(mc_msg, UserMessage):
-            oai_msgs.append(pt.UserChatCompletionMessage(
-                content=prepare_content_str(mc_msg.c),
-            ))
-
-        elif isinstance(mc_msg, ToolUseResultMessage):
-            tc: str
-            if isinstance(mc_msg.tur.c, str):
-                tc = mc_msg.tur.c
-            elif isinstance(mc_msg.tur.c, JsonContent):
-                tc = json.dumps_compact(mc_msg.tur.c)
-            else:
-                raise TypeError(mc_msg.tur.c)
-            oai_msgs.append(pt.ToolChatCompletionMessage(
-                tool_call_id=check.not_none(mc_msg.tur.id),
-                content=tc,
-            ))
-
-        else:
-            raise TypeError(mc_msg)
-
-    return oai_msgs
-
-
-#
-
-
-def build_mc_ai_choice(oai_choice: pt.ChatCompletionResponseChoice) -> AiChoice:
-    cur: list[AnyAiMessage] = []
-
-    oai_msg = oai_choice.message
-
-    if (oai_c := oai_msg.content) is not None:
-        cur.append(AiMessage(check.isinstance(oai_c, str)))
-
-    for oai_tc in oai_msg.tool_calls or []:
-        cur.append(ToolUseMessage(ToolUse(
-            id=oai_tc.id,
-            name=oai_tc.function.name,
-            args=json.loads(oai_tc.function.arguments or '{}'),
-            raw_args=oai_tc.function.arguments,
-        )))
-
-    return AiChoice(cur)
-
-
-def build_mc_ai_choices(oai_resp: pt.ChatCompletionResponse) -> AiChoices:
-    return [
-        build_mc_ai_choice(oai_choice)
-        for oai_choice in oai_resp.choices
-    ]
-
-
-def build_mc_choices_response(oai_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
-    return ChatChoicesResponse(
-        build_mc_ai_choices(oai_resp),
-
-        tv.TypedValues(
-            *([TokenUsageOutput(TokenUsage(
-                input=tu.prompt_tokens,
-                output=tu.completion_tokens,
-                total=tu.total_tokens,
-            ))] if (tu := oai_resp.usage) is not None else []),
-        ),
-    )
-
-
-##
-
-
-class OpenaiChatRequestHandler:
-    def __init__(
-            self,
-            chat: Chat,
-            *options: ChatChoicesOptions,
-            model: str,
-            mandatory_kwargs: ta.Mapping[str, ta.Any] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._chat = chat
-        self._options = options
-        self._model = model
-        self._mandatory_kwargs = mandatory_kwargs
-
-    DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
-        Temperature(0.),
-        MaxTokens(1024),
-    )
-
-    _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
-        temperature=Temperature,
-        max_tokens=MaxTokens,
-    )
-
-    class _ProcessedOptions(ta.NamedTuple):
-        kwargs: dict[str, ta.Any]
-        tools_by_name: dict[str, ToolSpec]
-
-    @cached.function
-    def _process_options(self) -> _ProcessedOptions:
-        kwargs: dict = dict(
-            temperature=0,
-            max_tokens=1024,
-        )
-
-        tools_by_name: dict[str, ToolSpec] = {}
-
-        with tv.TypedValues(*self._options).consume() as oc:
-            kwargs.update(oc.pop_scalar_kwargs(**self._OPTION_KWARG_NAMES_MAP))
-
-            for t in oc.pop(Tool, []):
-                if t.spec.name in tools_by_name:
-                    raise NameError(t.spec.name)
-                tools_by_name[check.non_empty_str(t.spec.name)] = t.spec
-
-        if (mk := self._mandatory_kwargs):
-            for k, v in mk.items():
-                check.not_in(k, kwargs)
-                kwargs[k] = v
-
-        return self._ProcessedOptions(
-            kwargs=kwargs,
-            tools_by_name=tools_by_name,
-        )
-
-    @cached.function
-    def oai_request(self) -> pt.ChatCompletionRequest:
-        po = self._process_options()
-
-        tools: list[pt.ChatCompletionRequestTool] = [
-            pt.ChatCompletionRequestTool(
-                function=pt.ChatCompletionRequestTool.Function(
-                    name=check.not_none(ts.name),
-                    description=prepare_content_str(ts.desc),
-                    parameters=build_tool_spec_params_json_schema(ts),
-                ),
-            )
-            for ts in po.tools_by_name.values()
-        ]
-
-        return pt.ChatCompletionRequest(
-            model=self._model,
-            messages=build_oai_request_msgs(self._chat),
-            top_p=1,
-            tools=tools or None,
-            frequency_penalty=0.0,
-            presence_penalty=0.0,
-            **po.kwargs,
-        )