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

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/ollama/chat.py

@@ -1,3 +1,29 @@
+"""
+dolphin3:latest           d5ab9ae8e1f2    4.9 GB    11 months ago (no tools)
+
+functiongemma:270m        7c19b650567a    300 MB    5 minutes ago
+gemma3:27b                a418f5838eaf    17 GB     7 weeks ago (no tools)
+gemma3:4b                 a2af6cc3eb7f    3.3 GB    7 weeks ago (no tools)
+
+llama3.2:1b               baf6a787fdff    1.3 GB    13 months ago (too stupid for tools)
+llama3.2:latest           a80c4f17acd5    2.0 GB    13 months ago
+
+devstral-small-2:24b      24277f07f62d    15 GB     15 hours ago
+ministral-3:14b           4760c35aeb9d    9.1 GB    11 hours ago
+mistral:latest            6577803aa9a0    4.4 GB    3 seconds ago
+
+nemotron-3-nano:30b       b725f1117407    24 GB     15 hours ago
+
+olmo-3.1:32b-instruct     a16b6a5be6cf    19 GB     11 hours ago (no tools)
+olmo-3.1:32b-think        223d4ec84d91    19 GB     11 hours ago (no tools)
+
+phi4-mini:latest          78fad5d182a7    2.5 GB    8 months ago (no tools)
+
+qwen3-coder:30b           06c1097efce0    18 GB     11 hours ago
+qwen3-next:80b            b2ebb986e4e9    50 GB     11 hours ago
+qwen3:30b                 ad815644918f    18 GB     11 hours ago
+qwen3:32b                 030ee887880f    20 GB     11 hours ago
+"""
 import typing as ta
 
 from omlish import check
@@ -16,20 +42,17 @@ from ....chat.choices.services import static_check_is_chat_choices_service
 from ....chat.choices.stream.services import ChatChoicesStreamRequest
 from ....chat.choices.stream.services import ChatChoicesStreamResponse
 from ....chat.choices.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.choices.stream.types import AiChoiceDeltas
 from ....chat.choices.stream.types import AiChoicesDeltas
-from ....chat.choices.types import AiChoice
-from ....chat.messages import AiMessage
-from ....chat.messages import AnyAiMessage
-from ....chat.messages import Message
-from ....chat.messages import SystemMessage
-from ....chat.messages import UserMessage
-from ....chat.stream.types import ContentAiDelta
+from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiUrl
 from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
+from .protocol import build_mc_ai_choice_deltas
+from .protocol import build_mc_choices_response
+from .protocol import build_ol_request_messages
+from .protocol import build_ol_request_tool
 
 
 ##
@@ -64,31 +87,6 @@ class BaseOllamaChatChoicesService(lang.Abstract):
             self._api_url = cc.pop(self.DEFAULT_API_URL)
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
 
-    #
-
-    ROLE_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.Role]] = {  # noqa
-        SystemMessage: 'system',
-        UserMessage: 'user',
-        AiMessage: 'assistant',
-    }
-
-    @classmethod
-    def _get_message_content(cls, m: Message) -> str | None:
-        if isinstance(m, (AiMessage, UserMessage, SystemMessage)):
-            return check.isinstance(m.c, str)
-        else:
-            raise TypeError(m)
-
-    @classmethod
-    def _build_request_messages(cls, mc_msgs: ta.Iterable[Message]) -> ta.Sequence[pt.Message]:
-        messages: list[pt.Message] = []
-        for m in mc_msgs:
-            messages.append(pt.Message(
-                role=cls.ROLE_MAP[type(m)],
-                content=cls._get_message_content(m),
-            ))
-        return messages
-
 
 ##
 
@@ -103,12 +101,18 @@ class OllamaChatChoicesService(BaseOllamaChatChoicesService):
             self,
             request: ChatChoicesRequest,
     ) -> ChatChoicesResponse:
-        messages = self._build_request_messages(request.v)
+        messages = build_ol_request_messages(request.v)
+
+        tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_ol_request_tool(t))
 
         a_req = pt.ChatRequest(
             model=self._model_name.v,
             messages=messages,
-            # tools=tools or None,
+            tools=tools or None,
             stream=False,
         )
 
