ommlds 0.0.0.dev480__py3-none-any.whl → 0.0.0.dev481__py3-none-any.whl

ommlds/minichain/backends/impls/duckduckgo/search.py

@@ -1,4 +1,4 @@
-import ddgs
+from omlish import lang
 
 from ....search import SearchHit
 from ....search import SearchHits
@@ -7,6 +7,10 @@ from ....search import SearchResponse
 from ....search import static_check_is_search_service
 
 
+with lang.auto_proxy_import(globals()):
+    import ddgs
+
+
 ##
 
 

ommlds/minichain/backends/impls/huggingface/repos.py

@@ -3,8 +3,6 @@ TODO:
  - local-only check first
   - cat ~/.cache/.../models/.../refs/main -> c5bfd839cd4cda0e5a39a97e00218d9c56e468af
 """
-import typing as ta
-
 from omlish import lang
 
 from ....models.configs import ModelRepo
@@ -12,10 +10,8 @@ from ....models.repos.resolving import ModelRepoResolver
 from ....models.repos.resolving import ResolvedModelRepo
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import huggingface_hub as hf
-else:
-    hf = lang.proxy_import('huggingface_hub')
 
 
 ##

ommlds/minichain/backends/impls/llamacpp/chat.py

@@ -2,13 +2,10 @@ import contextlib
 import os.path
 import typing as ta
 
-import llama_cpp as lcc
-
 from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import llamacpp as lcu
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -27,6 +24,12 @@ from .format import ROLES_MAP
 from .format import get_msg_content
 
 
+with lang.auto_proxy_import(globals()):
+    import llama_cpp as lcc
+
+    from .....backends import llamacpp as lcu
+
+
 ##
 
 

ommlds/minichain/backends/impls/llamacpp/completion.py

@@ -2,11 +2,9 @@ import contextlib
 import os.path
 import typing as ta
 
-import llama_cpp as lcc
-
+from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import llamacpp as lcu
 from ....completion import CompletionOption
 from ....completion import CompletionRequest
 from ....completion import CompletionResponse
@@ -18,6 +16,12 @@ from ....llms.types import Temperature
 from ....models.configs import ModelPath
 
 
+with lang.auto_proxy_import(globals()):
+    import llama_cpp as lcc
+
+    from .....backends import llamacpp as lcu
+
+
 ##
 
 

ommlds/minichain/backends/impls/llamacpp/stream.py

@@ -2,13 +2,10 @@ import contextlib
 import threading
 import typing as ta  # noqa
 
-import llama_cpp as lcc
-
 from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import llamacpp as lcu
 from ....chat.choices.services import ChatChoicesOutputs
 from ....chat.choices.stream.services import ChatChoicesStreamRequest
 from ....chat.choices.stream.services import ChatChoicesStreamResponse
@@ -26,6 +23,12 @@ from .format import ROLES_MAP
 from .format import get_msg_content
 
 
+with lang.auto_proxy_import(globals()):
+    import llama_cpp as lcc
+
+    from .....backends import llamacpp as lcu
+
+
 ##
 
 

ommlds/minichain/backends/impls/mlx/chat.py

@@ -5,7 +5,6 @@ from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import mlx as mlxu
 from ....chat.choices.services import ChatChoicesOutputs
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
@@ -33,6 +32,10 @@ from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 
 
+with lang.auto_proxy_import(globals()):
+    from .....backends import mlx as mlxu
+
+
 ##
 
 
@@ -83,7 +86,7 @@ class BaseMlxChatChoicesService(lang.ExitStacked):
             raise TypeError(m)
 
     @lang.cached_function(transient=True)
-    def _load_model(self) -> mlxu.LoadedModel:
+    def _load_model(self) -> 'mlxu.LoadedModel':
         # FIXME: walk state, find all mx.arrays, dealloc/set to empty
         check.not_none(self._exit_stack)
 
@@ -100,7 +103,7 @@ class BaseMlxChatChoicesService(lang.ExitStacked):
     )
 
     @lang.cached_function(transient=True)
-    def _get_tokenizer(self) -> mlxu.tokenization.Tokenizer:
+    def _get_tokenizer(self) -> 'mlxu.tokenization.Tokenizer':
         tokenizer = self._load_model().tokenization.tokenizer
 
         if not (

ommlds/minichain/backends/impls/sentencepiece/tokens.py

@@ -1,23 +1,26 @@
 import typing as ta
 
-import sentencepiece as spm
-
 from omlish import check
+from omlish import lang
 
 from .... import tokens as tks
 
 
+with lang.auto_proxy_import(globals()):
+    import sentencepiece as spm
+
+
 ##
 
 
-def build_vocab(spm_tokenizer: spm.SentencePieceProcessor) -> tks.Vocab:
+def build_vocab(spm_tokenizer: 'spm.SentencePieceProcessor') -> tks.Vocab:
     return tks.Vocab([
         (ta.cast(tks.Token, i), tks.TokenStr(spm_tokenizer.id_to_piece(i)))  # noqa
         for i in range(spm_tokenizer.get_piece_size())  # noqa
     ])
 
 
-def build_specials(spm_tokenizer: spm.SentencePieceProcessor) -> tks.SpecialTokens:
+def build_specials(spm_tokenizer: 'spm.SentencePieceProcessor') -> tks.SpecialTokens:
     # FIXME
     return tks.SpecialTokens([])
 
@@ -28,7 +31,7 @@ def build_specials(spm_tokenizer: spm.SentencePieceProcessor) -> tks.SpecialToke
 class SentencepieceTokenizer(tks.BaseTokenizer):
     def __init__(
             self,
-            spm_tokenizer: spm.SentencePieceProcessor,
+            spm_tokenizer: 'spm.SentencePieceProcessor',
     ) -> None:
         self._spm_tokenizer = check.isinstance(spm_tokenizer, spm.SentencePieceProcessor)
 
@@ -38,7 +41,7 @@ class SentencepieceTokenizer(tks.BaseTokenizer):
         )
 
     @property
-    def spm_tokenizer(self) -> spm.SentencePieceProcessor:
+    def spm_tokenizer(self) -> 'spm.SentencePieceProcessor':
         return self._spm_tokenizer
 
     #

ommlds/minichain/backends/impls/tinygrad/chat.py

@@ -4,7 +4,6 @@ import typing as ta
 from omlish import check
 from omlish import lang
 
-from .....backends.tinygrad.models import llama3 as tgl3
 from ....chat.choices.services import ChatChoicesOptions
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
@@ -28,6 +27,10 @@ from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 
 
+with lang.auto_proxy_import(globals()):
+    from .....backends.tinygrad.models import llama3 as tgl3
+
+
 ##
 
 
@@ -39,7 +42,7 @@ def _load_model(
         *,
         size: str | None = None,
         temperature: float | None = None,
-) -> tgl3.Llama3Llm:
+) -> 'tgl3.Llama3Llm':
     if size is None:
         size = DEFAULT_SIZE
     if temperature is None:
@@ -58,7 +61,7 @@ def _load_model(
 
 
 def _prepare_toks(
-        llm: tgl3.Llama3Llm,
+        llm: 'tgl3.Llama3Llm',
         chat: Chat,
         options: ta.Sequence[ChatChoicesOptions],
 ) -> list[int]:
@@ -100,7 +103,7 @@ class BaseTinygradLlama3ChatService(lang.ExitStacked, lang.Abstract):
         self._temperature = temperature
 
     @lang.cached_function(transient=True)
-    def _load_model(self) -> tgl3.Llama3Llm:
+    def _load_model(self) -> 'tgl3.Llama3Llm':
         check.not_none(self._exit_stack)
 
         return _load_model(

ommlds/minichain/backends/impls/tokenizers/tokens.py

@@ -1,23 +1,26 @@
 import typing as ta
 
-import tokenizers as tos
-
 from omlish import check
+from omlish import lang
 
 from .... import tokens as tks
 
 
+with lang.auto_proxy_import(globals()):
+    import tokenizers as tos
+
+
 ##
 
 
-def build_vocab(tos_tokenizer: tos.Tokenizer) -> tks.Vocab:
+def build_vocab(tos_tokenizer: 'tos.Tokenizer') -> tks.Vocab:
     return tks.Vocab([
         (ta.cast(tks.Token, i), tks.TokenStr(s))
         for s, i in tos_tokenizer.get_vocab().items()
     ])
 
 
-def build_specials(tos_tokenizer: tos.Tokenizer) -> tks.SpecialTokens:
+def build_specials(tos_tokenizer: 'tos.Tokenizer') -> tks.SpecialTokens:
     # FIXME
     return tks.SpecialTokens([])
 
@@ -28,7 +31,7 @@ def build_specials(tos_tokenizer: tos.Tokenizer) -> tks.SpecialTokens:
 class TokenizersTokenizer(tks.BaseTokenizer):
     def __init__(
             self,
-            tos_tokenizer: tos.Tokenizer,
+            tos_tokenizer: 'tos.Tokenizer',
     ) -> None:
         self._tos_tokenizer = check.isinstance(tos_tokenizer, tos.Tokenizer)
 
@@ -38,7 +41,7 @@ class TokenizersTokenizer(tks.BaseTokenizer):
         )
 
     @property
-    def tos_tokenizer(self) -> tos.Tokenizer:
+    def tos_tokenizer(self) -> 'tos.Tokenizer':
         return self._tos_tokenizer
 
     #

ommlds/minichain/backends/impls/transformers/sentence.py

@@ -1,7 +1,6 @@
 import typing as ta
 
-import sentence_transformers as stfm
-
+from omlish import lang
 from omlish import typedvalues as tv
 
 from ....configs import Config
@@ -13,6 +12,10 @@ from ....vectors.embeddings import static_check_is_embedding_service
 from ....vectors.types import Vector
 
 
+with lang.auto_proxy_import(globals()):
+    import sentence_transformers as stfm
+
+
 ##
 
 

ommlds/minichain/backends/impls/transformers/tokens.py

@@ -1,17 +1,20 @@
 import typing as ta
 
-import transformers as tfm
-
 from omlish import check
 from omlish import collections as col
+from omlish import lang
 
 from .... import tokens as tks
 
 
+with lang.auto_proxy_import(globals()):
+    import transformers as tfm
+
+
 ##
 
 
-def build_vocab(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.Vocab:
+def build_vocab(tfm_tokenizer: 'tfm.PreTrainedTokenizerBase') -> tks.Vocab:
     return tks.Vocab([
         (ta.cast(tks.Token, i), tks.TokenStr(s))
         for s, i in tfm_tokenizer.get_vocab().items()
@@ -32,7 +35,7 @@ SPECIAL_TOKEN_ATTR_MAP: col.BiMap[type[tks.SpecialToken], str] = col.make_bi_map
 })
 
 
-def build_specials(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.SpecialTokens:
+def build_specials(tfm_tokenizer: 'tfm.PreTrainedTokenizerBase') -> tks.SpecialTokens:
     return tks.SpecialTokens.from_dict({
         st: getattr(tfm_tokenizer, a)
         for st, a in SPECIAL_TOKEN_ATTR_MAP.items()
@@ -45,7 +48,7 @@ def build_specials(tfm_tokenizer: tfm.PreTrainedTokenizerBase) -> tks.SpecialTok
 class TransformersTokenizer(tks.BaseTokenizer):
     def __init__(
             self,
-            tfm_tokenizer: tfm.PreTrainedTokenizerBase,
+            tfm_tokenizer: 'tfm.PreTrainedTokenizerBase',
     ) -> None:
         self._tfm_tokenizer = check.isinstance(tfm_tokenizer, tfm.PreTrainedTokenizerBase)
 
@@ -55,7 +58,7 @@ class TransformersTokenizer(tks.BaseTokenizer):
         )
 
     @property
-    def tfm_tokenizer(self) -> tfm.PreTrainedTokenizerBase:
+    def tfm_tokenizer(self) -> 'tfm.PreTrainedTokenizerBase':
         return self._tfm_tokenizer
 
     #

ommlds/minichain/backends/impls/transformers/transformers.py

@@ -7,15 +7,11 @@ import sys
 import threading
 import typing as ta
 
-import transformers as tfm
-
 from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 from omlish.asyncs.asyncio.sync import AsyncioBufferRelay
 
-from .....backends.transformers.filecache import file_cache_patch_context
-from .....backends.transformers.streamers import CancellableTextStreamer
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -44,6 +40,12 @@ from ....stream.services import new_stream_response
 from ...impls.huggingface.configs import HuggingfaceHubToken
 
 
+with lang.auto_proxy_import(globals()):
+    import transformers as tfm
+
+    from .....backends import transformers as tfm_u
+
+
 ##
 
 
@@ -168,7 +170,7 @@ class BaseTransformersChatChoicesService(lang.ExitStacked):
             self._huggingface_hub_token = HuggingfaceHubToken.pop_secret(cc, env='HUGGINGFACE_HUB_TOKEN')
 
     @lang.cached_function(transient=True)
-    def _load_pipeline(self) -> tfm.Pipeline:
+    def _load_pipeline(self) -> 'tfm.Pipeline':
         # FIXME: unload
         check.not_none(self._exit_stack)
 
@@ -181,7 +183,7 @@ class BaseTransformersChatChoicesService(lang.ExitStacked):
         for pkw_cfg in self._pipeline_kwargs:
             pkw.update(pkw_cfg.v)
 
-        with file_cache_patch_context(
+        with tfm_u.file_cache_patch_context(
                 local_first=True,
                 local_config_present_is_authoritative=True,
         ):
@@ -246,7 +248,7 @@ class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
             if text or stream_end:
                 relay.push(text, *([None] if stream_end else []))
 
-        streamer = CancellableTextStreamer(
+        streamer = tfm_u.CancellableTextStreamer(
             check.not_none(pipeline.tokenizer),  # type: ignore[arg-type]
             streamer_callback,  # noqa
             skip_prompt=True,
@@ -255,7 +257,7 @@ class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
 
         async with UseResources.or_new(request.options) as rs:
             thread = threading.Thread(
-                target=CancellableTextStreamer.ignoring_cancelled(pipeline),
+                target=tfm_u.CancellableTextStreamer.ignoring_cancelled(pipeline),
                 args=(
                     inputs,
                 ),

ommlds/specs/mcp/clients.py

@@ -0,0 +1,146 @@
+import contextlib
+import subprocess
+import typing as ta
+
+import anyio.abc
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import marshal as msh
+from omlish.asyncs import anyio as aiu
+from omlish.specs import jsonrpc as jr
+
+from . import protocol as pt
+
+
+##
+
+
+class McpServerConnection:
+    def __init__(
+            self,
+            tg: anyio.abc.TaskGroup,
+            stream: anyio.abc.ByteStream,
+            *,
+            default_timeout: float | None = 30.,
+    ) -> None:
+        super().__init__()
+
+        self._conn = jr.Connection(
+            tg,
+            stream,
+            request_handler=self._handle_client_request,
+            notification_handler=self._handle_client_notification,
+            default_timeout=default_timeout,
+        )
+
+    #
+
+    @classmethod
+    def from_process(
+            cls,
+            tg: anyio.abc.TaskGroup,
+            proc: anyio.abc.Process,
+            **kwargs: ta.Any,
+    ) -> 'McpServerConnection':
+        return cls(
+            tg,
+            aiu.StapledByteStream(
+                check.not_none(proc.stdin),
+                check.not_none(proc.stdout),
+            ),
+            **kwargs,
+        )
+
+    @classmethod
+    def open_process(
+            cls,
+            tg: anyio.abc.TaskGroup,
+            cmd: ta.Sequence[str],
+            open_kwargs: ta.Mapping[str, ta.Any] | None = None,
+            **kwargs: ta.Any,
+    ) -> ta.AsyncContextManager[tuple[anyio.abc.Process, 'McpServerConnection']]:
+        @contextlib.asynccontextmanager
+        async def inner():
+            async with await anyio.open_process(
+                    cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    **open_kwargs or {},
+            ) as proc:
+                async with cls.from_process(
+                        tg,
+                        proc,
+                        **kwargs,
+                ) as client:
+                    yield (proc, client)
+
+        return inner()
+
+    #
+
+    async def __aenter__(self) -> 'McpServerConnection':
+        await self._conn.__aenter__()
+        return self
+
+    async def __aexit__(self, et, e, tb) -> None:
+        await self._conn.__aexit__(et, e, tb)
+
+    #
+
+    async def _handle_client_request(self, _client: jr.Connection, req: jr.Request) -> None:
+        pass
+
+    async def _handle_client_notification(self, _client: jr.Connection, no: jr.Request) -> None:
+        pass
+
+    #
+
+    async def request(self, req: pt.ClientRequest[pt.ClientResultT]) -> pt.ClientResultT:
+        res_cls = pt.MESSAGE_TYPES_BY_JSON_RPC_METHOD_NAME[pt.ClientResult][req.json_rpc_method_name]  # type: ignore[type-abstract]  # noqa
+        req_mv = msh.marshal(req)
+        res_mv = await self._conn.request(req.json_rpc_method_name, req_mv)  # type: ignore[arg-type]
+        res = msh.unmarshal(res_mv, res_cls)
+        return ta.cast(pt.ClientResultT, res)
+
+    async def notify(self, no: pt.Notification) -> None:
+        no_mv = msh.marshal(no)
+        await self._conn.notify(no.json_rpc_method_name, no_mv)  # type: ignore[arg-type]
+
+    #
+
+    async def yield_cursor_request(
+            self,
+            req: pt.CursorClientRequest[pt.CursorClientResultT],
+    ) -> ta.AsyncGenerator[pt.CursorClientResultT]:
+        check.none(req.cursor)
+
+        cursor: str | None = None
+        while True:
+            res = await self.request(dc.replace(req, cursor=cursor))  # noqa
+            yield res
+
+            if (cursor := res.next_cursor) is None:
+                break
+
+    async def list_cursor_request(
+            self,
+            req: pt.CursorClientRequest[pt.CursorClientResultT],
+    ) -> list[pt.CursorClientResultT]:
+        return [res async for res in self.yield_cursor_request(req)]
+
+    #
+
+    async def list_tools(self) -> list[pt.Tool]:
+        return [
+            tool
+            async for res in self.yield_cursor_request(pt.ListToolsRequest())
+            for tool in res.tools
+        ]
+
+    async def list_prompts(self) -> list[pt.Prompt]:
+        return [
+            prompt
+            async for res in self.yield_cursor_request(pt.ListPromptsRequest())
+            for prompt in res.prompts
+        ]