ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

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

@@ -0,0 +1,114 @@
+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 .....backends.cerebras import protocol as pt
+from .....backends.cerebras.clients import REQUIRED_HTTP_HEADERS
+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 AiChoicesDeltas
+from ....chat.tools.types import Tool
+from ....configs import Config
+from ....http.stream import BytesHttpStreamResponseBuilder
+from ....http.stream import SimpleSseLinesHttpStreamResponseHandler
+from ....standard import ApiKey
+from .chat import CerebrasChatChoicesService
+from .names import MODEL_NAMES
+from .protocol import build_cer_request_messages
+from .protocol import build_cer_request_tool
+from .protocol import build_mc_ai_choice_deltas
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='cerebras',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class CerebrasChatChoicesStreamService:
+    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(CerebrasChatChoicesService.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='CEREBRAS_API_KEY')
+
+    URL: ta.ClassVar[str] = 'https://api.cerebras.ai/v1/chat/completions'
+
+    def _process_sse(self, so: sse.SseDecoderOutput) -> ta.Sequence[AiChoicesDeltas | None]:
+        if not (isinstance(so, sse.SseEvent) and so.type == b'message'):
+            return []
+
+        ss = so.data.decode('utf-8')
+        if ss == '[DONE]':
+            return [None]
+
+        sj = json.loads(ss)  # ChatCompletionChunk
+
+        check.state(sj['object'] == 'chat.completion.chunk')
+
+        ccc = msh.unmarshal(sj, pt.ChatCompletionChunk)
+
+        # FIXME: stop reason
+        if not ccc.choices:
+            return []
+
+        if any(choice.finish_reason for choice in ccc.choices):
+            check.state(all(choice.finish_reason for choice in ccc.choices))
+            return [None]
+
+        return [AiChoicesDeltas([
+            build_mc_ai_choice_deltas(choice.delta)
+            for choice in ccc.choices
+        ])]
+
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_cer_request_tool(t))
+
+        cer_request = pt.ChatCompletionRequest(
+            messages=build_cer_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+            stream=True,
+        )
+
+        raw_request = msh.marshal(cer_request)
+
+        http_request = http.HttpRequest(
+            'https://api.cerebras.ai/v1/chat/completions',
+            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()),
+                **REQUIRED_HTTP_HEADERS,
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+        )
+
+        return await BytesHttpStreamResponseBuilder(
+            self._http_client,
+            lambda http_response: SimpleSseLinesHttpStreamResponseHandler(self._process_sse).as_lines().as_bytes(),
+            read_chunk_size=self.READ_CHUNK_SIZE,
+        ).new_stream_response(
+            http_request,
+            request.options,
+        )

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

@@ -0,0 +1,69 @@
+# ruff: noqa: PERF402
+import typing as ta
+
+from omlish.text.lorem import LOREM
+
+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.stream.types import ContentAiDelta
+from ....resources import UseResources
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='dummy',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class DummyChatChoicesService:
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        return ChatChoicesResponse([AiChoice([AiMessage(LOREM)])])
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='dummy',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class DummyChatChoicesStreamService:
+    async def invoke(self, request: ChatChoicesStreamRequest) -> ChatChoicesStreamResponse:
+        async with UseResources.or_new(request.options) as rs:
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
+                for s in LOREM:
+                    await sink.emit(AiChoicesDeltas([
+                        AiChoiceDeltas([
+                            ContentAiDelta(s),
+                        ]),
+                    ]))
+
+                return []
+
+            return await new_stream_response(rs, inner)
+
+
+##
+
+
+# @omlish-manifest $.minichain.backends.strings.manifests.BackendStringsManifest(
+#     [
+#         'ChatChoicesService',
+#         'ChatChoicesStreamService',
+#     ],
+#     'dummy',
+# )

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

@@ -16,16 +16,14 @@ from ....chat.choices.services import static_check_is_chat_choices_service
 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 ToolUseMessage
-from ....chat.messages import ToolUseResultMessage
-from ....chat.messages import UserMessage
 from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....standard import ApiKey
 from ....tools.types import ToolUse
 from .names import MODEL_NAMES
+from .protocol import make_msg_content
+from .protocol import pop_system_instructions
 from .tools import build_tool_spec_schema
 
 
@@ -40,97 +38,27 @@ from .tools import build_tool_spec_schema
 class GoogleChatChoicesService:
     DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
 
-    def __init__(self, *configs: ApiKey | ModelName) -> None:
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName,
+            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(self.DEFAULT_MODEL_NAME)
             self._api_key = ApiKey.pop_secret(cc, env='GEMINI_API_KEY')
 
