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

ommlds/minichain/backends/catalogs/base.py

@@ -3,15 +3,34 @@ import typing as ta
 
 from omlish import lang
 
+from ...configs import Config
+
+
+T = ta.TypeVar('T')
+
 
 ##
 
 
 class BackendCatalog(lang.Abstract):
+    class Backend(ta.NamedTuple):
+        factory: ta.Callable[..., ta.Any]
+        configs: ta.Sequence[Config] | None
+
     @abc.abstractmethod
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: type[T], name: str) -> Backend:
         raise NotImplementedError
 
+    def new_backend(
+            self,
+            service_cls: ta.Any,
+            name: str,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Any:
+        be = self.get_backend(service_cls, name)
+        return be.factory(*be.configs or [], *args, **kwargs)
+
     # #
     #
     # class Bound(lang.Final, ta.Generic[T]):

ommlds/minichain/backends/catalogs/simple.py

@@ -40,9 +40,9 @@ class SimpleBackendCatalog(BackendCatalog):
             sc_dct[e.name] = e
         self._dct = dct
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         e = self._dct[service_cls][name]
-        return e.factory_fn(*args, **kwargs)
+        return BackendCatalog.Backend(e.factory_fn, None)
 
 
 ##

ommlds/minichain/backends/catalogs/strings.py

@@ -5,7 +5,7 @@ from omlish import check
 from ...models.configs import ModelPath
 from ...models.configs import ModelRepo
 from ...models.repos.resolving import ModelRepoResolver
-from ...registries.globals import registry_new
+from ...registries.globals import get_registry_cls
 from ..strings.parsing import parse_backend_string
 from ..strings.resolving import BackendStringResolver
 from ..strings.resolving import ResolveBackendStringArgs
@@ -30,26 +30,28 @@ class BackendStringBackendCatalog(BackendCatalog):
         self._string_resolver = string_resolver
         self._model_repo_resolver = model_repo_resolver
 
-    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    def get_backend(self, service_cls: ta.Any, name: str, *args: ta.Any, **kwargs: ta.Any) -> BackendCatalog.Backend:
         ps = parse_backend_string(name)
         rs = check.not_none(self._string_resolver.resolve_backend_string(ResolveBackendStringArgs(
             service_cls,
             ps,
         )))
 
-        al = list(rs.args or [])
+        al: list = list(rs.args or [])
 
-        # FIXME: lol
+        # FIXME: lol - move *into* local model classes as an injected dep?
         if al and isinstance(al[0], ModelRepo):
             [mr] = al
             mrr = check.not_none(self._model_repo_resolver)
             mrp = check.not_none(mrr.resolve(mr))
             al = [ModelPath(mrp.path), *al[1:]]
 
-        return registry_new(
+        cls = get_registry_cls(
             service_cls,
             rs.name,
-            *al,
-            *args,
-            **kwargs,
+        )
+
+        return BackendCatalog.Backend(
+            cls,
+            al,
         )

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

@@ -17,20 +17,23 @@ 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.types import AiChoice
+from ....chat.choices.types import ChatChoicesOptions
 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 ....content.prepare import prepare_content_str
+from ....llms.types import MaxTokens
+from ....llms.types import Temperature
 from ....models.configs import ModelName
 from ....standard import ApiKey
-from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
+from ....types import Option
 from .names import MODEL_NAMES
+from .protocol import build_protocol_chat_messages
+from .protocol import build_protocol_tool
 
 
 ##
@@ -44,19 +47,15 @@ from .names import MODEL_NAMES
 class AnthropicChatChoicesService:
     DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
-        UserMessage: 'user',
-        AiMessage: 'assistant',
-        ToolUseMessage: 'assistant',
-    }
-
     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._api_key = check.not_none(ApiKey.pop_secret(cc, env='ANTHROPIC_API_KEY'))
             self._model_name = cc.pop(self.DEFAULT_MODEL_NAME)
@@ -72,80 +71,46 @@ class AnthropicChatChoicesService:
         else:
             raise TypeError(m)
 
+    DEFAULT_OPTIONS: ta.ClassVar[tv.TypedValues[Option]] = tv.TypedValues[Option](
+        MaxTokens(4096),
+    )
+
+    _OPTION_KWARG_NAMES_MAP: ta.ClassVar[ta.Mapping[str, type[ChatChoicesOptions]]] = dict(
+        temperature=Temperature,
+        max_tokens=MaxTokens,
+    )
+
     async def invoke(
             self,
             request: ChatChoicesRequest,
-            *,
-            max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesResponse:
-        messages: list[pt.Message] = []
-        system: list[pt.Content] | None = None
-        for i, m in enumerate(request.v):
-            if isinstance(m, SystemMessage):
-                if i != 0 or system is not None:
-                    raise Exception('Only supports one system message and must be first')
-                system = [pt.Text(check.not_none(self._get_msg_content(m)))]
-
-            elif isinstance(m, ToolUseResultMessage):
-                messages.append(pt.Message(
-                    role='user',
-                    content=[pt.ToolResult(
-                        tool_use_id=check.not_none(m.tur.id),
-                        content=json.dumps_compact(msh.marshal(m.tur.c)) if not isinstance(m.tur.c, str) else m.tur.c,
-                    )],
-                ))
+        messages, system = build_protocol_chat_messages(request.v)
 
-            elif isinstance(m, AiMessage):
-                # messages.append(pt.Message(
-                #     role=self.ROLES_MAP[type(m)],  # noqa
-                #     content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
-                # ))
-                messages.append(pt.Message(
-                    role='assistant',
-                    content=[
-                        *([pt.Text(check.isinstance(m.c, str))] if m.c is not None else []),
-                    ],
-                ))
-
-            elif isinstance(m, ToolUseMessage):
-                messages.append(pt.Message(
-                    role='assistant',
-                    content=[
-                        pt.ToolUse(
-                            id=check.not_none(m.tu.id),
-                            name=check.not_none(m.tu.name),
-                            input=m.tu.args,
-                        ),
-                    ],
-                ))
-
-            else:
-                messages.append(pt.Message(
-                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
-                    content=[pt.Text(check.isinstance(self._get_msg_content(m), str))],
-                ))
+        kwargs: dict = dict()
 
         tools: list[pt.ToolSpec] = []
-        with tv.TypedValues(*request.options).consume() as oc:
+        with tv.TypedValues(
+            *self.DEFAULT_OPTIONS,
+                *request.options,
+                override=True,
+        ).consume() as oc:
+            kwargs.update(oc.pop_scalar_kwargs(**self._OPTION_KWARG_NAMES_MAP))
+
             t: Tool
             for t in oc.pop(Tool, []):
-                tools.append(pt.ToolSpec(
-                    name=check.not_none(t.spec.name),
-                    description=prepare_content_str(t.spec.desc),
-                    input_schema=build_tool_spec_params_json_schema(t.spec),
-                ))
+                tools.append(build_protocol_tool(t))
 
         a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),
             system=system,
             messages=messages,
             tools=tools or None,
-            max_tokens=max_tokens,
+            **kwargs,
         )
 
         raw_request = msh.marshal(a_req)
 
