Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

fix(llm): send Ollama tools only to tool-capable models and keep call identity

FenjuFu558c06c3f88c
diff --git a/src/llm/providers/ollama.py b/src/llm/providers/ollama.py
index c36304c93..65256b179 100644
--- a/src/llm/providers/ollama.py
+++ b/src/llm/providers/ollama.py
@@ -2,7 +2,11 @@
from __future__ import annotations
+import json
+import logging
import os
+import urllib.request
+import uuid
from typing import Any
from llm.core.interface import (
@@ -15,11 +19,35 @@ from llm.core.interface import (
from llm.core.types import (
LLMInput,
LLMOutput,
+ Message,
ModelInfo,
ProviderType,
+ Role,
ToolCall,
)
+logger = logging.getLogger(__name__)
+
+
+def _messages_payload(messages: list[Message]) -> list[dict[str, Any]]:
+ """Serialize messages, naming the tool each tool result answers.
+
+ Ollama correlates a tool result with its call through ``tool_name``; ids
+ are optional on its side, so the name is what keeps several results apart.
+ """
+ names: dict[str, str] = {}
+ payload = []
+ for msg in messages:
+ item = msg.to_dict()
+ for tc in msg.tool_calls or []:
+ names[tc.id] = tc.name
+ if msg.role == Role.TOOL:
+ tool_name = msg.name or names.get(msg.tool_call_id or "")
+ if tool_name:
+ item["tool_name"] = tool_name
+ payload.append(item)
+ return payload
+
class OllamaProvider(LLMProvider):
provider_type = ProviderType.OLLAMA
@@ -35,7 +63,7 @@ class OllamaProvider(LLMProvider):
ModelInfo(
name="llama3.2",
provider=ProviderType.OLLAMA,
- supports_tools=False,
+ supports_tools=True,
supports_vision=False,
max_tokens=4096,
context_window=128000,
@@ -43,7 +71,7 @@ class OllamaProvider(LLMProvider):
ModelInfo(
name="mistral",
provider=ProviderType.OLLAMA,
- supports_tools=False,
+ supports_tools=True,
supports_vision=False,
max_tokens=4096,
context_window=8192,
@@ -57,18 +85,42 @@ class OllamaProvider(LLMProvider):
context_window=16384,
),
]
+ self._tool_support: dict[str, bool] = {}
+
+ def model_supports_tools(self, model: str) -> bool:
+ """Whether ``model`` declares tool support.
+
+ Catalogued models answer from :attr:`ModelInfo.supports_tools`. Any other
+ model is looked up once through ``/api/show``, whose ``capabilities``
+ list is what the installed model itself declares. A failed lookup counts
+ as no tool support.
+ """
+ for info in self._models:
+ if info.name == model:
+ return info.supports_tools
+ if model not in self._tool_support:
+ try:
+ req = urllib.request.Request(
+ f"{self.base_url}/api/show",
+ data=json.dumps({"model": model}).encode("utf-8"),
+ headers={"Content-Type": "application/json"},
+ )
+ with urllib.request.urlopen(req, timeout=10) as response:
+ capabilities = json.loads(response.read().decode("utf-8")).get("capabilities") or []
+ self._tool_support[model] = "tools" in capabilities
+ except Exception as e:
+ logger.warning("Could not read capabilities for Ollama model '%s': %s", model, type(e).__name__)
+ self._tool_support[model] = False
+ return self._tool_support[model]
def generate(self, input: LLMInput) -> LLMOutput:
- import json
- import urllib.request
-
try:
url = f"{self.base_url}/api/chat"
model = input.model or self.default_model
payload: dict[str, Any] = {
"model": model,
- "messages": [msg.to_dict() for msg in input.messages],
+ "messages": _messages_payload(input.messages),
"stream": False,
}
options: dict[str, Any] = {}
@@ -79,7 +131,10 @@ class OllamaProvider(LLMProvider):
if options:
payload["options"] = options
if input.tools:
- payload["tools"] = [tool.to_openai_tool() for tool in input.tools]
+ if self.model_supports_tools(model):
+ payload["tools"] = [tool.to_openai_tool() for tool in input.tools]
+ else:
+ logger.warning("Ollama model '%s' does not declare tool support; sending no tools", model)
data = json.dumps(payload).encode("utf-8")
req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
@@ -93,7 +148,9 @@ class OllamaProvider(LLMProvider):
if result.get("message", {}).get("tool_calls"):
tool_calls = [
ToolCall(
- id=tc.get("id", ""),
+ # Native Ollama calls often carry no id; give each one a
+ # unique id so its result can be matched to it.
+ id=tc.get("id") or f"call_{uuid.uuid4().hex[:24]}",
name=tc.get("function", {}).get("name", ""),
arguments=tc.get("function", {}).get("arguments", {}),
)
diff --git a/tests/test_provider_tools.py b/tests/test_provider_tools.py
index f73f5fdd6..caa0290c4 100644
--- a/tests/test_provider_tools.py
+++ b/tests/test_provider_tools.py
@@ -1,3 +1,4 @@
+import asyncio
import json
import urllib.request
from io import BytesIO
@@ -10,6 +11,7 @@ from llm.providers.claude import ClaudeProvider
from llm.providers.constants import EMPTY_FILTERED_RESPONSE_ERROR
from llm.providers.ollama import OllamaProvider
from llm.providers.openai import OpenAIProvider
+from llm.tools import ReActAgent, ToolExecutor, ToolRegistry
def _tool() -> ToolDefinition:
@@ -168,22 +170,59 @@ def test_ollama_provider_serializes_generation_options(
assert output.stop_reason == "stop"
-def test_ollama_provider_serializes_tools_and_parses_tool_calls(monkeypatch):
- requests = []
+class _FakeOllama:
+ """Serves /api/show and replays queued /api/chat replies, recording requests."""
+
+ def __init__(self, monkeypatch, replies, capabilities=None):
+ self.replies = list(replies)
+ self.capabilities = capabilities
+ self.chats = []
+ self.shows = []
+ monkeypatch.setattr(urllib.request, "urlopen", self.urlopen)
+
+ def urlopen(self, request, timeout):
+ body = json.loads(request.data)
+ if request.full_url.endswith("/api/show"):
+ self.shows.append(body["model"])
+ if self.capabilities is None:
+ raise OSError("connection refused")
+ return BytesIO(json.dumps({"capabilities": self.capabilities}).encode())
+ self.chats.append(body)
+ return BytesIO(json.dumps(self.replies.pop(0)).encode())
+
+
+def _ollama_tool_calls(*calls):
+ return {
+ "message": {
+ "content": "",
+ "tool_calls": [{"function": {"name": name, "arguments": args}} for name, args in calls],
+ },
+ "done_reason": "stop",
+ }
- def fake_urlopen(request, timeout):
- requests.append(request)
- return BytesIO(
- b'{"message": {"content": "", "tool_calls": [{"function": '
- b'{"name": "search", "arguments": {"query": "ollama"}}}]}, "done_reason": "stop"}'
- )
- monkeypatch.setattr(urllib.request, "urlopen", fake_urlopen)
+def _ollama_answer(text):
+ return {"message": {"content": text}, "done_reason": "stop"}
+
+
+def _lookup_tool() -> ToolDefinition:
+ return ToolDefinition(
+ name="lookup",
+ description="Look up a city",
+ parameters={"type": "object", "properties": {"city": {"type": "string"}}},
+ )
+
+
+def test_ollama_provider_serializes_tools_and_parses_tool_calls(monkeypatch):
+ server = _FakeOllama(
+ monkeypatch, [_ollama_tool_calls(("search", {"query": "ollama"}))], capabilities=["completion", "tools"]
+ )
provider = OllamaProvider(base_url="http://localhost:11434", default_model="qwen3")
output = provider.generate(LLMInput(messages=[Message(role=Role.USER, content="hi")], tools=[_tool()]))
- assert json.loads(requests[0].data)["tools"] == [
+ assert server.shows == ["qwen3"]
+ assert server.chats[0]["tools"] == [
{
"type": "function",
"function": {
@@ -197,6 +236,96 @@ def test_ollama_provider_serializes_tools_and_parses_tool_calls(monkeypatch):
assert output.has_tool_calls
assert output.tool_calls[0].name == "search"
assert output.tool_calls[0].arguments == {"query": "ollama"}
+ assert output.tool_calls[0].id
+
+
+ ("model", "capabilities", "expect_tools", "expect_shows"),
+ [
+ ("llama3.2", None, True, []),
+ ("codellama", None, False, []),
+ ("qwen3", ["completion", "tools"], True, ["qwen3"]),
+ ("gemma3", ["completion", "vision"], False, ["gemma3"]),
+ ("unknown", None, False, ["unknown"]),
+ ],
+)
+def test_ollama_provider_sends_tools_only_to_models_that_declare_them(
+ monkeypatch, model, capabilities, expect_tools, expect_shows
+):
+ server = _FakeOllama(monkeypatch, [_ollama_answer("ok"), _ollama_answer("ok")], capabilities=capabilities)
+ provider = OllamaProvider(default_model=model)
+ request = LLMInput(messages=[Message(role=Role.USER, content="hi")], tools=[_tool()])
+
+ provider.generate(request)
+ provider.generate(request)
+
+ assert all(("tools" in chat) is expect_tools for chat in server.chats)
+ # The capability lookup is cached per model.
+ assert server.shows == expect_shows
+
+
+def test_ollama_react_agent_correlates_multiple_calls_without_ids(monkeypatch):
+ server = _FakeOllama(
+ monkeypatch,
+ [
+ _ollama_tool_calls(("lookup", {"city": "Hefei"}), ("search", {"query": "weather"})),
+ _ollama_answer("Hefei is sunny."),
+ ],
+ capabilities=["completion", "tools"],
+ )
+ registry = ToolRegistry()
+ registry.register(_lookup_tool(), lambda city: f"city={city}")
+ registry.register(_tool(), lambda query: f"query={query}")
+ agent = ReActAgent(OllamaProvider(default_model="qwen3"), ToolExecutor(registry))
+
+ output = asyncio.run(
+ agent.run(
+ LLMInput(
+ messages=[Message(role=Role.USER, content="Weather in Hefei?")],
+ tools=[_lookup_tool(), _tool()],
+ )
+ )
+ )
+
+ assert output.content == "Hefei is sunny."
+ follow_up = server.chats[1]
+ assert "tools" in follow_up
+ assistant, first, second = follow_up["messages"][1:]
+ ids = [call["id"] for call in assistant["tool_calls"]]
+ assert all(ids) and len(set(ids)) == 2
+ assert [call["function"]["name"] for call in assistant["tool_calls"]] == ["lookup", "search"]
+ assert first == {"role": "tool", "content": "city=Hefei", "tool_call_id": ids[0], "tool_name": "lookup"}
+ assert second == {"role": "tool", "content": "query=weather", "tool_call_id": ids[1], "tool_name": "search"}
+
+
+def test_ollama_react_agent_reports_unknown_tool_under_its_own_name(monkeypatch):
+ server = _FakeOllama(
+ monkeypatch,
+ [_ollama_tool_calls(("missing", {}), ("search", {"query": "x"})), _ollama_answer("done")],
+ capabilities=["completion", "tools"],
+ )
+ registry = ToolRegistry()
+ registry.register(_tool(), lambda query: f"query={query}")
+ agent = ReActAgent(OllamaProvider(default_model="qwen3"), ToolExecutor(registry))
+
+ asyncio.run(agent.run(LLMInput(messages=[Message(role=Role.USER, content="go")], tools=[_tool()])))
+
+ results = server.chats[1]["messages"][2:]
+ assert [(r["tool_name"], r["content"]) for r in results] == [
+ ("missing", "Error: Tool 'missing' not found"),
+ ("search", "query=x"),
+ ]
+
+
+def test_ollama_react_agent_without_tool_support_answers_directly(monkeypatch):
+ server = _FakeOllama(monkeypatch, [_ollama_answer("I cannot call tools.")])
+ agent = ReActAgent(OllamaProvider(default_model="codellama"), ToolExecutor())
+
+ output = asyncio.run(agent.run(LLMInput(messages=[Message(role=Role.USER, content="hi")], tools=[_tool()])))
+
+ assert output.content == "I cannot call tools."
+ assert "tools" not in server.chats[0]
+ assert server.shows == []
def test_claude_provider_serializes_tools_for_messages_api():