langchain-llama-cpp 0.1.0__py3-none-any.whl

langchain_llama_cpp/content_blocks.py

@@ -0,0 +1,73 @@
+"""Content-block translator for llama-server messages (`model_provider` "llama-cpp").
+
+Core builds `content_blocks` for providers without a translator by best-effort
+parsing, and that is what we want, except when streaming with
+`output_version="v1"`. Core then numbers blocks that have no `index` with a
+counter that goes up whenever the block type changes (reasoning 0, text 1, ...),
+while a tool-call chunk keeps the server's tool-call index (0, 1, ...). Equal
+indexes are merged as one block, so the first tool call was folded into the
+reasoning or text block before it and vanished from `content_blocks`.
+
+For streamed chunks the translator returns core's blocks with two changes:
+
+- tool-call chunks get `lc_tc_<i>` indexes, which can't equal a counter value
+  (`merge_lists` merges `lc_` indexes only with the same string). Reasoning and
+  text keep core's counter, so text after a tool call stays a separate block.
+- every chunk that carries tool-call fragments gets them as `tool_call_chunk`
+  blocks. Core does that only when the chunk has no text; otherwise it adds a
+  partially parsed `tool_call` that would survive next to the finished call.
+
+The blocks are copies: reading `content_blocks` never changes the message.
+"""
+
+from typing import Any
+
+from langchain_core.messages import AIMessage, AIMessageChunk
+from langchain_core.messages import content as types
+from langchain_core.messages.block_translators import register_translator
+
+MODEL_PROVIDER = "llama-cpp"
+
+_TOOL_CALL_TYPES = {"tool_call", "invalid_tool_call", "tool_call_chunk"}
+
+
+def translate_content(message: AIMessage) -> list[types.ContentBlock]:
+    """Core's best-effort blocks, unchanged (a whole message isn't merged).
+
+    A copy of the message without our `model_provider` skips the registry, so
+    core falls back to its own parsing instead of calling us again.
+    """
+    metadata = {
+        key: value
+        for key, value in message.response_metadata.items()
+        if key != "model_provider"
+    }
+
+    return message.model_copy(update={"response_metadata": metadata}).content_blocks
+
+
+def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:
+    """Blocks for a streamed chunk: core's, with tool-call chunks re-indexed."""
+    blocks: list[dict[str, Any]] = [dict(block) for block in translate_content(message)]
+
+    if message.tool_call_chunks and message.chunk_position != "last":
+        blocks = [block for block in blocks if block["type"] not in _TOOL_CALL_TYPES]
+
+        for position, chunk in enumerate(message.tool_call_chunks):
+            # Without the server's index, the chunk's position stands in, so the
+            # block never falls back to core's colliding counter.
+            index = chunk.get("index")
+            blocks.append(
+                {
+                    "type": "tool_call_chunk",
+                    "id": chunk.get("id"),
+                    "name": chunk.get("name"),
+                    "args": chunk.get("args"),
+                    "index": f"lc_tc_{position if index is None else index}",
+                }
+            )
+
+    return blocks  # pyright: ignore[reportReturnType]
+
+
+register_translator(MODEL_PROVIDER, translate_content, translate_content_chunk)

langchain_llama_cpp/exceptions.py

@@ -0,0 +1,197 @@
+"""Errors raised by ChatLlama.
+
+Each class inherits from both the httpx exception it replaces and the matching
+`langchain_core.exceptions.ModelError` subclass, so `except httpx.HTTPStatusError`
+and `except ContextOverflowError` both work. `is_retryable` comes from core.
+"""
+
+from typing import Any, cast
+
+import httpx
+from langchain_core.exceptions import (
+    ContextOverflowError,
+    ModelAPIError,
+    ModelAuthenticationError,
+    ModelConnectionError,
+    ModelInvalidRequestError,
+    ModelNotFoundError,
+    ModelPermissionDeniedError,
+    ModelRateLimitError,
+    ModelTimeoutError,
+)
+
+from langchain_llama_cpp._wire import LlamaError
+
+
+class LlamaContextOverflowError(httpx.HTTPStatusError, ContextOverflowError):
+    """The prompt is longer than the server's context window (HTTP 400).
+
+    Attributes:
+        n_prompt_tokens: Tokens in the rejected prompt, as counted by the server.
+        n_ctx: The server's context window.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        request: httpx.Request,
+        response: httpx.Response,
+        n_prompt_tokens: int | None = None,
+        n_ctx: int | None = None,
+    ) -> None:
+        """Create the error with the server's token counts."""
+        super().__init__(message, request=request, response=response)
+        self.n_prompt_tokens = n_prompt_tokens
+        self.n_ctx = n_ctx
+
+
+class LlamaInvalidRequestError(httpx.HTTPStatusError, ModelInvalidRequestError):
+    """The server rejected the request (HTTP 400 and other 4xx)."""
+
+
+class LlamaAuthenticationError(httpx.HTTPStatusError, ModelAuthenticationError):
+    """The server needs an API key, or rejected the one sent (HTTP 401)."""
+
+
+class LlamaPermissionDeniedError(httpx.HTTPStatusError, ModelPermissionDeniedError):
+    """The server refused the request (HTTP 403)."""
+
+
+class LlamaModelNotFoundError(httpx.HTTPStatusError, ModelNotFoundError):
+    """llama-swap has no entry with this `model` name (HTTP 404)."""
+
+
+class LlamaRateLimitError(httpx.HTTPStatusError, ModelRateLimitError):
+    """The server has no free slot (HTTP 429)."""
+
+
+class LlamaAPIError(httpx.HTTPStatusError, ModelAPIError):
+    """The server failed (HTTP 5xx)."""
+
+
+class LlamaConnectionError(httpx.TransportError, ModelConnectionError):
+    """The server could not be reached, or the connection broke."""
+
+
+class LlamaTimeoutError(httpx.TimeoutException, ModelTimeoutError):
+    """The request took longer than `timeout`."""
+
+
+_STATUS_ERRORS: dict[int, type[httpx.HTTPStatusError]] = {
+    401: LlamaAuthenticationError,
+    403: LlamaPermissionDeniedError,
+    404: LlamaModelNotFoundError,
+    429: LlamaRateLimitError,
+}
+
+
+def error_from_response(response: httpx.Response) -> httpx.HTTPStatusError:
+    """Build the right error for an HTTP error response."""
+    # llama-server: {"error": {"type", "message", ...}}; llama-swap: plain text.
+    try:
+        body: object = response.json()
+    except ValueError:
+        body = None
+
+    raw_detail = _json_object(body).get("error")
+    detail = cast("LlamaError", _json_object(raw_detail))
+
+    reason = detail.get("message") or raw_detail or response.text
+    message = f"HTTP {response.status_code} from {response.request.url}: {reason}"
+
+    return _build_error(
+        message,
+        detail,
+        response.status_code,
+        response,
+        fallback=LlamaInvalidRequestError,  # e.g. a 3xx that wasn't followed
+    )
+
+
+def error_from_stream_event(
+    detail: object, response: httpx.Response
+) -> httpx.HTTPStatusError:
+    """Build the error for a `data: {"error": ...}` event in a running stream.
+
+    The HTTP status was already 200, so the class comes from the event's
+    `type` and `code` (llama-server's `format_error_response`).
+    """
+    fields = cast("LlamaError", _json_object(detail))
+    reason = fields.get("message") or detail or "error during streaming"
+    message = f"Error during streaming from {response.request.url}: {reason}"
+
+    code = fields.get("code")
+    status = code if isinstance(code, int) else None
+
+    return _build_error(message, fields, status, response, fallback=LlamaAPIError)
+
+
+def error_from_cut_off_stream(response: httpx.Response) -> LlamaConnectionError:
+    """The error for a stream that ended without `data: [DONE]` or an error event.
+
+    llama-server always ends a finished stream with `[DONE]`, so the
+    connection was closed early (a crash, a restart, or a proxy in between).
+    """
+    return LlamaConnectionError(
+        message=f"Stream from {response.request.url} ended without data: [DONE]",
+        request=response.request,
+    )
+
+
+def error_from_transport(exc: httpx.TransportError) -> httpx.TransportError:
+    """Wrap an httpx transport failure in the matching ChatLlama error."""
+    try:
+        request: httpx.Request | None = exc.request
+    except RuntimeError:  # httpx raises this when no request is attached
+        request = None
+
+    cls = (
+        LlamaTimeoutError
+        if isinstance(exc, httpx.TimeoutException)
+        else LlamaConnectionError
+    )
+    return cls(str(exc) or type(exc).__name__, request=request)
+
+
+def _build_error(
+    message: str,
+    detail: LlamaError,
+    status: int | None,
+    response: httpx.Response,
+    *,
+    fallback: type[httpx.HTTPStatusError],
+) -> httpx.HTTPStatusError:
+    """Pick the error class from llama-server's error `type` and the status.
+
+    Overflow is recognised by `type`, then the status decides: a mapped code,
+    any other 4xx (invalid request), 5xx (API error), else `fallback`.
+    """
+    request = response.request
+
+    if detail.get("type") == "exceed_context_size_error":
+        return LlamaContextOverflowError(
+            message,
+            request=request,
+            response=response,
+            n_prompt_tokens=detail.get("n_prompt_tokens"),
+            n_ctx=detail.get("n_ctx"),
+        )
+
+    if status is None:
+        cls = fallback
+    elif status in _STATUS_ERRORS:
+        cls = _STATUS_ERRORS[status]
+    elif 400 <= status < 500:  # noqa: PLR2004
+        cls = LlamaInvalidRequestError
+    elif status >= 500:  # noqa: PLR2004
+        cls = LlamaAPIError
+    else:
+        cls = fallback
+
+    return cls(message, request=request, response=response)
+
+
+def _json_object(value: object) -> dict[str, Any]:
+    """`value` if it's a JSON object, else an empty dict."""
+    return cast("dict[str, Any]", value) if isinstance(value, dict) else {}

langchain_llama_cpp/utils.py

@@ -0,0 +1,34 @@
+"""Helpers for working with messages from reasoning models."""
+
+from textwrap import indent
+
+from langchain_core.messages import AIMessage, BaseMessage
+from langchain_core.utils.interactive_env import is_interactive_env
+
+
+def pretty_repr(message: BaseMessage, *, html: bool = False) -> str:
+    """Like `message.pretty_repr()`, but shows an AI message's reasoning.
+
+    Reasoning is read from `content_blocks`, so it works for reasoning stored in
+    `additional_kwargs["reasoning_content"]` (ChatLlama, ChatDeepSeek, ChatOllama,
+    ChatGroq) and for reasoning blocks in `content` (`output_version="v1"`,
+    ChatAnthropic). Non-AI messages are passed to their own `pretty_repr`.
+    """
+    if not isinstance(message, AIMessage):
+        return message.pretty_repr(html=html)
+    parts = [
+        block.get("reasoning", "")
+        for block in message.content_blocks
+        if block["type"] == "reasoning"
+    ]
+    reasoning = "\n\n".join(part for part in parts if part)
+    # Core prints list content as a raw repr, so hand it text only, with the
+    # reasoning section in front; core still adds the title, name and tool calls.
+    section = f"Reasoning:\n{indent(reasoning, '  ')}" if reasoning else ""
+    content = "\n\n".join(part for part in (section, message.text) if part)
+    return message.model_copy(update={"content": content}).pretty_repr(html=html)
+
+
+def pretty_print(message: BaseMessage) -> None:
+    """Print `pretty_repr(message)`, with a bold title in Jupyter."""
+    print(pretty_repr(message, html=is_interactive_env()))  # noqa: T201

langchain_llama_cpp-0.1.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: langchain-llama-cpp
+Version: 0.1.0
+Summary: An integration package connecting llama.cpp's llama-server and LangChain, with reasoning, timings, structured output and tool calling
+Keywords: langchain,llama.cpp,llama-server,llama-swap,llm,local-llm,chat-model
+Author: Bharathan Mudaliar
+Author-email: Bharathan Mudaliar <bharathanmudaliar@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Typing :: Typed
+Requires-Dist: httpx>=0.27,<1
+Requires-Dist: langchain-core>=1.6,<2
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/bharat029/langchain-llama-cpp
+Project-URL: Issues, https://github.com/bharat029/langchain-llama-cpp/issues
+Description-Content-Type: text/markdown
+
+# langchain-llama-cpp
+
+[![PyPI - Version](https://img.shields.io/pypi/v/langchain-llama-cpp?label=%20)](https://pypi.org/project/langchain-llama-cpp/)
+[![PyPI - License](https://img.shields.io/pypi/l/langchain-llama-cpp)](https://opensource.org/licenses/MIT)
+
+A LangChain chat model, `ChatLlama`, for llama.cpp's `llama-server`. It's built
+on `langchain-core` and `httpx` only and talks to `/v1/chat/completions`
+directly, so nothing llama-server sends back is lost on the way.
+
+**Why not `ChatOpenAI`?** llama-server speaks the OpenAI format, but with extras
+that `ChatOpenAI` drops or gets wrong:
+
+- it drops `reasoning_content` (the model's thinking) and llama-server's `timings`;
+- it sends a named `tool_choice` as an object, which llama-server silently turns
+  into `"auto"`;
+- it can't send llama.cpp's own sampling fields (`top_k`, `min_p`, `samplers`,
+  DRY, XTC, ...) as typed parameters.
+
+## Install
+
+```bash
+pip install langchain-llama-cpp
+```
+
+or `uv add langchain-llama-cpp`. Python 3.10+.
+
+## Tested setup
+
+- **llama-swap** in front of llama-server. `model` is the llama-swap entry to
+  use. A bare llama-server (no llama-swap) is not tested yet.
+- llama-server build **b11429**, with gemma 4, Qwen3.6 and gpt-oss, on
+  langchain-core 1.6.
+
+## Quick start
+
+```python
+from langchain_llama_cpp import ChatLlama
+
+llm = ChatLlama(model="gemma", max_tokens=2000)  # base_url from LLAMA_BASE_URL
+msg = llm.invoke("What is 17 * 23? Answer with the number only.")
+
+msg.content  # '391'
+msg.additional_kwargs["reasoning_content"]  # 'The user wants to know the product...'
+msg.usage_metadata  # {'input_tokens': 32, 'output_tokens': 223, ...}
+msg.response_metadata["timings"]  # {'prompt_n': 25, 'predicted_n': 223, ...}
+```
+
+Set `max_tokens` with room for thinking. Reasoning length varies from run to
+run: gemma answered this in 223 tokens once, and in another run used all of
+`max_tokens=300` and ended mid-thought, with an empty `content` and
+`finish_reason: "length"`.
+
+`base_url` defaults to the `LLAMA_BASE_URL` environment variable, e.g.
+`http://localhost:8080`. Pass `base_url=` to override it.
+
+Reasoning is stored where ChatDeepSeek and ChatOllama put it,
+`additional_kwargs["reasoning_content"]`, so `msg.content_blocks` shows it as a
+standard `{"type": "reasoning"}` block. `langchain_llama_cpp.utils.pretty_print(msg)`
+prints a message with its reasoning.
+
+## Usage
+
+### Thinking
+
+The switch lives in the chat template, and its name differs per model family:
+
+```python
+ChatLlama(model="gemma", chat_template_kwargs={"enable_thinking": False})  # gemma, qwen
+ChatLlama(model="gpt-oss", chat_template_kwargs={"reasoning_effort": "low"})  # gpt-oss
+```
+
+Thinking tokens count towards `max_tokens` (see Quick start).
+
+When you send a conversation back, an `AIMessage`'s reasoning goes back too, and
+the model's chat template decides whether to show it to the model.
+
+### Streaming and async
+
+```python
+for chunk in llm.stream("Count to five."):
+    print(chunk.content, end="")
+
+msg = await llm.ainvoke("Hello!")
+async for chunk in llm.astream("Hello!"):
+    ...
+```
+
+Reasoning arrives in `chunk.additional_kwargs["reasoning_content"]`. Usage and
+timings come in the last chunk (`stream_usage=True`, the default).
+
+### Tool calling
+
+```python
+from langchain_core.tools import tool
+
+
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather in a city."""
+    return f"Sunny in {city}"
+
+
+llm_with_tools = llm.bind_tools([get_weather])
+msg = llm_with_tools.invoke("What's the weather in Paris?")
+msg.tool_calls  # [{'name': 'get_weather', 'args': {'city': 'Paris'}, 'id': '...', ...}]
+```
+
+llama-server accepts only the strings `"auto"`, `"none"` and `"required"` as
+`tool_choice`. A tool's name (or `"any"`, or `True`) is sent as `"required"`:
+the model must call a tool but may pick a different one, because the server
+can't force a particular tool.
+
+### Structured output
+
+```python
+from pydantic import BaseModel, Field
+
+
+class Person(BaseModel):
+    name: str
+    age: int = Field(description="Age in years")
+
+
+structured = llm.with_structured_output(Person)
+structured.invoke("Alice is 30.")  # Person(name='Alice', age=30)
+```
+
+Three methods:
+
+| `method` | What's sent | The model sees the schema? |
+|---|---|---|
+| `"function_calling"` (default) | the schema as the only tool, `tool_choice: "required"` | yes, through the chat template |
+| `"json_schema"` | `response_format: {"type": "json_schema", ...}` | no: it's enforced by the grammar only |
+| `"json_mode"` | `response_format: {"type": "json_object"}` | no |
+
+`function_calling` is the default because with `json_schema` the model never
+sees the schema's field descriptions: asked for an age described as "in months",
+it fills in years. Pass `include_format_instructions=True` with `json_schema` or
+`json_mode` to add the schema to the system message.
+
+### Request parameters
+
+Every field `/v1/chat/completions` accepts in b11429 is a typed parameter:
+`temperature`, `top_k`, `top_p`, `min_p`, `samplers`, `repeat_penalty`, the DRY
+and XTC samplers, `grammar`, `json_schema`, `reasoning_budget_tokens`,
+`cache_prompt`, `id_slot`, `lora` and more. Set them on the model or per call:
+
+```python
+llm = ChatLlama(model="gemma", temperature=0.2, top_k=40)
+llm.invoke("Hi", max_tokens=500)
+```
+
+They all default to `None`, which leaves them out of the request so the
+server's per-model defaults apply. To see those defaults:
+
+```python
+llm.get_server_defaults()
+# {'temperature': 1.0, 'top_k': 64, 'top_p': 0.95, 'max_tokens': -1, ..., 'n_ctx': 131072}
+```
+
+### Errors and retries
+
+Errors are subclasses of both the httpx exception and LangChain's `ModelError`
+classes, so either `except` works:
+
+```python
+from langchain_llama_cpp import LlamaContextOverflowError
+
+try:
+    llm.invoke(very_long_prompt)
+except LlamaContextOverflowError as error:
+    print(error.n_prompt_tokens, error.n_ctx)
+```
+
+There are also `LlamaModelNotFoundError` (an unknown llama-swap entry),
+`LlamaInvalidRequestError`, `LlamaRateLimitError`, `LlamaAPIError` (5xx),
+`LlamaConnectionError` and `LlamaTimeoutError`.
+
+Connection errors, timeouts, 429 and 5xx are retried `max_retries` times
+(default 2) with exponential backoff, obeying `Retry-After`. `timeout` is in
+seconds and defaults to `None` (no timeout), since local generation can be slow.
+
+## Known limitations
+
+- **Forcing a tool with Qwen3.5/3.6.** With `tool_choice="required"` (also used
+  by `with_structured_output`'s default method), llama-server's grammar for these
+  models lets the model write text before the call and won't let it stop
+  without one. A model that doesn't want a tool keeps writing until
+  `max_tokens`, and there's no tool call. This is
+  [ggml-org/llama.cpp#27217](https://github.com/ggml-org/llama.cpp/issues/27217);
+  keep `max_tokens` set.
+- **A named `tool_choice`** is sent as `"required"` (see Tool calling).
+- **JSON schema bounds on numbers** (`minimum`, `maximum`, `multipleOf` on
+  `number`) aren't enforced by llama-server's grammar. Integer bounds are.
+- **Bare llama-server** (without llama-swap) isn't tested; `get_server_defaults`
+  needs llama-swap's `/upstream/<model>/props`.
+
+## Development
+
+Bug reports and pull requests are welcome on
+[GitHub](https://github.com/bharat029/langchain-llama-cpp/issues).
+
+```bash
+uv sync
+uv run pytest tests/unit_tests          # offline
+uv run ruff check && uv run ruff format --check && uv run pyright
+```
+
+The integration tests (LangChain's standard `langchain-tests` suite, on gemma,
+qwen and gpt-oss) need a llama-swap server. Copy `.env.example` to `.env` and
+set `LLAMA_BASE_URL`, then:
+
+```bash
+uv run --env-file .env pytest tests/integration_tests
+```
+
+The JSON llama-server sends back is described in
+`src/langchain_llama_cpp/_wire.py`.
+
+## License
+
+MIT

langchain_llama_cpp-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+langchain_llama_cpp/__init__.py,sha256=XsmABAlyu2VPq63HO8kgsQnMejrAABizhzTahnza5Kg,699
+langchain_llama_cpp/_wire.py,sha256=e_RLwgm3B4r4fKjZD4sqqpBKqakOnJrNjnoY9Aid27o,9662
+langchain_llama_cpp/chat_models.py,sha256=9hHqPOU0VeTxEn0OdbdLunsglFXupaI3g98jnWhd_cc,51749
+langchain_llama_cpp/content_blocks.py,sha256=Wrq9fay9XAR49049cM2xW6wbSuqMTBI5ZPPBg00BXB0,3223
+langchain_llama_cpp/exceptions.py,sha256=IBLY9ksRGz8ln7q13CgIExpv8EI0ZJnN5dpOe8egrYo,6413
+langchain_llama_cpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_llama_cpp/utils.py,sha256=51-_rpeHFTWHysM6gOGvMUJ0-cmc-7kwrGh2vE3Sryc,1563
+langchain_llama_cpp-0.1.0.dist-info/licenses/LICENSE,sha256=RfhLrWQ1wQUzta_PGhka9c4cR6sNf8KuUZtc83a8Usc,1075
+langchain_llama_cpp-0.1.0.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+langchain_llama_cpp-0.1.0.dist-info/METADATA,sha256=6Y1eDoWzMsZSkQSWOBZYB5ZslKARnJpN0WIZF2pF3v8,8963
+langchain_llama_cpp-0.1.0.dist-info/RECORD,,

langchain_llama_cpp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.5
+Root-Is-Purelib: true
+Tag: py3-none-any

langchain_llama_cpp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bharathan Mudaliar
+
+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.