langchain-lexio 0.1.0__tar.gz

langchain_lexio-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv*/
+__pycache__/
+*.pyc
+dist/
+*.egg-info/
+.pytest_cache/

langchain_lexio-0.1.0/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 (2026-11-12)
+
+- First release: 6 read-only tools, opt-in quote tool, `LexioToolkit`.

langchain_lexio-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lexio Rent (https://lexio.rent)
+
+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_lexio-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: langchain-lexio
+Version: 0.1.0
+Summary: LangChain tools for the Lexio Rent API (car rental software): fleet, availability and prices, rentals, customers and quotes.
+Project-URL: Homepage, https://lexio.rent/logiciel-location-voiture
+Project-URL: Documentation, https://github.com/lexio-rent-git/langchain-lexio#readme
+Project-URL: API reference, https://docs.lexio.rent
+Project-URL: Source, https://github.com/lexio-rent-git/langchain-lexio
+Project-URL: Issues, https://github.com/lexio-rent-git/langchain-lexio/issues
+Author-email: Lexio Rent <contact@lexio.rent>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,car-rental,fleet-management,langchain,langchain-tools,lexio,lexio-rent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: langchain-core<2,>=0.3
+Requires-Dist: lexio-rent>=0.1.1
+Requires-Dist: pydantic>=2
+Provides-Extra: test
+Requires-Dist: langchain-tests>=0.3; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# langchain-lexio
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-lexio.svg)](https://pypi.org/project/langchain-lexio/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+LangChain tools for the [Lexio Rent API](https://docs.lexio.rent). They let an agent answer questions about a vehicle rental company: which vehicles are free next weekend and at what price, which bookings start tomorrow, what a customer has rented, and (optionally) prepare a priced quote.
+
+<a href="https://lexio.rent/logiciel-location-voiture">Lexio Rent</a> is rental management software for professional car, van and two-wheeler rental companies: planning, contracts, check-in/check-out inspections, deposits and fleet maintenance.
+
+## Installation
+
+```bash
+pip install -U langchain-lexio
+export LEXIO_API_KEY="lck_..."
+```
+
+The API key is created in Lexio under **Settings → Developer → API tokens**. API access is part of the Business plan. There is no sandbox: test against a dedicated organization.
+
+## Tools
+
+| Tool | Name | What it does | Writes? |
+|---|---|---|---|
+| `LexioSearchVehiclesTool` | `lexio_search_vehicles` | Active fleet with plate, model, type, status and odometer | no |
+| `LexioCheckAvailabilityTool` | `lexio_check_availability` | Bookable vehicles for a period, with the total price | no |
+| `LexioListRentalsTool` | `lexio_list_rentals` | Rentals by status, date window, vehicle or customer | no |
+| `LexioGetRentalTool` | `lexio_get_rental` | One rental with all its details | no |
+| `LexioFindCustomerTool` | `lexio_find_customer` | Customers by email or company registration number | no |
+| `LexioListCategoriesTool` | `lexio_list_categories` | Vehicle categories (pricing classes) | no |
+| `LexioCreateQuoteTool` | `lexio_create_quote` | Priced quote for a vehicle and a period; books nothing | quote only |
+
+`LexioToolkit` returns the read-only tools. Pass `allow_quotes=True` to add `lexio_create_quote`. No tool creates, changes or cancels a rental, a payment or a customer record.
+
+Dates are the rental company's local time without offset (`2026-12-14T09:00:00`). Lists are capped by `max_results` (default 20) so that tool outputs stay small.
+
+## Usage
+
+```python
+from langchain.agents import create_agent
+from langchain_lexio import LexioToolkit
+
+tools = LexioToolkit(allow_quotes=True).get_tools()
+
+agent = create_agent(
+    "anthropic:claude-sonnet-5-5",
+    tools=tools,
+    system_prompt="You help the counter staff of a car rental agency. Dates are local time.",
+)
+
+result = agent.invoke(
+    {"messages": [{"role": "user", "content": "Which vans are free from 14 to 16 December, and how much?"}]}
+)
+print(result["messages"][-1].content)
+```
+
+A single tool can also be called directly:
+
+```python
+from langchain_lexio import LexioCheckAvailabilityTool
+
+tool = LexioCheckAvailabilityTool()
+print(tool.invoke({"start_at": "2026-12-14T09:00:00", "end_at": "2026-12-16T18:00:00", "vehicle_type": "VAN"}))
+```
+
+API errors are raised as typed exceptions from the [`lexio-rent`](https://pypi.org/project/lexio-rent/) client (`NotFoundError`, `ValidationError`, `RateLimitError`...), with the Lexio error code and request id.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest tests/unit_tests                               # offline, includes the LangChain standard unit tests
+LEXIO_API_KEY=lck_... pytest tests/integration_tests  # LangChain standard integration tests, live
+```
+
+## About
+
+`langchain-lexio` is maintained by the team behind <a href="https://lexio.rent/logiciel-location-voiture">Lexio Rent, car rental management software</a>. When an agent prepares a quote, the counter still hands the customer a receipt for the security deposit; Lexio publishes a free <a href="https://lexio.rent/outils/recu-depot-de-garantie-location">rental security deposit receipt template</a> (in French) for that step.
+
+- API documentation: <https://docs.lexio.rent>
+- Python client: <https://github.com/lexio-rent-git/lexio-python>
+- Contact: contact@lexio.rent
+
+MIT License.

langchain_lexio-0.1.0/README.md

@@ -0,0 +1,82 @@
+# langchain-lexio
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-lexio.svg)](https://pypi.org/project/langchain-lexio/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+LangChain tools for the [Lexio Rent API](https://docs.lexio.rent). They let an agent answer questions about a vehicle rental company: which vehicles are free next weekend and at what price, which bookings start tomorrow, what a customer has rented, and (optionally) prepare a priced quote.
+
+<a href="https://lexio.rent/logiciel-location-voiture">Lexio Rent</a> is rental management software for professional car, van and two-wheeler rental companies: planning, contracts, check-in/check-out inspections, deposits and fleet maintenance.
+
+## Installation
+
+```bash
+pip install -U langchain-lexio
+export LEXIO_API_KEY="lck_..."
+```
+
+The API key is created in Lexio under **Settings → Developer → API tokens**. API access is part of the Business plan. There is no sandbox: test against a dedicated organization.
+
+## Tools
+
+| Tool | Name | What it does | Writes? |
+|---|---|---|---|
+| `LexioSearchVehiclesTool` | `lexio_search_vehicles` | Active fleet with plate, model, type, status and odometer | no |
+| `LexioCheckAvailabilityTool` | `lexio_check_availability` | Bookable vehicles for a period, with the total price | no |
+| `LexioListRentalsTool` | `lexio_list_rentals` | Rentals by status, date window, vehicle or customer | no |
+| `LexioGetRentalTool` | `lexio_get_rental` | One rental with all its details | no |
+| `LexioFindCustomerTool` | `lexio_find_customer` | Customers by email or company registration number | no |
+| `LexioListCategoriesTool` | `lexio_list_categories` | Vehicle categories (pricing classes) | no |
+| `LexioCreateQuoteTool` | `lexio_create_quote` | Priced quote for a vehicle and a period; books nothing | quote only |
+
+`LexioToolkit` returns the read-only tools. Pass `allow_quotes=True` to add `lexio_create_quote`. No tool creates, changes or cancels a rental, a payment or a customer record.
+
+Dates are the rental company's local time without offset (`2026-12-14T09:00:00`). Lists are capped by `max_results` (default 20) so that tool outputs stay small.
+
+## Usage
+
+```python
+from langchain.agents import create_agent
+from langchain_lexio import LexioToolkit
+
+tools = LexioToolkit(allow_quotes=True).get_tools()
+
+agent = create_agent(
+    "anthropic:claude-sonnet-5-5",
+    tools=tools,
+    system_prompt="You help the counter staff of a car rental agency. Dates are local time.",
+)
+
+result = agent.invoke(
+    {"messages": [{"role": "user", "content": "Which vans are free from 14 to 16 December, and how much?"}]}
+)
+print(result["messages"][-1].content)
+```
+
+A single tool can also be called directly:
+
+```python
+from langchain_lexio import LexioCheckAvailabilityTool
+
+tool = LexioCheckAvailabilityTool()
+print(tool.invoke({"start_at": "2026-12-14T09:00:00", "end_at": "2026-12-16T18:00:00", "vehicle_type": "VAN"}))
+```
+
+API errors are raised as typed exceptions from the [`lexio-rent`](https://pypi.org/project/lexio-rent/) client (`NotFoundError`, `ValidationError`, `RateLimitError`...), with the Lexio error code and request id.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest tests/unit_tests                               # offline, includes the LangChain standard unit tests
+LEXIO_API_KEY=lck_... pytest tests/integration_tests  # LangChain standard integration tests, live
+```
+
+## About
+
+`langchain-lexio` is maintained by the team behind <a href="https://lexio.rent/logiciel-location-voiture">Lexio Rent, car rental management software</a>. When an agent prepares a quote, the counter still hands the customer a receipt for the security deposit; Lexio publishes a free <a href="https://lexio.rent/outils/recu-depot-de-garantie-location">rental security deposit receipt template</a> (in French) for that step.
+
+- API documentation: <https://docs.lexio.rent>
+- Python client: <https://github.com/lexio-rent-git/lexio-python>
+- Contact: contact@lexio.rent
+
+MIT License.

langchain_lexio-0.1.0/langchain_lexio/__init__.py

@@ -0,0 +1,24 @@
+"""LangChain integration for the Lexio Rent API."""
+from langchain_lexio.toolkit import LexioToolkit
+from langchain_lexio.tools import (
+    LexioCheckAvailabilityTool,
+    LexioCreateQuoteTool,
+    LexioFindCustomerTool,
+    LexioGetRentalTool,
+    LexioListCategoriesTool,
+    LexioListRentalsTool,
+    LexioSearchVehiclesTool,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "LexioToolkit",
+    "LexioSearchVehiclesTool",
+    "LexioCheckAvailabilityTool",
+    "LexioListRentalsTool",
+    "LexioGetRentalTool",
+    "LexioFindCustomerTool",
+    "LexioListCategoriesTool",
+    "LexioCreateQuoteTool",
+]

langchain_lexio-0.1.0/langchain_lexio/toolkit.py

@@ -0,0 +1,61 @@
+"""Toolkit bundling the Lexio Rent tools."""
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from langchain_core.utils import secret_from_env
+from langchain_core.tools import BaseTool, BaseToolkit
+from lexio_rent import Lexio
+from pydantic import ConfigDict, Field, SecretStr
+
+from langchain_lexio.tools import (
+    LexioCheckAvailabilityTool,
+    LexioCreateQuoteTool,
+    LexioFindCustomerTool,
+    LexioGetRentalTool,
+    LexioListCategoriesTool,
+    LexioListRentalsTool,
+    LexioSearchVehiclesTool,
+)
+
+READ_TOOLS = (
+    LexioSearchVehiclesTool,
+    LexioCheckAvailabilityTool,
+    LexioListRentalsTool,
+    LexioGetRentalTool,
+    LexioFindCustomerTool,
+    LexioListCategoriesTool,
+)
+
+
+class LexioToolkit(BaseToolkit):
+    """Lexio Rent tools for agents.
+
+    Read-only by default: fleet, availability and prices, rentals, customers and
+    categories. ``allow_quotes=True`` adds ``lexio_create_quote``, which writes a
+    quote record but books nothing. Rentals, payments and customer records are
+    never created or changed by this toolkit.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    api_key: Optional[SecretStr] = Field(
+        default_factory=secret_from_env("LEXIO_API_KEY", default=None),
+        description="Lexio API key (lck_...). Defaults to LEXIO_API_KEY.",
+    )
+    base_url: Optional[str] = None
+    max_results: int = 20
+    allow_quotes: bool = False
+    client: Optional[Any] = Field(default=None, exclude=True)
+
+    def _client(self) -> Lexio:
+        if self.client is None:
+            key = self.api_key.get_secret_value() if self.api_key else os.environ.get("LEXIO_API_KEY")
+            self.client = Lexio(api_key=key, base_url=self.base_url)
+        return self.client
+
+    def get_tools(self) -> list[BaseTool]:
+        client = self._client()
+        classes = list(READ_TOOLS) + ([LexioCreateQuoteTool] if self.allow_quotes else [])
+        return [cls(client=client, max_results=self.max_results) for cls in classes]

langchain_lexio-0.1.0/langchain_lexio/tools.py

@@ -0,0 +1,317 @@
+"""LangChain tools for the Lexio Rent API (car and van rental management software)."""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Optional
+
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.utils import secret_from_env
+from langchain_core.tools import BaseTool
+from lexio_rent import Lexio
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, SecretStr
+
+VEHICLE_TYPES = "CITY, COMPACT, CROSSOVER, SEDAN, BREAK, SUV, OFF_ROAD, PICKUP, MINIVAN, VAN, UTILITY, COUPE, CONVERTIBLE, SPORT, LUXURY, MOTORCYCLE, SCOOTER"
+RENTAL_STATUSES = "PENDING_APPROVAL, RESERVED, IN_PROGRESS, COMPLETED, CANCELLED"
+LOCAL_TIME = "Local date-time of the rental company, without offset, e.g. 2026-12-14T09:00:00."
+
+
+def _dump(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, default=str)
+
+
+def _pick(obj: Optional[dict], *keys: str) -> Optional[dict]:
+    if not isinstance(obj, dict):
+        return obj
+    return {k: obj.get(k) for k in keys if k in obj}
+
+
+class LexioBaseTool(BaseTool):
+    """Shared settings: API key (``LEXIO_API_KEY``), base URL and client."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    api_key: Optional[SecretStr] = Field(
+        default_factory=secret_from_env("LEXIO_API_KEY", default=None),
+        description="Lexio API key (lck_...). Defaults to LEXIO_API_KEY.",
+    )
+    base_url: Optional[str] = Field(default=None, description="API base URL. Defaults to LEXIO_BASE_URL or production.")
+    max_results: int = Field(default=20, description="Upper bound on items returned to the model.")
+    client: Optional[Any] = Field(default=None, exclude=True, description="Optional shared lexio_rent.Lexio client.")
+    _own_client: Optional[Lexio] = PrivateAttr(default=None)
+
+    def _lexio(self) -> Lexio:
+        if self.client is not None:
+            return self.client
+        if self._own_client is None:
+            key = self.api_key.get_secret_value() if self.api_key else os.environ.get("LEXIO_API_KEY")
+            self._own_client = Lexio(api_key=key, base_url=self.base_url)
+        return self._own_client
+
+    def _list(self, method: Any, limit: Optional[int], **filters: Any) -> list:
+        cap = min(limit or self.max_results, self.max_results)
+        out = []
+        for item in self._lexio().paginate(method, limit=min(cap, 100), **filters):
+            out.append(item)
+            if len(out) >= cap:
+                break
+        return out
+
+
+# --- search vehicles -------------------------------------------------------
+
+class SearchVehiclesInput(BaseModel):
+    category_id: Optional[str] = Field(default=None, description="Only vehicles of this category id.")
+    vehicle_type: Optional[str] = Field(default=None, description="Vehicle type, one of: " + VEHICLE_TYPES + ".")
+    status: Optional[str] = Field(default=None, description="OPERATIONAL or BREAKDOWN.")
+    limit: Optional[int] = Field(default=None, description="Maximum number of vehicles to return.")
+
+
+class LexioSearchVehiclesTool(LexioBaseTool):
+    """List the active fleet of the rental company."""
+
+    name: str = "lexio_search_vehicles"
+    description: str = (
+        "List vehicles of the rental company fleet (active, not archived) with plate, model, category, "
+        "status and odometer. Use it to find a vehicle id."
+    )
+    args_schema: type[BaseModel] = SearchVehiclesInput
+
+    def _run(
+        self,
+        category_id: Optional[str] = None,
+        vehicle_type: Optional[str] = None,
+        status: Optional[str] = None,
+        limit: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        items = self._list(
+            self._lexio().vehicles.list,
+            limit,
+            is_archived=False,
+            category_id=category_id,
+            vehicle_type=vehicle_type,
+            status=status,
+        )
+        keys = ("id", "plate", "name", "brand", "model", "vehicleType", "status", "odometerKm", "category")
+        return _dump([_pick(v, *keys) for v in items])
+
+
+# --- availability ----------------------------------------------------------
+
+class CheckAvailabilityInput(BaseModel):
+    start_at: str = Field(description="Pick-up. " + LOCAL_TIME)
+    end_at: str = Field(description="Return. " + LOCAL_TIME)
+    category_id: Optional[str] = Field(default=None, description="Only this category id.")
+    vehicle_type: Optional[str] = Field(default=None, description="Vehicle type, one of: " + VEHICLE_TYPES + ".")
+    only_available: bool = Field(default=True, description="True: bookable vehicles only. False: the others, with reasons.")
+    limit: Optional[int] = Field(default=None, description="Maximum number of offers to return.")
+
+
+class LexioCheckAvailabilityTool(LexioBaseTool):
+    """Bookable vehicles and their price for a period."""
+
+    name: str = "lexio_check_availability"
+    description: str = (
+        "Check which vehicles can be booked for a period and their total price (tax included, with the default "
+        "mileage package, excess and deposit). Prices are indicative; only a quote fixes the price."
+    )
+    args_schema: type[BaseModel] = CheckAvailabilityInput
+
+    def _run(
+        self,
+        start_at: str,
+        end_at: str,
+        category_id: Optional[str] = None,
+        vehicle_type: Optional[str] = None,
+        only_available: bool = True,
+        limit: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        offers = self._list(
+            self._lexio().availability.list,
+            limit,
+            start_at=start_at,
+            end_at=end_at,
+            category_id=category_id,
+            vehicle_type=vehicle_type,
+            is_available=only_available,
+        )
+        out = []
+        for o in offers:
+            out.append(
+                {
+                    "vehicle": _pick(o.get("vehicle"), "id", "name", "brand", "model", "plate", "vehicleType"),
+                    "isAvailable": o.get("isAvailable"),
+                    "unavailableReasons": o.get("unavailableReasons"),
+                    "billedDays": (o.get("period") or {}).get("billedDays"),
+                    "currency": o.get("currency"),
+                    "totalTTC": o.get("totalTTC"),
+                    "mileage": _pick(o.get("mileage"), "name", "isUnlimited", "includedKm"),
+                }
+            )
+        return _dump(out)
+
+
+# --- rentals ---------------------------------------------------------------
+
+class ListRentalsInput(BaseModel):
+    status: Optional[str] = Field(default=None, description=f"Comma-separated statuses: {RENTAL_STATUSES}.")
+    from_date: Optional[str] = Field(default=None, description="First day (YYYY-MM-DD) of the window, included.")
+    to_date: Optional[str] = Field(default=None, description="Last day (YYYY-MM-DD) of the window, included.")
+    vehicle_id: Optional[str] = Field(default=None, description="Only rentals of this vehicle id.")
+    customer_id: Optional[str] = Field(default=None, description="Only rentals of this customer id.")
+    limit: Optional[int] = Field(default=None, description="Maximum number of rentals to return.")
+
+
+class LexioListRentalsTool(LexioBaseTool):
+    """Search rentals (bookings)."""
+
+    name: str = "lexio_list_rentals"
+    description: str = (
+        "Search rentals (bookings) by status, date window, vehicle or customer. Returns number, status, period, "
+        "vehicle, customer and totals. Without status, cancelled rentals are included."
+    )
+    args_schema: type[BaseModel] = ListRentalsInput
+
+    def _run(
+        self,
+        status: Optional[str] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        vehicle_id: Optional[str] = None,
+        customer_id: Optional[str] = None,
+        limit: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        items = self._list(
+            self._lexio().rentals.list,
+            limit,
+            status=status,
+            from_=from_date,
+            to=to_date,
+            vehicle_id=vehicle_id,
+            customer_id=customer_id,
+        )
+        return _dump([_compact_rental(r) for r in items])
+
+
+def _compact_rental(r: dict) -> dict:
+    return {
+        "id": r.get("id"),
+        "number": r.get("number"),
+        "status": r.get("status"),
+        "period": _pick(r.get("period"), "startAt", "endAt", "timezone"),
+        "vehicle": _pick(r.get("vehicle"), "id", "name", "plate"),
+        "customer": _pick(r.get("customer"), "id", "firstName", "lastName", "companyName", "email"),
+        "currency": r.get("currency"),
+        "totalTTC": r.get("totalTTC"),
+        "balance": r.get("balance"),
+    }
+
+
+class GetRentalInput(BaseModel):
+    rental_id: str = Field(description="Rental id (UUID).")
+
+
+class LexioGetRentalTool(LexioBaseTool):
+    """One rental with all its details."""
+
+    name: str = "lexio_get_rental"
+    description: str = (
+        "Get one rental by id with all details: period, actual pick-up and return, vehicle, customer, locations, "
+        "mileage package, excess, deposit, options, price lines, balance and notes."
+    )
+    args_schema: type[BaseModel] = GetRentalInput
+
+    def _run(self, rental_id: str, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        return _dump(self._lexio().rentals.get(rental_id)["data"])
+
+
+# --- customers -------------------------------------------------------------
+
+class FindCustomerInput(BaseModel):
+    email: Optional[str] = Field(default=None, description="Exact email address of the customer.")
+    company_registration_number: Optional[str] = Field(default=None, description="Company registration number (business customers).")
+    limit: Optional[int] = Field(default=None, description="Maximum number of customers to return.")
+
+
+class LexioFindCustomerTool(LexioBaseTool):
+    """Find customers by email or company registration number."""
+
+    name: str = "lexio_find_customer"
+    description: str = "Find customers of the rental company by exact email or company registration number."
+    args_schema: type[BaseModel] = FindCustomerInput
+
+    def _run(
+        self,
+        email: Optional[str] = None,
+        company_registration_number: Optional[str] = None,
+        limit: Optional[int] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        items = self._list(
+            self._lexio().customers.list, limit, email=email, company_registration_number=company_registration_number
+        )
+        return _dump(items)
+
+
+# --- catalogue -------------------------------------------------------------
+
+class ListCategoriesInput(BaseModel):
+    limit: Optional[int] = Field(default=None, description="Maximum number of categories to return.")
+
+
+class LexioListCategoriesTool(LexioBaseTool):
+    """Vehicle categories (pricing classes)."""
+
+    name: str = "lexio_list_categories"
+    description: str = "List the vehicle categories (pricing classes) of the rental company, with their ids."
+    args_schema: type[BaseModel] = ListCategoriesInput
+
+    def _run(self, limit: Optional[int] = None, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
+        return _dump(self._list(self._lexio().categories.list, limit))
+
+
+# --- quote (write, opt-in) -------------------------------------------------
+
+class CreateQuoteInput(BaseModel):
+    vehicle_id: str = Field(description="Vehicle id, from lexio_check_availability.")
+    start_at: str = Field(description="Pick-up. " + LOCAL_TIME)
+    end_at: str = Field(description="Return. " + LOCAL_TIME)
+    mileage_package_id: Optional[str] = Field(default=None, description="Mileage package id; default package if omitted.")
+    deductible_id: Optional[str] = Field(default=None, description="Excess (deductible) id; default if omitted.")
+    deposit_id: Optional[str] = Field(default=None, description="Deposit id; default if omitted.")
+    promo_code: Optional[str] = Field(default=None, description="Promo code, if the customer has one.")
+
+
+class LexioCreateQuoteTool(LexioBaseTool):
+    """Create a priced quote (writes to Lexio, books nothing)."""
+
+    name: str = "lexio_create_quote"
+    description: str = (
+        "Create a quote that fixes the price of a vehicle for a period. It writes a quote record in Lexio but does "
+        "not book the vehicle. Returns the quote id, total and expiry."
+    )
+    args_schema: type[BaseModel] = CreateQuoteInput
+
+    def _run(
+        self,
+        vehicle_id: str,
+        start_at: str,
+        end_at: str,
+        mileage_package_id: Optional[str] = None,
+        deductible_id: Optional[str] = None,
+        deposit_id: Optional[str] = None,
+        promo_code: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        body = {"vehicleId": vehicle_id, "startAt": start_at, "endAt": end_at}
+        optional = {
+            "mileagePackageId": mileage_package_id,
+            "deductibleId": deductible_id,
+            "depositId": deposit_id,
+            "promoCode": promo_code,
+        }
+        body.update({k: v for k, v in optional.items() if v is not None})
+        return _dump(self._lexio().quotes.create(body)["data"])

langchain_lexio-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-lexio"
+version = "0.1.0"
+description = "LangChain tools for the Lexio Rent API (car rental software): fleet, availability and prices, rentals, customers and quotes."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Lexio Rent", email = "contact@lexio.rent" }]
+keywords = ["langchain", "langchain-tools", "agents", "lexio", "lexio-rent", "car-rental", "fleet-management"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Office/Business",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["langchain-core>=0.3,<2", "lexio-rent>=0.1.1", "pydantic>=2"]
+
+[project.optional-dependencies]
+test = ["pytest>=7", "pytest-asyncio", "langchain-tests>=0.3"]
+
+[project.urls]
+Homepage = "https://lexio.rent/logiciel-location-voiture"
+Documentation = "https://github.com/lexio-rent-git/langchain-lexio#readme"
+"API reference" = "https://docs.lexio.rent"
+Source = "https://github.com/lexio-rent-git/langchain-lexio"
+Issues = "https://github.com/lexio-rent-git/langchain-lexio/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_lexio"]
+
+[tool.hatch.build.targets.sdist]
+include = ["langchain_lexio", "tests", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

langchain_lexio-0.1.0/tests/integration_tests/test_live.py

@@ -0,0 +1,52 @@
+"""LangChain standard integration tests against a real Lexio organization (needs LEXIO_API_KEY)."""
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+from langchain_tests.integration_tests import ToolsIntegrationTests
+
+from langchain_lexio import LexioCheckAvailabilityTool, LexioListRentalsTool, LexioSearchVehiclesTool, LexioToolkit
+
+pytestmark = pytest.mark.skipif(not os.environ.get("LEXIO_API_KEY"), reason="set LEXIO_API_KEY to run live tests")
+
+
+class TestSearchVehiclesLive(ToolsIntegrationTests):
+    @property
+    def tool_constructor(self):
+        return LexioSearchVehiclesTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"limit": 3}
+
+
+class TestCheckAvailabilityLive(ToolsIntegrationTests):
+    @property
+    def tool_constructor(self):
+        return LexioCheckAvailabilityTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"start_at": "2027-03-01T09:00:00", "end_at": "2027-03-03T18:00:00", "limit": 3}
+
+
+class TestListRentalsLive(ToolsIntegrationTests):
+    @property
+    def tool_constructor(self):
+        return LexioListRentalsTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"status": "RESERVED,IN_PROGRESS", "limit": 3}
+
+
+def test_toolkit_end_to_end():
+    tools = {t.name: t for t in LexioToolkit().get_tools()}
+    vehicles = json.loads(tools["lexio_search_vehicles"].invoke({"limit": 2}))
+    assert vehicles and vehicles[0]["id"]
+    rentals = json.loads(tools["lexio_list_rentals"].invoke({"limit": 1}))
+    if rentals:
+        full = json.loads(tools["lexio_get_rental"].invoke({"rental_id": rentals[0]["id"]}))
+        assert full["id"] == rentals[0]["id"]

langchain_lexio-0.1.0/tests/unit_tests/test_tools.py

@@ -0,0 +1,153 @@
+"""Offline tests: LangChain standard unit tests + behaviour against a mocked API."""
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from langchain_tests.unit_tests import ToolsUnitTests
+from lexio_rent import Lexio
+
+from langchain_lexio import (
+    LexioCheckAvailabilityTool,
+    LexioCreateQuoteTool,
+    LexioGetRentalTool,
+    LexioListRentalsTool,
+    LexioSearchVehiclesTool,
+    LexioToolkit,
+)
+
+
+def fake_client(handler, seen):
+    def wrapped(req):
+        seen.append(req)
+        return handler(req)
+
+    return Lexio("lck_test", http_client=httpx.Client(transport=httpx.MockTransport(wrapped)), max_retries=0)
+
+
+class _Std(ToolsUnitTests):
+    @property
+    def tool_constructor_params(self) -> dict:
+        return {"api_key": "lck_test"}
+
+    @property
+    def init_from_env_params(self):
+        return ({"LEXIO_API_KEY": "lck_env"}, {}, {"api_key": "lck_env"})
+
+
+class TestSearchVehiclesStandard(_Std):
+    @property
+    def tool_constructor(self):
+        return LexioSearchVehiclesTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"vehicle_type": "SUV", "limit": 5}
+
+
+class TestCheckAvailabilityStandard(_Std):
+    @property
+    def tool_constructor(self):
+        return LexioCheckAvailabilityTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"start_at": "2026-12-14T09:00:00", "end_at": "2026-12-16T18:00:00"}
+
+
+class TestGetRentalStandard(_Std):
+    @property
+    def tool_constructor(self):
+        return LexioGetRentalTool
+
+    @property
+    def tool_invoke_params_example(self) -> dict:
+        return {"rental_id": "9c2d7e4a-5b1f-4d3c-8a6e-0f1b2c3d4e5f"}
+
+
+def test_toolkit_is_read_only_by_default():
+    names = [t.name for t in LexioToolkit(api_key="lck_test").get_tools()]
+    assert "lexio_create_quote" not in names
+    assert names == [
+        "lexio_search_vehicles",
+        "lexio_check_availability",
+        "lexio_list_rentals",
+        "lexio_get_rental",
+        "lexio_find_customer",
+        "lexio_list_categories",
+    ]
+    assert "lexio_create_quote" in [t.name for t in LexioToolkit(api_key="lck_test", allow_quotes=True).get_tools()]
+
+
+def test_toolkit_shares_one_client():
+    tools = LexioToolkit(api_key="lck_test").get_tools()
+    assert len({id(t.client) for t in tools}) == 1
+
+
+def test_search_vehicles_filters_and_compacts():
+    seen = []
+
+    def handler(req):
+        return httpx.Response(200, json={"data": [{"id": "v1", "plate": "AB-123-CD", "vin": "secret-ish", "status": "AVAILABLE"}], "nextCursor": None})
+
+    tool = LexioSearchVehiclesTool(client=fake_client(handler, seen))
+    out = json.loads(tool.invoke({"vehicle_type": "VAN"}))
+    assert out == [{"id": "v1", "plate": "AB-123-CD", "status": "AVAILABLE"}]
+    url = str(seen[0].url)
+    assert "isArchived=false" in url and "vehicleType=VAN" in url
+    assert seen[0].headers["authorization"] == "Bearer lck_test"
+
+
+def test_max_results_caps_pagination():
+    seen = []
+    pages = {None: {"data": [{"id": i} for i in range(3)], "nextCursor": "c2"}, "c2": {"data": [{"id": 9}], "nextCursor": None}}
+
+    def handler(req):
+        return httpx.Response(200, json=pages[req.url.params.get("cursor")])
+
+    tool = LexioSearchVehiclesTool(client=fake_client(handler, seen), max_results=2)
+    assert len(json.loads(tool.invoke({}))) == 2
+    assert len(seen) == 1
+
+
+def test_check_availability_params():
+    seen = []
+
+    def handler(req):
+        return httpx.Response(200, json={"data": [{"vehicle": {"id": "v1", "name": "Clio"}, "isAvailable": True, "totalTTC": 120.5, "currency": "EUR", "period": {"billedDays": 3}}], "nextCursor": None})
+
+    tool = LexioCheckAvailabilityTool(client=fake_client(handler, seen))
+    out = json.loads(tool.invoke({"start_at": "2026-12-14T09:00:00", "end_at": "2026-12-16T18:00:00"}))
+    assert out[0]["totalTTC"] == 120.5 and out[0]["billedDays"] == 3
+    params = seen[0].url.params
+    assert params["startAt"] == "2026-12-14T09:00:00" and params["isAvailable"] == "true"
+
+
+def test_list_rentals_maps_date_window():
+    seen = []
+    tool = LexioListRentalsTool(client=fake_client(lambda r: httpx.Response(200, json={"data": [], "nextCursor": None}), seen))
+    assert json.loads(tool.invoke({"status": "RESERVED", "from_date": "2026-12-01", "to_date": "2026-12-31"})) == []
+    params = seen[0].url.params
+    assert params["from"] == "2026-12-01" and params["to"] == "2026-12-31" and params["status"] == "RESERVED"
+
+
+def test_create_quote_body_and_idempotency():
+    seen = []
+
+    def handler(req):
+        return httpx.Response(201, json={"data": {"id": "q1", "totalTTC": 99}})
+
+    tool = LexioCreateQuoteTool(client=fake_client(handler, seen))
+    out = json.loads(tool.invoke({"vehicle_id": "v1", "start_at": "2026-12-14T09:00:00", "end_at": "2026-12-16T18:00:00"}))
+    assert out["id"] == "q1"
+    assert json.loads(seen[0].content) == {"vehicleId": "v1", "startAt": "2026-12-14T09:00:00", "endAt": "2026-12-16T18:00:00"}
+    assert seen[0].method == "POST"
+
+
+def test_api_errors_surface():
+    from lexio_rent import NotFoundError
+
+    tool = LexioGetRentalTool(client=fake_client(lambda r: httpx.Response(404, json={"code": "NOT_FOUND", "detail": "x"}), []))
+    with pytest.raises(NotFoundError):
+        tool.invoke({"rental_id": "nope"})