Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
Fix LangChain tool_call argument handling for varied message formats
chopratejas876949e638d1
diff --git a/headroom/integrations/langchain/chat_model.py b/headroom/integrations/langchain/chat_model.pyindex 7cbacda8e..c052147ab 100644--- a/headroom/integrations/langchain/chat_model.py+++ b/headroom/integrations/langchain/chat_model.py@@ -79,6 +79,22 @@ def _check_langchain_available() -> None:)+def _tool_call_args_to_json(tc: dict[str, Any]) -> str:+ """Normalize tool call arguments to JSON string for OpenAI format.++ LangChain can provide 'args' (dict) or 'arguments' (str) depending on source.+ """+ if "args" in tc:+ val = tc["args"]+ return json.dumps(val) if isinstance(val, dict) else str(val)+ if "arguments" in tc:+ val = tc["arguments"]+ return val if isinstance(val, str) else json.dumps(val)+ if "function" in tc and isinstance(tc["function"], dict):+ return str(tc["function"].get("arguments", "{}"))+ return "{}"++def langchain_available() -> bool:"""Check if LangChain is installed."""return LANGCHAIN_AVAILABLE@@ -241,11 +257,11 @@ class HeadroomChatModel(BaseChatModel):if msg.tool_calls:entry["tool_calls"] = [{- "id": tc["id"],+ "id": tc.get("id", ""),"type": "function","function": {- "name": tc["name"],- "arguments": json.dumps(tc["args"]),+ "name": tc.get("name", ""),+ "arguments": _tool_call_args_to_json(tc),},}for tc in msg.tool_calls@@ -928,11 +944,11 @@ def optimize_messages(if hasattr(msg, "tool_calls") and msg.tool_calls:entry["tool_calls"] = [{- "id": tc["id"],+ "id": tc.get("id", ""),"type": "function","function": {- "name": tc["name"],- "arguments": json.dumps(tc["args"]),+ "name": tc.get("name", ""),+ "arguments": _tool_call_args_to_json(tc),},}for tc in msg.tool_callsdiff --git a/tests/test_integrations/langchain/test_langchain_live.py b/tests/test_integrations/langchain/test_langchain_live.pynew file mode 100644index 000000000..cc2df311b--- /dev/null+++ b/tests/test_integrations/langchain/test_langchain_live.py@@ -0,0 +1,312 @@+"""Live LangChain integration tests — no mocks, real API keys from .env.++Run with:+ pytest tests/test_integrations/langchain/test_langchain_live.py -v -s+ # Or with env loaded:+ set -a && source .env && set +a && pytest tests/test_integrations/langchain/test_langchain_live.py -v -s++Requires: OPENAI_API_KEY and/or ANTHROPIC_API_KEY in environment (e.g. from .env).+"""++from __future__ import annotations++import os+from pathlib import Path++import pytest++# Load .env from project root if present+_project_root = Path(__file__).resolve().parents[3]+_env = _project_root / ".env"+if _env.exists():+ try:+ from dotenv import load_dotenv++ load_dotenv(_env)+ except ImportError:+ pass++try:+ from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage+ from langchain_core.tools import tool++ LANGCHAIN_AVAILABLE = True+except ImportError:+ LANGCHAIN_AVAILABLE = False++OPENAI_KEY = os.environ.get("OPENAI_API_KEY", "").strip()+ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "").strip()+HAS_OPENAI = bool(OPENAI_KEY)+HAS_ANTHROPIC = bool(ANTHROPIC_KEY)+HAS_ANY_KEY = HAS_OPENAI or HAS_ANTHROPIC++pytestmark = [+ pytest.mark.skipif(not LANGCHAIN_AVAILABLE, reason="LangChain not installed"),+ pytest.mark.skipif(+ not HAS_ANY_KEY, reason="No OPENAI_API_KEY or ANTHROPIC_API_KEY in env (e.g. .env)"+ ),+]+++def openai_llm():+ """Real ChatOpenAI if OPENAI_API_KEY is set."""+ if not HAS_OPENAI:+ pytest.skip("OPENAI_API_KEY not set")+ from langchain_openai import ChatOpenAI++ return ChatOpenAI(model="gpt-4o-mini", temperature=0)+++def anthropic_llm():+ """Real ChatAnthropic if ANTHROPIC_API_KEY is set."""+ if not HAS_ANTHROPIC:+ pytest.skip("ANTHROPIC_API_KEY not set")+ from langchain_anthropic import ChatAnthropic++ # Allow override via env (e.g. claude-sonnet-4-20250514); default to a common current model+ model = os.environ.get("ANTHROPIC_MODEL", "claude-sonnet-4-20250514")+ return ChatAnthropic(model=model, temperature=0)+++# --- HeadroomChatModel: invoke (sync) ---+++class TestHeadroomChatModelLiveOpenAI:+ """Live tests: HeadroomChatModel wrapping ChatOpenAI."""++ def test_wrap_openai_and_invoke(self, openai_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ messages = [HumanMessage(content="Reply with exactly: OK")]+ response = model.invoke(messages)++ assert response is not None+ assert hasattr(response, "content")+ assert response.content is not None+ assert len(response.content) > 0+ assert len(model._metrics_history) >= 1+ m = model._metrics_history[-1]+ assert m.tokens_before >= 0+ assert m.tokens_after >= 0++ def test_invoke_with_string_input(self, openai_llm):+ """LangChain allows invoke(str); BaseChatModel converts to messages."""+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ response = model.invoke("Say hello in one word.")+ assert response is not None+ assert hasattr(response, "content")+ assert len(response.content) > 0++ def test_system_and_user_messages(self, openai_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ messages = [+ SystemMessage(content="You are a helpful assistant. Be very brief."),+ HumanMessage(content="What is 2+2? One number only."),+ ]+ response = model.invoke(messages)+ assert response.content is not None+ assert "4" in response.content or "four" in response.content.lower()++ def test_get_savings_summary_after_calls(self, openai_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ model.invoke([HumanMessage(content="Hi")])+ summary = model.get_savings_summary()+ assert summary["total_requests"] >= 1+ assert "total_tokens_saved" in summary+ assert "average_savings_percent" in summary+++class TestHeadroomChatModelLiveAnthropic:+ """Live tests: HeadroomChatModel wrapping ChatAnthropic.++ If your Anthropic account does not have access to the default model,+ set ANTHROPIC_MODEL=your-model (e.g. claude-3-5-sonnet-20241022) in .env.+ """++ def test_wrap_anthropic_and_invoke(self, anthropic_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(anthropic_llm)+ messages = [HumanMessage(content="Reply with exactly: OK")]+ try:+ response = model.invoke(messages)+ except Exception as e:+ if "404" in str(e) or "not_found" in str(e).lower():+ pytest.skip(f"Anthropic model not available: {e}")+ raise+ assert response is not None+ assert response.content is not None+ assert len(response.content) > 0+ assert len(model._metrics_history) >= 1++ def test_provider_detection_anthropic(self, anthropic_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(anthropic_llm)+ _ = model.pipeline+ assert model._provider is not None+ assert "anthropic" in model._provider.__class__.__name__.lower() or "anthropic" in str(+ type(model._provider)+ )+++# --- Streaming ---+++class TestHeadroomChatModelStreamingLive:+ """Live streaming tests."""++ def test_stream_openai(self, openai_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ messages = [HumanMessage(content="Count from 1 to 3, one number per line.")]+ chunks = list(model.stream(messages))+ assert len(chunks) >= 1+ full = "".join(c.content for c in chunks if c.content)+ assert "1" in full or "2" in full or "3" in full++ @pytest.mark.asyncio+ async def test_astream_openai(self, openai_llm):+ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ messages = [HumanMessage(content="Say 'stream' and nothing else.")]+ count = 0+ async for chunk in model.astream(messages):+ if chunk.content:+ count += 1+ assert count >= 1+++# --- Tool calling (real round-trip) ---+++class TestHeadroomChatModelToolCallsLive:+ """Live tool-calling tests: bind_tools + invoke with tool use."""++ def test_bind_tools_and_invoke_with_tool_output(self, openai_llm):+ """Simulate agent turn: user -> model (tool call) -> tool result -> model. We compress tool result."""+ from headroom.integrations import HeadroomChatModel++ @tool+ def big_search(query: str) -> str:+ """Search (returns large JSON)."""+ import json++ return json.dumps(+ {+ "results": [+ {"id": i, "title": f"Result {i}", "snippet": "x" * 200} for i in range(50)+ ],+ "total": 50,+ }+ )++ base = openai_llm.bind_tools([big_search])+ model = HeadroomChatModel(base)++ # User asks something that may trigger tool use+ messages = [+ HumanMessage(+ content="Search for 'python tutorials' and tell me how many results you got."+ ),+ ]+ response = model.invoke(messages)++ assert response is not None+ # Either direct answer or tool_calls+ if response.tool_calls:+ assert len(response.tool_calls) >= 1+ tc = response.tool_calls[0]+ assert "name" in tc or hasattr(tc, "get")+ assert len(model._metrics_history) >= 1++ def test_messages_with_tool_result_compressed(self, openai_llm):+ """Conversation with tool call + large tool result; Headroom should compress the tool result."""+ import json++ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ # Simulate: user -> assistant (tool call) -> tool (large result) -> user (follow-up)+ large_result = json.dumps([{"id": i, "data": "x" * 100} for i in range(100)])+ messages = [+ HumanMessage(content="Get items 1 to 100."),+ AIMessage(+ content="",+ tool_calls=[+ {+ "id": "call_1",+ "name": "get_items",+ "args": {"limit": 100},+ "type": "tool_call",+ }+ ],+ ),+ ToolMessage(content=large_result, tool_call_id="call_1"),+ HumanMessage(content="How many items did you get? One number only."),+ ]+ response = model.invoke(messages)++ assert response is not None+ assert response.content is not None+ # Optimization should have run (tool content was large)+ assert len(model._metrics_history) >= 1+ last = model._metrics_history[-1]+ assert last.tokens_before >= last.tokens_after or last.tokens_before == last.tokens_after+++# --- LCEL chain ---+++class TestHeadroomLCELive:+ """Live LCEL chain tests."""++ def test_prompt_pipe_headroom_pipe_llm(self, openai_llm):+ from langchain_core.output_parsers import StrOutputParser+ from langchain_core.prompts import ChatPromptTemplate++ from headroom.integrations import HeadroomChatModel++ model = HeadroomChatModel(openai_llm)+ prompt = ChatPromptTemplate.from_messages(+ [+ ("system", "You are helpful. Reply in one short sentence."),+ ("human", "{input}"),+ ]+ )+ chain = prompt | model | StrOutputParser()+ result = chain.invoke({"input": "What is the capital of France?"})+ assert result is not None+ assert "Paris" in result or "paris" in result.lower()+++# --- optimize_messages standalone (no LLM call) ---+++class TestOptimizeMessagesLive:+ """Live optimize_messages with real Headroom pipeline (no API key needed for this)."""++ def test_optimize_messages_large_conversation(self):+ from headroom.integrations import optimize_messages++ messages = [SystemMessage(content="You are helpful.")]+ for i in range(30):+ messages.append(HumanMessage(content=f"Question {i}: What is {i}?"))+ messages.append(AIMessage(content=f"Answer: {i}."))+ messages.append(HumanMessage(content="Summarize the last answer."))++ optimized, metrics = optimize_messages(messages)+ assert len(optimized) >= 1+ assert metrics["tokens_before"] >= metrics["tokens_after"]+ assert "transforms_applied" in metrics