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

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

@@ -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)
 

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

@@ -11,23 +11,28 @@ from omlish.http import all as http
 from omlish.io.buffers import DelimitingBuffer
 
 from .....backends.google.protocol import types as pt
+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 ChatChoicesOutputs
 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.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.stream.types import ContentAiDelta
+from ....chat.stream.types import ToolUseAiDelta
+from ....chat.tools.types import Tool
 from ....models.configs import ModelName
 from ....resources import UseResources
 from ....standard import ApiKey
 from ....stream.services import StreamResponseSink
 from ....stream.services import new_stream_response
 from .names import MODEL_NAMES
+from .tools import build_tool_spec_schema
 
 
 ##
@@ -41,32 +46,86 @@ from .names import MODEL_NAMES
 class GoogleChatChoicesStreamService:
     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)
+    def _make_str_content(
+            self,
+            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,
+        )
 
-        elif isinstance(m, (SystemMessage, UserMessage)):
-            return check.isinstance(m.c, str)
+    def _make_msg_content(self, m: Message) -> pt.Content:
+        if isinstance(m, (AiMessage, SystemMessage, UserMessage)):
+            return check.not_none(self._make_str_content(
+                check.isinstance(m.c, str),
+                role=self.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)
 
     BASE_URL: ta.ClassVar[str] = 'https://generativelanguage.googleapis.com/v1beta/models'
 
-    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], str]] = {
-        SystemMessage: 'system',
+    ROLES_MAP: ta.ClassVar[ta.Mapping[type[Message], pt.ContentRole | None]] = {  # noqa
+        SystemMessage: None,
         UserMessage: 'user',
-        AiMessage: 'assistant',
+        AiMessage: 'model',
     }
 
-    READ_CHUNK_SIZE = 64 * 1024
+    READ_CHUNK_SIZE: ta.ClassVar[int] = -1
 
     async def invoke(
             self,
@@ -74,16 +133,28 @@ class GoogleChatChoicesStreamService:
     ) -> ChatChoicesStreamResponse:
         key = check.not_none(self._api_key).reveal()
 
+        msgs = list(request.v)
+
+        system_inst: pt.Content | None = None
+        if msgs and isinstance(m0 := msgs[0], SystemMessage):
+            system_inst = self._make_msg_content(m0)
+            msgs.pop(0)
+
+        g_tools: list[pt.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                g_tools.append(pt.Tool(
+                    function_declarations=[build_tool_spec_schema(t.spec)],
+                ))
+
         g_req = pt.GenerateContentRequest(
             contents=[
-                pt.Content(
-                    parts=[pt.Part(
-                        text=check.not_none(self._get_msg_content(m)),
-                    )],
-                    role=self.ROLES_MAP[type(m)],  # type: ignore[arg-type]
-                )
-                for m in request.v
+                self._make_msg_content(m)
+                for m in msgs
             ],
+            tools=g_tools or None,
+            system_instruction=system_inst,
         )
 
         req_dct = msh.marshal(g_req)
@@ -98,30 +169,49 @@ class GoogleChatChoicesStreamService:
         )
 
         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:
                 db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
                 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 bl in db.feed(b):
                         if isinstance(bl, DelimitingBuffer.Incomplete):
                             # FIXME: handle
                             return []
+
                         l = bl.decode('utf-8')
                         if not l:
                             continue
+
                         if l.startswith('data: '):
                             gcr = msh.unmarshal(json.loads(l[6:]), pt.GenerateContentResponse)  # noqa
                             cnd = check.single(check.not_none(gcr.candidates))
+
                             for p in check.not_none(cnd.content).parts or []:
-                                await sink.emit(AiChoicesDeltas([
-                                    AiChoiceDeltas([
-                                        ContentAiChoiceDelta(check.not_none(p.text)),
-                                    ]),
-                                ]))
+                                if (txt := p.text) is not None:
+                                    check.none(p.function_call)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ContentAiDelta(check.not_none(txt)),
+                                        ]),
+                                    ]))
+
+                                elif (fc := p.function_call) is not None:
+                                    check.none(p.text)
+                                    await sink.emit(AiChoicesDeltas([
+                                        AiChoiceDeltas([
+                                            ToolUseAiDelta(
+                                                id=fc.id,
+                                                name=fc.name,
+                                                args=fc.args,
+                                            ),
+                                        ]),
+                                    ]))
+
+                                else:
+                                    raise ValueError(p)
 
                     if not b:
                         return []

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

@@ -0,0 +1,75 @@
+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 .....backends.groq import protocol as pt
+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.tools.types import Tool
+from ....models.configs import ModelName
+from ....standard import ApiKey
+from ....standard import DefaultOptions
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='groq',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class GroqChatChoicesService:
+    DEFAULT_MODEL_NAME: ta.ClassVar[ModelName] = ModelName(check.not_none(MODEL_NAMES.default))
+
+    def __init__(
+            self,
+            *configs: ApiKey | ModelName | DefaultOptions,
+            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='GROQ_API_KEY')
+            self._default_options: tv.TypedValues = DefaultOptions.pop(cc)
+
+    async def invoke(self, request: ChatChoicesRequest) -> ChatChoicesResponse:
+        tools: list[pt.ChatCompletionRequest.Tool] = []
+        with tv.TypedValues(*request.options).consume() as oc:
+            t: Tool
+            for t in oc.pop(Tool, []):
+                tools.append(build_gq_request_tool(t))
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=build_gq_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_response = await http.async_request(
+            'https://api.groq.com/openai/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()),
+            },
+            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'))
+
+        return build_mc_choices_response(msh.unmarshal(raw_response, pt.ChatCompletionResponse))

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

@@ -0,0 +1,48 @@
+"""
+https://console.groq.com/docs/models
+
+curl -X GET "https://api.groq.com/openai/v1/models" \
+     -H "Authorization: Bearer $GROQ_API_KEY" \
+     -H "Content-Type: application/json"
+
+"compound-beta",
+"compound-beta-mini",
+"gemma2-9b-it",
+"llama-3.1-8b-instant",
+"llama-3.3-70b-versatile",
+"meta-llama/llama-4-maverick-17b-128e-instruct",
+"meta-llama/llama-4-scout-17b-16e-instruct",
+"meta-llama/llama-guard-4-12b",
+"moonshotai/kimi-k2-instruct",
+"openai/gpt-oss-120b",
+"openai/gpt-oss-20b",
+"qwen/qwen3-32b",
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'gpt-oss-120b': 'openai/gpt-oss-120b',
+        'openai/gpt-oss-120b': None,
+
+        'gpt-oss-20b': 'openai/gpt-oss-20b',
+        'openai/gpt-oss-20b': None,
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'groq',
+    model_names=MODEL_NAMES,
+)

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

@@ -0,0 +1,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.groq 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.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_gq_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    gq_msgs: list[pt.ChatCompletionRequest.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:
+                gq_msgs.append(pt.ChatCompletionRequest.AssistantMessage(
+                    content=check.isinstance(mc_ai_msg.c, str) if mc_ai_msg is not None else None,
+                    tool_calls=[
+                        pt.ChatCompletionRequest.AssistantMessage.ToolCall(
+                            function=pt.ChatCompletionRequest.AssistantMessage.ToolCall.Function(
+                                name=mc_tu_msg.tu.name,
+                                arguments=check.not_none(mc_tu_msg.tu.raw_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):
+                    gq_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    gq_msgs.append(pt.ChatCompletionRequest.ToolMessage(
+                        tool_call_id=check.not_none(mc_msg.tur.id),
+                        content=check.isinstance(mc_msg.tur.c, str),
+                    ))
+
+                else:
+                    raise TypeError(mc_msg)
+
+    return gq_msgs
+
+
+def build_gq_request_tool(t: Tool) -> pt.ChatCompletionRequest.Tool:
+    return pt.ChatCompletionRequest.Tool(
+        function=pt.ChatCompletionRequest.Tool.Function(
+            name=check.not_none(t.spec.name),
+            description=prepare_content_str(t.spec.desc),
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(gq_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(gq_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        gq_msg = gq_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if gq_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(gq_msg.content, str),
+            ))
+
+        for gq_tc in gq_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=gq_tc.id,
+                name=gq_tc.function.name,
+                args=json.loads(gq_tc.function.arguments or '{}'),
+                raw_args=gq_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, gq_resp.choices)))
+
+
+def build_mc_ai_choice_deltas(delta: pt.ChatCompletionChunk.Choice.Delta) -> AiChoiceDeltas:
+    if delta.role in (None, 'assistant'):
+        lst: list[AiDelta] = []
+
+        if delta.content is not None:
+            lst.append(ContentAiDelta(delta.content))
+
+        for tc in delta.tool_calls or []:
+            tc_fn = check.not_none(tc.function)
+            lst.append(ToolUseAiDelta(
+                id=tc.id,
+                name=check.not_none(tc_fn.name),
+                args=json.loads(tc_fn.arguments or '{}'),
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)

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

@@ -0,0 +1,125 @@
+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.groq import protocol as pt
+from ....chat.choices.services import ChatChoicesOutputs
+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 ....resources import UseResources
+from ....standard import ApiKey
+from ....stream.services import StreamResponseSink
+from ....stream.services import new_stream_response
+from .chat import GroqChatChoicesService
+from .names import MODEL_NAMES
+from .protocol import build_gq_request_messages
+from .protocol import build_gq_request_tool
+from .protocol import build_mc_ai_choice_deltas
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='groq',
+#     type='ChatChoicesStreamService',
+# )
+@static_check_is_chat_choices_stream_service
+class GroqChatChoicesStreamService:
+    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(GroqChatChoicesService.DEFAULT_MODEL_NAME)
+            self._api_key = ApiKey.pop_secret(cc, env='GROQ_API_KEY')
+
+    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_gq_request_tool(t))
+
+        gq_request = pt.ChatCompletionRequest(
+            messages=build_gq_request_messages(request.v),
+            model=MODEL_NAMES.resolve(self._model_name.v),
+            tools=tools or None,
+            stream=True,
+        )
+
+        raw_request = msh.marshal(gq_request)
+
+        http_request = http.HttpRequest(
+            'https://api.groq.com/openai/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()),
+            },
+            data=json.dumps(raw_request).encode('utf-8'),
+        )
+
+        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))
+
+            async def inner(sink: StreamResponseSink[AiChoicesDeltas]) -> ta.Sequence[ChatChoicesOutputs]:
+                db = DelimitingBuffer([b'\r', b'\n', b'\r\n'])
+                sd = sse.SseDecoder()
+                while True:
+                    b = await http_response.stream.read1(self.READ_CHUNK_SIZE)
+                    for l in db.feed(b):
+                        if isinstance(l, DelimitingBuffer.Incomplete):
+                            # FIXME: handle
+                            return []
+
+                        # FIXME: https://platform.openai.com/docs/guides/function-calling?api-mode=responses#streaming
+                        for so in sd.process_line(l):
+                            if isinstance(so, sse.SseEvent) and so.type == b'message':
+                                ss = so.data.decode('utf-8')
+                                if ss == '[DONE]':
+                                    return []
+
+                                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:
+                                    continue
+
+                                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([
+                                    build_mc_ai_choice_deltas(choice.delta)
+                                    for choice in ccc.choices
+                                ]))
+
+                    if not b:
+                        return []
+
+            # raw_response = json.loads(check.not_none(http_response.data).decode('utf-8'))
+            # return rh.build_response(raw_response)
+
+            return await new_stream_response(rs, inner)

ommlds/minichain/backends/impls/huggingface/repos.py

@@ -3,8 +3,6 @@ TODO:
  - local-only check first
   - cat ~/.cache/.../models/.../refs/main -> c5bfd839cd4cda0e5a39a97e00218d9c56e468af
 """
-import typing as ta
-
 from omlish import lang
 
 from ....models.configs import ModelRepo
@@ -12,10 +10,8 @@ from ....models.repos.resolving import ModelRepoResolver
 from ....models.repos.resolving import ResolvedModelRepo
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import huggingface_hub as hf
-else:
-    hf = lang.proxy_import('huggingface_hub')
 
 
 ##