-        raw_response = http.request(
+        raw_response = await http.async_request(
             'https://api.anthropic.com/v1/messages',
             headers={
                 http.consts.HEADER_CONTENT_TYPE: http.consts.CONTENT_TYPE_JSON,
@@ -153,6 +118,7 @@ class AnthropicChatChoicesService:
                 b'anthropic-version': b'2023-06-01',
             },
             data=json.dumps(raw_request).encode('utf-8'),
+            client=self._http_client,
         )
 
         response = json.loads(check.not_none(raw_response.data).decode('utf-8'))

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

@@ -22,10 +22,9 @@ MODEL_NAMES = ModelNameCollection(
         'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
         'claude-sonnet': 'claude-sonnet-4-5',
 
-        'claude-3-5-haiku-latest': None,
-        'claude-haiku-3-5-latest': 'claude-3-5-haiku-latest',
-        'claude-haiku-3-5': 'claude-haiku-3-5-latest',
-        'claude-haiku': 'claude-haiku-3-5',
+        'claude-haiku-4-5-20251001': None,
+        'claude-haiku-4-5': 'claude-haiku-4-5-20251001',
+        'claude-haiku': 'claude-haiku-4-5',
 
         'claude': 'claude-haiku',
     },

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

@@ -0,0 +1,109 @@
+import typing as ta
+
+from omlish import check
+from omlish import marshal as msh
+from omlish.formats import json
+
+from .....backends.anthropic.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
+from ....chat.tools.types import Tool
+from ....content.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+
+
+##
+
+
+def get_message_content(m: Message) -> str | None:
+    if isinstance(m, AiMessage):
+        return check.isinstance(m.c, str)
+
+    elif isinstance(m, (UserMessage, SystemMessage)):
+        return check.isinstance(m.c, str)
+
+    else:
+        raise TypeError(m)
+
+
+#
+
+
+class BuiltChatMessages(ta.NamedTuple):
+    messages: list[pt.Message]
+    system: list[pt.Content] | None
+
+
+ROLES_MAP: ta.Mapping[type[Message], str] = {
+    SystemMessage: 'system',
+    UserMessage: 'user',
+    AiMessage: 'assistant',
+    ToolUseMessage: 'assistant',
+}
+
+
+def build_protocol_chat_messages(msgs: ta.Iterable[Message]) -> BuiltChatMessages:
+    messages: list[pt.Message] = []
+    system: list[pt.Content] | None = None
+
+    for i, m in enumerate(msgs):
+        if isinstance(m, SystemMessage):
+            if i or system is not None:
+                raise Exception('Only supports one system message and must be first')
+            system = [pt.Text(check.not_none(get_message_content(m)))]
+
+        elif isinstance(m, ToolUseResultMessage):
+            messages.append(pt.Message(
+                role='user',
+                content=[pt.ToolResult(
+                    tool_use_id=check.not_none(m.tur.id),
+                    content=json.dumps_compact(msh.marshal(m.tur.c)) if not isinstance(m.tur.c, str) else m.tur.c,
+                )],
+            ))
+
+        elif isinstance(m, AiMessage):
+            # messages.append(pt.Message(
+            #     role=ROLES_MAP[type(m)],  # noqa
+            #     content=[pt.Text(check.isinstance(get_message_content(m), str))],
+            # ))
+            messages.append(pt.Message(
+                role='assistant',
+                content=[
+                    *([pt.Text(check.isinstance(m.c, str))] if m.c is not None else []),
+                ],
+            ))
+
+        elif isinstance(m, ToolUseMessage):
+            messages.append(pt.Message(
+                role='assistant',
+                content=[
+                    pt.ToolUse(
+                        id=check.not_none(m.tu.id),
+                        name=check.not_none(m.tu.name),
+                        input=m.tu.args,
+                    ),
+                ],
+            ))
+
+        else:
+            messages.append(pt.Message(
+                role=ROLES_MAP[type(m)],  # type: ignore[arg-type]
+                content=[pt.Text(check.isinstance(get_message_content(m), str))],
+            ))
+
+    return BuiltChatMessages(messages, system)
+
+
+##
+
+
+def build_protocol_tool(t: Tool) -> pt.ToolSpec:
+    return pt.ToolSpec(
+        name=check.not_none(t.spec.name),
+        description=prepare_content_str(t.spec.desc),
+        input_schema=build_tool_spec_params_json_schema(t.spec),
+    )

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

@@ -1,7 +1,6 @@
 import typing as ta
 
 from omlish import check
-from omlish import lang
 from omlish import marshal as msh
 from omlish import typedvalues as tv
 from omlish.formats import json
@@ -9,15 +8,17 @@ from omlish.http import all as http
 from omlish.http import sse
 from omlish.io.buffers import DelimitingBuffer
 
+from .....backends.anthropic.protocol import types as pt
 from .....backends.anthropic.protocol.sse.events import AnthropicSseDecoderEvents
 from ....chat.choices.services import ChatChoicesOutputs
-from ....chat.messages import SystemMessage
-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 AiChoiceDeltas
-from ....chat.stream.types import AiChoicesDeltas
-from ....chat.stream.types import ContentAiChoiceDelta
+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.stream.types import ContentAiDelta
+from ....chat.stream.types import PartialToolUseAiDelta
+from ....chat.tools.types import Tool
 from ....configs import Config
 from ....resources import UseResources
 from ....standard import ApiKey
@@ -25,6 +26,8 @@ from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .chat import AnthropicChatChoicesService
 from .names import MODEL_NAMES
+from .protocol import build_protocol_chat_messages
+from .protocol import build_protocol_tool
 
 
 ##
@@ -36,14 +39,20 @@ from .names import MODEL_NAMES
 # )
 @static_check_is_chat_choices_stream_service
 class AnthropicChatChoicesStreamService:
-    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(AnthropicChatChoicesService.DEFAULT_MODEL_NAME)
             self._api_key = check.not_none(ApiKey.pop_secret(cc, env='ANTHROPIC_API_KEY'))
 
-    READ_CHUNK_SIZE = 64 * 1024
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
     async def invoke(
             self,
@@ -51,27 +60,25 @@ class AnthropicChatChoicesStreamService:
             *,
             max_tokens: int = 4096,  # FIXME: ChatOption
     ) -> ChatChoicesStreamResponse:
-        messages = []
-        system: str | None = None
-        for i, m in enumerate(request.v):
-            if isinstance(m, SystemMessage):
-                if i != 0 or system is not None:
-                    raise Exception('Only supports one system message and must be first')
-                system = AnthropicChatChoicesService._get_msg_content(m)  # noqa
-            else:
-                messages.append(dict(
-                    role=AnthropicChatChoicesService.ROLES_MAP[type(m)],  # noqa
-                    content=check.isinstance(AnthropicChatChoicesService._get_msg_content(m), str),  # noqa
-                ))
-
-        raw_request = dict(
+        messages, system = build_protocol_chat_messages(request.v)
+
+        tools: list[pt.ToolSpec] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_protocol_tool(t))
+
+        a_req = pt.MessagesRequest(
             model=MODEL_NAMES.resolve(self._model_name.v),
-            **lang.opt_kw(system=system),
+            system=system,
             messages=messages,
+            tools=tools or None,
             max_tokens=max_tokens,
             stream=True,
         )
 
+        raw_request = msh.marshal(a_req)
+
         http_request = http.HttpRequest(
             'https://api.anthropic.com/v1/messages',
             headers={
@@ -83,8 +90,8 @@ class AnthropicChatChoicesStreamService:
         )
 
         async 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))
