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

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

@@ -30,10 +30,12 @@ _GPT_MODEL_NAMES = [
     'gpt-5-chat-latest',
     'gpt-5-mini',
     'gpt-5-nano',
+
+    'gpt-5.1',
 ]
 
 
-MODEL_NAMES = ModelNameCollection(
+CHAT_MODEL_NAMES = ModelNameCollection(
     default='gpt',
     aliases={
         **{
@@ -46,8 +48,8 @@ MODEL_NAMES = ModelNameCollection(
             for n in _GPT_MODEL_NAMES
         },
 
-        'gpt': 'gpt-4o',
-        'gpt-mini': 'gpt-4o-mini',
+        'gpt': 'gpt-5.1',
+        'gpt-mini': 'gpt-5-mini',
 
         #
 
@@ -61,11 +63,35 @@ MODEL_NAMES = ModelNameCollection(
 
 
 # @omlish-manifest
-_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+_CHAT_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
     [
         'ChatChoicesService',
         'ChatChoicesStreamService',
     ],
     'openai',
-    model_names=MODEL_NAMES,
+    model_names=CHAT_MODEL_NAMES,
+)
+
+
+##
+
+
+# @omlish-manifest
+_COMPLETION_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'CompletionService',
+    ],
+    'openai',
+)
+
+
+##
+
+
+# @omlish-manifest
+_EMBEDDING_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'EmbeddingService',
+    ],
+    'openai',
 )

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

@@ -1,28 +1,35 @@
+"""
+https://platform.openai.com/docs/api-reference/responses-streaming
+"""
 import typing as ta
 
 from omlish import check
+from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
 from omlish.http import all as http
 from omlish.http import sse
 from omlish.io.buffers import DelimitingBuffer
 
+from .....backends.openai import protocol as pt
 from ....chat.choices.services import ChatChoicesOutputs
-from ....chat.stream.services import ChatChoicesStreamRequest
-from ....chat.stream.services import ChatChoicesStreamResponse
-from ....chat.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.stream.types import AiChoiceDelta
-from ....chat.stream.types import AiChoiceDeltas
-from ....chat.stream.types import ChatChoicesStreamOption
+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.stream.types import ChatChoicesStreamOption
 from ....configs import Config
 from ....resources import ResourcesOption
 from ....resources import UseResources
 from ....standard import ApiKey
 from ....stream.services import StreamOption
+from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .chat import OpenaiChatChoicesService
 from .format import OpenaiChatRequestHandler
-from .names import MODEL_NAMES
+from .format import build_mc_ai_delta
+from .names import CHAT_MODEL_NAMES
 
 
 ##
@@ -34,16 +41,22 @@ from .names import MODEL_NAMES
 # )
 @static_check_is_chat_choices_stream_service
 class OpenaiChatChoicesStreamService:
-    def __init__(self, *configs: Config) -> None:
+    def __init__(
+            self,
+            *configs: Config,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
         super().__init__()
 
+        self._http_client = http_client
+
         with tv.consume(*configs) as cc:
             self._model_name = cc.pop(OpenaiChatChoicesService.DEFAULT_MODEL_NAME)
             self._api_key = ApiKey.pop_secret(cc, env='OPENAI_API_KEY')
 
-    READ_CHUNK_SIZE = 64 * 1024
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
-    def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
         # check.isinstance(request, ChatRequest)
 
         rh = OpenaiChatRequestHandler(
@@ -53,16 +66,16 @@ class OpenaiChatChoicesStreamService:
                 for o in request.options
                 if not isinstance(o, (ChatChoicesStreamOption, StreamOption, ResourcesOption))
             ],
-            model=MODEL_NAMES.resolve(self._model_name.v),
+            model=CHAT_MODEL_NAMES.resolve(self._model_name.v),
             mandatory_kwargs=dict(
                 stream=True,
-                stream_options=dict(
+                stream_options=pt.ChatCompletionRequest.StreamOptions(
                     include_usage=True,
                 ),
             ),
         )
 
-        raw_request = rh.raw_request()
+        raw_request = msh.marshal(rh.oai_request())
 
         http_request = http.HttpRequest(
             'https://api.openai.com/v1/chat/completions',
@@ -73,16 +86,15 @@ class OpenaiChatChoicesStreamService:
             data=json.dumps(raw_request).encode('utf-8'),
         )
 
-        with UseResources.or_new(request.options) as rs:
-            http_client = rs.enter_context(http.client())
-            http_response = rs.enter_context(http_client.stream_request(http_request))
+        async with UseResources.or_new(request.options) as rs:
+            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))
 
