ommlds 0.0.0.dev462__tar.gz → 0.0.0.dev464__tar.gz

{ommlds-0.0.0.dev462/ommlds.egg-info → ommlds-0.0.0.dev464}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev462
+Version: 0.0.0.dev464
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev462
-Requires-Dist: omlish==0.0.0.dev462
+Requires-Dist: omdev==0.0.0.dev464
+Requires-Dist: omlish==0.0.0.dev464
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev462 → ommlds-0.0.0.dev464}/ommlds/backends/mlx/loading.py

@@ -15,6 +15,63 @@ from .tokenization import load_tokenization
 ##
 
 
+def get_model_path(
+        path_or_hf_repo: str,
+        revision: str | None = None,
+) -> tuple[pathlib.Path, str | None]:
+    """
+    Ensures the model is available locally. If the path does not exist locally,
+    it is downloaded from the Hugging Face Hub.
+
+    Args:
+        path_or_hf_repo (str): The local path or Hugging Face repository ID of the model.
+        revision (str, optional): A revision id which can be a branch name, a tag, or a commit hash.
+
+    Returns:
+        Tuple[Path, str]: A tuple containing the local file path and the Hugging Face repo ID.
+    """
+
+    model_path = pathlib.Path(path_or_hf_repo)
+
+    if not model_path.exists():
+        from huggingface_hub import snapshot_download
+        hf_path = path_or_hf_repo
+        model_path = pathlib.Path(
+            snapshot_download(
+                path_or_hf_repo,
+                revision=revision,
+                allow_patterns=[
+                    '*.jinja',
+                    '*.json',
+                    '*.jsonl',
+                    '*.py',
+                    '*.txt',
+
+                    'model*.safetensors',
+
+                    '*.tiktoken',
+                    'tiktoken.model',
+                    'tokenizer.model',
+                ],
+            ),
+        )
+
+    else:
+        from huggingface_hub import ModelCard
+
+        card_path = model_path / 'README.md'
+        if card_path.is_file():
+            card = ModelCard.load(card_path)
+            hf_path = card.data.base_model
+        else:
+            hf_path = None
+
+    return model_path, hf_path
+
+
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class LoadedModel:
     path: pathlib.Path
@@ -46,7 +103,7 @@ def load_model(
 ) -> LoadedModel:
     # FIXME: get_model_path return annotation is wrong:
     #   https://github.com/ml-explore/mlx-lm/blob/9ee2b7358f5e258af7b31a8561acfbbe56ad5085/mlx_lm/utils.py#L82
-    model_path_res = ta.cast(ta.Any, mlx_lm.utils.get_model_path(path_or_hf_repo))
+    model_path_res = ta.cast(ta.Any, get_model_path(path_or_hf_repo))
     if isinstance(model_path_res, tuple):
         model_path = check.isinstance(model_path_res[0], pathlib.Path)
     else:

{ommlds-0.0.0.dev462 → ommlds-0.0.0.dev464}/ommlds/cli/inject.py

@@ -10,8 +10,6 @@ with lang.auto_proxy_import(globals()):
     from .backends import inject as backends_inj
     from .sessions import base as sessions_base
     from .sessions import inject as sessions_inj
-    from .tools import config as tools_cfg
-    from .tools import inject as tools_inj
 
 
 ##
@@ -33,7 +31,6 @@ def _provide_state_storage() -> 'state.StateStorage':
 def bind_main(
         *,
         session_cfg: 'sessions_base.Session.Config',
-        tools_config: 'tools_cfg.ToolsConfig',
         enable_backend_strings: bool = False,
 ) -> inj.Elements:
     els: list[inj.Elemental] = [
@@ -42,8 +39,6 @@ def bind_main(
         ),
 
         sessions_inj.bind_sessions(session_cfg),
-
-        tools_inj.bind_tools(tools_config),
     ]
 
     #

{ommlds-0.0.0.dev462 → ommlds-0.0.0.dev464}/ommlds/cli/main.py

