content
") + ] + await info.single_fn(["https://example.com"]) + + _, call_kwargs = mock_contents["tool"].api_wrapper.contents_async.call_args + assert call_kwargs.get("formats") == ["html"] + + async def test_cache_returns_same_result(self, mock_contents, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouContentsToolConfig() + builder = MagicMock() + + async with you_contents(config, builder) as info: + mock_contents["tool"].api_wrapper.contents_async.return_value = [ + _make_doc("https://example.com", "Example", "cached content") + ] + out1 = await info.single_fn(["https://example.com"]) + out2 = await info.single_fn(["https://example.com"]) + + assert out1 == out2 + assert mock_contents["tool"].api_wrapper.contents_async.call_count == 1 diff --git a/sources/you_com/tests/test_you_finance_research.py b/sources/you_com/tests/test_you_finance_research.py new file mode 100644 index 000000000..6679c4874 --- /dev/null +++ b/sources/you_com/tests/test_you_finance_research.py @@ -0,0 +1,161 @@ +# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for the you_finance_research NAT tool registration.""" + +import asyncio +from unittest.mock import AsyncMock +from unittest.mock import MagicMock + +import pytest +from pydantic import SecretStr +from you_com.register import ResearchEffort +from you_com.register import YouFinanceResearchToolConfig +from you_com.register import you_finance_research + + +@pytest.fixture +def mock_finance(monkeypatch): + captured = {} + + def factory(**kwargs): + wrapper = MagicMock() + wrapper.finance_text_async = AsyncMock(return_value="## Answer\n\nSome financial insight.\n") + tool = MagicMock(api_wrapper=wrapper) + captured["tool"] = tool + captured["kwargs"] = kwargs + return tool + + monkeypatch.setattr("you_com.register.YouFinanceResearchTool", factory) + return captured + + +class TestYouFinanceResearchToolConfig: + def test_defaults(self): + config = YouFinanceResearchToolConfig() + assert config.research_effort == ResearchEffort.deep + assert config.api_key is None + assert config.max_retries == 3 + assert config.timeout is None + + def test_inherits_from_function_base_config(self): + from nat.data_models.function import FunctionBaseConfig + + assert issubclass(YouFinanceResearchToolConfig, FunctionBaseConfig) + + def test_rejects_lite_effort(self): + with pytest.raises(Exception, match="deep.*exhaustive|exhaustive.*deep"): + YouFinanceResearchToolConfig(research_effort=ResearchEffort.lite) + + def test_rejects_standard_effort(self): + with pytest.raises(Exception, match="deep.*exhaustive|exhaustive.*deep"): + YouFinanceResearchToolConfig(research_effort=ResearchEffort.standard) + + +class TestYouFinanceResearchStub: + async def test_stub_when_no_api_key(self): + config = YouFinanceResearchToolConfig() + builder = MagicMock() + + async with you_finance_research(config, builder) as info: + result = await info.single_fn("anything") + + assert "YDC_API_KEY" in result + assert "unavailable" in result.lower() + + +class TestYouFinanceResearchLive: + async def test_config_api_key_used(self, mock_finance, monkeypatch): + config = YouFinanceResearchToolConfig(api_key=SecretStr("key-from-config")) + builder = MagicMock() + + async with you_finance_research(config, builder) as _: + pass + + assert mock_finance["kwargs"].get("api_wrapper", {}).get("ydc_api_key") == "key-from-config" + + async def test_successful_call_returns_markdown(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouFinanceResearchToolConfig() + builder = MagicMock() + + async with you_finance_research(config, builder) as info: + out = await info.single_fn("What drove NVIDIA revenue growth?") + + assert "Answer" in out + assert "financial insight" in out + + async def test_empty_result_returns_error(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouFinanceResearchToolConfig(max_retries=1) + builder = MagicMock() + + async with you_finance_research(config, builder) as info: + mock_finance["tool"].api_wrapper.finance_text_async.return_value = "" + out = await info.single_fn("q") + + assert "no results" in out.lower() + + async def test_retries_then_succeeds(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouFinanceResearchToolConfig(max_retries=3) + builder = MagicMock() + + async with you_finance_research(config, builder) as info: + mock_finance["tool"].api_wrapper.finance_text_async.side_effect = [ + RuntimeError("transient"), + "## Answer\n\nRecovered.\n", + ] + out = await info.single_fn("q") + + assert "Recovered" in out + assert mock_finance["tool"].api_wrapper.finance_text_async.call_count == 2 + + async def test_401_returns_friendly_message(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouFinanceResearchToolConfig(max_retries=2) + builder = MagicMock() + + async with you_finance_research(config, builder) as info: + mock_finance["tool"].api_wrapper.finance_text_async.side_effect = RuntimeError("401 Unauthorized") + out = await info.single_fn("q") + + assert "401" in out + + async def test_timeout_applied(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouFinanceResearchToolConfig(max_retries=1, timeout=0.001) + builder = MagicMock() + + async def _hang(_): + await asyncio.sleep(10) + + async with you_finance_research(config, builder) as info: + mock_finance["tool"].api_wrapper.finance_text_async.side_effect = _hang + out = await info.single_fn("q") + + assert "error" in out.lower() + + async def test_research_effort_passed_to_tool(self, mock_finance, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouFinanceResearchToolConfig(research_effort=ResearchEffort.exhaustive) + builder = MagicMock() + + async with you_finance_research(config, builder) as _: + pass + + assert mock_finance["kwargs"].get("api_wrapper", {}).get("research_effort") == "exhaustive" diff --git a/sources/you_com/tests/test_you_helpers.py b/sources/you_com/tests/test_you_helpers.py new file mode 100644 index 000000000..75acb733c --- /dev/null +++ b/sources/you_com/tests/test_you_helpers.py @@ -0,0 +1,208 @@ +# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for shared helpers and tool registration smoke tests.""" + +import asyncio +from unittest.mock import AsyncMock + +import pytest +from pydantic import SecretStr +from you_com.register import YouContentsToolConfig +from you_com.register import YouFinanceResearchToolConfig +from you_com.register import YouResearchToolConfig +from you_com.register import YouToolConfig +from you_com.register import YouWebSearchToolConfig +from you_com.register import _make_stub +from you_com.register import _resolve_api_key +from you_com.register import _run_with_retries +from you_com.register import _warn_missing_key_once + + +@pytest.fixture(autouse=True) +def _reset_warn_flag(): + import you_com.register as reg + + reg._missing_key_warned = False + yield + reg._missing_key_warned = False + + +@pytest.fixture(autouse=True) +def _clear_env(monkeypatch): + monkeypatch.delenv("YDC_API_KEY", raising=False) + + +# --------------------------------------------------------------------------- +# Registration smoke tests — guards that all three tools have the right name +# --------------------------------------------------------------------------- + + +class TestRegistrationNames: + def test_web_search_name(self): + assert YouWebSearchToolConfig._typed_model_name == "you_web_search" + + def test_finance_research_name(self): + assert YouFinanceResearchToolConfig._typed_model_name == "you_finance_research" + + def test_research_name(self): + assert YouResearchToolConfig._typed_model_name == "you_research" + + def test_contents_name(self): + assert YouContentsToolConfig._typed_model_name == "you_contents" + + def test_base_config_not_registered(self): + assert YouToolConfig._typed_model_name is None + + +# --------------------------------------------------------------------------- +# _resolve_api_key +# --------------------------------------------------------------------------- + + +class TestResolveApiKey: + def test_returns_env_key_when_no_config_key(self, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "from-env") + config = YouToolConfig() + assert _resolve_api_key(config) == "from-env" + + def test_returns_config_key(self, monkeypatch): + config = YouToolConfig(api_key=SecretStr("from-config")) + assert _resolve_api_key(config) == "from-config" + + def test_config_key_takes_precedence_over_env(self, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "from-env") + config = YouToolConfig(api_key=SecretStr("from-config")) + assert _resolve_api_key(config) == "from-config" + + def test_returns_none_when_no_key(self): + config = YouToolConfig() + assert _resolve_api_key(config) is None + + +# --------------------------------------------------------------------------- +# _warn_missing_key_once +# --------------------------------------------------------------------------- + + +class TestWarnMissingKeyOnce: + def test_warns_only_once(self, caplog): + import logging + + with caplog.at_level(logging.WARNING, logger="you_com.register"): + _warn_missing_key_once("web search") + _warn_missing_key_once("web search") + + assert sum(1 for r in caplog.records if "YDC_API_KEY" in r.message) == 1 + + +# --------------------------------------------------------------------------- +# _make_stub +# --------------------------------------------------------------------------- + + +class TestMakeStub: + async def test_stub_contains_label_and_unavailable(self): + stub = _make_stub("Finance research") + result = await stub.single_fn("anything") + assert "Finance research" in result + assert "unavailable" in result.lower() + assert "YDC_API_KEY" in result + + async def test_stub_different_labels_produce_different_messages(self): + web = _make_stub("Web search") + finance = _make_stub("Finance research") + web_result = await web.single_fn("q") + finance_result = await finance.single_fn("q") + assert "Web search" in web_result + assert "Finance research" in finance_result + assert web_result != finance_result + + +# --------------------------------------------------------------------------- +# _run_with_retries +# --------------------------------------------------------------------------- + + +class TestRunWithRetries: + async def test_success_on_first_attempt(self): + factory = AsyncMock(return_value="ok result") + cache: dict = {} + out = await _run_with_retries("T", factory, "q", max_retries=3, timeout=None, cache=cache) + assert out == "ok result" + assert cache["q"] == "ok result" + + async def test_cache_hit_skips_factory(self): + factory = AsyncMock(return_value="fresh") + cache = {"q": "cached"} + out = await _run_with_retries("T", factory, "q", max_retries=3, timeout=None, cache=cache) + assert out == "cached" + factory.assert_not_called() + + async def test_retries_on_transient_error(self, monkeypatch): + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + factory = AsyncMock(side_effect=[RuntimeError("transient"), "recovered"]) + cache: dict = {} + out = await _run_with_retries("T", factory, "q", max_retries=3, timeout=None, cache=cache) + assert out == "recovered" + assert factory.call_count == 2 + + async def test_exhausted_retries_returns_error_string(self, monkeypatch): + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + factory = AsyncMock(side_effect=RuntimeError("boom")) + cache: dict = {} + out = await _run_with_retries("T", factory, "q", max_retries=2, timeout=None, cache=cache) + assert "error" in out.lower() + assert "boom" in out + + async def test_empty_result_returns_no_results_message(self, monkeypatch): + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + factory = AsyncMock(return_value="") + cache: dict = {} + out = await _run_with_retries("T", factory, "q", max_retries=1, timeout=None, cache=cache) + assert "no results" in out.lower() + assert out.startswith("Error: ") + + async def test_401_returns_friendly_message(self, monkeypatch): + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + factory = AsyncMock(side_effect=RuntimeError("401 Unauthorized")) + cache: dict = {} + out = await _run_with_retries("T", factory, "q", max_retries=1, timeout=None, cache=cache) + assert "401" in out + + async def test_timeout_applied(self): + async def _hang(_q): + await asyncio.sleep(10) + + cache: dict = {} + out = await _run_with_retries("T", _hang, "q", max_retries=1, timeout=0.001, cache=cache) + assert "error" in out.lower() + + async def test_cache_evicts_oldest_when_full(self, monkeypatch): + from you_com import register as reg + + original = reg._CACHE_MAX_SIZE + monkeypatch.setattr(reg, "_CACHE_MAX_SIZE", 2) + try: + factory = AsyncMock(side_effect=["r1", "r2", "r3"]) + cache: dict = {} + await _run_with_retries("T", factory, "q1", max_retries=1, timeout=None, cache=cache) + await _run_with_retries("T", factory, "q2", max_retries=1, timeout=None, cache=cache) + await _run_with_retries("T", factory, "q3", max_retries=1, timeout=None, cache=cache) + assert "q1" not in cache + assert "q2" in cache + assert "q3" in cache + finally: + monkeypatch.setattr(reg, "_CACHE_MAX_SIZE", original) diff --git a/sources/you_com/tests/test_you_research.py b/sources/you_com/tests/test_you_research.py new file mode 100644 index 000000000..82ac27c7b --- /dev/null +++ b/sources/you_com/tests/test_you_research.py @@ -0,0 +1,167 @@ +# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for the you_research NAT tool registration.""" + +import asyncio +from unittest.mock import AsyncMock +from unittest.mock import MagicMock + +import pytest +from pydantic import SecretStr +from you_com.register import ResearchEffort +from you_com.register import YouResearchToolConfig +from you_com.register import you_research + + +@pytest.fixture +def mock_research(monkeypatch): + captured = {} + + def factory(**kwargs): + wrapper = MagicMock() + wrapper.research_text_async = AsyncMock( + return_value="## Answer\n\nSome research findings.\n\n[1] [Source Title](https://example.com)\n" + ) + tool = MagicMock(api_wrapper=wrapper) + captured["tool"] = tool + captured["kwargs"] = kwargs + return tool + + monkeypatch.setattr("you_com.register.YouResearchTool", factory) + return captured + + +class TestYouResearchToolConfig: + def test_defaults(self): + config = YouResearchToolConfig() + assert config.research_effort == ResearchEffort.standard + assert config.api_key is None + assert config.max_retries == 3 + assert config.timeout is None + + def test_inherits_from_function_base_config(self): + from nat.data_models.function import FunctionBaseConfig + + assert issubclass(YouResearchToolConfig, FunctionBaseConfig) + + +class TestYouResearchStub: + async def test_stub_when_no_api_key(self): + config = YouResearchToolConfig() + builder = MagicMock() + + async with you_research(config, builder) as info: + result = await info.single_fn("anything") + + assert "YDC_API_KEY" in result + assert "unavailable" in result.lower() + + +class TestYouResearchLive: + async def test_config_api_key_used(self, mock_research, monkeypatch): + config = YouResearchToolConfig(api_key=SecretStr("key-from-config")) + builder = MagicMock() + + async with you_research(config, builder) as _: + pass + + assert mock_research["kwargs"].get("api_wrapper", {}).get("ydc_api_key") == "key-from-config" + + async def test_successful_call_returns_markdown(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouResearchToolConfig() + builder = MagicMock() + + async with you_research(config, builder) as info: + out = await info.single_fn("What is quantum computing?") + + assert "Answer" in out + assert "research findings" in out + + async def test_empty_result_returns_error(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouResearchToolConfig(max_retries=1) + builder = MagicMock() + + async with you_research(config, builder) as info: + mock_research["tool"].api_wrapper.research_text_async.return_value = "" + out = await info.single_fn("q") + + assert "no results" in out.lower() + + async def test_retries_then_succeeds(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouResearchToolConfig(max_retries=3) + builder = MagicMock() + + async with you_research(config, builder) as info: + mock_research["tool"].api_wrapper.research_text_async.side_effect = [ + RuntimeError("transient"), + "## Answer\n\nRecovered.\n", + ] + out = await info.single_fn("q") + + assert "Recovered" in out + assert mock_research["tool"].api_wrapper.research_text_async.call_count == 2 + + async def test_401_returns_friendly_message(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouResearchToolConfig(max_retries=2) + builder = MagicMock() + + async with you_research(config, builder) as info: + mock_research["tool"].api_wrapper.research_text_async.side_effect = RuntimeError("401 Unauthorized") + out = await info.single_fn("q") + + assert "401" in out + + async def test_timeout_applied(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouResearchToolConfig(max_retries=1, timeout=0.001) + builder = MagicMock() + + async def _hang(_): + await asyncio.sleep(10) + + async with you_research(config, builder) as info: + mock_research["tool"].api_wrapper.research_text_async.side_effect = _hang + out = await info.single_fn("q") + + assert "error" in out.lower() + + async def test_research_effort_passed_to_tool(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouResearchToolConfig(research_effort=ResearchEffort.deep) + builder = MagicMock() + + async with you_research(config, builder) as _: + pass + + assert mock_research["kwargs"].get("api_wrapper", {}).get("research_effort") == "deep" + + async def test_cache_returns_same_result(self, mock_research, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouResearchToolConfig() + builder = MagicMock() + + async with you_research(config, builder) as info: + out1 = await info.single_fn("cached question") + out2 = await info.single_fn("cached question") + + assert out1 == out2 + assert mock_research["tool"].api_wrapper.research_text_async.call_count == 1 diff --git a/sources/you_com/tests/test_you_web_search.py b/sources/you_com/tests/test_you_web_search.py new file mode 100644 index 000000000..c6ba4406a --- /dev/null +++ b/sources/you_com/tests/test_you_web_search.py @@ -0,0 +1,231 @@ +# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for the you_web_search NAT tool registration.""" + +import asyncio +from types import SimpleNamespace +from unittest.mock import AsyncMock +from unittest.mock import MagicMock + +import pytest +from pydantic import SecretStr +from you_com.register import FreshnessMode +from you_com.register import YouWebSearchToolConfig +from you_com.register import you_web_search + + +def _make_doc(title="Title", url="https://example.com", description="", page_content="content", source=None): + metadata = {"title": title, "url": url, "description": description} + if source: + metadata["source"] = source + return SimpleNamespace(metadata=metadata, page_content=page_content) + + +@pytest.fixture +def mock_search(monkeypatch): + captured = {} + + def factory(api_wrapper): + wrapper = MagicMock() + wrapper.results_async = AsyncMock(return_value=[]) + tool = MagicMock(api_wrapper=wrapper) + captured["tool"] = tool + captured["kwargs"] = api_wrapper + return tool + + monkeypatch.setattr("you_com.register.YouSearchTool", factory) + return captured + + +class TestYouWebSearchToolConfig: + def test_defaults(self): + config = YouWebSearchToolConfig() + assert config.max_results == 10 + assert config.api_key is None + assert config.max_retries == 3 + assert config.safesearch.value == "moderate" + assert config.livecrawl_mode.value == "web" + assert config.livecrawl_format.value == "markdown" + assert config.freshness == FreshnessMode.off + assert config.max_content_length == 50000 + assert config.include_news_results is False + assert config.timeout is None + + def test_inherits_from_function_base_config(self): + from nat.data_models.function import FunctionBaseConfig + + assert issubclass(YouWebSearchToolConfig, FunctionBaseConfig) + + +class TestYouWebSearchStub: + async def test_stub_when_no_api_key(self): + config = YouWebSearchToolConfig() + builder = MagicMock() + + async with you_web_search(config, builder) as info: + result = await info.single_fn("anything") + + assert "YDC_API_KEY" in result + assert "unavailable" in result.lower() + + +class TestYouWebSearchLive: + async def test_config_api_key_used(self, mock_search, monkeypatch): + config = YouWebSearchToolConfig(api_key=SecretStr("key-from-config")) + builder = MagicMock() + + async with you_web_search(config, builder) as _: + pass + + assert mock_search["kwargs"].get("ydc_api_key") == "key-from-config" + + async def test_successful_search_formats_documents(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(max_results=2) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [ + _make_doc("Title A", "https://a.example", page_content="Body A"), + _make_doc("Title B", "https://b.example", page_content="Body B"), + ] + out = await info.single_fn("query") + + assert "Title A" in out + assert "Title B" in out + assert "Body A" in out + assert "Body B" in out + assert "---" in out + + async def test_max_content_length_truncates(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(max_content_length=5) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [ + _make_doc(page_content="abcdefghijklmnop"), + ] + out = await info.single_fn("q") + + assert "abcde" in out + assert "abcdefgh" not in out + + async def test_default_bounds_oversized_livecrawl_content(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(max_results=10) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [ + _make_doc(page_content="x" * 200_000) for _ in range(10) + ] + out = await info.single_fn("q") + + assert len(out) <= 10 * 50000 + 10_000 + + async def test_news_source_filtered_by_default(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(include_news_results=False) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [ + _make_doc("Web", "https://web.example", page_content="web body"), + _make_doc("News", "https://news.example", page_content="news body", source="news"), + ] + out = await info.single_fn("q") + + assert "https://web.example" in out + assert "https://news.example" not in out + + async def test_include_news_results_keeps_news(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(include_news_results=True) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [ + _make_doc("Web", "https://web.example", page_content="web body"), + _make_doc("News", "https://news.example", page_content="news body", source="news"), + ] + out = await info.single_fn("q") + + assert "https://web.example" in out + assert "https://news.example" in out + + async def test_empty_results_returns_error(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(max_retries=1) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.return_value = [] + out = await info.single_fn("q") + + assert "no results" in out.lower() + + async def test_retries_then_succeeds(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouWebSearchToolConfig(max_retries=3) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.side_effect = [ + RuntimeError("transient"), + [_make_doc("T", "https://a.example", page_content="ok")], + ] + out = await info.single_fn("q") + + assert "ok" in out + assert mock_search["tool"].api_wrapper.results_async.call_count == 2 + + async def test_401_returns_friendly_message(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + monkeypatch.setattr("you_com.register.asyncio.sleep", AsyncMock()) + config = YouWebSearchToolConfig(max_retries=2) + builder = MagicMock() + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.side_effect = RuntimeError("401 Unauthorized") + out = await info.single_fn("q") + + assert "401" in out + + async def test_wrapper_kwargs_exclude_none_freshness(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig() # freshness=off → mapped to None before request + builder = MagicMock() + + async with you_web_search(config, builder) as _: + pass + + assert "freshness" not in mock_search["kwargs"] + + async def test_timeout_applied(self, mock_search, monkeypatch): + monkeypatch.setenv("YDC_API_KEY", "test-key") + config = YouWebSearchToolConfig(max_retries=1, timeout=0.001) + builder = MagicMock() + + async def _hang(_): + await asyncio.sleep(10) + + async with you_web_search(config, builder) as info: + mock_search["tool"].api_wrapper.results_async.side_effect = _hang + out = await info.single_fn("q") + + assert "error" in out.lower() diff --git a/uv.lock b/uv.lock index ee6196c52..e5e151a29 100644 --- a/uv.lock +++ b/uv.lock @@ -24,6 +24,7 @@ members = [ "knowledge-layer", "polymarket-prediction-market", "tavily-web-search", + "you-com", ] overrides = [ { name = "authlib", specifier = ">=1.6.11,<2" }, @@ -266,6 +267,7 @@ dev = [ { name = "ruff" }, { name = "tavily-web-search" }, { name = "yapf" }, + { name = "you-com" }, ] [package.metadata] @@ -330,6 +332,7 @@ dev = [ { name = "ruff", specifier = "~=0.15.1" }, { name = "tavily-web-search", editable = "sources/tavily_web_search" }, { name = "yapf", specifier = ">=0.40.0" }, + { name = "you-com", editable = "sources/you_com" }, ] [[package]] @@ -2931,6 +2934,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d3/26/1ef06f56198d631296d646a6223de35bcc6cf9795ceb2442816bc963b84c/langchain_text_splitters-1.1.2-py3-none-any.whl", hash = "sha256:a2de0d799ff31886429fd6e2e0032df275b60ec817c19059a7b46181cc1c2f10", size = 35903, upload-time = "2026-04-16T14:20:38.243Z" }, ] +[[package]] +name = "langchain-youdotcom" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "langchain-core" }, + { name = "youdotcom" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/9e/4d6fe20f509f04b245502b0816b2282232b4ef4ade14d98ec2d79b1869a4/langchain_youdotcom-0.3.1.tar.gz", hash = "sha256:dd0ad3358ad3590c0fffe673d0de173ce6d0e7930792893f0c5a5019b0b042b4", size = 104026, upload-time = "2026-06-12T22:04:28.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/e7/5e772c2ca51cf4fbe9d3dc606faae8f2024b3c08243f2d664b445ae6aff6/langchain_youdotcom-0.3.1-py3-none-any.whl", hash = "sha256:b76a01bdb2e7668ef3649370a625eeedd65a34a8fd68fbb997c74fd0d232b518", size = 12515, upload-time = "2026-06-12T22:04:29.299Z" }, +] + [[package]] name = "langgraph" version = "1.2.8" @@ -7278,6 +7294,37 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/4d/4b880086bd0d3e034d25647be1d830afc3e3f610e98c4ab3490af6b1b6d5/yarl-1.24.2-py3-none-any.whl", hash = "sha256:2783d9226db8797636cd6896e4de81feed252d1db72265686c9558d97a4d94b9", size = 53576, upload-time = "2026-05-19T21:31:03.909Z" }, ] +[[package]] +name = "you-com" +version = "1.0.0" +source = { editable = "sources/you_com" } +dependencies = [ + { name = "httpx" }, + { name = "langchain-youdotcom" }, + { name = "pydantic" }, +] + +[package.metadata] +requires-dist = [ + { name = "httpx", specifier = ">=0.24.0" }, + { name = "langchain-youdotcom", specifier = ">=0.3.1" }, + { name = "pydantic", specifier = ">=2.0.0" }, +] + +[[package]] +name = "youdotcom" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpcore" }, + { name = "httpx" }, + { name = "pydantic" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3c/6b/1d3dd77f5968086d1606972697074ddd07b72abcb514c38a39feda77031f/youdotcom-2.3.0.tar.gz", hash = "sha256:f35e4ba53bb7f235100e7b7fcccfdcb84e9a08c85bb053d4e6c76bf29ecc7547", size = 71806, upload-time = "2026-03-04T03:21:11.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/0c/a57beaa961914c9014ee7ffc16697844874e4a7910848f11a55b45b58619/youdotcom-2.3.0-py3-none-any.whl", hash = "sha256:5750d0bcc88cf666b88e36e116c9775607db5d3491a02afad219eb9d4ec97eb0", size = 89388, upload-time = "2026-03-04T03:21:09.308Z" }, +] + [[package]] name = "zict" version = "3.0.0"