-            def yield_choices() -> ta.Generator[AiChoiceDeltas, None, ta.Sequence[ChatChoicesOutputs] | None]:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 sd = sse.SseDecoder()
                 while True:
-                    # FIXME: read1 not on response stream protocol
-                    b = http_response.stream.read1(self.READ_CHUNK_SIZE)  # type: ignore[attr-defined]
+                    b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
                     for l in db.feed(b):
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
@@ -99,14 +111,20 @@ class OpenaiChatChoicesStreamService:
 
                                 check.state(sj['object'] == 'chat.completion.chunk')
 
+                                ccc = msh.unmarshal(sj, pt.ChatCompletionChunk)
+
                                 # FIXME: stop reason
-                                if not sj['choices']:
+                                if not ccc.choices:
                                     continue
 
-                                yield [
-                                    AiChoiceDelta(rh.build_ai_message_delta(choice['delta']))
-                                    for choice in sj['choices']
-                                ]
+                                if any(choice.finish_reason for choice in ccc.choices):
+                                    check.state(all(choice.finish_reason for choice in ccc.choices))
+                                    break
+
+                                await sink.emit(AiChoicesDeltas([
+                                    AiChoiceDeltas([build_mc_ai_delta(choice.delta)])
+                                    for choice in ccc.choices
+                                ]))
 
                     if not b:
                         return []
@@ -114,4 +132,4 @@ class OpenaiChatChoicesStreamService:
             # raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
             # return rh.build_response(raw_response)
 
-            return new_stream_response(rs, yield_choices())
+            return await new_stream_response(rs, inner)

ommlds/minichain/backends/impls/tavily.py

