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

ommlds/specs/mcp/_marshal.py

@@ -0,0 +1,23 @@
+from omlish import lang
+from omlish import marshal as msh
+
+from .protocol import ContentBlock
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    for root_cls, tag_field in [
+        (ContentBlock, 'type'),
+    ]:
+        msh.install_standard_factories(*msh.standard_polymorphism_factories(
+            msh.polymorphism_from_subclasses(
+                root_cls,
+                naming=msh.Naming.SNAKE,
+                strip_suffix=msh.AutoStripSuffix,
+            ),
+            msh.FieldTypeTagging(tag_field),
+            unions='partial',
+        ))

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
+        ]

ommlds/specs/mcp/protocol.py

@@ -0,0 +1,371 @@
+"""
+https://modelcontextprotocol.io/specification/2025-06-18
+https://modelcontextprotocol.io/specification/2025-06-18/schema
+
+TODO:
+ - https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/cancellation
+ - https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/progress
+ - https://modelcontextprotocol.io/specification/2025-06-18/client/sampling
+ - https://modelcontextprotocol.io/specification/2025-06-18/client/elicitation
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/prompts
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/resources
+ - https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/logging
+"""
+import abc
+import typing as ta
+
+from omlish import collections as col
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+
+
+ClientRequestT = ta.TypeVar('ClientRequestT', bound='ClientRequest')
+ClientResultT = ta.TypeVar('ClientResultT', bound='ClientResult')
+
+ServerRequestT = ta.TypeVar('ServerRequestT', bound='ServerRequest')
+ServerResultT = ta.TypeVar('ServerResultT', bound='ServerResult')
+
+CursorClientRequestT = ta.TypeVar('CursorClientRequestT', bound='CursorClientRequest')
+CursorClientResultT = ta.TypeVar('CursorClientResultT', bound='CursorClientResult')
+
+
+msh.register_global_module_import('._marshal', __package__)
+
+
+##
+
+
+def _set_class_marshal_options(cls):
+    msh.update_object_metadata(
+        cls,
+        field_naming=msh.Naming.LOW_CAMEL,
+        field_defaults=msh.FieldMetadata(
+            options=msh.FieldOptions(
+                omit_if=lang.is_none,
+            ),
+        ),
+    )
+    return cls
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Message(lang.Sealed, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def json_rpc_method_name(self) -> str:
+        raise NotImplementedError
+
+
+#
+
+
+class ClientRequest(Message, lang.Abstract, ta.Generic[ClientResultT]):
+    pass
+
+
+class ClientResult(Message, lang.Abstract, ta.Generic[ClientRequestT]):
+    pass
+
+
+#
+
+
+class ServerRequest(Message, lang.Abstract, ta.Generic[ServerResultT]):
+    pass
+
+
+class ServerResult(Message, lang.Abstract, ta.Generic[ServerRequestT]):
+    pass
+
+
+#
+
+
+class Notification(Message, lang.Abstract):
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class WithMeta(lang.Sealed, lang.Abstract):
+    meta_: ta.Mapping[str, ta.Any] | None = dc.field(default=None) | msh.with_field_metadata(name='_meta')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Implementation(lang.Final):
+    name: str
+    version: str
+
+
+DEFAULT_PROTOCOL_VERSION = '2025-06-18'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ClientCapabilities(lang.Final):
+    elicitation: ta.Any | None = None
+
+    experimental: ta.Mapping[str, ta.Any] | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Roots:
+        list_changed: bool | None = None
+
+    roots: Roots | None = None
+
+    sampling: ta.Any | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializeRequest(ClientRequest['InitializeResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialize'
+
+    client_info: Implementation
+    protocol_version: str = DEFAULT_PROTOCOL_VERSION
+    capabilities: ClientCapabilities = ClientCapabilities()
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ServerCapabilities:
+    completions: ta.Any | None = None
+
+    experimental: ta.Mapping[str, ta.Any] | None = None
+
+    logging: ta.Any | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Prompts:
+        list_changed: bool | None = None
+
+    prompts: Prompts | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Resources:
+        list_changed: bool | None = None
+        subscribe: bool | None = None
+
+    resources: Resources | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Tools:
+        list_changed: bool | None = None
+
+    tools: Tools | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializeResult(ClientResult[InitializeRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialize'
+
+    server_info: Implementation
+    protocol_version: str
+    capabilities: ServerCapabilities
+    instructions: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class InitializedNotification(Notification):
+    json_rpc_method_name: ta.ClassVar[str] = 'initialized'
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CursorClientRequest(ClientRequest[CursorClientResultT], lang.Abstract):
+    cursor: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CursorClientResult(ClientResult[CursorClientRequestT], lang.Abstract):
+    next_cursor: str | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ToolAnnotations(lang.Final):
+    destructive_hint: bool | None = None
+    idempotent_hint: bool | None = None
+    open_world_hint: bool | None = None
+    read_only_hint: bool | None = None
+    title: str | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Tool(WithMeta, lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    annotations: ToolAnnotations | None = None
+
+    input_schema: ta.Any
+    output_schema: ta.Any | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListToolsRequest(CursorClientRequest['ListToolsResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/list'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListToolsResult(CursorClientResult[ListToolsRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/list'
+
+    tools: ta.Sequence[Tool]
+
+
+##
+
+
+class ContentBlock(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class TextContentBlock(ContentBlock, lang.Final):
+    text: str
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class CallToolRequest(ClientRequest['CallToolResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/call'
+
+    name: str
+    arguments: ta.Mapping[str, ta.Any] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class CallToolResult(ClientResult[CallToolRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'tools/call'
+
+    content: ta.Sequence[ContentBlock]
+    is_error: bool | None = None
+    structured_content: ta.Mapping[str, ta.Any] | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingClientRequest(ClientRequest['PingClientResult'], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingClientResult(ClientResult[PingClientRequest]):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingServerRequest(ServerRequest['PingServerResult'], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PingServerResult(ServerResult[PingServerRequest]):
+    json_rpc_method_name: ta.ClassVar[str] = 'ping'
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class PromptArgument(lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    required: bool | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class Prompt(WithMeta, lang.Final):
+    name: str
+    title: str | None = None
+
+    description: str | None = None
+
+    arguments: ta.Sequence[PromptArgument] | None = None
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListPromptsRequest(CursorClientRequest['ListPromptsResult']):
+    json_rpc_method_name: ta.ClassVar[str] = 'prompts/list'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ListPromptsResult(CursorClientResult[ListPromptsRequest], WithMeta):
+    json_rpc_method_name: ta.ClassVar[str] = 'prompts/list'
+
+    prompts: ta.Sequence[Prompt]
+
+
+##
+
+
+LoggingLevel: ta.TypeAlias = ta.Literal[
+    'debug',
+    'info',
+    'notice',
+    'warning',
+    'error',
+    'critical',
+    'alert',
+    'emergency',
+]
+
+
+##
+
+
+MESSAGE_TYPES_BY_JSON_RPC_METHOD_NAME: ta.Mapping[type[Message], ta.Mapping[str, type[Message]]] = {
+    bty: col.make_map_by(lambda mty: mty.json_rpc_method_name, lang.deep_subclasses(bty, concrete_only=True))  # type: ignore  # noqa
+    for bty in [
+        ClientRequest,
+        ClientResult,
+        ServerRequest,
+        ServerResult,
+        Notification,
+    ]
+}

ommlds/tools/git.py

@@ -12,10 +12,12 @@ import urllib.request
 
 from omdev.git.magic import GIT_DIFF_OMIT_MAGIC_COMMENT
 from omdev.home.secrets import load_secrets
+from omdev.py.srcheaders import get_py_header_lines
 from omdev.tools.git.messages import GitMessageGenerator
 from omlish import check
 from omlish import lang
 from omlish.configs.classes import Configurable
+from omlish.http import all as http
 from omlish.subprocesses.sync import subprocesses
 
 from .. import minichain as mc
@@ -23,10 +25,8 @@ from ..minichain.backends.impls.openai.chat import OpenaiChatChoicesService
 from ..server.client import McServerClient
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from ..minichain.backends.impls.mlx import chat as mc_mlx_chat
-else:
-    mc_mlx_chat = lang.proxy_import('..minichain.backends.impls.mlx.chat', __package__)
 
 
 GitAiBackendConfigT = ta.TypeVar('GitAiBackendConfigT', bound='GitAiBackend.Config')
@@ -45,6 +45,22 @@ class GitAiBackend(Configurable[GitAiBackendConfigT], lang.Abstract):
         raise NotImplementedError
 
 
+def _get_single_ai_message_str(resp: mc.ChatChoicesResponse) -> str:
+    return check.not_empty(
+        check.isinstance(
+            check.isinstance(
+                check.single(
+                    check.single(
+                        resp.v,
+                    ).ms,
+                ),
+                mc.AiMessage,
+            ).c,
+            str,
+        ),
+    )
+
+
 #
 
 
@@ -62,13 +78,15 @@ class OpenaiGitAiBackend(GitAiBackend['OpenaiGitAiBackend.Config']):
             if (sec := load_secrets().try_get(key.lower())) is not None:
                 os.environ[key] = sec.reveal()
 
-        llm = OpenaiChatChoicesService()
+        llm = OpenaiChatChoicesService(
+            http_client=http.SyncAsyncHttpClient(http.client()),
+        )
 
-        resp = llm.invoke(mc.ChatChoicesRequest(
+        resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
             [mc.UserMessage(prompt)],
             # FIXME:  *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
-        ))
-        return check.not_empty(check.isinstance(resp.v[0].m.c, str))
+        )))
+        return _get_single_ai_message_str(resp)
 
 
 #
@@ -93,11 +111,11 @@ class MlxGitAiBackend(GitAiBackend['MlxGitAiBackend.Config']):
 
     def _run_prompt(self, prompt: str) -> str:
         with mc_mlx_chat.MlxChatChoicesService(mc.ModelRepo.parse(self._config.model)) as llm:
-            resp = llm.invoke(mc.ChatChoicesRequest(
+            resp = lang.sync_await(llm.invoke(mc.ChatChoicesRequest(
                 [mc.UserMessage(prompt)],
                 # FIXME: *((MaxTokens(self._config.max_tokens),) if self._config.max_tokens is not None else ()),
-            ))
-            text = check.not_empty(check.isinstance(resp.v[0].m.c, str))
+            )))
+            text = _get_single_ai_message_str(resp)
 
             text = _strip_markdown_code_block(text)
 
@@ -199,9 +217,14 @@ class AiGitMessageGenerator(GitMessageGenerator):
         except FileNotFoundError:
             return False
 
+        hls = get_py_header_lines(f_src)
+
         return any(
-            l.startswith(GIT_DIFF_OMIT_MAGIC_COMMENT)
-            for l in f_src.splitlines()
+            hl.src.strip() in (
+                '# @omlish-generated',
+                GIT_DIFF_OMIT_MAGIC_COMMENT,
+            )
+            for hl in hls
         )
 
     # TODO: configurable

ommlds/tools/ocr.py

@@ -13,20 +13,13 @@ from omlish import check
 from omlish import lang
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import pytesseract
     import rapidocr_onnxruntime as rapidocr
     from PIL import Image
 
     from omdev.clipboard import darwin_cf as darwin_clipboard
 
-else:
-    pytesseract = lang.proxy_import('pytesseract')
-    rapidocr = lang.proxy_import('rapidocr_onnxruntime')
-    Image = lang.proxy_import('PIL.Image')
-
-    darwin_clipboard = lang.proxy_import('omdev.clipboard.darwin_cf')
-
 
 ##
 
@@ -34,7 +27,7 @@ else:
 Ocr: ta.TypeAlias = ta.Callable[['Image.Image'], str]
 
 OCR_BACKENDS: ta.Mapping[str, Ocr] = {
-    'rapidocr': lambda img: '\n'.join(text[1] for text in rapidocr.RapidOCR()(img)[0] or []),
+    'rapidocr': lambda img: '\n'.join(text[1] for text in rapidocr.RapidOCR()(_get_img_png_bytes(img))[0] or []),
     'tesseract': lambda img: pytesseract.image_to_string(img),
 }
 
@@ -62,6 +55,12 @@ def _get_img_data(file: str | None) -> ta.Any:
         return sys.stdin.buffer
 
 
+def _get_img_png_bytes(img: 'Image.Image') -> bytes:
+    out = io.BytesIO()
+    img.save(out, format='PNG')
+    return out.getvalue()
+
+
 def _main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument('file', nargs='?')