-    def _get_msg_content(self, m: Message) -> str | None:
-        if isinstance(m, AiMessage):
-            return check.isinstance(m.c, str)
-
-        elif isinstance(m, (SystemMessage, UserMessage)):
-            return check.isinstance(m.c, str)
-
-        else:
-            raise TypeError(m)
-
     BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        UserMessage: 'user',
-        AiMessage: 'model',
-        ToolUseMessage: 'model',
-    }
-
     async def invoke(
             self,
             request: ChatChoicesRequest,
     ) -> ChatChoicesResponse:
         key = check.not_none(self._api_key).reveal()
 
-        g_sys_content: pt.Content | None = None
-        g_contents: list[pt.Content] = []
-        for i, m in enumerate(request.v):
-            if isinstance(m, SystemMessage):
-                check.arg(i == 0)
-                check.none(g_sys_content)
-                g_sys_content = pt.Content(
-                    parts=[pt.Part(
-                        text=check.not_none(self._get_msg_content(m)),
-                    )],
-                )
-
-            elif isinstance(m, ToolUseResultMessage):
-                tr_resp_val: pt.Value
-                if m.tur.c is None:
-                    tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
-                elif isinstance(m.tur.c, str):
-                    tr_resp_val = pt.StringValue(m.tur.c)
-                else:
-                    raise TypeError(m.tur.c)
-                g_contents.append(pt.Content(
-                    parts=[pt.Part(
-                        function_response=pt.FunctionResponse(
-                            id=m.tur.id,
-                            name=m.tur.name,
-                            response={
-                                'value': tr_resp_val,
-                            },
-                        ),
-                    )],
-                ))
-
-            elif isinstance(m, AiMessage):
-                g_contents.append(pt.Content(
-                    parts=[pt.Part(
-                        text=check.not_none(self._get_msg_content(m)),
-                    )],
-                    role='model',
-                ))
-
-            elif isinstance(m, ToolUseMessage):
-                g_contents.append(pt.Content(
-                    parts=[pt.Part(
-                        function_call=pt.FunctionCall(
-                            id=m.tu.id,
-                            name=m.tu.name,
-                            args=m.tu.args,
-                        ),
-                    )],
-                    role='model',
-                ))
-
-            else:
-                g_contents.append(pt.Content(
-                    parts=[pt.Part(
-                        text=check.not_none(self._get_msg_content(m)),
-                    )],
-                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
-                ))
-
         g_tools: list[pt.Tool] = []
         with tv.TypedValues(*request.options).consume() as oc:
             t: Tool
@@ -139,21 +67,29 @@ class GoogleChatChoicesService:
                     function_declarations=[build_tool_spec_schema(t.spec)],
                 ))
 
+        msgs = list(request.v)
+
+        system_inst = pop_system_instructions(msgs)
+
         g_req = pt.GenerateContentRequest(
-            contents=g_contents or None,
+            contents=[
+                make_msg_content(m)
+                for m in msgs
+            ] or None,
             tools=g_tools or None,
-            system_instruction=g_sys_content,
+            system_instruction=system_inst,
         )
 
         req_dct = msh.marshal(g_req)
 
         model_name = MODEL_NAMES.resolve(self._model_name.v)
 
