langchain-fxmacrodata 0.1.0__tar.gz

langchain_fxmacrodata-0.1.0/LICENSE

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

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: langchain-fxmacrodata
+Version: 0.1.0
+Summary: LangChain and LangGraph tools for the public FXMacroData API
+License-Expression: MIT
+Project-URL: Documentation, https://fxmacrodata.com/docs?utm_source=pypi&utm_medium=referral&utm_campaign=langchain-fxmacrodata&utm_content=package
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core==1.7.3
+Provides-Extra: langgraph
+Requires-Dist: langgraph==1.2.19; extra == "langgraph"
+Dynamic: license-file
+
+# FXMacroData tools for LangChain
+
+`langchain-fxmacrodata` is a standalone package that gives a LangChain agent the public FXMacroData API.
+
+USD catalogue, USD macro history and the USD release calendar work with no API key and no account. For other data, set `FXMACRODATA_API_KEY` in the environment. The package sends that value as the `X-API-Key` header. A key is not a tool argument and is not written into the URL.
+
+```python
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+catalogue = next(tool for tool in tools if tool.name == "fxmacrodata_data_catalogue_currency")
+print(catalogue.invoke({"currency": "USD"}))
+```
+
+## LangGraph
+
+The same tools work in a LangGraph agent. Install the extra with `pip install "langchain-fxmacrodata[langgraph]"`, then pass the tools to a `ToolNode` and bind them to any chat model that supports tool calling:
+
+```python
+from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+model = chat_model.bind_tools(tools)  # your LangChain chat model
+
+
+def agent(state: MessagesState):
+    return {"messages": [model.invoke(state["messages"])]}
+
+
+graph = StateGraph(MessagesState)
+graph.add_node("agent", agent)
+graph.add_node("tools", ToolNode(tools))
+graph.add_edge(START, "agent")
+graph.add_conditional_edges("agent", tools_condition)
+graph.add_edge("tools", "agent")
+app = graph.compile()
+
+app.invoke({"messages": [("user", "What USD indicators does FXMacroData cover?")]})
+```
+
+To keep a model's tool list short, pass only the tools you need, for example `[tool for tool in tools if tool.name.startswith("fxmacrodata_calendar")]`.
+
+## Behaviour
+
+Each tool calls one public GET route and returns the response body. A non-200 response comes back as JSON with `status` and `body`. This package does not call `POST /v1/research/panel`. The event tool can send `Last-Event-ID` and returns one response.
+
+Requests go only to `https://api.fxmacrodata.com`.
+
+Documentation: https://fxmacrodata.com/docs?utm_source=langchain&utm_medium=integration&utm_campaign=langchain-fxmacrodata&utm_content=readme-docs

langchain_fxmacrodata-0.1.0/README.md

@@ -0,0 +1,52 @@
+# FXMacroData tools for LangChain
+
+`langchain-fxmacrodata` is a standalone package that gives a LangChain agent the public FXMacroData API.
+
+USD catalogue, USD macro history and the USD release calendar work with no API key and no account. For other data, set `FXMACRODATA_API_KEY` in the environment. The package sends that value as the `X-API-Key` header. A key is not a tool argument and is not written into the URL.
+
+```python
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+catalogue = next(tool for tool in tools if tool.name == "fxmacrodata_data_catalogue_currency")
+print(catalogue.invoke({"currency": "USD"}))
+```
+
+## LangGraph
+
+The same tools work in a LangGraph agent. Install the extra with `pip install "langchain-fxmacrodata[langgraph]"`, then pass the tools to a `ToolNode` and bind them to any chat model that supports tool calling:
+
+```python
+from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+model = chat_model.bind_tools(tools)  # your LangChain chat model
+
+
+def agent(state: MessagesState):
+    return {"messages": [model.invoke(state["messages"])]}
+
+
+graph = StateGraph(MessagesState)
+graph.add_node("agent", agent)
+graph.add_node("tools", ToolNode(tools))
+graph.add_edge(START, "agent")
+graph.add_conditional_edges("agent", tools_condition)
+graph.add_edge("tools", "agent")
+app = graph.compile()
+
+app.invoke({"messages": [("user", "What USD indicators does FXMacroData cover?")]})
+```
+
+To keep a model's tool list short, pass only the tools you need, for example `[tool for tool in tools if tool.name.startswith("fxmacrodata_calendar")]`.
+
+## Behaviour
+
+Each tool calls one public GET route and returns the response body. A non-200 response comes back as JSON with `status` and `body`. This package does not call `POST /v1/research/panel`. The event tool can send `Last-Event-ID` and returns one response.
+
+Requests go only to `https://api.fxmacrodata.com`.
+
+Documentation: https://fxmacrodata.com/docs?utm_source=langchain&utm_medium=integration&utm_campaign=langchain-fxmacrodata&utm_content=readme-docs

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata/__init__.py

