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

ommlds/minichain/_typedvalues.py

@@ -23,14 +23,21 @@ def _tv_field_coercer(
 ) -> ta.Callable[[ta.Sequence], tv.TypedValues]:
     if isinstance(tvc, tuple):
         check.arg(all(issubclass(e, tv.TypedValue) for e in tvc))
+
     else:
         check.issubclass(tvc, tv.TypedValue)
 
     def inner(seq):
-        return tv.TypedValues(*[
-            check.isinstance(e, tvc)
-            for e in check.isinstance(seq, ta.Sequence)
-        ])
+        if isinstance(seq, tv.TypedValues):
+            for e in seq:
+                check.isinstance(e, tvc)
+            return seq
+
+        else:
+            return tv.TypedValues(*[
+                check.isinstance(e, tvc)
+                for e in check.isinstance(seq, ta.Sequence)
+            ])
 
     return inner
 

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

@@ -14,9 +14,9 @@ from ...strings.manifests import BackendStringsManifest
 MODEL_NAMES = ModelNameCollection(
     default='claude',
     aliases={
-        'claude-opus-4-1-20250805': None,
-        'claude-opus-4-1': 'claude-opus-4-1-20250805',
-        'claude-opus': 'claude-opus-4-1',
+        'claude-opus-4-5-20251101': None,
+        'claude-opus-4-5': 'claude-opus-4-5-20251101',
+        'claude-opus': 'claude-opus-4-5',
 
         'claude-sonnet-4-5-20250929': None,
         'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',

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

@@ -12,7 +12,7 @@ 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 ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 
 
@@ -104,6 +104,6 @@ def build_protocol_chat_messages(msgs: ta.Iterable[Message]) -> BuiltChatMessage
 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),
+        description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else '',
         input_schema=build_tool_spec_params_json_schema(t.spec),
     )

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

@@ -105,7 +105,7 @@ class AnthropicChatChoicesStreamService:
                     for l in db.feed(b):
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(l)
 
                         # FIXME: https://docs.anthropic.com/en/docs/build-with-claude/streaming
                         for so in sd.process_line(l):

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

@@ -0,0 +1,80 @@
+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.cerebras 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_cer_request_messages
+from .protocol import build_cer_request_tool
+from .protocol import build_mc_choices_response
+
+
+##
+
+
+# @omlish-manifest $.minichain.registries.manifests.RegistryManifest(
+#     name='cerebras',
+#     type='ChatChoicesService',
+# )
+@static_check_is_chat_choices_service
+class CerebrasChatChoicesService:
+    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='CEREBRAS_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_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,
+        )
+
+        raw_request = msh.marshal(cer_request)
+
+        # TODO: headers:
+        #  - CF-RAY
+        #  - X-Amz-Cf-Id
+        #  - X-delay-time
+
+        http_response = await http.async_request(
+            '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()),
+            },
+            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/cerebras/names.py

@@ -0,0 +1,45 @@
+"""
+https://inference-docs.cerebras.ai/models/overview
+"""
+from ....models.names import ModelNameCollection
+from ...strings.manifests import BackendStringsManifest
+
+
+##
+
+
+MODEL_NAMES = ModelNameCollection(
+    default='gpt-oss-120b',
+    aliases={
+        'llama3.1-8b': None,
+
+        'llama-3.3-70b': None,
+        'llama3': 'llama-3.3-70b',
+
+        'gpt-oss-120b': None,
+        'gpt-oss': 'gpt-oss-120b',
+
+        'qwen-3-32b': None,
+        'qwen3': 'qwen-3-32b',
+
+        ##
+        # preview
+
+        'qwen-3-235b-a22b-instruct-2507': None,
+        'qwen-3-235b': 'qwen-3-235b-a22b-instruct-2507',
+
+        'zai-glm-4.7': None,
+        'glm': 'zai-glm-4.7',
+    },
+)
+
+
+# @omlish-manifest
+_BACKEND_STRINGS_MANIFEST = BackendStringsManifest(
+    [
+        'ChatChoicesService',
+        'ChatChoicesStreamService',
+    ],
+    'cerebras',
+    model_names=MODEL_NAMES,
+)

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

