langchain-cloro 0.1.0__tar.gz

langchain_cloro-0.1.0/.env.example

@@ -0,0 +1,3 @@
+# Cloro API Key
+# Get your API key at https://cloro.dev
+CLORO_API_KEY=your-api-key-here

langchain_cloro-0.1.0/.gitignore

@@ -0,0 +1,64 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.log
+uv.lock

langchain_cloro-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cloro.dev
+
+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_cloro-0.1.0/Makefile

@@ -0,0 +1,28 @@
+.PHONY: help test lint format typing clean
+
+help:
+	@echo "Available commands:"
+	@echo "  make test       - Run unit tests"
+	@echo "  make lint       - Run linter"
+	@echo "  make format     - Format code"
+	@echo "  make typing     - Run type checker"
+	@echo "  make clean      - Clean build artifacts"
+
+test:
+	pytest tests/unit_tests -v
+
+lint:
+	ruff check .
+
+format:
+	ruff format .
+
+typing:
+	mypy langchain_cloro
+
+clean:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	find . -type d -name __pycache__ -exec rm -rf {} +
+	find . -type f -name "*.pyc" -delete

langchain_cloro-0.1.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: langchain-cloro
+Version: 0.1.0
+Summary: An integration package connecting Cloro.dev and LangChain
+Project-URL: Homepage, https://docs.cloro.dev
+Project-URL: Documentation, https://docs.cloro.dev
+Project-URL: Source, https://github.com/cloro-dev/langchain-cloro
+Project-URL: Changelog, https://github.com/cloro-dev/langchain-cloro/releases
+Project-URL: Repository, https://github.com/cloro-dev/langchain-cloro
+License: MIT
+License-File: LICENSE
+Requires-Python: <4.0.0,>=3.10.0
+Requires-Dist: httpx<1.0.0,>=0.25.0
+Requires-Dist: langchain-core<1.0.0,>=0.1.0
+Description-Content-Type: text/markdown
+
+# langchain-cloro
+
+This package contains the LangChain integration for [Cloro.dev](https://cloro.dev).
+
+## Installation
+
+```bash
+pip install langchain-cloro
+```
+
+## Setup
+
+You'll need a Cloro API key. Get one at [https://cloro.dev](https://cloro.dev).
+
+Set the API key as an environment variable:
+
+```bash
+export CLORO_API_KEY="your-api-key-here"
+```
+
+Or pass it directly when initializing:
+
+```python
+from langchain_cloro import CloroSearchRun
+
+tool = CloroSearchRun(cloro_api_key="your-api-key-here")
+```
+
+## Usage
+
+### With an Agent
+
+```python
+from langchain.agents import initialize_agent, AgentType
+from langchain_openai import OpenAI
+from langchain_cloro import CloroSearchRun
+
+llm = OpenAI(temperature=0)
+search = CloroSearchRun()
+
+agent = initialize_agent(
+    [search],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True,
+)
+
+agent.run("What are the latest developments in AI?")
+```
+
+### Direct Tool Usage
+
+```python
+from langchain_cloro import CloroSearchRun
+
+tool = CloroSearchRun()
+
+# Simple search
+results = tool.invoke({"query": "Python programming tips"})
+
+# Search with custom parameters
+results = tool.invoke({
+    "query": "machine learning tutorials",
+    "num_results": 5,
+})
+```
+
+### With LCEL
+
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_openai import ChatOpenAI
+from langchain_cloro import CloroSearchRun
+
+search = CloroSearchRun()
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "Answer the question based on the search results:\n\n{results}"),
+    ("user", "{question}")
+])
+
+chain = {
+    "results": lambda x: search.invoke({"query": x["question"]}),
+    "question": lambda x: x["question"]
+} | prompt | ChatOpenAI() | StrOutputParser()
+
+response = chain.invoke({"question": "What is LangChain?"})
+print(response)
+```
+
+## API Reference
+
+### CloroSearchRun
+
+Main search tool for Cloro.dev API.
+
+**Parameters:**
+- `cloro_api_key` (str, optional): Cloro API key. Defaults to `CLORO_API_KEY` environment variable.
+- `timeout` (float, optional): Request timeout in seconds. Defaults to 10.0.
+
+**Methods:**
+
+##### `_run`
+
+Execute a search query.
+
+```python
+_run(
+    query: str,
+    num_results: int = 10,
+    **kwargs: dict
+) -> str
+```
+
+**Parameters:**
+- `query` (str): The search query string.
+- `num_results` (int): Number of results to return. Default: 10.
+- `**kwargs`: Additional search parameters to pass to the Cloro API.
+
+**Returns:**
+- `str`: JSON string of search results.
+
+## Development
+
+### Running Tests
+
+```bash
+# Unit tests
+pytest tests/unit_tests
+
+# Linting
+ruff check .
+ruff format .
+```
+
+## Contributing
+
+This package follows LangChain's contribution guidelines. See:
+- [LangChain Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview)
+
+## License
+
+MIT
+
+## Links
+
+- Documentation: [https://docs.cloro.dev](https://docs.cloro.dev)
+- Source: [https://github.com/cloro-dev/langchain-cloro](https://github.com/cloro-dev/langchain-cloro)
+- Cloro API: [https://cloro.dev](https://cloro.dev)

langchain_cloro-0.1.0/README.md

@@ -0,0 +1,150 @@
+# langchain-cloro
+
+This package contains the LangChain integration for [Cloro.dev](https://cloro.dev).
+
+## Installation
+
+```bash
+pip install langchain-cloro
+```
+
+## Setup
+
+You'll need a Cloro API key. Get one at [https://cloro.dev](https://cloro.dev).
+
+Set the API key as an environment variable:
+
+```bash
+export CLORO_API_KEY="your-api-key-here"
+```
+
+Or pass it directly when initializing:
+
+```python
+from langchain_cloro import CloroSearchRun
+
+tool = CloroSearchRun(cloro_api_key="your-api-key-here")
+```
+
+## Usage
+
+### With an Agent
+
+```python
+from langchain.agents import initialize_agent, AgentType
+from langchain_openai import OpenAI
+from langchain_cloro import CloroSearchRun
+
+llm = OpenAI(temperature=0)
+search = CloroSearchRun()
+
+agent = initialize_agent(
+    [search],
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True,
+)
+
+agent.run("What are the latest developments in AI?")
+```
+
+### Direct Tool Usage
+
+```python
+from langchain_cloro import CloroSearchRun
+
+tool = CloroSearchRun()
+
+# Simple search
+results = tool.invoke({"query": "Python programming tips"})
+
+# Search with custom parameters
+results = tool.invoke({
+    "query": "machine learning tutorials",
+    "num_results": 5,
+})
+```
+
+### With LCEL
+
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_openai import ChatOpenAI
+from langchain_cloro import CloroSearchRun
+
+search = CloroSearchRun()
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "Answer the question based on the search results:\n\n{results}"),
+    ("user", "{question}")
+])
+
+chain = {
+    "results": lambda x: search.invoke({"query": x["question"]}),
+    "question": lambda x: x["question"]
+} | prompt | ChatOpenAI() | StrOutputParser()
+
+response = chain.invoke({"question": "What is LangChain?"})
+print(response)
+```
+
+## API Reference
+
+### CloroSearchRun
+
+Main search tool for Cloro.dev API.
+
+**Parameters:**
+- `cloro_api_key` (str, optional): Cloro API key. Defaults to `CLORO_API_KEY` environment variable.
+- `timeout` (float, optional): Request timeout in seconds. Defaults to 10.0.
+
+**Methods:**
+
+##### `_run`
+
+Execute a search query.
+
+```python
+_run(
+    query: str,
+    num_results: int = 10,
+    **kwargs: dict
+) -> str
+```
+
+**Parameters:**
+- `query` (str): The search query string.
+- `num_results` (int): Number of results to return. Default: 10.
+- `**kwargs`: Additional search parameters to pass to the Cloro API.
+
+**Returns:**
+- `str`: JSON string of search results.
+
+## Development
+
+### Running Tests
+
+```bash
+# Unit tests
+pytest tests/unit_tests
+
+# Linting
+ruff check .
+ruff format .
+```
+
+## Contributing
+
+This package follows LangChain's contribution guidelines. See:
+- [LangChain Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview)
+
+## License
+
+MIT
+
+## Links
+
+- Documentation: [https://docs.cloro.dev](https://docs.cloro.dev)
+- Source: [https://github.com/cloro-dev/langchain-cloro](https://github.com/cloro-dev/langchain-cloro)
+- Cloro API: [https://cloro.dev](https://cloro.dev)

langchain_cloro-0.1.0/langchain_cloro/__init__.py

@@ -0,0 +1,8 @@
+"""LangChain integration for Cloro.dev Search API."""
+
+from langchain_cloro.tools import CloroSearchRun, CloroSearchResults
+
+__all__ = [
+    "CloroSearchRun",
+    "CloroSearchResults",
+]

langchain_cloro-0.1.0/langchain_cloro/_utilities.py

@@ -0,0 +1,55 @@
+"""Utilities for Cloro integration."""
+
+import os
+from typing import Any
+
+import httpx
+from langchain_core.utils import convert_to_secret_str
+
+
+def initialize_client(values: dict, *, timeout: float = 10.0) -> dict:
+    """Initialize the Cloro HTTP client.
+
+    Args:
+        values: The values dictionary containing configuration.
+        timeout: Request timeout in seconds. Default: 10.0
+
+    Returns:
+        The updated values dictionary with initialized client.
+    """
+    cloro_api_key = values.get("cloro_api_key") or os.environ.get("CLORO_API_KEY") or ""
+    values["cloro_api_key"] = convert_to_secret_str(cloro_api_key)
+
+    # Initialize httpx client with appropriate settings
+    values["client"] = httpx.Client(
+        base_url="https://api.cloro.dev",
+        headers={
+            "Authorization": f"Bearer {values['cloro_api_key'].get_secret_value()}",
+            "Content-Type": "application/json",
+        },
+        timeout=timeout,
+    )
+    return values
+
+
+def build_search_params(
+    query: str,
+    num_results: int = 10,
+    **kwargs: dict,
+) -> dict[str, Any]:
+    """Build search parameters for the Cloro API.
+
+    Args:
+        query: The search query string.
+        num_results: Number of results to return. Default: 10
+        **kwargs: Additional search parameters.
+
+    Returns:
+        Dictionary of search parameters.
+    """
+    params = {
+        "query": query,
+        "num_results": num_results,
+    }
+    params.update(kwargs)
+    return params

langchain_cloro-0.1.0/langchain_cloro/tools.py

@@ -0,0 +1,119 @@
+"""Tool for the Cloro.dev Search API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+from pydantic import Field, SecretStr, model_validator
+
+from langchain_cloro._utilities import build_search_params, initialize_client
+
+
+class CloroSearchRun(BaseTool):
+    r"""Cloro.dev Search tool.
+
+    Setup:
+        Install ``langchain-cloro`` and set environment variable ``CLORO_API_KEY``.
+
+        .. code-block:: bash
+
+            pip install -U langchain-cloro
+            export CLORO_API_KEY="your-api-key"
+
+    Instantiation:
+        .. code-block:: python
+
+            from langchain_cloro import CloroSearchRun
+
+            tool = CloroSearchRun()
+
+    Invocation with args:
+        .. code-block:: python
+
+            tool.invoke({"query": "latest AI news", "num_results": 5})
+
+    Invocation with ToolCall:
+        .. code-block:: python
+
+            tool.invoke(
+                {
+                    "args": {"query": "python programming", "num_results": 3},
+                    "id": "1",
+                    "name": tool.name,
+                    "type": "tool_call",
+                }
+            )
+    """
+
+    name: str = "cloro_search"
+    description: str = (
+        "A wrapper around Cloro.dev Search API. "
+        "Useful for when you need to answer questions about current events. "
+        "Input should be a search query. "
+        "Output is a JSON array of search results."
+    )
+    client: httpx.Client = Field(default=None)  # type: ignore[assignment]
+    cloro_api_key: SecretStr = Field(default=SecretStr(""))
+    timeout: float = Field(default=10.0, description="Request timeout in seconds")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: dict) -> Any:
+        """Validate the environment and initialize the client.
+
+        Args:
+            values: The values dictionary containing configuration.
+
+        Returns:
+            The validated and updated values dictionary.
+        """
+        return initialize_client(values, timeout=values.get("timeout", 10.0))
+
+    def _run(
+        self,
+        query: str,
+        num_results: int = 10,
+        run_manager: CallbackManagerForToolRun | None = None,
+        **kwargs: dict,
+    ) -> str:
+        """Use the Cloro tool to search.
+
+        Args:
+            query: The search query string.
+            num_results: Number of search results to return (default: 10).
+            run_manager: The run manager for callbacks.
+            **kwargs: Additional search parameters to pass to the API.
+
+        Returns:
+            JSON string of search results or error message.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        try:
+            params = build_search_params(
+                query=query,
+                num_results=num_results,
+                **kwargs,
+            )
+
+            response = self.client.get(
+                "/search",
+                params=params,
+            )
+            response.raise_for_status()
+
+            results = response.json()
+            return str(results)
+
+        except httpx.HTTPError as e:
+            return f"Error searching with Cloro: {e!s}"
+        except Exception as e:
+            return f"Unexpected error: {e!s}"
+
+
+# Alias for backwards compatibility
+CloroSearchResults = CloroSearchRun

langchain_cloro-0.1.0/pyproject.toml

@@ -0,0 +1,118 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+authors = []
+license = { text = "MIT" }
+requires-python = ">=3.10.0,<4.0.0"
+dependencies = [
+    "langchain-core>=0.1.0,<1.0.0",
+    "httpx>=0.25.0,<1.0.0",
+]
+name = "langchain-cloro"
+version = "0.1.0"
+description = "An integration package connecting Cloro.dev and LangChain"
+readme = "README.md"
+
+[project.urls]
+Homepage = "https://docs.cloro.dev"
+Documentation = "https://docs.cloro.dev"
+Source = "https://github.com/cloro-dev/langchain-cloro"
+Changelog = "https://github.com/cloro-dev/langchain-cloro/releases"
+Repository = "https://github.com/cloro-dev/langchain-cloro"
+
+[dependency-groups]
+test = [
+    "pytest>=7.3.0,<8.0.0",
+    "pytest-mock>=3.10.0,<4.0.0",
+    "pytest-watcher>=0.3.4,<1.0.0",
+    "pytest-asyncio>=0.21.1,<1.0.0",
+    "freezegun>=1.2.2,<2.0.0",
+    "langchain-core",
+]
+lint = ["ruff>=0.13.1,<0.14.0"]
+dev = ["langchain-core"]
+typing = [
+    "mypy>=1.10.0,<2.0.0",
+    "langchain-core",
+]
+
+[tool.mypy]
+disallow_untyped_defs = "True"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+    "A",      # flake8-builtins
+    "ASYNC",  # flake8-async
+    "C4",     # flake8-comprehensions
+    "COM",    # flake8-commas
+    "D",      # pydocstyle
+    "E",      # pycodestyle error
+    "EM",     # flake8-errmsg
+    "F",      # pyflakes
+    "FA",     # flake8-future-annotations
+    "FBT",    # flake8-boolean-trap
+    "FLY",    # flake8-flynt
+    "I",      # isort
+    "ICN",    # flake8-import-conventions
+    "INT",    # flake8-gettext
+    "ISC",    # isort-comprehensions
+    "PGH",    # pygrep-hooks
+    "PIE",    # flake8-pie
+    "PERF",   # flake8-perf
+    "PYI",    # flake8-pyi
+    "Q",      # flake8-quotes
+    "RET",    # flake8-return
+    "RSE",    # flake8-rst-docstrings
+    "RUF",    # ruff
+    "S",      # flake8-bandit
+    "SLF",    # flake8-self
+    "SLOT",   # flake8-slots
+    "SIM",    # flake8-simplify
+    "T10",    # flake8-debugger
+    "T20",    # flake8-print
+    "TID",    # flake8-tidy-imports
+    "UP",     # pyupgrade
+    "W",      # pycodestyle warning
+    "YTT",    # flake8-2020
+]
+ignore = [
+    "COM812",  # Messes with the formatter
+    "ISC001",  # Messes with the formatter
+    "PERF203", # Rarely useful
+    "S112",    # Rarely useful
+    "RUF012",  # Doesn't play well with Pydantic
+    "SLF001",  # Private member access
+]
+unfixable = ["B028"] # People should intentionally tune the stacklevel
+
+[tool.coverage.run]
+omit = ["tests/*"]
+
+[tool.pytest.ini_options]
+addopts = "--snapshot-warn-unused --strict-markers --strict-config --durations=5"
+markers = [
+    "requires: mark tests as requiring a specific library",
+    "compile: mark placeholder test used to compile integration tests without running them",
+]
+asyncio_mode = "auto"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+ignore-var-parameters = true  # ignore missing documentation for *args and **kwargs parameters
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/**/*.py" = [
+    "S101", # Tests need assertions
+    "S311", # Standard pseudo-random generators are not suitable for cryptographic purposes
+]
+"scripts/*.py" = [
+    "INP001",   # Not a package
+]

langchain_cloro-0.1.0/tests/unit_tests/test_tools.py

@@ -0,0 +1,145 @@
+"""Unit tests for Cloro tools."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from langchain_cloro.tools import CloroSearchRun
+
+
+class TestCloroSearchRun:
+    """Test CloroSearchRun tool."""
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_initialization_with_api_key(self, mock_init: MagicMock) -> None:
+        """Test initialization with API key."""
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": MagicMock(),
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+
+        assert tool.name == "cloro_search"
+        assert "Cloro.dev Search API" in tool.description
+        mock_init.assert_called_once()
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_run_success(self, mock_init: MagicMock) -> None:
+        """Test successful search execution."""
+        mock_client = MagicMock()
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"results": [{"title": "Test Result"}]}
+        mock_response.raise_for_status = MagicMock()
+        mock_client.get.return_value = mock_response
+
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": mock_client,
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+        result = tool._run(query="test query", num_results=5)
+
+        # Verify the API call was made correctly
+        mock_client.get.assert_called_once()
+        call_args = mock_client.get.call_args
+        assert call_args[0][0] == "/search"
+        assert "params" in call_args[1]
+        assert call_args[1]["params"]["query"] == "test query"
+        assert call_args[1]["params"]["num_results"] == 5
+
+        # Verify result
+        assert "Test Result" in result
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_run_with_http_error(self, mock_init: MagicMock) -> None:
+        """Test handling of HTTP errors."""
+        import httpx
+
+        mock_client = MagicMock()
+        mock_client.get.side_effect = httpx.HTTPStatusError(
+            "404 Not Found", request=MagicMock(), response=MagicMock()
+        )
+
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": mock_client,
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+        result = tool._run(query="test query")
+
+        assert "Error searching with Cloro" in result
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_run_with_unexpected_error(self, mock_init: MagicMock) -> None:
+        """Test handling of unexpected errors."""
+        mock_client = MagicMock()
+        mock_client.get.side_effect = Exception("Unexpected error")
+
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": mock_client,
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+        result = tool._run(query="test query")
+
+        assert "Unexpected error" in result
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_run_with_additional_params(self, mock_init: MagicMock) -> None:
+        """Test search with additional parameters."""
+        mock_client = MagicMock()
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"results": []}
+        mock_response.raise_for_status = MagicMock()
+        mock_client.get.return_value = mock_response
+
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": mock_client,
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+        result = tool._run(
+            query="test query",
+            num_results=10,
+            domain="example.com",
+            language="en",
+        )
+
+        # Verify additional params were passed
+        call_args = mock_client.get.call_args
+        assert call_args[1]["params"]["domain"] == "example.com"
+        assert call_args[1]["params"]["language"] == "en"
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_default_timeout(self, mock_init: MagicMock) -> None:
+        """Test default timeout is set correctly."""
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": MagicMock(),
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key")
+
+        # Check that initialize_client was called with default timeout
+        mock_init.assert_called_once()
+        call_kwargs = mock_init.call_args[1]
+        assert call_kwargs["timeout"] == 10.0
+
+    @patch("langchain_cloro.tools.initialize_client")
+    def test_custom_timeout(self, mock_init: MagicMock) -> None:
+        """Test custom timeout can be set."""
+        mock_init.return_value = {
+            "cloro_api_key": "test-key",
+            "client": MagicMock(),
+        }
+
+        tool = CloroSearchRun(cloro_api_key="test-api-key", timeout=30.0)
+
+        # Check that initialize_client was called with custom timeout
+        mock_init.assert_called_once()
+        call_kwargs = mock_init.call_args[1]
+        assert call_kwargs["timeout"] == 30.0