@@ -0,0 +1,5 @@
+"""FXMacroData tools for LangChain."""
+
+from langchain_fxmacrodata.tools import fxmacrodata_tools
+
+__all__ = ["fxmacrodata_tools"]

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata/client.py

@@ -0,0 +1,161 @@
+"""Public FXMacroData HTTP requests. No third-party client."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+
+API_ORIGIN = "https://api.fxmacrodata.com"
+MAX_BODY = 2_000_000
+
+# method, OpenAPI path, query names. Path fields are the {placeholders}.
+OPERATIONS: tuple[tuple[str, str, str], ...] = (
+    ("GET", "/v1/announcements/changes", "currencies indicators since limit payload strict_cursor"),
+    ("GET", "/v1/announcements/{currency}/latest", ""),
+    ("GET", "/v1/announcements/{currency}/{indicator}", "start_date end_date series_mode limit offset page seasonality frequency annualization period_aggregation revisions basis base official_only fields as_of availability dataset_version value_mode"),
+    ("GET", "/v1/calendar/{currency}", "indicator start_date end_date timezone"),
+    ("GET", "/v1/calendar/{currency}/coverage", "start_date end_date as_of"),
+    ("GET", "/v1/calendar/{currency}/events/{archive_event_id}/versions", "checkpoint cursor limit"),
+    ("GET", "/v1/calendar/{currency}/snapshot", "as_of start_date end_date importance event_kind knowledge_mode checkpoint cursor limit"),
+    ("GET", "/v1/commodities/latest", ""),
+    ("GET", "/v1/commodities/{indicator}", "start_date end_date limit offset page"),
+    ("GET", "/v1/cot/{currency}", "start_date end_date limit offset page report"),
+    ("GET", "/v1/curves/{currency}", "curve_family metric view method date as_of availability max_staleness_days require_common_date"),
+    ("GET", "/v1/data_catalogue/{currency}", "include_capabilities include_coverage include_analytics indicator"),
+    ("GET", "/v1/factors/{currency}/{factor}", "start_date end_date include_components include_sources limit offset"),
+    ("GET", "/v1/financial_prices/{currency}", "source start_date end_date measure instrument_id issuer limit offset"),
+    ("GET", "/v1/forex/{base}/{quote}", "start_date end_date limit offset page indicators dataset_version"),
+    ("GET", "/v1/fx/intraday-reference-rates/{base}/{quote}", "start_time end_time"),
+    ("GET", "/v1/fx/reference-rates/{base}/{quote}", "date start_date end_date source timestamp_type native_only include_source_legs order limit offset page dataset_version"),
+    ("GET", "/v1/fx/session-rates/{base}/{quote}", "session date start_date end_date order limit offset page dataset_version"),
+    ("GET", "/v1/fx/source-universe", "currency source"),
+    ("GET", "/v1/fx/sources", ""),
+    ("GET", "/v1/health", ""),
+    ("GET", "/v1/market_sessions", "at"),
+    ("GET", "/v1/native", ""),
+    ("GET", "/v1/native/{source}", "year measure holder_country_code ownership_basis maturity account_type region product limit offset order"),
+    ("GET", "/v1/organisations", "q category limit"),
+    ("GET", "/v1/organisations/{slug}", ""),
+    ("GET", "/v1/ping", ""),
+    ("GET", "/v1/positioning", ""),
+    ("GET", "/v1/positioning/{instrument}", "report start_date end_date limit offset"),
+    ("GET", "/v1/predictions/coverage", ""),
+    ("GET", "/v1/predictions/coverage/{currency}", ""),
+    ("GET", "/v1/predictions/{currency}", "prediction_source prediction_class statistic respondent_population start_date end_date variable target_period publication_precision before_id limit"),
+    ("GET", "/v1/predictions/{currency}/{indicator}", "prediction_class prediction_type prediction_source official_limit pre_release_only seasonality frequency annualization period_aggregation basis start_date end_date limit offset page before_date as_of event_compatible_only"),
+    ("GET", "/v1/press-releases/{currency}", "limit offset"),
+    ("GET", "/v1/rate_differentials/{base}/{quote}", "measure rate_type curve_family start_tenor_years end_tenor_years start_date end_date limit offset as_of availability"),
+    ("POST", "/v1/research/panel", ""),
+    ("GET", "/v1/risk_sentiment", "start_date end_date limit offset"),
+    ("GET", "/v1/risk_sentiment/changes", "after_sequence limit"),
+    ("GET", "/v1/settlement/contracts", ""),
+    ("GET", "/v1/settlement/contracts/{contract_id}", "period strike comparison currency"),
+    ("GET", "/v1/settlement/keys", ""),
+    ("GET", "/v1/settlement/{currency}/{indicator}", "period announcement_id strike comparison decimals"),
+    ("GET", "/v1/stream/events", "currencies indicators payload live_only max_age_ms"),
+)
+
+
+class FXMacroDataError(RuntimeError):
+    pass
+
+
+def path_fields(template: str) -> tuple[str, ...]:
+    fields = []
+    start = 0
+    while True:
+        left = template.find("{", start)
+        if left < 0:
+            return tuple(fields)
+        right = template.find("}", left)
+        if right < 0:
+            raise FXMacroDataError("broken path template")
+        fields.append(template[left + 1 : right])
+        start = right + 1
+
+
+def build_url(template: str, query_names: str, values: dict[str, str], origin: str = API_ORIGIN) -> str:
+    parsed = urllib.parse.urlsplit(origin)
+    if parsed.scheme != "https" or parsed.netloc != "api.fxmacrodata.com" or parsed.path not in {"", "/"}:
+        raise FXMacroDataError("requests stay on https://api.fxmacrodata.com")
+    path = template
+    for name in path_fields(template):
+        value = values.get(name, "")
+        if not value:
+            raise FXMacroDataError(f"missing {name}")
+        path = path.replace("{" + name + "}", urllib.parse.quote(value, safe=""))
+    if "{" in path or "}" in path:
+        raise FXMacroDataError("unfilled path")
+    query = []
+    for name in query_names.split():
+        value = values.get(name, "")
+        if value:
+            query.append((name, value))
+    return urllib.parse.urlunsplit(("https", "api.fxmacrodata.com", path, urllib.parse.urlencode(query), ""))
+
+
+def _opener() -> urllib.request.OpenerDirector:
+    class _NoRedirect(urllib.request.HTTPRedirectHandler):
+        def redirect_request(self, req, fp, code, msg, headers, newurl):  # noqa: ANN001
+            raise FXMacroDataError("redirect refused")
+
+    return urllib.request.build_opener(_NoRedirect)
+
+
+def request(
+    method: str,
+    url: str,
+    api_key: str | None = None,
+    timeout: float = 30,
+    extra_headers: dict[str, str] | None = None,
+) -> tuple[int, str]:
+    parsed = urllib.parse.urlsplit(url)
+    if parsed.scheme != "https" or parsed.netloc != "api.fxmacrodata.com":
+        raise FXMacroDataError("requests stay on https://api.fxmacrodata.com")
+    if method != "GET":
+        raise FXMacroDataError("this client sends GET requests only")
+    headers = {"Accept": "application/json", "User-Agent": "langchain-fxmacrodata/0.1"}
+    for name, value in (extra_headers or {}).items():
+        if name.lower() in {"x-api-key", "authorization", "host"}:
+            raise FXMacroDataError("that header is reserved")
+        if value:
+            headers[name] = value
+    if api_key:
+        headers["X-API-Key"] = api_key
+    call = urllib.request.Request(url, headers=headers, method="GET")
+    try:
+        with _opener().open(call, timeout=timeout) as response:
+            status = getattr(response, "status", 200)
+            body = response.read(MAX_BODY + 1)
+    except urllib.error.HTTPError as exc:
+        status = exc.code
+        body = exc.read(MAX_BODY + 1)
+    except FXMacroDataError:
+        raise
+    except urllib.error.URLError as exc:
+        raise FXMacroDataError("request failed") from exc
+    if len(body) > MAX_BODY:
+        raise FXMacroDataError("response exceeds 2 MB")
+    return status, body.decode("utf-8")
+
+
+def call_operation(template: str, query_names: str, values: dict[str, str], transport=None) -> str:
+    if template == "/v1/research/panel":
+        raise FXMacroDataError("the research panel needs a JSON body and is not a GET")
+    url = build_url(template, query_names, values)
+    key = os.environ.get("FXMACRODATA_API_KEY", "").strip() or None
+    if "api_key=" in url:
+        raise FXMacroDataError("API key must not be placed in the URL")
+    extra = {}
+    if template == "/v1/stream/events" and values.get("last_event_id"):
+        extra["Last-Event-ID"] = values["last_event_id"]
+    if transport is None:
+        status, body = request("GET", url, key, extra_headers=extra)
+    else:
+        status, body = transport("GET", url, key)
+    if status == 200:
+        return body
+    return json.dumps({"status": status, "body": body}, ensure_ascii=False)

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata/tools.py

@@ -0,0 +1,53 @@
+"""LangChain tools for the public FXMacroData API."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from langchain_core.tools import StructuredTool
+from pydantic import create_model
+
+from langchain_fxmacrodata.client import OPERATIONS, call_operation, path_fields
+
+Transport = Callable[[str, str, str | None], tuple[int, str]]
+
+
+def tool_name(template: str) -> str:
+    parts = []
+    for part in template.strip("/").split("/"):
+        parts.append(part[1:-1] if part.startswith("{") and part.endswith("}") else part)
+    return "fxmacrodata_" + "_".join(parts[1:])
+
+
+def fxmacrodata_tools(transport: Transport | None = None) -> list[StructuredTool]:
+    """One LangChain tool for every public REST operation this client can send."""
+    tools = []
+    for method, template, query_names in OPERATIONS:
+        if method != "GET":
+            continue
+        fields = {name: (str, ...) for name in path_fields(template)}
+        for name in query_names.split():
+            fields[name] = (str, "")
+        if template == "/v1/stream/events":
+            fields["last_event_id"] = (str, "")
+        schema = create_model(tool_name(template) + "_args", **fields)
+        description = (
+            f"Read FXMacroData {method} {template}. "
+            "USD catalogue, USD macro history and the USD release calendar work with no API key. "
+            "An optional FXMACRODATA_API_KEY is sent as a header for protected data. "
+            "The response body is returned unchanged."
+        )
+
+        def run(_template=template, _query=query_names, **kwargs: str) -> str:
+            return call_operation(_template, _query, kwargs, transport)
+
+        tools.append(
+            StructuredTool.from_function(
+                func=run,
+                name=tool_name(template),
+                description=description,
+                args_schema=schema,
+                infer_schema=False,
+            )
+        )
+    return tools

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: langchain-fxmacrodata
+Version: 0.1.0
+Summary: LangChain and LangGraph tools for the public FXMacroData API
+License-Expression: MIT
+Project-URL: Documentation, https://fxmacrodata.com/docs?utm_source=pypi&utm_medium=referral&utm_campaign=langchain-fxmacrodata&utm_content=package
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core==1.7.3
+Provides-Extra: langgraph
+Requires-Dist: langgraph==1.2.19; extra == "langgraph"
+Dynamic: license-file
+
+# FXMacroData tools for LangChain
+
+`langchain-fxmacrodata` is a standalone package that gives a LangChain agent the public FXMacroData API.
+
+USD catalogue, USD macro history and the USD release calendar work with no API key and no account. For other data, set `FXMACRODATA_API_KEY` in the environment. The package sends that value as the `X-API-Key` header. A key is not a tool argument and is not written into the URL.
+
+```python
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+catalogue = next(tool for tool in tools if tool.name == "fxmacrodata_data_catalogue_currency")
+print(catalogue.invoke({"currency": "USD"}))
+```
+
+## LangGraph
+
+The same tools work in a LangGraph agent. Install the extra with `pip install "langchain-fxmacrodata[langgraph]"`, then pass the tools to a `ToolNode` and bind them to any chat model that supports tool calling:
+
+```python
+from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from langchain_fxmacrodata import fxmacrodata_tools
+
+tools = fxmacrodata_tools()
+model = chat_model.bind_tools(tools)  # your LangChain chat model
+
+
+def agent(state: MessagesState):
+    return {"messages": [model.invoke(state["messages"])]}
+
+
+graph = StateGraph(MessagesState)
+graph.add_node("agent", agent)
+graph.add_node("tools", ToolNode(tools))
+graph.add_edge(START, "agent")
+graph.add_conditional_edges("agent", tools_condition)
+graph.add_edge("tools", "agent")
+app = graph.compile()
+
+app.invoke({"messages": [("user", "What USD indicators does FXMacroData cover?")]})
+```
+
+To keep a model's tool list short, pass only the tools you need, for example `[tool for tool in tools if tool.name.startswith("fxmacrodata_calendar")]`.
+
+## Behaviour
+
+Each tool calls one public GET route and returns the response body. A non-200 response comes back as JSON with `status` and `body`. This package does not call `POST /v1/research/panel`. The event tool can send `Last-Event-ID` and returns one response.
+
+Requests go only to `https://api.fxmacrodata.com`.
+
+Documentation: https://fxmacrodata.com/docs?utm_source=langchain&utm_medium=integration&utm_campaign=langchain-fxmacrodata&utm_content=readme-docs

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_fxmacrodata/__init__.py
+langchain_fxmacrodata/client.py
+langchain_fxmacrodata/tools.py
+langchain_fxmacrodata.egg-info/PKG-INFO
+langchain_fxmacrodata.egg-info/SOURCES.txt
+langchain_fxmacrodata.egg-info/dependency_links.txt
+langchain_fxmacrodata.egg-info/requires.txt
+langchain_fxmacrodata.egg-info/top_level.txt
+tests/test_langgraph.py
+tests/test_tools.py

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata.egg-info/requires.txt

