langchain-keln 0.1.0__tar.gz

langchain_keln-0.1.0/.gitignore

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

langchain_keln-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0
+
+- First release.
+- `ChatKeln` chat model for Keln, based on `langchain-openai`'s `BaseChatOpenAI`.
+- Reads `KELN_API_KEY` and `KELN_API_BASE`. Defaults to `https://api.keln.ai/v1` and `zai-org/glm-5.3`.
+- Reads the reasoning trace from `reasoning_content` in `invoke` and `stream`, and sends it back on assistant messages.
+- Uses `/v1/chat/completions` with the `system` role and `max_tokens`, and leaves out `store`.
+- Passes LangChain's standard unit tests.

langchain_keln-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Keln
+
+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_keln-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: langchain-keln
+Version: 0.1.0
+Summary: LangChain integration for Keln, an inference platform for open models
+Project-URL: Homepage, https://keln.ai
+Project-URL: Documentation, https://docs.keln.ai
+Project-URL: Repository, https://github.com/kris-holy/langchain-keln
+Project-URL: Issues, https://github.com/kris-holy/langchain-keln/issues
+Author-email: kris-holy <kris@keln.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: keln,langchain,llm,open models,openai-compatible
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+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-keln
+
+LangChain chat model for [Keln](https://keln.ai), an inference platform for open models.
+
+`ChatKeln` works like `ChatOpenAI`: `invoke`, `stream`, async calls, tool calling, structured output and agents. It also handles 2 Keln details for you. It reads the reasoning trace that reasoning models return, and it sends that trace back on assistant messages in a tool call loop.
+
+## Install
+
+```bash
+pip install -U langchain-keln
+```
+
+## Get an API key
+
+1. Sign up at [app.keln.ai/signup](https://app.keln.ai/signup).
+2. Go to **Keys** → **Create key**.
+3. Set the key as an environment variable:
+
+```bash
+export KELN_API_KEY="your-api-key"
+```
+
+On Windows PowerShell:
+
+```powershell
+$env:KELN_API_KEY = "your-api-key"
+```
+
+## Chat
+
+```python
+from langchain_keln import ChatKeln
+
+llm = ChatKeln(model="zai-org/glm-5.3", reasoning_effort="low")
+
+print(llm.invoke("Explain prompt caching in 1 sentence.").content)
+
+for chunk in llm.stream("Write a haiku about open models."):
+    print(chunk.text, end="", flush=True)
+```
+
+The model list with context lengths and reasoning levels is at [docs.keln.ai/models-pricing](https://docs.keln.ai/models-pricing/). The same list is available as JSON at `GET https://api.keln.ai/v1/models`, with no key needed.
+
+## Tool calling and structured output
+
+```python
+from langchain_core.tools import tool
+from pydantic import BaseModel
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Return the current weather for a city."""
+    return "sunny, 21 C"
+
+
+llm_with_tools = llm.bind_tools([get_weather])
+print(llm_with_tools.invoke("What is the weather in Paris?").tool_calls)
+
+
+class Summary(BaseModel):
+    title: str
+    bullets: list[str]
+
+
+print(
+    llm.with_structured_output(Summary).invoke(
+        "Summarize what an inference platform does."
+    )
+)
+```
+
+## Agents
+
+With the `langchain` package installed (`pip install -U langchain`):
+
+```python
+from langchain.agents import create_agent
+
+agent = create_agent(ChatKeln(model="moonshotai/kimi-k3"), tools=[get_weather])
+agent.invoke(
+    {"messages": [{"role": "user", "content": "What is the weather in Paris?"}]}
+)
+```
+
+## Reasoning
+
+Most Keln models can think before they answer. Set the level with `reasoning_effort`, for example `"none"`, `"low"`, `"high"` or `"max"`. Each model lists the levels it accepts in `/v1/models`. If you leave it out, each model uses the default level listed in `/v1/models`.
+
+The trace is in `message.additional_kwargs["reasoning_content"]`, in `invoke` and in `stream`. When you pass the conversation back, `ChatKeln` sends each assistant message's trace with it, so the model keeps its train of thought across tool calls.
+
+## Configuration
+
+| Argument | Env var | Default |
+|---|---|---|
+| `api_key` | `KELN_API_KEY` | required |
+| `base_url` | `KELN_API_BASE` | `https://api.keln.ai/v1` |
+| `model` | | `zai-org/glm-5.3` |
+
+Every other `ChatOpenAI` argument (`temperature`, `max_tokens`, `timeout`, `max_retries`, `model_kwargs` and others) works the same way. `max_tokens` covers reasoning and answer together.
+
+`ChatKeln` uses the `/v1/chat/completions` endpoint. It sends the `system` role and `max_tokens`, and leaves out the `store` field.
+
+## Docs
+
+- Keln docs: [docs.keln.ai](https://docs.keln.ai)
+- Models and prices: [docs.keln.ai/models-pricing](https://docs.keln.ai/models-pricing/)
+
+## Development
+
+```bash
+pip install -e . --group test --group lint --group typing
+pytest tests/unit_tests --disable-socket --allow-unix-socket
+KELN_API_KEY=... pytest tests/integration_tests
+ruff check . && ruff format --check . && mypy langchain_keln tests
+```
+
+## License
+
+MIT, Keln.

langchain_keln-0.1.0/README.md

@@ -0,0 +1,120 @@
+# langchain-keln
+
+LangChain chat model for [Keln](https://keln.ai), an inference platform for open models.
+
+`ChatKeln` works like `ChatOpenAI`: `invoke`, `stream`, async calls, tool calling, structured output and agents. It also handles 2 Keln details for you. It reads the reasoning trace that reasoning models return, and it sends that trace back on assistant messages in a tool call loop.
+
+## Install
+
+```bash
+pip install -U langchain-keln
+```
+
+## Get an API key
+
+1. Sign up at [app.keln.ai/signup](https://app.keln.ai/signup).
+2. Go to **Keys** → **Create key**.
+3. Set the key as an environment variable:
+
+```bash
+export KELN_API_KEY="your-api-key"
+```
+
+On Windows PowerShell:
+
+```powershell
+$env:KELN_API_KEY = "your-api-key"
+```
+
+## Chat
+
+```python
+from langchain_keln import ChatKeln
+
+llm = ChatKeln(model="zai-org/glm-5.3", reasoning_effort="low")
+
+print(llm.invoke("Explain prompt caching in 1 sentence.").content)
+
+for chunk in llm.stream("Write a haiku about open models."):
+    print(chunk.text, end="", flush=True)
+```
+
+The model list with context lengths and reasoning levels is at [docs.keln.ai/models-pricing](https://docs.keln.ai/models-pricing/). The same list is available as JSON at `GET https://api.keln.ai/v1/models`, with no key needed.
+
+## Tool calling and structured output
+
+```python
+from langchain_core.tools import tool
+from pydantic import BaseModel
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Return the current weather for a city."""
+    return "sunny, 21 C"
+
+
+llm_with_tools = llm.bind_tools([get_weather])
+print(llm_with_tools.invoke("What is the weather in Paris?").tool_calls)
+
+
+class Summary(BaseModel):
+    title: str
+    bullets: list[str]
+
+
+print(
+    llm.with_structured_output(Summary).invoke(
+        "Summarize what an inference platform does."
+    )
+)
+```
+
+## Agents
+
+With the `langchain` package installed (`pip install -U langchain`):
+
+```python
+from langchain.agents import create_agent
+
+agent = create_agent(ChatKeln(model="moonshotai/kimi-k3"), tools=[get_weather])
+agent.invoke(
+    {"messages": [{"role": "user", "content": "What is the weather in Paris?"}]}
+)
+```
+
+## Reasoning
+
+Most Keln models can think before they answer. Set the level with `reasoning_effort`, for example `"none"`, `"low"`, `"high"` or `"max"`. Each model lists the levels it accepts in `/v1/models`. If you leave it out, each model uses the default level listed in `/v1/models`.
+
+The trace is in `message.additional_kwargs["reasoning_content"]`, in `invoke` and in `stream`. When you pass the conversation back, `ChatKeln` sends each assistant message's trace with it, so the model keeps its train of thought across tool calls.
+
+## Configuration
+
+| Argument | Env var | Default |
+|---|---|---|
+| `api_key` | `KELN_API_KEY` | required |
+| `base_url` | `KELN_API_BASE` | `https://api.keln.ai/v1` |
+| `model` | | `zai-org/glm-5.3` |
+
+Every other `ChatOpenAI` argument (`temperature`, `max_tokens`, `timeout`, `max_retries`, `model_kwargs` and others) works the same way. `max_tokens` covers reasoning and answer together.
+
+`ChatKeln` uses the `/v1/chat/completions` endpoint. It sends the `system` role and `max_tokens`, and leaves out the `store` field.
+
+## Docs
+
+- Keln docs: [docs.keln.ai](https://docs.keln.ai)
+- Models and prices: [docs.keln.ai/models-pricing](https://docs.keln.ai/models-pricing/)
+
+## Development
+
+```bash
+pip install -e . --group test --group lint --group typing
+pytest tests/unit_tests --disable-socket --allow-unix-socket
+KELN_API_KEY=... pytest tests/integration_tests
+ruff check . && ruff format --check . && mypy langchain_keln tests
+```
+
+## License
+
+MIT, Keln.

langchain_keln-0.1.0/langchain_keln/__init__.py

@@ -0,0 +1,12 @@
+"""LangChain integration for Keln."""
+
+from importlib import metadata
+
+from langchain_keln.chat_models import ChatKeln
+
+try:
+    __version__ = metadata.version(__package__ or "langchain-keln")
+except metadata.PackageNotFoundError:
+    __version__ = ""
+
+__all__ = ["ChatKeln", "__version__"]

langchain_keln-0.1.0/langchain_keln/chat_models.py

@@ -0,0 +1,257 @@
+"""Keln chat models."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import openai
+from langchain_core.language_models import LangSmithParams, LanguageModelInput
+from langchain_core.messages import AIMessage, AIMessageChunk
+from langchain_core.outputs import ChatGenerationChunk, ChatResult
+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.keln.ai/v1"
+DEFAULT_MODEL = "zai-org/glm-5.3"
+
+
+def _reasoning_from_message(message: AIMessage) -> str | None:
+    """Return the reasoning trace stored on an assistant message, if any."""
+    reasoning = message.additional_kwargs.get("reasoning_content")
+    if isinstance(reasoning, str) and reasoning:
+        return reasoning
+    # `output_version="v1"` keeps the trace in standard reasoning content blocks.
+    if isinstance(message.content, list):
+        parts = [
+            block["reasoning"]
+            for block in message.content
+            if isinstance(block, dict)
+            and block.get("type") == "reasoning"
+            and isinstance(block.get("reasoning"), str)
+        ]
+        if parts:
+            return "".join(parts)
+    return None
+
+
+class ChatKeln(BaseChatOpenAI):
+    """Chat models on Keln, an inference platform for open models.
+
+    Keln serves open models through an OpenAI-compatible API. The live model
+    list is at `GET https://api.keln.ai/v1/models` (no key needed) and on
+    https://docs.keln.ai/models-pricing/.
+
+    Setup:
+        Install `langchain-keln` and set the `KELN_API_KEY` environment variable.
+        To create a key, sign up at https://app.keln.ai/signup, then go to
+        **Keys** and select **Create key**.
+
+        ```bash
+        pip install -U langchain-keln
+        export KELN_API_KEY="your-api-key"
+        ```
+
+    Key init args (completion params):
+        model:
+            Keln model id. Defaults to `"zai-org/glm-5.3"`.
+        temperature:
+            Sampling temperature.
+        max_tokens:
+            Max number of tokens to generate, reasoning included.
+        reasoning_effort:
+            Reasoning level, for example `"none"`, `"low"`, `"high"` or `"max"`.
+            The levels each model accepts are listed in `/v1/models`. If you leave
+            it out, each model uses the default level listed in `/v1/models`.
+
+    Key init args (client params):
+        api_key:
+            Keln API key. Read from `KELN_API_KEY` if not passed.
+        base_url:
+            API base URL. Read from `KELN_API_BASE`, defaults to
+            `https://api.keln.ai/v1`.
+        timeout:
+            Timeout for requests.
+        max_retries:
+            Max number of retries.
+
+    Instantiate:
+        ```python
+        from langchain_keln import ChatKeln
+
+        model = ChatKeln(model="zai-org/glm-5.3", reasoning_effort="low")
+        ```
+
+    Invoke:
+        ```python
+        model.invoke("Explain prompt caching in 1 sentence.")
+        ```
+
+    Stream:
+        ```python
+        for chunk in model.stream("Write a haiku about open models."):
+            print(chunk.text, end="")
+        ```
+
+    Tool calling and structured output work as with `ChatOpenAI`
+    (`bind_tools`, `with_structured_output`).
+
+    Reasoning:
+        Reasoning models return their trace in
+        `message.additional_kwargs["reasoning_content"]`, in `invoke` and in
+        `stream`. `ChatKeln` sends that trace back on assistant messages, so
+        reasoning models keep their train of thought across a tool call loop.
+
+    `ChatKeln` uses the `/v1/chat/completions` endpoint. It sends the `system`
+    role and `max_tokens`, and leaves out the `store` field.
+    """
+
+    model_name: str = Field(default=DEFAULT_MODEL, alias="model")
+    """Keln model id."""
+    api_key: SecretStr | None = Field(
+        default_factory=secret_from_env("KELN_API_KEY", default=None),
+    )
+    """Keln API key. Read from `KELN_API_KEY` if not provided."""
+    api_base: str = Field(
+        alias="base_url",
+        default_factory=from_env("KELN_API_BASE", default=DEFAULT_API_BASE),
+    )
+    """Keln API base URL. Read from `KELN_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-keln"
+
+    @property
+    def lc_secrets(self) -> dict[str, str]:
+        """A map of constructor argument names to secret ids."""
+        return {"api_key": "KELN_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"] = "keln"
+        return ls_params
+
+    @model_validator(mode="after")
+    def validate_environment(self) -> Self:
+        """Check the API key and build the OpenAI clients pointed at Keln."""
+        if self.api_base == DEFAULT_API_BASE and not (
+            self.api_key and self.api_key.get_secret_value()
+        ):
+            msg = (
+                "KELN_API_KEY must be set, or pass api_key=... "
+                "Create a key at https://app.keln.ai under Keys."
+            )
+            raise ValueError(msg)
+        client_params: dict = {
+            k: v
+            for k, v in {
+                "api_key": self.api_key.get_secret_value() if self.api_key else None,
+                "base_url": self.api_base,
+                "timeout": self.request_timeout,
+                "max_retries": self.max_retries,
+                "default_headers": self.default_headers,
+                "default_query": self.default_query,
+            }.items()
+            if v is not None
+        }
+        if not (self.client or None):
+            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 or None):
+            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:
+        # Keln requests go to /v1/chat/completions.
+        return False
+
+    def _get_request_payload(
+        self,
+        input_: LanguageModelInput,
+        *,
+        stop: list[str] | None = None,
+        **kwargs: Any,
+    ) -> dict:
+        messages = self._convert_input(input_).to_messages()
+        payload = super()._get_request_payload(input_, stop=stop, **kwargs)
+        # Keln keeps no copy of requests, so `store` is left out.
+        payload.pop("store", None)
+        message_dicts = payload.get("messages", [])
+        for message, message_dict in zip(messages, message_dicts, strict=False):
+            if message_dict.get("role") == "developer":
+                message_dict["role"] = "system"
+            if isinstance(message, AIMessage) and message_dict.get("role") == (
+                "assistant"
+            ):
+                reasoning = _reasoning_from_message(message)
+                if reasoning:
+                    message_dict["reasoning_content"] = reasoning
+        return payload
+
+    def _create_chat_result(
+        self,
+        response: dict | openai.BaseModel,
+        generation_info: dict | None = None,
+    ) -> ChatResult:
+        result = super()._create_chat_result(response, generation_info)
+        response_dict = (
+            response
+            if isinstance(response, dict)
+            else response.model_dump(
+                exclude={"choices": {"__all__": {"message": {"parsed"}}}},
+                warnings=False,
+            )
+        )
+        for generation in result.generations:
+            generation.message.response_metadata["model_provider"] = "keln"
+        choices = response_dict.get("choices") or []
+        for generation, choice in zip(result.generations, choices, strict=False):
+            message = choice.get("message") or {}
+            reasoning = message.get("reasoning_content") or message.get("reasoning")
+            if isinstance(reasoning, str) and reasoning:
+                generation.message.additional_kwargs["reasoning_content"] = reasoning
+        return result
+
+    def _convert_chunk_to_generation_chunk(
+        self,
+        chunk: dict,
+        default_chunk_class: type,
+        base_generation_info: dict | None,
+    ) -> ChatGenerationChunk | None:
+        generation_chunk = super()._convert_chunk_to_generation_chunk(
+            chunk, default_chunk_class, base_generation_info
+        )
+        if not generation_chunk or not isinstance(
+            generation_chunk.message, AIMessageChunk
+        ):
+            return generation_chunk
+        if choices := chunk.get("choices"):
+            generation_chunk.message.response_metadata = {
+                **generation_chunk.message.response_metadata,
+                "model_provider": "keln",
+            }
+            delta = choices[0].get("delta") or {}
+            reasoning = delta.get("reasoning_content")
+            if reasoning is None:
+                reasoning = delta.get("reasoning")
+            if isinstance(reasoning, str) and reasoning:
+                generation_chunk.message.additional_kwargs["reasoning_content"] = (
+                    reasoning
+                )
+        return generation_chunk

langchain_keln-0.1.0/pyproject.toml

@@ -0,0 +1,81 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-keln"
+version = "0.1.0"
+description = "LangChain integration for Keln, an inference platform for open models"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "kris-holy", email = "kris@keln.ai" }]
+requires-python = ">=3.10,<4.0"
+keywords = ["keln", "langchain", "llm", "open models", "openai-compatible"]
+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",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "langchain-core>=1.0.0,<2.0.0",
+    "langchain-openai>=1.0.0,<2.0.0",
+]
+
+[project.urls]
+Homepage = "https://keln.ai"
+Documentation = "https://docs.keln.ai"
+Repository = "https://github.com/kris-holy/langchain-keln"
+Issues = "https://github.com/kris-holy/langchain-keln/issues"
+
+[dependency-groups]
+test = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "pytest-socket>=0.7",
+    "langchain-tests>=1.0.0,<2.0.0",
+]
+lint = ["ruff>=0.15"]
+typing = ["mypy>=1.10"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "langchain_keln",
+    "tests",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_keln"]
+
+[tool.ruff]
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "D", "T201"]
+ignore = ["D100", "D104", "D105", "D107", "D203", "D213"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["D"]
+
+[tool.mypy]
+strict = true
+disallow_any_generics = false
+warn_return_any = false
+
+[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_keln-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_keln-0.1.0/tests/integration_tests/test_standard.py

@@ -0,0 +1,52 @@
+"""Standard LangChain integration tests for ChatKeln.
+
+These tests call the live Keln API and run only when `KELN_API_KEY` is set.
+"""
+
+import os
+
+import pytest
+from langchain_core.language_models import BaseChatModel
+from langchain_tests.integration_tests import ChatModelIntegrationTests
+
+from langchain_keln import ChatKeln
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("KELN_API_KEY"), reason="KELN_API_KEY is not set"
+)
+
+MODEL_NAME = "zai-org/glm-5.3"
+
+
+class TestChatKelnIntegration(ChatModelIntegrationTests):
+    @property
+    def chat_model_class(self) -> type[BaseChatModel]:
+        return ChatKeln
+
+    @property
+    def chat_model_params(self) -> dict:
+        # The output cap covers reasoning and answer together, so leave room
+        # for both.
+        return {
+            "model": MODEL_NAME,
+            "reasoning_effort": "low",
+            "max_tokens": 4096,
+            "timeout": 120,
+        }
+
+    @property
+    def model_override_value(self) -> str:
+        return "moonshotai/kimi-k3"
+
+    @property
+    def supports_json_mode(self) -> bool:
+        return True
+
+    @property
+    def supports_image_inputs(self) -> bool:
+        # zai-org/glm-5.3 takes text input only.
+        return False
+
+    @property
+    def returns_usage_metadata(self) -> bool:
+        return True

langchain_keln-0.1.0/tests/integration_tests/test_tool_loop.py

@@ -0,0 +1,89 @@
+"""Streamed multi-turn tool loop on Keln reasoning models.
+
+Checks that each streamed turn returns a reasoning trace, that `ChatKeln` sends
+the trace back on the assistant message, and that the loop ends with an answer.
+Runs only when `KELN_API_KEY` is set.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+from langchain_core.messages import (
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.runnables import Runnable
+from langchain_core.tools import tool
+
+from langchain_keln import ChatKeln
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("KELN_API_KEY"), reason="KELN_API_KEY is not set"
+)
+
+MODELS = ["zai-org/glm-5.3", "moonshotai/kimi-k3"]
+MAX_TURNS = 6
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Return the current weather for a city."""
+    weather = {"paris": "sunny, 21 C", "tokyo": "rain, 16 C"}
+    return weather.get(city.strip().lower(), "cloudy, 18 C")
+
+
+def _stream_turn(model: Runnable, messages: list[BaseMessage]) -> AIMessageChunk:
+    merged: AIMessageChunk | None = None
+    for chunk in model.stream(messages):
+        assert isinstance(chunk, AIMessageChunk)
+        merged = chunk if merged is None else merged + chunk
+    assert merged is not None, "the stream returned no chunks"
+    return merged
+
+
+@pytest.mark.parametrize("model_name", MODELS)
+def test_streamed_tool_loop_sends_reasoning_back(model_name: str) -> None:
+    llm = ChatKeln(model=model_name, max_tokens=4096, timeout=180)
+    bound = llm.bind_tools([get_weather])
+    messages: list[BaseMessage] = [
+        SystemMessage(
+            "Use the get_weather tool for every city the user names, 1 call per "
+            "city, then answer in 1 short sentence."
+        ),
+        HumanMessage("What is the weather in Paris and in Tokyo right now?"),
+    ]
+
+    tool_rounds = 0
+    reasoning_turns = 0
+    final: AIMessageChunk | None = None
+    for _ in range(MAX_TURNS):
+        reply = _stream_turn(bound, messages)
+        if reply.additional_kwargs.get("reasoning_content"):
+            reasoning_turns += 1
+        messages.append(reply)
+        if not reply.tool_calls:
+            final = reply
+            break
+        tool_rounds += 1
+        for call in reply.tool_calls:
+            assert call["name"] == "get_weather"
+            result = get_weather.invoke(call["args"])
+            messages.append(ToolMessage(result, tool_call_id=call["id"]))
+
+        # The next request must carry this turn's reasoning trace.
+        payload = llm._get_request_payload(messages)
+        sent = [m for m in payload["messages"] if m["role"] == "assistant"][-1]
+        trace = reply.additional_kwargs.get("reasoning_content")
+        if trace:
+            assert sent["reasoning_content"] == trace
+
+    assert tool_rounds >= 1, "the model made no tool call"
+    assert reasoning_turns >= 1, "the stream returned no reasoning_content"
+    assert final is not None, f"no final answer after {MAX_TURNS} turns"
+    assert final.text.strip(), "the final answer is empty"
+    assert final.usage_metadata is not None

langchain_keln-0.1.0/tests/unit_tests/test_chat_models.py

@@ -0,0 +1,249 @@
+"""Unit tests for ChatKeln behaviour specific to Keln."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from pydantic import SecretStr
+
+from langchain_keln import ChatKeln
+from langchain_keln.chat_models import DEFAULT_API_BASE, DEFAULT_MODEL
+
+
+def _model(**kwargs: Any) -> ChatKeln:
+    return ChatKeln(api_key=SecretStr("test-key"), **kwargs)
+
+
+def test_defaults() -> None:
+    model = _model()
+    assert model.model_name == DEFAULT_MODEL == "zai-org/glm-5.3"
+    assert model.api_base == DEFAULT_API_BASE == "https://api.keln.ai/v1"
+    assert model._llm_type == "chat-keln"
+    assert model.lc_secrets == {"api_key": "KELN_API_KEY"}
+    assert str(model.root_client.base_url).rstrip("/") == DEFAULT_API_BASE
+
+
+def test_api_key_from_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("KELN_API_KEY", "env-key")
+    model = ChatKeln()
+    assert model.api_key is not None
+    assert model.api_key.get_secret_value() == "env-key"
+
+
+def test_missing_api_key_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("KELN_API_KEY", raising=False)
+    monkeypatch.delenv("KELN_API_BASE", raising=False)
+    with pytest.raises(ValueError, match="KELN_API_KEY"):
+        ChatKeln()
+
+
+def test_api_key_hidden_in_repr() -> None:
+    model = _model()
+    assert "test-key" not in repr(model)
+    assert "test-key" not in str(model)
+
+
+def test_ls_params() -> None:
+    params = _model()._get_ls_params()
+    assert params["ls_provider"] == "keln"
+    assert params["ls_model_name"] == DEFAULT_MODEL
+
+
+def test_payload_uses_chat_completions_shape() -> None:
+    model = _model(max_tokens=64, reasoning_effort="low")
+    payload = model._get_request_payload(
+        [SystemMessage("Be brief."), HumanMessage("Hi")]
+    )
+    assert payload["model"] == DEFAULT_MODEL
+    assert payload["max_tokens"] == 64
+    assert "max_completion_tokens" not in payload
+    assert payload["reasoning_effort"] == "low"
+    assert payload["messages"][0] == {"role": "system", "content": "Be brief."}
+    assert "input" not in payload
+
+
+def test_payload_omits_store() -> None:
+    model = _model(store=True)
+    payload = model._get_request_payload([HumanMessage("Hi")])
+    assert "store" not in payload
+
+
+def test_developer_role_becomes_system() -> None:
+    message = SystemMessage(
+        "Be brief.", additional_kwargs={"__openai_role__": "developer"}
+    )
+    payload = _model()._get_request_payload([message, HumanMessage("Hi")])
+    assert payload["messages"][0]["role"] == "system"
+
+
+def test_responses_api_not_used() -> None:
+    model = _model(use_responses_api=True, reasoning={"effort": "low"})
+    payload = model._get_request_payload([HumanMessage("Hi")])
+    assert "messages" in payload
+    assert "input" not in payload
+
+
+def test_reasoning_content_sent_back_on_assistant_messages() -> None:
+    tool_call = {
+        "name": "get_weather",
+        "args": {"city": "Paris"},
+        "id": "call_1",
+        "type": "tool_call",
+    }
+    messages = [
+        HumanMessage("Weather in Paris?"),
+        AIMessage(
+            "",
+            tool_calls=[tool_call],
+            additional_kwargs={"reasoning_content": "Call the weather tool."},
+        ),
+        ToolMessage("Sunny, 21 C", tool_call_id="call_1"),
+        AIMessage("It is sunny."),
+    ]
+    payload = _model()._get_request_payload(messages)
+    sent = payload["messages"]
+    assert sent[1]["role"] == "assistant"
+    assert sent[1]["reasoning_content"] == "Call the weather tool."
+    assert sent[1]["tool_calls"][0]["id"] == "call_1"
+    assert "reasoning_content" not in sent[0]
+    assert "reasoning_content" not in sent[2]
+    assert "reasoning_content" not in sent[3]
+
+
+def test_reasoning_content_from_v1_content_blocks() -> None:
+    message = AIMessage(
+        content=[
+            {"type": "reasoning", "reasoning": "Think first."},
+            {"type": "text", "text": "Answer."},
+        ]
+    )
+    payload = _model()._get_request_payload([HumanMessage("Hi"), message])
+    assert payload["messages"][1]["reasoning_content"] == "Think first."
+
+
+def _completion(message: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": "chatcmpl-1",
+        "object": "chat.completion",
+        "created": 0,
+        "model": DEFAULT_MODEL,
+        "choices": [{"index": 0, "message": message, "finish_reason": "stop"}],
+        "usage": {"prompt_tokens": 3, "completion_tokens": 5, "total_tokens": 8},
+    }
+
+
+def test_reasoning_content_read_from_response() -> None:
+    response = _completion(
+        {
+            "role": "assistant",
+            "content": "391",
+            "reasoning_content": "17 x 23",
+            "reasoning": "17 x 23",
+        }
+    )
+    result = _model()._create_chat_result(response)
+    message = result.generations[0].message
+    assert message.content == "391"
+    assert message.additional_kwargs["reasoning_content"] == "17 x 23"
+    assert message.response_metadata["model_provider"] == "keln"
+
+
+def test_reasoning_mirror_read_from_response() -> None:
+    response = _completion(
+        {"role": "assistant", "content": "391", "reasoning": "17 x 23"}
+    )
+    result = _model()._create_chat_result(response)
+    assert result.generations[0].message.additional_kwargs["reasoning_content"] == (
+        "17 x 23"
+    )
+
+
+def test_no_reasoning_key_when_absent() -> None:
+    response = _completion({"role": "assistant", "content": "Hi"})
+    result = _model()._create_chat_result(response)
+    assert "reasoning_content" not in result.generations[0].message.additional_kwargs
+
+
+def _chunk(delta: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": "chatcmpl-1",
+        "object": "chat.completion.chunk",
+        "created": 0,
+        "model": DEFAULT_MODEL,
+        "choices": [{"index": 0, "delta": delta, "finish_reason": None}],
+    }
+
+
+def test_reasoning_content_read_from_stream() -> None:
+    model = _model()
+    first = model._convert_chunk_to_generation_chunk(
+        _chunk({"role": "assistant", "reasoning_content": "Let me ", "reasoning": ""}),
+        AIMessageChunk,
+        None,
+    )
+    second = model._convert_chunk_to_generation_chunk(
+        _chunk({"reasoning": "think"}), AIMessageChunk, None
+    )
+    third = model._convert_chunk_to_generation_chunk(
+        _chunk({"content": "391"}), AIMessageChunk, None
+    )
+    assert first is not None and second is not None and third is not None
+    merged = first.message + second.message + third.message
+    assert merged.additional_kwargs["reasoning_content"] == "Let me think"
+    assert merged.content == "391"
+    assert merged.response_metadata["model_provider"] == "keln"
+
+
+def test_streamed_reasoning_round_trip() -> None:
+    model = _model()
+    chunks = [
+        model._convert_chunk_to_generation_chunk(
+            _chunk({"role": "assistant", "reasoning_content": "Use the "}),
+            AIMessageChunk,
+            None,
+        ),
+        model._convert_chunk_to_generation_chunk(
+            _chunk({"reasoning_content": "tool."}), AIMessageChunk, None
+        ),
+        model._convert_chunk_to_generation_chunk(
+            _chunk(
+                {
+                    "tool_calls": [
+                        {
+                            "index": 0,
+                            "id": "call_1",
+                            "type": "function",
+                            "function": {
+                                "name": "get_weather",
+                                "arguments": '{"city": "Paris"}',
+                            },
+                        }
+                    ]
+                }
+            ),
+            AIMessageChunk,
+            None,
+        ),
+    ]
+    merged = chunks[0].message  # type: ignore[union-attr]
+    for chunk in chunks[1:]:
+        merged = merged + chunk.message  # type: ignore[union-attr]
+    assert isinstance(merged, AIMessageChunk)
+    payload = model._get_request_payload(
+        [
+            HumanMessage("Weather in Paris?"),
+            merged,
+            ToolMessage("Sunny", tool_call_id="call_1"),
+        ]
+    )
+    assistant = payload["messages"][1]
+    assert assistant["reasoning_content"] == "Use the tool."
+    assert assistant["tool_calls"][0]["function"]["name"] == "get_weather"

langchain_keln-0.1.0/tests/unit_tests/test_imports.py

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

langchain_keln-0.1.0/tests/unit_tests/test_standard.py

@@ -0,0 +1,32 @@
+"""Standard LangChain unit tests for ChatKeln."""
+
+from langchain_core.language_models import BaseChatModel
+from langchain_tests.unit_tests import ChatModelUnitTests
+
+from langchain_keln import ChatKeln
+
+MODEL_NAME = "zai-org/glm-5.3"
+
+
+class TestChatKelnUnit(ChatModelUnitTests):
+    @property
+    def chat_model_class(self) -> type[BaseChatModel]:
+        return ChatKeln
+
+    @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 (
+            {
+                "KELN_API_KEY": "api_key",
+                "KELN_API_BASE": "https://base.example.com/v1",
+            },
+            {"model": MODEL_NAME},
+            {
+                "api_key": "api_key",
+                "api_base": "https://base.example.com/v1",
+            },
+        )