@@ -24,12 +24,9 @@ from omlish.subprocesses.sync import subprocesses
 from .. import minichain as mc
 from .inject import bind_main
 from .sessions.base import Session
-from .sessions.chat.code import CodeChatSession
-from .sessions.chat.interactive import InteractiveChatSession
-from .sessions.chat.prompt import PromptChatSession
+from .sessions.chat.session import ChatSession
 from .sessions.completion.completion import CompletionSession
 from .sessions.embedding.embedding import EmbeddingSession
-from .tools.config import ToolsConfig
 
 
 if ta.TYPE_CHECKING:
@@ -56,6 +53,7 @@ async def _a_main(args: ta.Any = None) -> None:
     parser.add_argument('-C', '--completion', action='store_true')
 
     parser.add_argument('-n', '--new', action='store_true')
+    parser.add_argument('--ephemeral', action='store_true')
 
     parser.add_argument('-e', '--editor', action='store_true')
     parser.add_argument('-i', '--interactive', action='store_true')
@@ -90,6 +88,7 @@ async def _a_main(args: ta.Any = None) -> None:
     elif args.interactive:
         if args.prompt:
             raise ValueError('Must not provide prompt')
+        content = None
 
     elif args.code:
         if args.prompt:
@@ -128,25 +127,7 @@ async def _a_main(args: ta.Any = None) -> None:
 
     session_cfg: Session.Config
 
-    if args.interactive:
-        session_cfg = InteractiveChatSession.Config(
-            backend=args.backend,
-            model_name=args.model_name,
-            new=bool(args.new),
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
-        )
-
-    elif args.code:
-        session_cfg = CodeChatSession.Config(
-            backend=args.backend,
-            model_name=args.model_name,
-            new=bool(args.new),
-            dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
-            initial_message=content,  # noqa
-            markdown=bool(args.markdown),
-        )
-
-    elif args.embed:
+    if args.embed:
         session_cfg = EmbeddingSession.Config(
             check.not_none(content),  # noqa
             backend=args.backend,
@@ -159,31 +140,38 @@ async def _a_main(args: ta.Any = None) -> None:
         )
 
     else:
-        session_cfg = PromptChatSession.Config(
-            check.not_none(content),  # noqa
+        from ..minichain.lib.code.prompts import CODE_AGENT_SYSTEM_PROMPT
+
+        session_cfg = ChatSession.Config(
             backend=args.backend,
             model_name=args.model_name,
-            new=bool(args.new),
-            stream=bool(args.stream),
+            state='ephemeral' if args.ephemeral else 'new' if args.new else 'continue',
+            initial_system_content=CODE_AGENT_SYSTEM_PROMPT if args.new and args.code else None,
+            initial_user_content=content,  # noqa
+            interactive=args.interactive,
             markdown=bool(args.markdown),
+            stream=bool(args.stream),
+            enable_tools=(
+                args.enable_fs_tools or
+                args.enable_todo_tools or
+                args.enable_unsafe_tools_do_not_use_lol or
+                args.enable_test_weather_tool or
+                args.code
+            ),
+            enabled_tools={
+                *(['fs'] if args.enable_fs_tools else []),
+                *(['todo'] if args.enable_todo_tools else []),
+                *(['weather'] if args.enable_test_weather_tool else []),
+                # FIXME: enable_unsafe_tools_do_not_use_lol
+            },
             dangerous_no_tool_confirmation=bool(args.dangerous_no_tool_confirmation),
         )
 
     #
 
-    tools_config = ToolsConfig(
-        enable_fs_tools=args.enable_fs_tools or args.code,
-        enable_todo_tools=args.enable_todo_tools or args.code,
-        enable_unsafe_tools_do_not_use_lol=args.enable_unsafe_tools_do_not_use_lol,
-        enable_test_weather_tool=args.enable_test_weather_tool,
-    )
-
-    #
-
     with inj.create_managed_injector(bind_main(
             session_cfg=session_cfg,
-            tools_config=tools_config,
-            enable_backend_strings=isinstance(session_cfg, (PromptChatSession.Config, CodeChatSession.Config)),
+            enable_backend_strings=isinstance(session_cfg, ChatSession.Config),
     )) as injector:
         await injector[Session].run()
 

ommlds-0.0.0.dev464/ommlds/cli/sessions/chat/backends/catalog.py

@@ -0,0 +1,56 @@
+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-0.0.0.dev464/ommlds/cli/sessions/chat/backends/inject.py

@@ -0,0 +1,37 @@
+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-0.0.0.dev464/ommlds/cli/sessions/chat/backends/injection.py

@@ -0,0 +1,16 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+with lang.auto_proxy_import(globals()):
+    from . import types as _types
+
+
+##
+
+
+@lang.cached_function
+def backend_configs() -> 'inj.ItemsBinderHelper[mc.Config]':
+    return inj.items_binder_helper[mc.Config](_types.BackendConfigs)

ommlds-0.0.0.dev464/ommlds/cli/sessions/chat/backends/types.py

@@ -0,0 +1,36 @@
+import abc
+import typing as ta
+
+from omlish import lang
+
+from ..... import minichain as mc
+
+
+ServiceT = ta.TypeVar('ServiceT', bound=mc.Service)
+
+
+##
+
+
+BackendName = ta.NewType('BackendName', str)
+BackendConfigs = ta.NewType('BackendConfigs', ta.Sequence['mc.Config'])
+
+
+##
+
+
+class BackendProvider(lang.Abstract, ta.Generic[ServiceT]):
+    @abc.abstractmethod
+    def provide_backend(self) -> ta.AsyncContextManager[ServiceT]:
+        raise NotImplementedError
+
+
+##
+
+
+class ChatChoicesServiceBackendProvider(BackendProvider['mc.ChatChoicesService'], lang.Abstract):
+    pass
+
+
+class ChatChoicesStreamServiceBackendProvider(BackendProvider['mc.ChatChoicesStreamService'], lang.Abstract):
+    pass

ommlds-0.0.0.dev464/ommlds/cli/sessions/chat/chat/ai/inject.py

@@ -0,0 +1,81 @@
+from omlish import inject as inj
+from omlish import lang
+
+from ...... import minichain as mc
+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(
+        *,
+        stream: bool = False,
+        silent: bool = False,
+        enable_tools: bool = False,
+) -> 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))
+
+    #
+
+    if stream:
+        ai_stack = inj.wrapper_binder_helper(_types.StreamAiChatGenerator)
+
+        els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesStreamServiceStreamAiChatGenerator, singleton=True))
+
+        if not silent:
+            els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingStreamAiChatGenerator, singleton=True))
+
+        if enable_tools:
+            raise NotImplementedError
+
+        els.extend([
+            inj.bind(_types.StreamAiChatGenerator, to_key=ai_stack.top),
+            inj.bind(_types.AiChatGenerator, to_key=_types.StreamAiChatGenerator),
+        ])
+
+    else:
+        ai_stack = inj.wrapper_binder_helper(_types.AiChatGenerator)
+
+        els.append(ai_stack.push_bind(to_ctor=_services.ChatChoicesServiceAiChatGenerator, singleton=True))
+
+        if not silent:
+            els.append(ai_stack.push_bind(to_ctor=_rendering.RenderingAiChatGenerator, singleton=True))
+
+        if 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 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-0.0.0.dev464/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-0.0.0.dev464/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.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+    ) -> mc.Chat:
+        async with self._renderer.create_context() as renderer:
+            async def inner(delta: mc.AiChoiceDelta) -> None:
+                if isinstance(delta, mc.ContentAiChoiceDelta):
+                    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-0.0.0.dev464/ommlds/cli/sessions/chat/chat/ai/services.py

@@ -0,0 +1,81 @@
+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.AiChoiceDelta'], ta.Awaitable[None]] | None = None,
+    ) -> mc.AiChat:
+        opts = self._options() if self._options is not None else []
+
+        lst: list[str] = []
+
+        async with self._service_provider.provide_backend() as service:
+            async with (await service.invoke(mc.ChatChoicesStreamRequest(chat, opts))).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-0.0.0.dev464/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