langchain-outrun 0.1.0__tar.gz

langchain_outrun-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.env

langchain_outrun-0.1.0/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 (2026-11-14)
+
+- First release: `ChatOutrun` chat model (invoke, stream, async, tool calling, structured output) on the Outrun OpenAI-compatible API.

langchain_outrun-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Outrun LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_outrun-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.5
+Name: langchain-outrun
+Version: 0.1.0
+Summary: LangChain integration for Outrun, a prepaid OpenAI-compatible API for GPT, Claude, Gemini, DeepSeek and more
+Project-URL: Homepage, https://outrun.to
+Project-URL: Documentation, https://github.com/OutrunAIAPI/langchain-outrun#readme
+Project-URL: Pricing, https://outrun.to/pricing
+Project-URL: Repository, https://github.com/OutrunAIAPI/langchain-outrun
+Project-URL: Issues, https://github.com/OutrunAIAPI/langchain-outrun/issues
+Author-email: Outrun LLC <support@outrun.to>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chat,langchain,llm,openai-compatible,outrun
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.10
+Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-openai<2.0.0,>=1.0.0
+Description-Content-Type: text/markdown
+
+# langchain-outrun
+
+LangChain integration for [Outrun](https://outrun.to), a prepaid, OpenAI-compatible API. One Outrun key reaches GPT, Claude, Gemini, Grok, DeepSeek, GLM, Kimi, Qwen and MiniMax models.
+
+`ChatOutrun` is a LangChain chat model built on `langchain-openai`, with the Outrun base URL and key set for you.
+
+## Install
+
+```bash
+pip install -U langchain-outrun
+```
+
+Create a key at https://outrun.to/key, then:
+
+```bash
+export OUTRUN_API_KEY="your-api-key"
+```
+
+## Chat model
+
+```python
+from langchain_outrun import ChatOutrun
+
+model = ChatOutrun(model="gpt-5.6-terra", temperature=0)
+print(model.invoke("Explain prompt caching in one sentence.").content)
+```
+
+Pick any model id from https://outrun.to/pricing (for example `claude-haiku-5-5`, `gemini-3.8-flash` or `deepseek-v4.1-flash`). The same list is available as JSON, without a key, at `https://api.outrun.to/pricing`.
+
+### Streaming
+
+```python
+for chunk in model.stream("Write a haiku about rain."):
+    print(chunk.text, end="", flush=True)
+```
+
+Token usage is included in streamed responses (`usage_metadata` on the last chunk).
+
+### Tool calling
+
+```python
+from pydantic import BaseModel, Field
+
+
+class GetWeather(BaseModel):
+    """Get the current weather for a city."""
+
+    city: str = Field(description="City name")
+
+
+model_with_tools = model.bind_tools([GetWeather])
+msg = model_with_tools.invoke("What's the weather in Paris?")
+print(msg.tool_calls)
+```
+
+### Structured output
+
+```python
+class Answer(BaseModel):
+    answer: str
+    confidence: float
+
+
+structured = model.with_structured_output(Answer)
+print(structured.invoke("Is the sky blue? Answer briefly."))
+```
+
+Tool calling and structured output depend on the model you pick.
+
+### Async
+
+`ainvoke`, `astream` and `abatch` work as with any LangChain chat model.
+
+## Settings
+
+| Argument | Environment variable | Default |
+|---|---|---|
+| `api_key` | `OUTRUN_API_KEY` | none (required) |
+| `base_url` | `OUTRUN_API_BASE` | `https://api.outrun.to/v1` |
+| `model` | | none (required) |
+
+Other `ChatOpenAI` arguments such as `temperature`, `max_tokens`, `timeout`, `max_retries` and `default_headers` work the same way.
+
+- Requests go to `/v1/chat/completions`. Pass `use_responses_api=True` to use `/v1/responses` instead (GPT models only).
+- `ChatOutrun` never reads `OPENAI_API_KEY`, so an OpenAI key is never sent to Outrun.
+- Each request carries an `X-Outrun-SDK: langchain/<version>` header.
+
+## Development
+
+```bash
+pip install -e . pytest pytest-asyncio pytest-socket "langchain-tests>=1,<2"
+pytest tests/unit_tests --disable-socket --allow-unix-socket
+```
+
+`tests/integration_tests` call the live API (billed to your balance) and run only when `OUTRUN_API_KEY` is set.
+
+## Links
+
+- Outrun docs: https://outrun.to/docs/
+- Plain OpenAI SDK wrapper: [`outrun-ai`](https://pypi.org/project/outrun-ai/)
+- Support: support@outrun.to
+
+License: MIT.

langchain_outrun-0.1.0/README.md

@@ -0,0 +1,103 @@
+# langchain-outrun
+
+LangChain integration for [Outrun](https://outrun.to), a prepaid, OpenAI-compatible API. One Outrun key reaches GPT, Claude, Gemini, Grok, DeepSeek, GLM, Kimi, Qwen and MiniMax models.
+
+`ChatOutrun` is a LangChain chat model built on `langchain-openai`, with the Outrun base URL and key set for you.
+
+## Install
+
+```bash
+pip install -U langchain-outrun
+```
+
+Create a key at https://outrun.to/key, then:
+
+```bash
+export OUTRUN_API_KEY="your-api-key"
+```
+
+## Chat model
+
+```python
+from langchain_outrun import ChatOutrun
+
+model = ChatOutrun(model="gpt-5.6-terra", temperature=0)
+print(model.invoke("Explain prompt caching in one sentence.").content)
+```
+
+Pick any model id from https://outrun.to/pricing (for example `claude-haiku-5-5`, `gemini-3.8-flash` or `deepseek-v4.1-flash`). The same list is available as JSON, without a key, at `https://api.outrun.to/pricing`.
+
+### Streaming
+
+```python
+for chunk in model.stream("Write a haiku about rain."):
+    print(chunk.text, end="", flush=True)
+```
+
+Token usage is included in streamed responses (`usage_metadata` on the last chunk).
+
+### Tool calling
+
+```python
+from pydantic import BaseModel, Field
+
+
+class GetWeather(BaseModel):
+    """Get the current weather for a city."""
+
+    city: str = Field(description="City name")
+
+
+model_with_tools = model.bind_tools([GetWeather])
+msg = model_with_tools.invoke("What's the weather in Paris?")
+print(msg.tool_calls)
+```
+
+### Structured output
+
+```python
+class Answer(BaseModel):
+    answer: str
+    confidence: float
+
+
+structured = model.with_structured_output(Answer)
+print(structured.invoke("Is the sky blue? Answer briefly."))
+```
+
+Tool calling and structured output depend on the model you pick.
+
+### Async
+
+`ainvoke`, `astream` and `abatch` work as with any LangChain chat model.
+
+## Settings
+
+| Argument | Environment variable | Default |
+|---|---|---|
+| `api_key` | `OUTRUN_API_KEY` | none (required) |
+| `base_url` | `OUTRUN_API_BASE` | `https://api.outrun.to/v1` |
+| `model` | | none (required) |
+
+Other `ChatOpenAI` arguments such as `temperature`, `max_tokens`, `timeout`, `max_retries` and `default_headers` work the same way.
+
+- Requests go to `/v1/chat/completions`. Pass `use_responses_api=True` to use `/v1/responses` instead (GPT models only).
+- `ChatOutrun` never reads `OPENAI_API_KEY`, so an OpenAI key is never sent to Outrun.
+- Each request carries an `X-Outrun-SDK: langchain/<version>` header.
+
+## Development
+
+```bash
+pip install -e . pytest pytest-asyncio pytest-socket "langchain-tests>=1,<2"
+pytest tests/unit_tests --disable-socket --allow-unix-socket
+```
+
+`tests/integration_tests` call the live API (billed to your balance) and run only when `OUTRUN_API_KEY` is set.
+
+## Links
+
+- Outrun docs: https://outrun.to/docs/
+- Plain OpenAI SDK wrapper: [`outrun-ai`](https://pypi.org/project/outrun-ai/)
+- Support: support@outrun.to
+
+License: MIT.

langchain_outrun-0.1.0/langchain_outrun/__init__.py

@@ -0,0 +1,12 @@
+"""LangChain integration for Outrun."""
+
+from importlib import metadata
+
+try:
+    __version__ = metadata.version(__package__ or "langchain-outrun")
+except metadata.PackageNotFoundError:
+    __version__ = ""
+
+from langchain_outrun.chat_models import ChatOutrun  # noqa: E402
+
+__all__ = ["ChatOutrun", "__version__"]

langchain_outrun-0.1.0/langchain_outrun/chat_models.py

@@ -0,0 +1,181 @@
+"""Outrun chat models."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import openai
+from langchain_core.language_models import LangSmithParams, LanguageModelInput
+from langchain_core.utils import from_env, secret_from_env
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from pydantic import ConfigDict, Field, SecretStr, model_validator
+from typing_extensions import Self
+
+DEFAULT_API_BASE = "https://api.outrun.to/v1"
+SDK_HEADER = "X-Outrun-SDK"
+
+
+def _sdk_header_value() -> str:
+    from langchain_outrun import __version__
+
+    return f"langchain/{__version__ or 'dev'}"
+
+
+class ChatOutrun(BaseChatOpenAI):
+    """Chat models on Outrun, a prepaid OpenAI-compatible API.
+
+    One Outrun key reaches GPT, Claude, Gemini, Grok, DeepSeek, GLM, Kimi, Qwen
+    and MiniMax models. The model list with prices is at
+    https://outrun.to/pricing (JSON: `GET https://api.outrun.to/pricing`, no key
+    needed).
+
+    Setup:
+        Install `langchain-outrun` and set the `OUTRUN_API_KEY` environment
+        variable. Create a key at https://outrun.to/key.
+
+        ```bash
+        pip install -U langchain-outrun
+        export OUTRUN_API_KEY="your-api-key"
+        ```
+
+    Key init args (completion params):
+        model:
+            Outrun model id, for example `"gpt-5.6-terra"` or
+            `"deepseek-v4.1-flash"`. Required.
+        temperature:
+            Sampling temperature.
+        max_tokens:
+            Max number of tokens to generate.
+
+    Key init args (client params):
+        api_key:
+            Outrun API key. Read from `OUTRUN_API_KEY` if not passed.
+        base_url:
+            API base URL. Read from `OUTRUN_API_BASE`, defaults to
+            `https://api.outrun.to/v1`.
+        timeout:
+            Timeout for requests.
+        max_retries:
+            Max number of retries.
+
+    Instantiate:
+        ```python
+        from langchain_outrun import ChatOutrun
+
+        model = ChatOutrun(model="gpt-5.6-terra", temperature=0)
+        ```
+
+    Invoke:
+        ```python
+        model.invoke("Explain prompt caching in one sentence.")
+        ```
+
+    Stream:
+        ```python
+        for chunk in model.stream("Write a haiku about rain."):
+            print(chunk.text, end="")
+        ```
+
+    Tool calling and structured output use the same methods as `ChatOpenAI`
+    (`bind_tools`, `with_structured_output`). Support depends on the model.
+
+    `ChatOutrun` sends requests to `/v1/chat/completions`. Pass
+    `use_responses_api=True` to use `/v1/responses` instead (GPT models only).
+    It never reads `OPENAI_API_KEY`, so an OpenAI key is never sent to Outrun.
+    """
+
+    model_name: str = Field(alias="model")
+    """Outrun model id."""
+    api_key: SecretStr | None = Field(
+        default_factory=secret_from_env("OUTRUN_API_KEY", default=None),
+    )
+    """Outrun API key. Read from `OUTRUN_API_KEY` if not provided."""
+    api_base: str = Field(
+        alias="base_url",
+        default_factory=from_env("OUTRUN_API_BASE", default=DEFAULT_API_BASE),
+    )
+    """Outrun API base URL. Read from `OUTRUN_API_BASE` if not provided."""
+    stream_usage: bool | None = True
+    """Include token usage in streamed responses."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of chat model."""
+        return "chat-outrun"
+
+    @property
+    def lc_secrets(self) -> dict[str, str]:
+        """A map of constructor argument names to secret ids."""
+        return {"api_key": "OUTRUN_API_KEY"}
+
+    def _get_ls_params(
+        self,
+        stop: list[str] | None = None,
+        **kwargs: Any,
+    ) -> LangSmithParams:
+        ls_params = super()._get_ls_params(stop=stop, **kwargs)
+        ls_params["ls_provider"] = "outrun"
+        return ls_params
+
+    @model_validator(mode="after")
+    def validate_environment(self) -> Self:
+        """Check the API key and build OpenAI clients pointed at Outrun."""
+        if self.n is not None and self.n < 1:
+            msg = "n must be at least 1."
+            raise ValueError(msg)
+        if self.n is not None and self.n > 1 and self.streaming:
+            msg = "n must be 1 when streaming."
+            raise ValueError(msg)
+        # Always require an Outrun key: with no key, the OpenAI client would fall
+        # back to OPENAI_API_KEY and send it to this base URL.
+        if not (self.api_key and self.api_key.get_secret_value()):
+            msg = (
+                "OUTRUN_API_KEY must be set, or pass api_key=... "
+                "Create a key at https://outrun.to/key"
+            )
+            raise ValueError(msg)
+        headers = {SDK_HEADER: _sdk_header_value(), **(self.default_headers or {})}
+        client_params: dict = {
+            k: v
+            for k, v in {
+                "api_key": self.api_key.get_secret_value(),
+                "base_url": self.api_base,
+                "timeout": self.request_timeout,
+                "max_retries": self.max_retries,
+                "default_headers": headers,
+                "default_query": self.default_query,
+            }.items()
+            if v is not None
+        }
+        if not self.client:
+            sync_specific: dict = {"http_client": self.http_client}
+            self.root_client = openai.OpenAI(**client_params, **sync_specific)
+            self.client = self.root_client.chat.completions
+        if not self.async_client:
+            async_specific: dict = {"http_client": self.http_async_client}
+            self.root_async_client = openai.AsyncOpenAI(
+                **client_params, **async_specific
+            )
+            self.async_client = self.root_async_client.chat.completions
+        return self
+
+    def _use_responses_api(self, payload: dict) -> bool:
+        # Chat completions work for every Outrun model; /v1/responses only for
+        # GPT models, so use it only when asked.
+        return self.use_responses_api is True
+
+    def _get_request_payload(
+        self,
+        input_: LanguageModelInput,
+        *,
+        stop: list[str] | None = None,
+        **kwargs: Any,
+    ) -> dict:
+        payload = super()._get_request_payload(input_, stop=stop, **kwargs)
+        # Not every model behind Outrun accepts the `developer` role.
+        for message in payload.get("messages", []):
+            if message.get("role") == "developer":
+                message["role"] = "system"
+        return payload

langchain_outrun-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-outrun"
+version = "0.1.0"
+description = "LangChain integration for Outrun, a prepaid OpenAI-compatible API for GPT, Claude, Gemini, DeepSeek and more"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Outrun LLC", email = "support@outrun.to" }]
+requires-python = ">=3.10,<4.0"
+keywords = ["outrun", "langchain", "llm", "openai-compatible", "chat"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "langchain-core>=1.0.0,<2.0.0",
+    "langchain-openai>=1.0.0,<2.0.0",
+]
+
+[project.urls]
+Homepage = "https://outrun.to"
+Documentation = "https://github.com/OutrunAIAPI/langchain-outrun#readme"
+Pricing = "https://outrun.to/pricing"
+Repository = "https://github.com/OutrunAIAPI/langchain-outrun"
+Issues = "https://github.com/OutrunAIAPI/langchain-outrun/issues"
+
+[dependency-groups]
+test = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "pytest-socket>=0.7",
+    "langchain-tests>=1.0.0,<2.0.0",
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["langchain_outrun", "tests", "README.md", "CHANGELOG.md", "LICENSE", "pyproject.toml"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_outrun"]
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers --strict-config --durations=5"
+markers = [
+    "compile: mark placeholder test used to compile integration tests without running them",
+]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

langchain_outrun-0.1.0/tests/integration_tests/test_compile.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.compile
+def test_placeholder() -> None:
+    """Used to compile integration tests without running them."""

langchain_outrun-0.1.0/tests/integration_tests/test_standard.py

@@ -0,0 +1,32 @@
+"""Standard LangChain integration tests for ChatOutrun.
+
+These tests call the live Outrun API, which bills the key's balance. They run
+only when `OUTRUN_API_KEY` is set.
+"""
+
+import os
+
+import pytest
+from langchain_core.language_models import BaseChatModel
+from langchain_outrun import ChatOutrun
+from langchain_tests.integration_tests import ChatModelIntegrationTests
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("OUTRUN_API_KEY"), reason="OUTRUN_API_KEY is not set"
+)
+
+MODEL_NAME = os.environ.get("OUTRUN_TEST_MODEL", "gpt-5.6-terra")
+
+
+class TestChatOutrunIntegration(ChatModelIntegrationTests):
+    @property
+    def chat_model_class(self) -> type[BaseChatModel]:
+        return ChatOutrun
+
+    @property
+    def chat_model_params(self) -> dict:
+        return {"model": MODEL_NAME, "max_tokens": 1024, "timeout": 120}
+
+    @property
+    def returns_usage_metadata(self) -> bool:
+        return True

langchain_outrun-0.1.0/tests/unit_tests/test_chat_models.py

@@ -0,0 +1,197 @@
+"""Unit tests for ChatOutrun. Requests go to an in-memory mock, never the network."""
+
+import json
+
+try:  # openai 3.x ships its HTTP layer as httpx2
+    import httpx2 as httpx
+except ImportError:  # openai 1.x / 2.x
+    import httpx
+import pytest
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_outrun import ChatOutrun
+from langchain_outrun.chat_models import DEFAULT_API_BASE
+from pydantic import BaseModel
+
+MODEL = "gpt-5.6-terra"
+
+COMPLETION = {
+    "id": "c1",
+    "object": "chat.completion",
+    "created": 1,
+    "model": MODEL,
+    "choices": [
+        {
+            "index": 0,
+            "finish_reason": "stop",
+            "message": {"role": "assistant", "content": "hello there"},
+        }
+    ],
+    "usage": {"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5},
+}
+
+
+def _chunk(delta: dict, finish: str | None = None, usage: dict | None = None) -> str:
+    body = {
+        "id": "c",
+        "object": "chat.completion.chunk",
+        "created": 1,
+        "model": MODEL,
+        "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+    }
+    if usage is not None:
+        body["choices"] = []
+        body["usage"] = usage
+    return f"data: {json.dumps(body)}\n\n"
+
+
+SSE = (
+    _chunk({"role": "assistant", "content": "Hel"})
+    + _chunk({"content": "lo"})
+    + _chunk({}, finish="stop")
+    + _chunk({}, usage={"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5})
+    + "data: [DONE]\n\n"
+)
+
+
+def _handler(seen: list):
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        body = json.loads(request.content or b"{}")
+        if body.get("stream"):
+            return httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=SSE
+            )
+        return httpx.Response(200, json=COMPLETION)
+
+    return handler
+
+
+def _model(seen: list, **kwargs) -> ChatOutrun:
+    kwargs.setdefault("model", MODEL)
+    kwargs.setdefault("api_key", "test-key")
+    return ChatOutrun(
+        http_client=httpx.Client(transport=httpx.MockTransport(_handler(seen))),
+        http_async_client=httpx.AsyncClient(
+            transport=httpx.MockTransport(_handler(seen))
+        ),
+        **kwargs,
+    )
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    for name in ("OUTRUN_API_KEY", "OUTRUN_API_BASE", "OPENAI_API_KEY", "OPENAI_BASE_URL"):
+        monkeypatch.delenv(name, raising=False)
+
+
+def test_defaults() -> None:
+    model = ChatOutrun(model=MODEL, api_key="k")
+    assert model.api_base == DEFAULT_API_BASE
+    assert str(model.root_client.base_url) == "https://api.outrun.to/v1/"
+    assert model._llm_type == "chat-outrun"
+    assert model._get_ls_params()["ls_provider"] == "outrun"
+    assert model.stream_usage is True
+
+
+def test_model_is_required() -> None:
+    with pytest.raises(ValueError):
+        ChatOutrun(api_key="k")  # type: ignore[call-arg]
+
+
+def test_missing_key_raises_even_with_openai_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-openai-should-not-be-used")
+    with pytest.raises(ValueError, match="OUTRUN_API_KEY"):
+        ChatOutrun(model=MODEL)
+
+
+def test_custom_base_url_still_needs_outrun_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-openai-should-not-be-used")
+    with pytest.raises(ValueError, match="OUTRUN_API_KEY"):
+        ChatOutrun(model=MODEL, base_url="http://localhost:8080/v1")
+    model = ChatOutrun(model=MODEL, base_url="http://localhost:8080/v1", api_key="k")
+    assert str(model.root_client.base_url) == "http://localhost:8080/v1/"
+    assert model.root_client.api_key == "k"
+
+
+def test_invoke_sends_outrun_key_never_openai_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-openai-should-not-be-used")
+    monkeypatch.setenv("OUTRUN_API_KEY", "outrun-env-key")
+    seen: list = []
+    model = ChatOutrun(
+        model=MODEL,
+        http_client=httpx.Client(transport=httpx.MockTransport(_handler(seen))),
+    )
+    result = model.invoke("hi")
+    assert result.content == "hello there"
+    assert result.usage_metadata["total_tokens"] == 5
+    request = seen[0]
+    assert str(request.url) == "https://api.outrun.to/v1/chat/completions"
+    assert request.headers["authorization"] == "Bearer outrun-env-key"
+    assert request.headers["x-outrun-sdk"].startswith("langchain/")
+    body = json.loads(request.content)
+    assert body["model"] == MODEL
+    assert body["messages"] == [{"role": "user", "content": "hi"}]
+
+
+def test_key_not_in_repr() -> None:
+    model = ChatOutrun(model=MODEL, api_key="secret-value-123")
+    assert "secret-value-123" not in repr(model)
+    assert "secret-value-123" not in str(model)
+
+
+def test_user_headers_are_kept() -> None:
+    seen: list = []
+    _model(seen, default_headers={"X-Extra": "1"}).invoke("hi")
+    assert seen[0].headers["x-extra"] == "1"
+    assert seen[0].headers["x-outrun-sdk"].startswith("langchain/")
+
+
+def test_stream_requests_usage_and_yields_text() -> None:
+    seen: list = []
+    chunks = list(_model(seen).stream("hi"))
+    assert "".join(c.text for c in chunks) == "Hello"
+    body = json.loads(seen[0].content)
+    assert body["stream"] is True
+    assert body["stream_options"] == {"include_usage": True}
+    total = sum(chunks[1:], chunks[0])
+    assert total.usage_metadata["total_tokens"] == 5
+
+
+async def test_async_invoke() -> None:
+    seen: list = []
+    result = await _model(seen).ainvoke("hi")
+    assert result.content == "hello there"
+    assert str(seen[0].url) == "https://api.outrun.to/v1/chat/completions"
+
+
+def test_chat_completions_even_for_models_the_parent_would_route_elsewhere() -> None:
+    class Weather(BaseModel):
+        """Get the weather for a city."""
+
+        city: str
+
+    seen: list = []
+    model = _model(seen, model="gpt-6-astra").bind_tools([Weather])
+    model.invoke("weather in Paris?")
+    assert str(seen[0].url) == "https://api.outrun.to/v1/chat/completions"
+    body = json.loads(seen[0].content)
+    assert body["tools"][0]["function"]["name"] == "Weather"
+
+
+def test_responses_api_only_when_asked() -> None:
+    assert ChatOutrun(model="gpt-6-astra", api_key="k")._use_responses_api({}) is False
+    assert (
+        ChatOutrun(model="gpt-6-astra", api_key="k", use_responses_api=True)._use_responses_api({})
+        is True
+    )
+
+
+def test_developer_role_sent_as_system() -> None:
+    model = ChatOutrun(model=MODEL, api_key="k")
+    payload = model._get_request_payload(
+        [
+            SystemMessage("be brief", additional_kwargs={"__openai_role__": "developer"}),
+            HumanMessage("hi"),
+        ]
+    )
+    assert [m["role"] for m in payload["messages"]] == ["system", "user"]

langchain_outrun-0.1.0/tests/unit_tests/test_imports.py

@@ -0,0 +1,7 @@
+from langchain_outrun import __all__
+
+EXPECTED_ALL = ["ChatOutrun", "__version__"]
+
+
+def test_all_imports() -> None:
+    assert sorted(EXPECTED_ALL) == sorted(__all__)

langchain_outrun-0.1.0/tests/unit_tests/test_standard.py

@@ -0,0 +1,31 @@
+"""Standard LangChain unit tests for ChatOutrun."""
+
+from langchain_core.language_models import BaseChatModel
+from langchain_outrun import ChatOutrun
+from langchain_tests.unit_tests import ChatModelUnitTests
+
+MODEL_NAME = "gpt-5.6-terra"
+
+
+class TestChatOutrunUnit(ChatModelUnitTests):
+    @property
+    def chat_model_class(self) -> type[BaseChatModel]:
+        return ChatOutrun
+
+    @property
+    def chat_model_params(self) -> dict:
+        return {"model": MODEL_NAME, "api_key": "test-key"}
+
+    @property
+    def init_from_env_params(self) -> tuple[dict, dict, dict]:
+        return (
+            {
+                "OUTRUN_API_KEY": "api_key",
+                "OUTRUN_API_BASE": "https://base.example.com/v1",
+            },
+            {"model": MODEL_NAME},
+            {
+                "api_key": "api_key",
+                "api_base": "https://base.example.com/v1",
+            },
+        )