Personal AI, On Personal Devices
Python
fix: preserve Gemini tool calls while streaming
Dustin Zander1bfc25a860d0
diff --git a/src/openjarvis/engine/cloud.py b/src/openjarvis/engine/cloud.pyindex 9e39cf6d..fe5172f6 100644--- a/src/openjarvis/engine/cloud.py+++ b/src/openjarvis/engine/cloud.py@@ -1305,6 +1305,133 @@ class CloudEngine(InferenceEngine):if chunk.text:yield chunk.text+ async def _stream_full_google(+ self,+ messages: Sequence[Message],+ *,+ model: str,+ temperature: float,+ max_tokens: int,+ **kwargs: Any,+ ) -> AsyncIterator[StreamChunk]:+ """Stream Google text and function-call parts as full chunks."""+ if self._google_client is None:+ raise EngineConnectionError("Google client not available")++ system_text = ""+ contents: List[Dict[str, Any]] = []+ for message in messages:+ if message.role.value == "system":+ system_text = message.content+ elif message.role.value == "tool":+ function_response = {+ "function_response": {+ "name": message.name or "unknown",+ "response": {"result": message.content},+ }+ }+ if (+ contents+ and contents[-1]["role"] == "user"+ and contents[-1]["parts"]+ and "function_response" in contents[-1]["parts"][-1]+ ):+ contents[-1]["parts"].append(function_response)+ else:+ contents.append({"role": "user", "parts": [function_response]})+ elif message.role.value == "assistant" and message.tool_calls:+ parts: List[Dict[str, Any]] = []+ if message.content:+ parts.append({"text": message.content})+ for tool_call in message.tool_calls:+ args = tool_call.arguments+ if isinstance(args, str):+ try:+ args = json.loads(args)+ except (json.JSONDecodeError, TypeError):+ args = {"input": args}+ function_call: Dict[str, Any] = {+ "name": tool_call.name,+ "args": args if isinstance(args, dict) else {},+ }+ signature = self._thought_sigs.get(tool_call.id)+ if signature is not None:+ function_call["thought_signature"] = signature+ parts.append({"function_call": function_call})+ contents.append({"role": "model", "parts": parts})+ elif message.role.value == "assistant":+ contents.append({"role": "model", "parts": [{"text": message.content}]})+ else:+ contents.append({"role": "user", "parts": [{"text": message.content}]})++ from google.genai import types as genai_types++ config = genai_types.GenerateContentConfig(+ temperature=temperature,+ max_output_tokens=max_tokens,+ )+ if system_text:+ config.system_instruction = system_text++ tools = kwargs.pop("tools", None)+ if tools:+ config.tools = [{"function_declarations": _convert_tools_to_google(tools)}]++ tool_ids: Dict[str, int] = {}+ for chunk in self._google_client.models.generate_content_stream(+ model=model,+ contents=contents,+ config=config,+ ):+ candidates = getattr(chunk, "candidates", None)+ parts = []+ if candidates:+ parts = getattr(candidates[0].content, "parts", []) or []++ if parts:+ text_found = False+ calls: List[Dict[str, Any]] = []+ for part in parts:+ text = getattr(part, "text", None)+ if text:+ text_found = True+ yield StreamChunk(content=text)++ function_call = getattr(part, "function_call", None)+ if function_call:+ name = getattr(function_call, "name", "")+ raw_args = getattr(function_call, "args", {})+ args = dict(raw_args) if hasattr(raw_args, "items") else {}+ tool_id = f"google_{name}"+ tool_index = tool_ids.setdefault(tool_id, len(tool_ids))+ tool_call = {+ "index": tool_index,+ "id": tool_id,+ "type": "function",+ "function": {+ "name": name,+ "arguments": json.dumps(args),+ },+ }+ calls.append(tool_call)+ signature = getattr(part, "thought_signature", None)+ if signature is not None:+ tool_call["thought_signature"] = signature+ self._thought_sigs[tool_id] = signature+ if calls:+ yield StreamChunk(tool_calls=calls)+ if text_found:+ continue++ try:+ text = chunk.text+ except (AttributeError, ValueError):+ text = None+ if text:+ yield StreamChunk(content=text)++ yield StreamChunk(finish_reason="tool_calls" if tool_ids else "stop")+async def _stream_openrouter(self,messages: Sequence[Message],@@ -1600,7 +1727,7 @@ class CloudEngine(InferenceEngine):async for chunk in self._stream_full_anthropic(messages, **kw):yield chunkelif _is_google_model(model):- async for chunk in super().stream_full(messages, **kw):+ async for chunk in self._stream_full_google(messages, **kw):yield chunkelse:async for chunk in self._stream_full_openai(messages, **kw):diff --git a/tests/engine/test_cloud_stream_full.py b/tests/engine/test_cloud_stream_full.pyindex ce73d83a..8adf235e 100644--- a/tests/engine/test_cloud_stream_full.py+++ b/tests/engine/test_cloud_stream_full.py@@ -3,6 +3,8 @@ and _prepare_anthropic_messages."""from __future__ import annotations+import sys+from types import ModuleType, SimpleNamespacefrom typing import Any, Listfrom unittest.mock import MagicMock@@ -63,6 +65,28 @@ def _openai_tool_call_delta(return tc+class _GoogleConfig:+ def __init__(self, **kwargs: Any) -> None:+ self.__dict__.update(kwargs)+++def _google_stream_chunk(*parts: Any, text: str | None = None) -> Any:+ candidates = []+ if parts:+ candidates = [SimpleNamespace(content=SimpleNamespace(parts=list(parts)))]+ return SimpleNamespace(text=text, candidates=candidates, usage_metadata=None)+++def _google_types_modules() -> dict[str, ModuleType]:+ types = ModuleType("google.genai.types")+ types.GenerateContentConfig = _GoogleConfig+ genai = ModuleType("google.genai")+ genai.types = types+ google = ModuleType("google")+ google.genai = genai+ return {"google": google, "google.genai": genai, "google.genai.types": types}++# ---------------------------------------------------------------------------# _stream_full_openai tests# ---------------------------------------------------------------------------@@ -413,6 +437,166 @@ def test_prepare_anthropic_messages_tool_calls():assert blocks[1]["input"] == {"city": "Berlin"}+# ---------------------------------------------------------------------------+# _stream_full_google tests+# ---------------------------------------------------------------------------+++async def test_stream_full_google_text_only(monkeypatch: pytest.MonkeyPatch):+ """Google text chunks retain their content and finish normally."""+ client = MagicMock()+ client.models.generate_content_stream.return_value = iter(+ [_google_stream_chunk(text="Hello"), _google_stream_chunk(text=" world")]+ )+ engine = _make_cloud_engine(google_client=client)+ engine._thought_sigs = {}+ messages = [Message(role=Role.USER, content="hi")]+ modules = _google_types_modules()++ with monkeypatch.context() as patch:+ for name, module in modules.items():+ patch.setitem(sys.modules, name, module)+ result = [+ chunk+ async for chunk in engine.stream_full(messages, model="gemini-2.5-flash")+ ]++ assert [chunk.content for chunk in result[:-1]] == ["Hello", " world"]+ assert result[-1].finish_reason == "stop"+++async def test_stream_full_google_preserves_tool_calls(monkeypatch: pytest.MonkeyPatch):+ """Google function_call parts become OpenAI-compatible tool call chunks."""+ function_call = SimpleNamespace(name="get_weather", args={"city": "Berlin"})+ part = SimpleNamespace(+ function_call=function_call, text=None, thought_signature=b"sig"+ )+ client = MagicMock()+ client.models.generate_content_stream.return_value = iter(+ [_google_stream_chunk(part)]+ )+ engine = _make_cloud_engine(google_client=client)+ engine._thought_sigs = {}+ messages = [Message(role=Role.USER, content="weather")]+ modules = _google_types_modules()++ with monkeypatch.context() as patch:+ for name, module in modules.items():+ patch.setitem(sys.modules, name, module)+ result = [+ chunk+ async for chunk in engine.stream_full(+ messages,+ model="gemini-2.5-flash",+ tools=[+ {+ "type": "function",+ "function": {+ "name": "get_weather",+ "description": "Get weather",+ "parameters": {"type": "object", "properties": {}},+ },+ }+ ],+ )+ ]++ tool_call = result[0].tool_calls[0]+ assert tool_call == {+ "index": 0,+ "id": "google_get_weather",+ "type": "function",+ "function": {"name": "get_weather", "arguments": '{"city": "Berlin"}'},+ "thought_signature": b"sig",+ }+ assert engine._thought_sigs["google_get_weather"] == b"sig"+ assert result[-1].finish_reason == "tool_calls"+ config = client.models.generate_content_stream.call_args.kwargs["config"]+ assert config.tools == [+ {+ "function_declarations": [+ {+ "name": "get_weather",+ "description": "Get weather",+ "parameters": {"type": "object", "properties": {}},+ }+ ]+ }+ ]+++async def test_stream_full_google_preserves_mixed_and_multiple_calls(+ monkeypatch: pytest.MonkeyPatch,+):+ """Google streams retain mixed text and multiple deterministic tool calls."""+ weather = SimpleNamespace(name="get_weather", args={"city": "Berlin"})+ calendar = SimpleNamespace(name="get_calendar", args={"day": "Monday"})+ text_part = SimpleNamespace(text="I'll check.", function_call=None)+ weather_part = SimpleNamespace(+ function_call=weather, text=None, thought_signature=None+ )+ calendar_part = SimpleNamespace(+ function_call=calendar, text=None, thought_signature=None+ )+ client = MagicMock()+ client.models.generate_content_stream.return_value = iter(+ [+ _google_stream_chunk(text_part, weather_part),+ _google_stream_chunk(weather_part, calendar_part),+ ]+ )+ engine = _make_cloud_engine(google_client=client)+ engine._thought_sigs = {}+ modules = _google_types_modules()++ with monkeypatch.context() as patch:+ for name, module in modules.items():+ patch.setitem(sys.modules, name, module)+ result = [+ chunk+ async for chunk in engine.stream_full(+ [Message(role=Role.USER, content="plan")], model="gemini-2.5-flash"+ )+ ]++ assert result[0].content == "I'll check."+ assert result[1].tool_calls == [+ {+ "index": 0,+ "id": "google_get_weather",+ "type": "function",+ "function": {+ "name": "get_weather",+ "arguments": '{"city": "Berlin"}',+ },+ }+ ]+ assert result[2].tool_calls == [+ {+ "index": 0,+ "id": "google_get_weather",+ "type": "function",+ "function": {+ "name": "get_weather",+ "arguments": '{"city": "Berlin"}',+ },+ },+ {+ "index": 1,+ "id": "google_get_calendar",+ "type": "function",+ "function": {+ "name": "get_calendar",+ "arguments": '{"day": "Monday"}',+ },+ },+ ]+ assert result[-1].finish_reason == "tool_calls"++# ---------------------------------------------------------------------------# stream_full routing tests# ---------------------------------------------------------------------------