@@ -0,0 +1,4 @@
+langchain-core==1.7.3
+
+[langgraph]
+langgraph==1.2.19

langchain_fxmacrodata-0.1.0/langchain_fxmacrodata.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_fxmacrodata

langchain_fxmacrodata-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools==84.2.1", "wheel==0.48.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-fxmacrodata"
+version = "0.1.0"
+description = "LangChain and LangGraph tools for the public FXMacroData API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["langchain-core==1.7.3"]
+
+[project.optional-dependencies]
+langgraph = ["langgraph==1.2.19"]
+
+[project.urls]
+Documentation = "https://fxmacrodata.com/docs?utm_source=pypi&utm_medium=referral&utm_campaign=langchain-fxmacrodata&utm_content=package"
+
+[tool.setuptools]
+packages = ["langchain_fxmacrodata"]
+include-package-data = false

langchain_fxmacrodata-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_fxmacrodata-0.1.0/tests/test_langgraph.py

@@ -0,0 +1,55 @@
+import json
+import unittest
+
+try:
+    from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+    from langgraph.graph import START, MessagesState, StateGraph
+    from langgraph.prebuilt import ToolNode, tools_condition
+except ImportError:  # the langgraph extra is optional
+    StateGraph = None
+
+from langchain_fxmacrodata import fxmacrodata_tools
+
+
+@unittest.skipIf(StateGraph is None, "install the langgraph extra")
+class LangGraphTests(unittest.TestCase):
+    def test_tool_node_runs_a_tool_call_and_returns_the_body(self) -> None:
+        body = '{"currency":"USD","indicators":[]}'
+        seen = []
+
+        def transport(method, url, key):
+            seen.append((method, url, key))
+            return 200, body
+
+        tools = fxmacrodata_tools(transport=transport)
+
+        def agent(state):
+            # Stands in for a chat model bound with the tools: one tool call, then an answer.
+            if not any(isinstance(message, ToolMessage) for message in state["messages"]):
+                call = {
+                    "name": "fxmacrodata_data_catalogue_currency",
+                    "args": {"currency": "USD"},
+                    "id": "call-1",
+                    "type": "tool_call",
+                }
+                return {"messages": [AIMessage(content="", tool_calls=[call])]}
+            return {"messages": [AIMessage(content="done")]}
+
+        graph = StateGraph(MessagesState)
+        graph.add_node("agent", agent)
+        graph.add_node("tools", ToolNode(tools))
+        graph.add_edge(START, "agent")
+        graph.add_conditional_edges("agent", tools_condition)
+        graph.add_edge("tools", "agent")
+        result = graph.compile().invoke({"messages": [HumanMessage(content="What USD data is there?")]})
+
+        tool_messages = [message for message in result["messages"] if isinstance(message, ToolMessage)]
+        self.assertEqual(len(tool_messages), 1)
+        self.assertEqual(tool_messages[0].content, body)
+        self.assertEqual(json.loads(tool_messages[0].content)["currency"], "USD")
+        self.assertEqual(result["messages"][-1].content, "done")
+        self.assertEqual(seen, [("GET", "https://api.fxmacrodata.com/v1/data_catalogue/USD", None)])
+
+
+if __name__ == "__main__":
+    unittest.main()

langchain_fxmacrodata-0.1.0/tests/test_tools.py

@@ -0,0 +1,80 @@
+import os
+import unittest
+from unittest import mock
+
+from langchain_fxmacrodata.client import OPERATIONS, build_url, call_operation
+from langchain_fxmacrodata.tools import fxmacrodata_tools, tool_name
+
+
+class ToolTests(unittest.TestCase):
+    def test_every_get_operation_is_a_distinct_tool(self) -> None:
+        tools = fxmacrodata_tools(transport=lambda method, url, key: (200, url))
+        names = [tool.name for tool in tools]
+        self.assertEqual(len(names), len(set(names)))
+        self.assertEqual(len(tools), sum(method == "GET" for method, _path, _query in OPERATIONS))
+        self.assertGreater(len(tools), 40)
+        self.assertIn("fxmacrodata_data_catalogue_currency", names)
+
+    def test_public_catalogue_keeps_the_response_body(self) -> None:
+        body = '{"indicator":"9007199254740993.0000"}'
+        seen = {}
+
+        def transport(method, url, key):
+            seen["method"] = method
+            seen["url"] = url
+            seen["key"] = key
+            return 200, body
+
+        tool = next(item for item in fxmacrodata_tools(transport=transport) if item.name == "fxmacrodata_data_catalogue_currency")
+        self.assertEqual(tool.invoke({"currency": "USD", "include_coverage": "true"}), body)
+        self.assertEqual(seen["method"], "GET")
+        self.assertEqual(seen["url"], "https://api.fxmacrodata.com/v1/data_catalogue/USD?include_coverage=true")
+        self.assertIsNone(seen["key"])
+        self.assertNotIn("api_key", seen["url"])
+
+    def test_optional_key_is_a_header_value_not_a_url(self) -> None:
+        def transport(method, url, key):
+            return 200, key or ""
+
+        with mock.patch.dict(os.environ, {"FXMACRODATA_API_KEY": "not-a-real-key"}):
+            tool = next(item for item in fxmacrodata_tools(transport=transport) if item.name == tool_name("/v1/forex/{base}/{quote}"))
+            self.assertEqual(tool.invoke({"base": "EUR", "quote": "USD"}), "not-a-real-key")
+
+    def test_research_panel_is_refused(self) -> None:
+        with self.assertRaises(Exception):
+            call_operation("/v1/research/panel", "", {})
+
+    def test_origin_cannot_be_replaced(self) -> None:
+        with self.assertRaises(Exception):
+            build_url("/v1/health", "", {}, origin="https://example.invalid")
+
+    def test_stream_resume_id_is_a_header(self) -> None:
+        captured = {}
+
+        class _Body:
+            status = 200
+
+            def read(self, _limit):
+                return b'{"events":[]}'
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, *_args):
+                return False
+
+        def _open(self, req, data=None, timeout=None):
+            captured["url"] = req.full_url
+            captured["headers"] = {key.lower(): value for key, value in req.header_items()}
+            return _Body()
+
+        tool = next(item for item in fxmacrodata_tools() if item.name == "fxmacrodata_stream_events")
+        with mock.patch("urllib.request.OpenerDirector.open", _open):
+            self.assertEqual(tool.invoke({"currencies": "USD", "last_event_id": "42"}), '{"events":[]}')
+        self.assertEqual(captured["url"], "https://api.fxmacrodata.com/v1/stream/events?currencies=USD")
+        self.assertEqual(captured["headers"].get("last-event-id"), "42")
+        self.assertNotIn("last_event_id", captured["url"])
+
+
+if __name__ == "__main__":
+    unittest.main()