querais 0.2.0__tar.gz

querais-0.2.0/.gitignore

@@ -0,0 +1,52 @@
+# dependencies
+node_modules/
+.pnpm-store/
+
+# build output
+dist/
+*.tsbuildinfo
+
+# hardhat / contracts
+packages/contracts/artifacts/
+packages/contracts/cache/
+packages/contracts/typechain-types/
+packages/contracts/coverage/
+packages/contracts/coverage.json
+# Slither's symlink-free analysis copy (built fresh by the CI slither job)
+packages/contracts/slither-scratch/
+# Ephemeral local deployment only; real-network manifests (e.g. Sepolia) are committed.
+packages/contracts/deployments/addresses.localhost.json
+packages/contracts/src/abis.ts
+
+# env & secrets
+.env
+.env.*
+!.env.example
+*.keystore
+
+# logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# editor / os
+.DS_Store
+.idea/
+.vscode/*
+!.vscode/extensions.json
+
+# runtime data
+data/
+*.local.json
+
+# release artifacts (built by scripts/bundle-daemon.mjs / release.yml)
+# anchored: scripts/release/ (launcher sources) must stay tracked
+/release/
+
+# python (sdk-python)
+.venv/
+__pycache__/
+*.egg-info/
+.ruff_cache/
+.pytest_cache/
+sdk-python/dist/

querais-0.2.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: querais
+Version: 0.2.0
+Summary: Python client for QueraIS, the decentralized AI inference marketplace. OpenAI-shaped chat/streaming plus QueraIS extras: nodes, stats, model manifest.
+Project-URL: Homepage, https://github.com/ShavitR/querais/tree/main/sdk-python#readme
+Project-URL: Repository, https://github.com/ShavitR/querais
+Project-URL: Issues, https://github.com/ShavitR/querais/issues
+Author: QueraIS contributors
+License-Expression: MIT
+Keywords: ai,arbitrum,decentralized,inference,llm,openai-compatible,querais,web3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-openai>=0.2; extra == 'langchain'
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-llms-openai-like>=0.3; extra == 'llamaindex'
+Description-Content-Type: text/markdown
+
+# querais
+
+Python client for [QueraIS](https://github.com/ShavitR/querais) — the decentralized
+AI inference marketplace. Anyone with a GPU serves models and earns; you buy
+inference through one OpenAI-compatible endpoint.
+
+```bash
+pip install querais
+```
+
+```python
+from querais import QueraisClient
+
+client = QueraisClient("https://querais-gateway.fly.dev", api_key="sk-...")
+result = client.chat([{"role": "user", "content": "hello"}], model="llama3.2")
+print(result.content)
+```
+
+## OpenAI-compatible
+
+The gateway speaks the OpenAI chat-completions protocol, so the official `openai`
+package works too — point it at the gateway:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="https://querais-gateway.fly.dev/v1", api_key="sk-...")
+```
+
+This package is thin sugar over that protocol plus QueraIS-specific helpers.
+
+## Streaming
+
+```python
+for delta in client.chat_stream([{"role": "user", "content": "tell me a story"}],
+                                model="llama3.2"):
+    print(delta, end="", flush=True)
+```
+
+## QueraIS extras
+
+```python
+client.models()          # model ids served by connected nodes
+client.nodes()           # public node directory: reputation, prices, dimensions
+client.stats()           # network stats
+client.model_manifest()  # the gateway's signed model-digest manifest (404 if unpinned)
+```
+
+Routing extensions on `chat()` / `chat_stream()`:
+
+```python
+client.chat(messages, model="llama3.2",
+            max_price_per_1k_tokens=0.5,  # cap what you pay
+            min_reputation=0.7)           # floor the node quality
+```
+
+## LangChain / LlamaIndex
+
+The integrations return the **official** LangChain / LlamaIndex OpenAI classes
+configured for the gateway — nothing reimplemented:
+
+```bash
+pip install 'querais[langchain]'   # or 'querais[llamaindex]'
+```
+
+```python
+from querais.langchain import chat_model
+llm = chat_model("https://querais-gateway.fly.dev", api_key="sk-...", model="llama3.2")
+
+from querais.llamaindex import llm as qllm
+llm = qllm("https://querais-gateway.fly.dev", api_key="sk-...", model="llama3.2")
+```
+
+## License
+
+MIT

querais-0.2.0/README.md

@@ -0,0 +1,76 @@
+# querais
+
+Python client for [QueraIS](https://github.com/ShavitR/querais) — the decentralized
+AI inference marketplace. Anyone with a GPU serves models and earns; you buy
+inference through one OpenAI-compatible endpoint.
+
+```bash
+pip install querais
+```
+
+```python
+from querais import QueraisClient
+
+client = QueraisClient("https://querais-gateway.fly.dev", api_key="sk-...")
+result = client.chat([{"role": "user", "content": "hello"}], model="llama3.2")
+print(result.content)
+```
+
+## OpenAI-compatible
+
+The gateway speaks the OpenAI chat-completions protocol, so the official `openai`
+package works too — point it at the gateway:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="https://querais-gateway.fly.dev/v1", api_key="sk-...")
+```
+
+This package is thin sugar over that protocol plus QueraIS-specific helpers.
+
+## Streaming
+
+```python
+for delta in client.chat_stream([{"role": "user", "content": "tell me a story"}],
+                                model="llama3.2"):
+    print(delta, end="", flush=True)
+```
+
+## QueraIS extras
+
+```python
+client.models()          # model ids served by connected nodes
+client.nodes()           # public node directory: reputation, prices, dimensions
+client.stats()           # network stats
+client.model_manifest()  # the gateway's signed model-digest manifest (404 if unpinned)
+```
+
+Routing extensions on `chat()` / `chat_stream()`:
+
+```python
+client.chat(messages, model="llama3.2",
+            max_price_per_1k_tokens=0.5,  # cap what you pay
+            min_reputation=0.7)           # floor the node quality
+```
+
+## LangChain / LlamaIndex
+
+The integrations return the **official** LangChain / LlamaIndex OpenAI classes
+configured for the gateway — nothing reimplemented:
+
+```bash
+pip install 'querais[langchain]'   # or 'querais[llamaindex]'
+```
+
+```python
+from querais.langchain import chat_model
+llm = chat_model("https://querais-gateway.fly.dev", api_key="sk-...", model="llama3.2")
+
+from querais.llamaindex import llm as qllm
+llm = qllm("https://querais-gateway.fly.dev", api_key="sk-...", model="llama3.2")
+```
+
+## License
+
+MIT

querais-0.2.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "querais"
+version = "0.2.0"
+description = "Python client for QueraIS, the decentralized AI inference marketplace. OpenAI-shaped chat/streaming plus QueraIS extras: nodes, stats, model manifest."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "QueraIS contributors" }]
+keywords = [
+  "querais",
+  "ai",
+  "llm",
+  "inference",
+  "openai-compatible",
+  "decentralized",
+  "arbitrum",
+  "web3",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+# Integrations return the OFFICIAL LangChain / LlamaIndex OpenAI classes pointed at
+# the gateway — nothing is reimplemented, and `pip install querais` stays light.
+langchain = ["langchain-openai>=0.2"]
+llamaindex = ["llama-index-llms-openai-like>=0.3"]
+dev = ["pytest>=8", "ruff>=0.8", "build>=1.2"]
+
+[project.urls]
+Homepage = "https://github.com/ShavitR/querais/tree/main/sdk-python#readme"
+Repository = "https://github.com/ShavitR/querais"
+Issues = "https://github.com/ShavitR/querais/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/querais"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+# Defaults (pyflakes + pycodestyle errors) plus import sorting, bugbear, pyupgrade.
+select = ["E", "F", "I", "B", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

querais-0.2.0/src/querais/__init__.py

@@ -0,0 +1,12 @@
+"""QueraIS — Python client for the decentralized AI inference marketplace.
+
+The gateway is OpenAI-compatible; this package is thin sugar plus QueraIS-specific
+helpers. LangChain / LlamaIndex users: see ``querais.langchain`` /
+``querais.llamaindex`` (optional extras).
+"""
+
+from .client import ChatResult, Message, QueraisClient, QueraisError
+
+__version__ = "0.1.0"
+
+__all__ = ["ChatResult", "Message", "QueraisClient", "QueraisError", "__version__"]

querais-0.2.0/src/querais/client.py

@@ -0,0 +1,201 @@
+"""Thin, typed client for the QueraIS gateway.
+
+The gateway is OpenAI-compatible, so this is convenience sugar (exactly like the
+TypeScript SDK): chat + SSE streaming plus QueraIS-specific helpers (nodes, stats,
+model manifest). The official ``openai`` package also works against the gateway.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import Any
+
+import httpx
+
+Message = dict[str, str]
+"""An OpenAI-shaped chat message: ``{"role": "user", "content": "..."}``."""
+
+
+class QueraisError(Exception):
+    """A non-2xx response from the gateway (carries status + body text)."""
+
+    def __init__(self, status: int, body: str):
+        super().__init__(f"QueraIS gateway returned HTTP {status}: {body}")
+        self.status = status
+        self.body = body
+
+
+@dataclass
+class ChatResult:
+    """A buffered completion: the text, token usage, and the on-chain job id."""
+
+    content: str
+    usage: dict[str, int] = field(default_factory=dict)
+    job_id: str | None = None
+
+
+class QueraisClient:
+    """Synchronous client for a QueraIS gateway.
+
+    >>> client = QueraisClient("https://querais-gateway.fly.dev", api_key="sk-...")
+    >>> result = client.chat([{"role": "user", "content": "hello"}], model="llama3.2")
+    >>> print(result.content)
+
+    ``transport`` is injectable for tests (``httpx.MockTransport``) — no network,
+    no gateway needed.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        api_key: str,
+        timeout: float = 120.0,
+        transport: httpx.BaseTransport | None = None,
+    ):
+        self._http = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            timeout=timeout,
+            headers={"authorization": f"Bearer {api_key}"},
+            transport=transport,
+        )
+
+    # ── lifecycle ──────────────────────────────────────────────────────────────
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> QueraisClient:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    # ── chat ───────────────────────────────────────────────────────────────────
+
+    def _chat_body(
+        self,
+        messages: list[Message],
+        model: str,
+        stream: bool,
+        max_tokens: int | None,
+        temperature: float | None,
+        max_price_per_1k_tokens: float | None,
+        min_reputation: float | None,
+    ) -> dict[str, Any]:
+        body: dict[str, Any] = {"model": model, "messages": messages, "stream": stream}
+        if max_tokens is not None:
+            body["max_tokens"] = max_tokens
+        if temperature is not None:
+            body["temperature"] = temperature
+        # QueraIS routing extensions (ignored by other OpenAI-compatible servers).
+        if max_price_per_1k_tokens is not None:
+            body["max_price_per_1k_tokens"] = max_price_per_1k_tokens
+        if min_reputation is not None:
+            body["min_reputation"] = min_reputation
+        return body
+
+    def chat(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        max_price_per_1k_tokens: float | None = None,
+        min_reputation: float | None = None,
+    ) -> ChatResult:
+        """Buffered chat completion."""
+        res = self._http.post(
+            "/v1/chat/completions",
+            json=self._chat_body(
+                messages,
+                model,
+                False,
+                max_tokens,
+                temperature,
+                max_price_per_1k_tokens,
+                min_reputation,
+            ),
+        )
+        if res.status_code >= 400:
+            raise QueraisError(res.status_code, res.text)
+        data = res.json()
+        choices = data.get("choices") or [{}]
+        return ChatResult(
+            content=(choices[0].get("message") or {}).get("content", ""),
+            usage=data.get("usage") or {},
+            job_id=res.headers.get("x-querais-job-id"),
+        )
+
+    def chat_stream(
+        self,
+        messages: list[Message],
+        *,
+        model: str,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        max_price_per_1k_tokens: float | None = None,
+        min_reputation: float | None = None,
+    ) -> Iterator[str]:
+        """Streaming chat completion — yields content deltas as they arrive (SSE)."""
+        with self._http.stream(
+            "POST",
+            "/v1/chat/completions",
+            json=self._chat_body(
+                messages,
+                model,
+                True,
+                max_tokens,
+                temperature,
+                max_price_per_1k_tokens,
+                min_reputation,
+            ),
+        ) as res:
+            if res.status_code >= 400:
+                res.read()
+                raise QueraisError(res.status_code, res.text)
+            for line in res.iter_lines():
+                if not line.startswith("data:"):
+                    continue
+                data = line[len("data:") :].strip()
+                if not data or data == "[DONE]":
+                    continue
+                try:
+                    frame = json.loads(data)
+                except ValueError:
+                    continue  # keep-alives / non-JSON frames
+                delta = ((frame.get("choices") or [{}])[0].get("delta") or {}).get("content")
+                if delta:
+                    yield delta
+
+    # ── QueraIS extras ─────────────────────────────────────────────────────────
+
+    def models(self) -> list[str]:
+        """Model ids currently served by at least one connected node."""
+        data = self._get_json("/v1/models")
+        return [m["id"] for m in data.get("data", [])]
+
+    def nodes(self) -> list[dict[str, Any]]:
+        """The public node directory: wallet, reputation, offers, dimensions."""
+        return self._get_json("/v1/nodes").get("data", [])
+
+    def stats(self) -> dict[str, Any]:
+        """Network stats (jobs, volume, nodes)."""
+        return self._get_json("/v1/stats")
+
+    def model_manifest(self) -> dict[str, Any]:
+        """The gateway's signed model manifest (Slice 9). Raises 404 when unpinned.
+
+        The returned object is signed (EIP-191) by the gateway's settler address and
+        can be verified offline — see ``GET /v1/credit/info`` for the settler.
+        """
+        return self._get_json("/v1/models/manifest")
+
+    def _get_json(self, path: str) -> dict[str, Any]:
+        res = self._http.get(path)
+        if res.status_code >= 400:
+            raise QueraisError(res.status_code, res.text)
+        return res.json()

querais-0.2.0/src/querais/langchain.py

@@ -0,0 +1,30 @@
+"""LangChain integration: the OFFICIAL ``ChatOpenAI`` pointed at a QueraIS gateway.
+
+Nothing is reimplemented — the gateway speaks the OpenAI protocol, so the genuine
+LangChain class works as-is. Requires the optional extra::
+
+    pip install 'querais[langchain]'
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def chat_model(base_url: str, *, api_key: str, model: str, **kwargs: Any) -> Any:
+    """A ``langchain_openai.ChatOpenAI`` configured for the gateway.
+
+    Extra ``kwargs`` (temperature, max_tokens, …) pass straight through.
+    """
+    try:
+        from langchain_openai import ChatOpenAI
+    except ImportError as err:  # pragma: no cover - exercised via the extra
+        raise ImportError(
+            "LangChain support needs the optional extra: pip install 'querais[langchain]'"
+        ) from err
+    return ChatOpenAI(
+        base_url=f"{base_url.rstrip('/')}/v1",
+        api_key=api_key,
+        model=model,
+        **kwargs,
+    )

querais-0.2.0/src/querais/llamaindex.py

@@ -0,0 +1,32 @@
+"""LlamaIndex integration: the OFFICIAL ``OpenAILike`` pointed at a QueraIS gateway.
+
+Nothing is reimplemented — the gateway speaks the OpenAI protocol, so the genuine
+LlamaIndex class works as-is. Requires the optional extra::
+
+    pip install 'querais[llamaindex]'
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def llm(base_url: str, *, api_key: str, model: str, **kwargs: Any) -> Any:
+    """A ``llama_index.llms.openai_like.OpenAILike`` configured for the gateway.
+
+    ``is_chat_model`` defaults to True (the gateway serves chat completions).
+    Extra ``kwargs`` (temperature, max_tokens, …) pass straight through.
+    """
+    try:
+        from llama_index.llms.openai_like import OpenAILike
+    except ImportError as err:  # pragma: no cover - exercised via the extra
+        raise ImportError(
+            "LlamaIndex support needs the optional extra: pip install 'querais[llamaindex]'"
+        ) from err
+    kwargs.setdefault("is_chat_model", True)
+    return OpenAILike(
+        api_base=f"{base_url.rstrip('/')}/v1",
+        api_key=api_key,
+        model=model,
+        **kwargs,
+    )

querais-0.2.0/tests/test_client.py

@@ -0,0 +1,127 @@
+"""QueraisClient unit tests on httpx.MockTransport — no network, no gateway."""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+from querais import ChatResult, QueraisClient, QueraisError
+
+BASE = "https://gw.test"
+
+
+def make_client(handler) -> QueraisClient:
+    return QueraisClient(BASE, api_key="sk-test", transport=httpx.MockTransport(handler))
+
+
+def test_chat_returns_content_usage_and_job_id():
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.path == "/v1/chat/completions"
+        assert request.headers["authorization"] == "Bearer sk-test"
+        body = json.loads(request.content)
+        assert body["model"] == "mock-model"
+        assert body["stream"] is False
+        assert body["max_tokens"] == 32
+        assert body["max_price_per_1k_tokens"] == 0.5  # QueraIS routing extension
+        return httpx.Response(
+            200,
+            headers={"x-querais-job-id": "0xjob"},
+            json={
+                "choices": [{"message": {"role": "assistant", "content": "hello back"}}],
+                "usage": {"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5},
+            },
+        )
+
+    with make_client(handler) as client:
+        result = client.chat(
+            [{"role": "user", "content": "hello"}],
+            model="mock-model",
+            max_tokens=32,
+            max_price_per_1k_tokens=0.5,
+        )
+    assert result == ChatResult(
+        content="hello back",
+        usage={"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5},
+        job_id="0xjob",
+    )
+
+
+def test_chat_raises_typed_error_with_status_and_body():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            503, json={"error": {"message": "no capacity", "type": "no_eligible_nodes"}}
+        )
+
+    with make_client(handler) as client:
+        with pytest.raises(QueraisError) as exc:
+            client.chat([{"role": "user", "content": "hi"}], model="mock-model")
+    assert exc.value.status == 503
+    assert "no_eligible_nodes" in exc.value.body
+
+
+def test_chat_stream_yields_deltas_and_skips_done_and_noise():
+    sse = (
+        'data: {"choices":[{"delta":{"content":"Hel"}}]}\n\n'
+        "data: \n\n"  # keep-alive
+        'data: {"choices":[{"delta":{}}]}\n\n'  # finish frame, no content
+        'data: {"choices":[{"delta":{"content":"lo!"}}]}\n\n'
+        "data: [DONE]\n\n"
+    )
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert json.loads(request.content)["stream"] is True
+        return httpx.Response(
+            200, content=sse.encode(), headers={"content-type": "text/event-stream"}
+        )
+
+    with make_client(handler) as client:
+        chunks = list(client.chat_stream([{"role": "user", "content": "hi"}], model="mock-model"))
+    assert chunks == ["Hel", "lo!"]
+
+
+def test_chat_stream_raises_on_error_status():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(401, json={"error": {"message": "bad key"}})
+
+    with make_client(handler) as client:
+        with pytest.raises(QueraisError) as exc:
+            list(client.chat_stream([{"role": "user", "content": "hi"}], model="mock-model"))
+    assert exc.value.status == 401
+
+
+def test_models_nodes_stats_and_manifest():
+    manifest = {
+        "models": {"llama3.2": {"digest": "sha256:" + "a" * 64}},
+        "signer": "0x" + "1" * 40,
+        "signature": "0x" + "2" * 130,
+    }
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        routes = {
+            "/v1/models": {"object": "list", "data": [{"id": "llama3.2"}, {"id": "phi3"}]},
+            "/v1/nodes": {"data": [{"wallet": "0xabc", "reputation": 0.71}]},
+            "/v1/stats": {"jobs24h": 7, "nodes": 1},
+            "/v1/models/manifest": manifest,
+        }
+        payload = routes.get(request.url.path)
+        if payload is None:
+            return httpx.Response(404, json={"error": "not found"})
+        return httpx.Response(200, json=payload)
+
+    with make_client(handler) as client:
+        assert client.models() == ["llama3.2", "phi3"]
+        assert client.nodes() == [{"wallet": "0xabc", "reputation": 0.71}]
+        assert client.stats() == {"jobs24h": 7, "nodes": 1}
+        assert client.model_manifest() == manifest
+
+
+def test_model_manifest_404_when_gateway_unpinned():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(404, json={"error": "no model manifest configured"})
+
+    with make_client(handler) as client:
+        with pytest.raises(QueraisError) as exc:
+            client.model_manifest()
+    assert exc.value.status == 404

querais-0.2.0/tests/test_integrations.py

@@ -0,0 +1,27 @@
+"""Integration-module tests — skip cleanly when the optional extra isn't installed."""
+
+from __future__ import annotations
+
+import pytest
+
+
+def test_langchain_chat_model_points_at_the_gateway():
+    pytest.importorskip("langchain_openai")
+    from querais.langchain import chat_model
+
+    llm = chat_model("https://gw.test/", api_key="sk-test", model="llama3.2", temperature=0)
+    # The official class, configured for the gateway (trailing slash normalized).
+    assert type(llm).__name__ == "ChatOpenAI"
+    assert llm.openai_api_base == "https://gw.test/v1"
+    assert llm.model_name == "llama3.2"
+
+
+def test_llamaindex_llm_points_at_the_gateway():
+    pytest.importorskip("llama_index.llms.openai_like")
+    from querais.llamaindex import llm
+
+    model = llm("https://gw.test", api_key="sk-test", model="llama3.2")
+    assert type(model).__name__ == "OpenAILike"
+    assert model.api_base == "https://gw.test/v1"
+    assert model.model == "llama3.2"
+    assert model.is_chat_model is True