@@ -0,0 +1,143 @@
+import itertools
+
+from omlish import check
+from omlish.formats import json
+
+from .....backends.cerebras 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 PartialToolUseAiDelta
+from ....chat.tools.types import Tool
+from ....content.transform.prepare import prepare_content_str
+from ....tools.jsonschema import build_tool_spec_params_json_schema
+from ....tools.types import ToolUse
+
+
+##
+
+
+def build_cer_request_messages(chat: Chat) -> list[pt.ChatCompletionRequest.Message]:
+    cer_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:
+                cer_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):
+                    cer_msgs.append(pt.ChatCompletionRequest.SystemMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, UserMessage):
+                    cer_msgs.append(pt.ChatCompletionRequest.UserMessage(
+                        content=check.isinstance(mc_msg.c, str),
+                    ))
+
+                elif isinstance(mc_msg, ToolUseResultMessage):
+                    cer_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 cer_msgs
+
+
+def build_cer_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) if t.spec.desc is not None else None,
+            parameters=build_tool_spec_params_json_schema(t.spec),
+        ),
+    )
+
+
+def build_mc_choices_response(cer_resp: pt.ChatCompletionResponse) -> ChatChoicesResponse:
+    def build_choice(cer_choice: pt.ChatCompletionResponse.Choice) -> AiChoice:
+        cer_msg = cer_choice.message
+
+        lst: list[AnyAiMessage] = []
+
+        if cer_msg.content is not None:
+            lst.append(AiMessage(
+                check.isinstance(cer_msg.content, str),
+            ))
+
+        for cer_tc in cer_msg.tool_calls or []:
+            lst.append(ToolUseMessage(ToolUse(
+                id=cer_tc.id,
+                name=cer_tc.function.name,
+                args=json.loads(cer_tc.function.arguments or '{}'),
+                raw_args=cer_tc.function.arguments,
+            )))
+
+        return AiChoice(lst)
+
+    return ChatChoicesResponse(list(map(build_choice, cer_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(PartialToolUseAiDelta(
+                id=tc.id,
+                name=tc_fn.name,
+                raw_args=tc_fn.arguments,
+            ))
+
+        return AiChoiceDeltas(lst)
+
+    elif delta.channel in ('analysis', 'commentary'):
+        return AiChoiceDeltas([])
+
+    else:
+        raise ValueError(delta)

ommlds/minichain/backends/impls/cerebras/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.cerebras 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 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')
+
+    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()),
+            },
+            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
+                            raise TypeError(l)
+
+                        # 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/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/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/stream.py

@@ -179,7 +179,7 @@ class GoogleChatChoicesStreamService:
                     for bl in db.feed(b):
                         if isinstance(bl, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(bl)
 
                         l = bl.decode('utf-8')
                         if not l:

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

@@ -7,8 +7,8 @@ from omlish import check
 from omlish import dataclasses as dc
 
 from .....backends.google.protocol import types as pt
-from ....content.prepare import ContentStrPreparer
-from ....content.prepare import default_content_str_preparer
+from ....content.transform.prepare import ContentStrPreparer
+from ....content.transform.prepare import default_content_str_preparer
 from ....tools.types import EnumToolDtype
 from ....tools.types import MappingToolDtype
 from ....tools.types import NullableToolDtype

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

@@ -7,6 +7,7 @@ from omlish.formats import json
 from omlish.http import all as http
 
 from .....backends.groq import protocol as pt
+from .....backends.groq.clients import REQUIRED_HTTP_HEADERS
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -65,6 +66,7 @@ class GroqChatChoicesService:
             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'),
             client=self._http_client,

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

@@ -18,7 +18,7 @@ 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 ....content.transform.prepare import prepare_content_str
 from ....tools.jsonschema import build_tool_spec_params_json_schema
 from ....tools.types import ToolUse
 
@@ -89,7 +89,7 @@ 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),
+            description=prepare_content_str(t.spec.desc) if t.spec.desc is not None else None,
             parameters=build_tool_spec_params_json_schema(t.spec),
         ),
     )

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

@@ -9,6 +9,7 @@ from omlish.http import sse
 from omlish.io.buffers import DelimitingBuffer
 
 from .....backends.groq import protocol as pt
+from .....backends.groq.clients import REQUIRED_HTTP_HEADERS
 from ....chat.choices.services import ChatChoicesOutputs
 from ....chat.choices.stream.services import ChatChoicesStreamRequest
 from ....chat.choices.stream.services import ChatChoicesStreamResponse
@@ -72,6 +73,7 @@ class GroqChatChoicesStreamService:
             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'),
         )
@@ -88,7 +90,7 @@ class GroqChatChoicesStreamService:
                     for l in db.feed(b):
                         if isinstance(l, DelimitingBuffer.Incomplete):
                             # FIXME: handle
-                            return []
+                            raise TypeError(l)
 
                         # FIXME: https://platform.openai.com/docs/guides/function-calling?api-mode=responses#streaming
                         for so in sd.process_line(l):

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')
 
 
 ##

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

@@ -2,13 +2,10 @@ import contextlib
 import os.path
 import typing as ta
 
-import llama_cpp as lcc
-
 from omlish import check
 from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import llamacpp as lcu
 from ....chat.choices.services import ChatChoicesRequest
 from ....chat.choices.services import ChatChoicesResponse
 from ....chat.choices.services import static_check_is_chat_choices_service
@@ -27,6 +24,12 @@ from .format import ROLES_MAP
 from .format import get_msg_content
 
 
+with lang.auto_proxy_import(globals()):
+    import llama_cpp as lcc
+
+    from .....backends import llamacpp as lcu
+
+
 ##
 
 

ommlds/minichain/backends/impls/llamacpp/completion.py

@@ -2,11 +2,9 @@ import contextlib
 import os.path
 import typing as ta
 
-import llama_cpp as lcc
-
+from omlish import lang
 from omlish import typedvalues as tv
 
-from .....backends import llamacpp as lcu
 from ....completion import CompletionOption
 from ....completion import CompletionRequest
 from ....completion import CompletionResponse
@@ -18,6 +16,12 @@ from ....llms.types import Temperature
 from ....models.configs import ModelPath
 
 
+with lang.auto_proxy_import(globals()):
+    import llama_cpp as lcc
+
+    from .....backends import llamacpp as lcu
+
+
 ##