-        resp = http.request(
+        resp = await http.async_request(
             f'{self.BASE_URL.rstrip("/")}/{model_name}:generateContent?key={key}',
             headers={'Content-Type': 'application/json'},
             data=json.dumps_compact(req_dct).encode('utf-8'),
             method='POST',
+            client=self._http_client,
         )
 
         resp_dct = json.loads(check.not_none(resp.data).decode('utf-8'))

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

@@ -16,6 +16,12 @@ from ...strings.manifests import BackendStringsManifest
 MODEL_NAMES = ModelNameCollection(
     default='gemini',
     aliases={
+        'gemini-3-pro-preview': None,
+        'gemini-3-pro': 'gemini-3-pro-preview',
+
+        'gemini-3-flash-preview': None,
+        'gemini-3-flash': 'gemini-3-flash-preview',
+
         'gemini-2.5-pro': None,
         'gemini-2.5-flash': None,
         'gemini-2.5-flash-lite': None,

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

@@ -0,0 +1,105 @@
+import typing as ta
+
+from omlish import check
+
+from .....backends.google.protocol import types as pt
+from ....chat.messages import AiMessage
+from ....chat.messages import Message
+from ....chat.messages import SystemMessage
+from ....chat.messages import ToolUseMessage
+from ....chat.messages import ToolUseResultMessage
+from ....chat.messages import UserMessage
+
+
+##
+
+
+ROLES_MAP: ta.Mapping[type[Message], pt.ContentRole | None] = {  # noqa
+    SystemMessage: None,
+    UserMessage: 'user',
+    AiMessage: 'model',
+    ToolUseMessage: 'model',
+}
+
+
+def make_str_content(
+        s: str | None,
+        *,
+        role: pt.ContentRole | None = None,
+) -> pt.Content | None:
+    if s is None:
+        return None
+
+    return pt.Content(
+        parts=[pt.Part(
+            text=check.not_none(s),
+        )],
+        role=role,
+    )
+
+
+def make_msg_content(m: Message) -> pt.Content:
+    if isinstance(m, (AiMessage, SystemMessage, UserMessage)):
+        return check.not_none(make_str_content(
+            check.isinstance(m.c, str),
+            role=ROLES_MAP[type(m)],
+        ))
+
+    elif isinstance(m, ToolUseResultMessage):
+        tr_resp_val: pt.Value
+        if m.tur.c is None:
+            tr_resp_val = pt.NullValue()  # type: ignore[unreachable]
+        elif isinstance(m.tur.c, str):
+            tr_resp_val = pt.StringValue(m.tur.c)
+        else:
+            raise TypeError(m.tur.c)
+
+        return pt.Content(
+            parts=[pt.Part(
+                function_response=pt.FunctionResponse(
+                    id=m.tur.id,
+                    name=m.tur.name,
+                    response={
+                        'value': tr_resp_val,
+                    },
+                ),
+            )],
+        )
+
+    elif isinstance(m, ToolUseMessage):
+        return pt.Content(
+            parts=[pt.Part(
+                function_call=pt.FunctionCall(
+                    id=m.tu.id,
+                    name=m.tu.name,
+                    args=m.tu.args,
+                ),
+            )],
+            role='model',
+        )
+
+    else:
+        raise TypeError(m)
+
+
+def pop_system_instructions(msgs: list[Message]) -> pt.Content | None:
+    if not msgs:
+        return None
+
+    m0 = msgs[0]
+    if not isinstance(m0 := msgs[0], SystemMessage):
+        return None
+
+    msgs.pop(0)
+    return make_msg_content(m0)
+
+
+def get_msg_content(m: Message) -> str | None:
+    if isinstance(m, AiMessage):
+        return check.isinstance(m.c, str)
+
+    elif isinstance(m, (SystemMessage, UserMessage)):
+        return check.isinstance(m.c, str)
+
+    else:
+        raise TypeError(m)

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

@@ -24,7 +24,7 @@ from ....search import static_check_is_search_service
 
 
 @dc.dataclass(frozen=True)
-@msh.update_object_metadata(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
+@msh.update_object_options(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
 class CseSearchResult(lang.Final):
     kind: str | None = None
 
@@ -49,7 +49,7 @@ class CseSearchResult(lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_object_metadata(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
+@msh.update_object_options(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
 class CseSearchInfo(lang.Final):
     search_time: float | None = None
     total_results: int | None = None
@@ -58,10 +58,10 @@ class CseSearchInfo(lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_object_metadata(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
+@msh.update_object_options(field_naming=msh.Naming.LOW_CAMEL, unknown_field='x')
 class CseSearchResponse(lang.Final):
     kind: str | None = None
-    info: CseSearchInfo | None = dc.xfield(None) | msh.with_field_metadata(name='searchInformation')
+    info: CseSearchInfo | None = dc.xfield(None) | msh.with_field_options(name='searchInformation')
     items: ta.Sequence[CseSearchResult] | None = None
 
     x: ta.Mapping[str, ta.Any] | None = dc.field(default=None, repr=False)
@@ -82,12 +82,16 @@ class CseSearchService:
             self,
             cse_id: str | None = None,
             cse_api_key: str | None = None,
+            *,
+            http_client: http.AsyncHttpClient | None = None,
     ) -> None:
         super().__init__()
 
         self._cse_id = cse_id
         self._cse_api_key = cse_api_key
 
+        self._http_client = http_client
+
     async def invoke(
             self,
             request: SearchRequest,
@@ -97,8 +101,9 @@ class CseSearchService:
             cx=check.non_empty_str(self._cse_id),
             q=request.v,
         ))
-        resp = http.request(
+        resp = await http.async_request(
             f'https://www.googleapis.com/customsearch/v1?{qs}',
+            client=self._http_client,
         )
         out = check.not_none(resp.data)