@@ -124,17 +128,7 @@ class OllamaChatChoicesService(BaseOllamaChatChoicesService):
 
         resp = msh.unmarshal(json_response, pt.ChatResponse)
 
-        out: list[AnyAiMessage] = []
-        if resp.message.role == 'assistant':
-            out.append(AiMessage(
-                check.not_none(resp.message.content),
-            ))
-        else:
-            raise TypeError(resp.message.role)
-
-        return ChatChoicesResponse([
-            AiChoice(out),
-        ])
+        return build_mc_choices_response(resp)
 
 
 ##
@@ -152,12 +146,18 @@ class OllamaChatChoicesStreamService(BaseOllamaChatChoicesService):
             self,
             request: ChatChoicesStreamRequest,
     ) -> ChatChoicesStreamResponse:
-        messages = self._build_request_messages(request.v)
+        messages = build_ol_request_messages(request.v)
+
+        tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_ol_request_tool(t))
 
         a_req = pt.ChatRequest(
             model=self._model_name.v,
             messages=messages,
-            # tools=tools or None,
+            tools=tools or None,
             stream=True,
         )
 
@@ -179,19 +179,13 @@ class OllamaChatChoicesStreamService(BaseOllamaChatChoicesService):
                     for l in db.feed(b):
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(l)
 
                         lj = json.loads(l.decode('utf-8'))
                         lp: pt.ChatResponse = msh.unmarshal(lj, pt.ChatResponse)
 
-                        check.state(lp.message.role == 'assistant')
-                        check.none(lp.message.tool_name)
-                        check.state(not lp.message.tool_calls)
-
-                        if (c := lp.message.content):
-                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
-                                c,
-                            )])]))
+                        if (ds := build_mc_ai_choice_deltas(lp)).deltas:
+                            await sink.emit(AiChoicesDeltas([ds]))
 
                     if not b:
                         return []

ommlds/minichain/backends/impls/ollama/protocol.py

@@ -0,0 +1,144 @@
+import itertools
+
+from omlish import check
+
+from .....backends.ollama import protocol as pt
+from ....chat.choices.services import ChatChoicesResponse
+from ....chat.choices.stream.types import AiChoiceDeltas
+from ....chat.choices.types import AiChoice
+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.stream.types import AiDelta
+from ....chat.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.transform.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_ol_request_messages(chat: Chat) -> list[pt.Message]:
+    ol_msgs: list[pt.Message] = []
+
+    for _, g in itertools.groupby(chat, lambda mc_m: isinstance(mc_m, AnyAiMessage)):
+        mc_msgs = list(g)
+
+        if isinstance(mc_msgs[0], AnyAiMessage):
+            tups: list[tuple[AiMessage | None, list[ToolUseMessage]]] = []
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, AiMessage):
+                    tups.append((mc_msg, []))
+
+                elif isinstance(mc_msg, ToolUseMessage):
+                    if not tups:
+                        tups.append((None, []))
+                    tups[-1][1].append(mc_msg)
+
+                else:
+                    raise TypeError(mc_msg)
+
+            for mc_ai_msg, mc_tu_msgs in tups:
+                ol_msgs.append(pt.Message(
+                    role='assistant',
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.Message.ToolCall(
+                            function=pt.Message.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=mc_tu_msg.tu.args,
+                            ),
+                            id=check.not_none(mc_tu_msg.tu.id),
+                        )
+                        for mc_tu_msg in mc_tu_msgs
+                    ] if mc_tu_msgs else None,
+                ))
+
+        else:
+            for mc_msg in mc_msgs:
+                if isinstance(mc_msg, SystemMessage):
+                    ol_msgs.append(pt.Message(
+                        role='system',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    ol_msgs.append(pt.Message(
+                        role='user',
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    ol_msgs.append(pt.Message(
+                        role='tool',
+                        tool_name=mc_msg.tur.name,
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return ol_msgs
+
+
+def build_ol_request_tool(t: Tool) -> pt.Tool:
+    return pt.Tool(
+        function=pt.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(ol_resp: pt.ChatResponse) -> ChatChoicesResponse:
+    ol_msg = ol_resp.message
+
+    lst: list[AnyAiMessage] = []
+
+    if ol_msg.role in (None, 'assistant'):
+        if ol_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(ol_msg.content, str),
+            ))
+
+        for ol_tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=ol_tc.id,
+                name=ol_tc.function.name,
+                args=ol_tc.function.arguments,
+            )))
+
+    else:
+        raise ValueError(ol_msg)
+
+    return ChatChoicesResponse([AiChoice(lst)])
+
+
+def build_mc_ai_choice_deltas(ol_resp: pt.ChatResponse) -> AiChoiceDeltas:
+    ol_msg = ol_resp.message
+
+    if ol_msg.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if ol_msg.content is not None:
+            lst.append(ContentAiDelta(ol_msg.content))
+
+        for tc in ol_msg.tool_calls or []:
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc.function.name),
+                args=tc.function.arguments,
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    else:
+        raise ValueError(ol_msg)

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

@@ -22,7 +22,7 @@ from ....chat.stream.types import ContentAiDelta
 from ....chat.stream.types import PartialToolUseAiDelta
 from ....chat.tools.types import Tool
 from ....content.json import JsonContent
-from ....content.prepare import prepare_content_str
+from ....content.transform.prepare import prepare_content_str
 from ....llms.types import MaxCompletionTokens
 from ....llms.types import MaxTokens
 from ....llms.types import Temperature
@@ -145,7 +145,8 @@ def build_mc_ai_delta(delta: pt.ChatCompletionChunkChoiceDelta) -> AiDelta:
         )
 
     else:
-        raise ValueError(delta)
+        # FIXME: no
+        return ContentAiDelta('')
 
 
 ##
@@ -216,7 +217,7 @@ class OpenaiChatRequestHandler:
             pt.ChatCompletionRequestTool(
                 function=pt.ChatCompletionRequestTool.Function(
                     name=check.not_none(ts.name),
-                    description=prepare_content_str(ts.desc),
+                    description=prepare_content_str(ts.desc) if ts.desc is not None else None,
                     parameters=build_tool_spec_params_json_schema(ts),
                 ),
             )

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

@@ -32,6 +32,8 @@ _GPT_MODEL_NAMES = [
     'gpt-5-nano',
 
     'gpt-5.1',
+
+    'gpt-5.2',
 ]
 
 
@@ -48,7 +50,7 @@ CHAT_MODEL_NAMES = ModelNameCollection(
             for n in _GPT_MODEL_NAMES
         },
 
-        'gpt': 'gpt-5.1',
+        'gpt': 'gpt-5.2',
         'gpt-mini': 'gpt-5-mini',
 
         #

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

@@ -4,6 +4,7 @@ https://platform.openai.com/docs/api-reference/responses-streaming
 import typing as ta
 
 from omlish import check
+from omlish import dataclasses as dc
 from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
@@ -35,6 +36,12 @@ from .names import CHAT_MODEL_NAMES
 ##
 
 
+@dc.dataclass()
+class OpenaiChatChoicesStreamServiceError(Exception):
+    status: int
+    data: ta.Any | None = None
+
+
 # @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
 #     name='openai',
 #     type='ChatChoicesStreamService',
@@ -90,18 +97,43 @@ class OpenaiChatChoicesStreamService:
             http_client = await rs.enter_async_context(http.manage_async_client(self._http_client))
             http_response = await rs.enter_async_context(await http_client.stream_request(http_request))
 
+            if http_response.status != 200:
+                data: ta.Any
+                try:
+                    data = await http_response.stream.readall()
+                except Exception as e:  # noqa
+                    data = e
+                try:
+                    data_obj = json.loads(data.decode())
+                except Exception as e:  # noqa
+                    pass
+                else:
+                    data = data_obj
+                raise OpenaiChatChoicesStreamServiceError(http_response.status, data)
+
             async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 sd = sse.SseDecoder()
+
+                # bs = []
+                # ls = []
+                # sos = []
+
                 while True:
                     b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
+                    # bs.append(b)
+
                     for l in db.feed(b):
+                        # ls.append(l)
+
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(l)
 
                         # FIXME: https://platform.openai.com/docs/guides/function-calling?api-mode=responses#streaming
                         for so in sd.process_line(l):
+                            # sos.append(so)
+
                             if isinstance(so, sse.SseEvent) and so.type == b'message':
                                 ss = so.data.decode('utf-8')
                                 if ss == '[DONE]':

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