+            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))
 
             async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs] | None:
                 msg_start: AnthropicSseDecoderEvents.MessageStart | None = None
@@ -94,8 +101,7 @@ class AnthropicChatChoicesStreamService:
                 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
@@ -123,19 +129,35 @@ class AnthropicChatChoicesStreamService:
                                         check.not_none(msg_start)
                                         check.none(cbk_start)
                                         cbk_start = ae
+
                                         if isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Text):  # noqa
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
                                                 ae.content_block.text,
                                             )])]))
+
+                                        elif isinstance(ae.content_block, AnthropicSseDecoderEvents.ContentBlockStart.ToolUse):  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiDelta(  # noqa
+                                                id=ae.content_block.id,
+                                                name=ae.content_block.name,
+                                                raw_args=ae.content_block.input,
+                                            )])]))
+
                                         else:
                                             raise TypeError(ae.content_block)
 
                                     case AnthropicSseDecoderEvents.ContentBlockDelta():
                                         check.not_none(cbk_start)
+
                                         if isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.TextDelta):
-                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiChoiceDelta(
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([ContentAiDelta(
                                                 ae.delta.text,
                                             )])]))
+
+                                        elif isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.InputJsonDelta):  # noqa
+                                            await sink.emit(AiChoicesDeltas([AiChoiceDeltas([PartialToolUseAiDelta(  # noqa
+                                                raw_args=ae.delta.partial_json,
+                                            )])]))
+
                                         else:
                                             raise TypeError(ae.delta)
 

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

@@ -40,9 +40,15 @@ 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')
@@ -149,11 +155,12 @@ class GoogleChatChoicesService:
 
         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'))