@@ -0,0 +1,66 @@
+from omlish import check
+from omlish import marshal as msh
+from omlish import typedvalues as tv
+from omlish.formats import json
+from omlish.http import all as http
+
+from ....backends.tavily import protocol as pt
+from ...search import SearchHit
+from ...search import SearchHits
+from ...search import SearchRequest
+from ...search import SearchResponse
+from ...search import static_check_is_search_service
+from ...standard import ApiKey
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='tavily',
+#     type='SearchService',
+# )
+@static_check_is_search_service
+class TavilySearchService:
+    def __init__(
+            self,
+            *configs: ApiKey,
+            http_client: http.AsyncHttpClient | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._http_client = http_client
+
+        with tv.consume(*configs) as cc:
+            self._api_key = ApiKey.pop_secret(cc, env='TAVILY_API_KEY')
+
+    async def invoke(self, request: SearchRequest) -> SearchResponse:
+        pt_request = pt.SearchRequest(
+            query=request.v,
+        )
+
+        raw_request = msh.marshal(pt_request)
+
+        http_response = await http.async_request(
+            'https://api.tavily.com/search',
+            headers={
+                http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
+                http.consts.HEADER_AUTH: http.consts.format_bearer_auth_header(check.not_none(self._api_key).reveal()),
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
+        )
+
+        raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+
+        pt_response = msh.unmarshal(raw_response, pt.SearchResponse)
+
+        return SearchResponse(SearchHits(
+            l=[
+                SearchHit(
+                    title=r.title,
+                    url=r.url,
+                )
+                for r in pt_response.results or []
+            ],
+        ))

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

@@ -9,20 +9,22 @@ from ....chat.choices.services import ChatChoicesOptions
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 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.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Chat
 from ....chat.messages import SystemMessage
 from ....chat.messages import UserMessage
-from ....chat.stream.services import ChatChoicesStreamGenerator
-from ....chat.stream.services import ChatChoicesStreamRequest
-from ....chat.stream.services import ChatChoicesStreamResponse
-from ....chat.stream.services import static_check_is_chat_choices_stream_service
-from ....chat.stream.types import AiChoiceDelta
-from ....chat.stream.types import AiMessageDelta
+from ....chat.stream.types import ContentAiDelta
 from ....chat.types import ChatOption
 from ....llms.types import LlmOption
 from ....resources import UseResources
+from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 
 
@@ -111,12 +113,12 @@ class BaseTinygradLlama3ChatService(lang.ExitStacked, lang.Abstract):
 
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='tinygrad_llama3',
+#     name='tinygrad-llama3',
 #     type='ChatChoicesService',
 # )
 @static_check_is_chat_choices_service
 class TinygradLlama3ChatChoicesService(BaseTinygradLlama3ChatService):
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
         llm = self._load_model()
         toks = _prepare_toks(llm, request.v, request.options)
 
@@ -124,20 +126,20 @@ class TinygradLlama3ChatChoicesService(BaseTinygradLlama3ChatService):
         for s in tgl3.run_llm(llm, toks):
             out.append(s)
 
-        return ChatChoicesResponse([AiChoice(AiMessage(''.join(out)))])
+        return ChatChoicesResponse([AiChoice([AiMessage(''.join(out))])])
 
 
 ##
 
 
 # @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='tinygrad_llama3',
+#     name='tinygrad-llama3',
 #     type='ChatChoicesStreamService',
 # )
 @static_check_is_chat_choices_stream_service
 class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
-    def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
-        with UseResources.or_new(request.options) as rs:
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        async with UseResources.or_new(request.options) as rs:
             llm = self._load_model()
             toks = _prepare_toks(
                 llm,
@@ -145,12 +147,17 @@ class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
                 request.options.get_any((ChatOption, LlmOption)),  # FIXME  # noqa
             )
 
-            def yield_choices() -> ChatChoicesStreamGenerator:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
                 for s in tgl3.run_llm(llm, toks):
-                    yield [AiChoiceDelta(AiMessageDelta(s))]
+                    await sink.emit(AiChoicesDeltas([
+                        AiChoiceDeltas([
+                            ContentAiDelta(s),
+                        ]),
+                    ]))
+
                 return []
 
-            return new_stream_response(rs, yield_choices())
+            return await new_stream_response(rs, inner)
 
 
 ##
@@ -161,5 +168,5 @@ class TinygradLlama3ChatChoicesStreamService(BaseTinygradLlama3ChatService):
 #         'ChatChoicesService',
 #         'ChatChoicesStreamService',
 #     ],
-#     'tinygrad_llama3',
+#     'tinygrad-llama3',
 # )

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

@@ -33,7 +33,7 @@ class SentenceTransformersEmbeddingService:
         with tv.consume(*configs) as cc:
             self._model_path = cc.pop(ModelPath(self.DEFAULT_MODEL))
 
-    def invoke(self, request: EmbeddingRequest) -> EmbeddingResponse:
+    async def invoke(self, request: EmbeddingRequest) -> EmbeddingResponse:
         mdl = stfm.SentenceTransformer(
             self._model_path.v,
         )

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

@@ -72,7 +72,7 @@ class TransformersTokenizer(tks.BaseTokenizer):
             self,
             tokens: ta.Iterable[tks.Token],
     ) -> str:
-        return self._tfm_tokenizer.decode(tokens)
+        return self._tfm_tokenizer.decode(tokens)  # type: ignore[arg-type]
 
 
 ##

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

@@ -4,6 +4,7 @@ TODO:
  - https://huggingface.co/blog/aifeifei798/transformers-streaming-output
 """
 import sys
+import threading
 import typing as ta
 
 import transformers as tfm
@@ -11,26 +12,50 @@ 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
+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  # noqa
+from ....chat.choices.stream.types import AiChoicesDeltas  # noqa
+from ....chat.choices.types import AiChoice
+from ....chat.choices.types import ChatChoicesOutputs
 from ....chat.messages import AiMessage
 from ....chat.messages import Message
 from ....chat.messages import SystemMessage
-from ....chat.messages import ToolExecResultMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
 from ....chat.messages import UserMessage
+from ....chat.stream.types import ContentAiDelta  # noqa
 from ....completion import CompletionRequest
 from ....completion import CompletionResponse
 from ....completion import static_check_is_completion_service
 from ....configs import Config
 from ....models.configs import ModelPath
+from ....resources import UseResources
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
 from ...impls.huggingface.configs import HuggingfaceHubToken
 
 
 ##
 
 
+# @omlish-manifest $.minichain.backends.strings.manifests.BackendStringsManifest(
+#     ['ChatChoicesService', 'ChatChoicesStreamService'],
+#     'transformers',
+# )
+
+
+##
+
+
 class TransformersPipelineKwargs(Config, tv.ScalarTypedValue[ta.Mapping[str, ta.Any]]):
     pass
 
@@ -59,7 +84,7 @@ class TransformersCompletionService(lang.ExitStacked):
             self._pipeline_kwargs = cc.pop(TransformersPipelineKwargs, [])
             self._huggingface_hub_token = HuggingfaceHubToken.pop_secret(cc, env='HUGGINGFACE_HUB_TOKEN')
 
-    def invoke(self, request: CompletionRequest) -> CompletionResponse:
+    async def invoke(self, request: CompletionRequest) -> CompletionResponse:
         pkw: dict[str, ta.Any] = dict(
             model=self._model_path.v,
             device='mps' if sys.platform == 'darwin' else 'cuda',
@@ -94,17 +119,19 @@ def build_chat_message(m: Message) -> ta.Mapping[str, ta.Any]:
         return dict(
             role='assistant',
             content=check.isinstance(m.c, str),
-            **(dict(tool_calls=[
-                dict(
-                    id=te.id,
-                    function=dict(
-                        arguments=te.args,
-                        name=te.name,
-                    ),
-                    type='function',
-                )
-                for te in m.tool_exec_requests
-            ]) if m.tool_exec_requests else {}),
+        )
+
+    elif isinstance(m, ToolUseMessage):
+        return dict(
+            role='assistant',
+            tool_calls=[dict(
+                id=m.tu.id,
+                function=dict(
+                    arguments=m.tu.args,
+                    name=m.tu.name,
+                ),
+                type='function',
+            )],
         )
 
     elif isinstance(m, UserMessage):
@@ -113,24 +140,21 @@ def build_chat_message(m: Message) -> ta.Mapping[str, ta.Any]:
             content=check.isinstance(m.c, str),
         )
 
-    elif isinstance(m, ToolExecResultMessage):
+    elif isinstance(m, ToolUseResultMessage):
         return dict(
             role='tool',
-            tool_call_id=m.id,
-            content=check.isinstance(m.c, str),
+            tool_call_id=m.tur.id,
+            content=check.isinstance(m.tur.c, str),
         )
 
     else:
         raise TypeError(m)
 
 
-# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
-#     name='transformers',
-#     aliases=['tfm'],
-#     type='ChatChoicesService',
-# )
-@static_check_is_chat_choices_service
-class TransformersChatChoicesService(lang.ExitStacked):
+##
+
+
+class BaseTransformersChatChoicesService(lang.ExitStacked):
     DEFAULT_MODEL: ta.ClassVar[str] = (
         'meta-llama/Llama-3.2-1B-Instruct'
     )
@@ -157,21 +181,118 @@ class TransformersChatChoicesService(lang.ExitStacked):
         for pkw_cfg in self._pipeline_kwargs:
             pkw.update(pkw_cfg.v)
 
-        return tfm.pipeline(
-            'text-generation',
-            **pkw,
-        )
+        with file_cache_patch_context(
+                local_first=True,
+                local_config_present_is_authoritative=True,
+        ):
+            return tfm.pipeline(
+                'text-generation',
+                **pkw,
+            )
 
-    def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='transformers',
+#     aliases=['tfm'],
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class TransformersChatChoicesService(BaseTransformersChatChoicesService):
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
         check.empty(request.options)
 
         pipeline = self._load_pipeline()
 
-        output = pipeline(
-            [
-                build_chat_message(m)
-                for m in request.v
-            ],
+        inputs = [
+            build_chat_message(m)
+            for m in request.v
+        ]
+
+        outputs = pipeline(inputs)
+
+        gts = check.single(outputs)['generated_text']
+        ugt, agt = gts
+        check.state(ugt['role'] == 'user')
+        check.state(agt['role'] == 'assistant')
+
+        return ChatChoicesResponse([AiChoice([AiMessage(agt['content'])])])
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='transformers',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class TransformersChatChoicesStreamService(BaseTransformersChatChoicesService):
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        check.empty(request.options)
+
+        pipeline = self._load_pipeline()  # noqa
+
+        inputs = [  # noqa
+            build_chat_message(m)
+            for m in request.v
+        ]
+
+        relay: AsyncioBufferRelay = AsyncioBufferRelay()
+
+        def streamer_callback(text: str, *, stream_end: bool) -> None:
+            if text or stream_end:
+                relay.push(text, *([None] if stream_end else []))
+
+        streamer = CancellableTextStreamer(
+            check.not_none(pipeline.tokenizer),  # type: ignore[arg-type]
+            streamer_callback,  # noqa
+            skip_prompt=True,
+            skip_special_tokens=True,
         )
 
-        return ChatChoicesResponse(output)
+        async with UseResources.or_new(request.options) as rs:
+            thread = threading.Thread(
+                target=CancellableTextStreamer.ignoring_cancelled(pipeline),
+                args=(
+                    inputs,
+                ),
+                kwargs=dict(
+                    streamer=streamer,
+                ),
+            )
+
+            def stop_thread() -> None:
+                streamer.cancel()
+                # thread.join()
+
+            rs.enter_context(lang.defer(stop_thread))
+
+            thread.start()
+
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
+                while True:
+                    await relay.wait()
+                    got = relay.swap()
+
+                    if not got:
+                        raise RuntimeError
+
+                    if got[-1] is None:
+                        out = ''.join(got[:-1])
+                        end = True
+                    else:
+                        out = ''.join(got)
+                        end = False
+
+                    if out:
+                        await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(out)])]))
+
+                    if end:
+                        break
+
+                return []
+
+            return await new_stream_response(rs, inner)

ommlds/minichain/backends/strings/parsing.py

@@ -56,7 +56,7 @@ _REPO_MODEL_PAT = re.compile(
 def parse_backend_string(s: str) -> ParsedBackendString:
     backend: str | None
     if ':' in s:
-        backend, s = s.split(':')
+        backend, _, s = s.partition(':')
     else:
         backend = None
 

ommlds/minichain/backends/strings/resolving.py

@@ -108,7 +108,10 @@ class ManifestBackendStringResolver(BackendStringResolver):
 
         mn: str | None = mdl.name
 
-        if mn == m.backend_name:
+        if args.parsed.backend == m.backend_name and mn is not None:
+            pass
+
+        elif mn == m.backend_name:
             if m.model_names is not None:
                 mn = m.model_names.resolved_default
             else: