Skip to content
Python

tests: cover OpenAI provider gaps — key resolution, Qwen XML salvage, stream edges

ayobamiseunf03ec863c6c3
diff --git a/tests/test_openai_provider.py b/tests/test_openai_provider.py
new file mode 100644
index 00000000..f27b2395
--- /dev/null
+++ b/tests/test_openai_provider.py
@@ -0,0 +1,313 @@
+"""OpenAI provider — coverage for what test_providers.py (complete/stream basics,
+param-fix retries) and test_provider_router.py (JSON-form tool-call salvage) don't
+reach: API-key resolution, client bootstrap, the Qwen/Hermes XML tool-call template,
+salvage gating inside complete()/stream(), and stream edge cases. SDK-free: fakes
+mimic the OpenAI SDK's chat.completions surface with SimpleNamespace objects, the
+same pattern test_providers.py uses."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from coworker.providers import OpenAIProvider, ToolCall
+from coworker.providers.openai_provider import (
+ _coerce_param,
+ _salvage_tool_calls_from_text,
+ resolve_api_key,
+)
+
+# -- fakes ------------------------------------------------------------------------
+
+
+class _FakeCompletions:
+ def __init__(self, response):
+ self._response = response
+ self.calls: list[dict] = []
+
+ def create(self, **kwargs):
+ self.calls.append(kwargs)
+ return self._response
+
+
+class _FakeClient:
+ def __init__(self, response):
+ self.chat = SimpleNamespace(completions=_FakeCompletions(response))
+
+
+class _StreamClient:
+ def __init__(self, chunks):
+ self.chat = SimpleNamespace(
+ completions=SimpleNamespace(create=lambda **kwargs: iter(chunks))
+ )
+
+
+def _response(content=None, tool_calls=None, finish_reason="stop"):
+ message = SimpleNamespace(content=content, tool_calls=tool_calls)
+ choice = SimpleNamespace(message=message, finish_reason=finish_reason)
+ return SimpleNamespace(choices=[choice])
+
+
+def _chunk(content=None, tool_call=None, finish=None):
+ delta = SimpleNamespace(
+ content=content, tool_calls=[tool_call] if tool_call else None
+ )
+ return SimpleNamespace(choices=[SimpleNamespace(delta=delta, finish_reason=finish)])
+
+
+class _Secrets:
+ def __init__(self, profile):
+ self._profile = profile
+
+ def get(self, key):
+ assert key == "provider:openai"
+ return self._profile
+
+
+_FS_TOOLS = [
+ {
+ "type": "function",
+ "function": {
+ "name": "write_file",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "path": {"type": "string"},
+ "content": {"type": "string"},
+ },
+ "required": ["path", "content"],
+ },
+ },
+ },
+ {
+ "type": "function",
+ "function": {
+ "name": "list_files",
+ "parameters": {
+ "type": "object",
+ "properties": {"recursive": {"type": "boolean"}},
+ },
+ },
+ },
+]
+
+
+# -- key resolution / client bootstrap ------------------------------------------------
+
+
+def test_resolve_api_key_env_wins(monkeypatch):
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-env")
+ assert resolve_api_key(_Secrets({"api_key": "sk-stored"})) == "sk-env"
+
+
+def test_resolve_api_key_falls_back_to_secret_store(monkeypatch):
+ monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+ assert resolve_api_key(_Secrets({"api_key": "sk-stored"})) == "sk-stored"
+ assert resolve_api_key(_Secrets(None)) is None # no stored profile
+ assert resolve_api_key(_Secrets({})) is None # profile without api_key
+ assert resolve_api_key(None) is None # no secret store at all
+
+
+def test_ensure_client_without_key_raises(monkeypatch):
+ monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+ with pytest.raises(RuntimeError, match="No model API key"):
+ OpenAIProvider()._ensure_client()
+
+
+def test_ensure_client_passes_key_and_base_url(monkeypatch):
+ captured: dict = {}
+
+ class _FakeOpenAI:
+ def __init__(self, **kwargs):
+ captured.update(kwargs)
+
+ monkeypatch.setattr("openai.OpenAI", _FakeOpenAI)
+
+ OpenAIProvider(api_key="sk-x")._ensure_client()
+ assert captured == {"api_key": "sk-x"} # no base_url kwarg when unset
+
+ captured.clear()
+ OpenAIProvider(api_key="sk-x", base_url="http://localhost:11434/v1")._ensure_client()
+ assert captured == {"api_key": "sk-x", "base_url": "http://localhost:11434/v1"}
+
+
+# -- Qwen/Hermes XML tool-call template (salvage path 1b) ------------------------------
+
+
+def test_salvage_qwen_xml_function_call():
+ # qwen3-coder's native template: nested XML, not JSON, wrapped in <tool_call>.
+ text = (
+ "<tool_call>\n<function=write_file>\n"
+ "<parameter=path>\nhello.txt\n</parameter>\n"
+ "<parameter=content>\nHello, world!\n</parameter>\n"
+ "</function>\n</tool_call>"
+ )
+ calls = _salvage_tool_calls_from_text(text, _FS_TOOLS)
+ assert len(calls) == 1
+ assert calls[0].name == "write_file"
+ assert calls[0].arguments == {"path": "hello.txt", "content": "Hello, world!"}
+
+
+def test_salvage_qwen_xml_keeps_free_text_verbatim():
+ # File content with embedded whitespace must survive as-is (stripped, not coerced).
+ text = (
+ "<function=write_file><parameter=path>a.md</parameter>"
+ "<parameter=content>line one\nline two</parameter></function>"
+ )
+ calls = _salvage_tool_calls_from_text(text, _FS_TOOLS)
+ assert calls[0].arguments["content"] == "line one\nline two"
+
+
+def test_salvage_qwen_xml_coerces_json_params():
+ text = "<function=list_files><parameter=recursive>true</parameter></function>"
+ calls = _salvage_tool_calls_from_text(text, _FS_TOOLS)
+ assert calls[0].arguments == {"recursive": True}
+
+
+def test_salvage_qwen_xml_filters_unknown_function():
+ text = "<function=rm_rf><parameter=path>/</parameter></function>"
+ assert _salvage_tool_calls_from_text(text, _FS_TOOLS) == []
+
+
+def test_salvage_qwen_xml_without_schemas_accepts_any_name():
+ text = "<function=anything><parameter=x>1</parameter></function>"
+ calls = _salvage_tool_calls_from_text(text, None)
+ assert calls[0].name == "anything"
+ assert calls[0].arguments == {"x": 1}
+
+
+def test_salvage_qwen_xml_multiple_blocks_renumbered():
+ text = (
+ "<function=list_files><parameter=recursive>true</parameter></function>"
+ "<function=write_file><parameter=path>a</parameter>"
+ "<parameter=content>b</parameter></function>"
+ )
+ calls = _salvage_tool_calls_from_text(text, _FS_TOOLS)
+ assert [c.id for c in calls] == ["call_salvaged_0", "call_salvaged_1"]
+ assert [c.name for c in calls] == ["list_files", "write_file"]
+
+
+def test_coerce_param():
+ assert _coerce_param(" 42 ") == 42
+ assert _coerce_param("true") is True
+ assert _coerce_param('{"a":1}') == {"a": 1}
+ assert _coerce_param("two words") == "two words" # whitespace → verbatim
+ assert _coerce_param('"quoted"') == '"quoted"' # JSON strings stay verbatim
+
+
+# -- salvage gating inside complete() --------------------------------------------------
+
+
+def test_complete_salvages_text_form_tool_call():
+ content = '<tool_call>{"name": "list_files", "arguments": {"recursive": true}}</tool_call>'
+ provider = OpenAIProvider(client=_FakeClient(_response(content=content)))
+ turn = provider.complete(
+ model="qwen3", messages=[{"role": "user", "content": "ls"}], tools=_FS_TOOLS
+ )
+ assert turn.text is None # salvaged calls replace the text
+ assert [c.name for c in turn.tool_calls] == ["list_files"]
+ assert turn.tool_calls[0].arguments == {"recursive": True}
+
+
+def test_complete_keeps_text_when_no_tools_offered():
+ # Salvage is gated on tools being requested — never rewrites a plain chat turn.
+ content = '<tool_call>{"name": "list_files", "arguments": {}}</tool_call>'
+ provider = OpenAIProvider(client=_FakeClient(_response(content=content)))
+ turn = provider.complete(model="qwen3", messages=[{"role": "user", "content": "hi"}])
+ assert turn.text == content
+ assert turn.tool_calls == []
+
+
+def test_complete_prefers_structured_tool_calls_over_text():
+ # When the server DID populate tool_calls, text is never reinterpreted.
+ tc = SimpleNamespace(
+ id="call_1", function=SimpleNamespace(name="list_files", arguments="{}")
+ )
+ content = '{"name": "write_file", "arguments": {"path": "x", "content": "y"}}'
+ provider = OpenAIProvider(
+ client=_FakeClient(_response(content=content, tool_calls=[tc]))
+ )
+ turn = provider.complete(
+ model="gpt-5.5", messages=[{"role": "user", "content": "go"}], tools=_FS_TOOLS
+ )
+ assert turn.text == content
+ assert [c.name for c in turn.tool_calls] == ["list_files"]
+
+
+# -- stream edge cases -----------------------------------------------------------------
+
+
+def test_stream_salvages_text_form_tool_call_at_end():
+ parts = ["<tool_call>", '{"name": "list_files",', ' "arguments": {}}', "</tool_call>"]
+ chunks = [_chunk(content=p) for p in parts] + [_chunk(finish="stop")]
+ provider = OpenAIProvider(client=_StreamClient(chunks))
+ out = list(provider.stream(model="qwen3", messages=[], tools=_FS_TOOLS))
+ # Deltas still stream out as text (the UI shows them live) …
+ assert "".join(c.text_delta for c in out if c.text_delta) == "".join(parts)
+ # … but the final turn carries the recovered structured call, not the text.
+ turn = out[-1].turn
+ assert turn.text is None
+ assert [c.name for c in turn.tool_calls] == ["list_files"]
+
+
+def test_stream_bad_tool_args_surface_raw():
+ tc = SimpleNamespace(
+ index=0, id="call_1", function=SimpleNamespace(name="f", arguments="{not json")
+ )
+ chunks = [_chunk(tool_call=tc), _chunk(finish="tool_calls")]
+ provider = OpenAIProvider(client=_StreamClient(chunks))
+ turn = list(provider.stream(model="gpt-5.5", messages=[]))[-1].turn
+ assert turn.tool_calls == [
+ ToolCall(id="call_1", name="f", arguments={"_raw": "{not json"})
+ ]
+
+
+def test_stream_orders_parallel_tool_calls_by_index():
+ # Chunks may interleave; the final list is ordered by tool-call index.
+ second = SimpleNamespace(
+ index=1, id="call_b", function=SimpleNamespace(name="b", arguments="{}")
+ )
+ first = SimpleNamespace(
+ index=0, id="call_a", function=SimpleNamespace(name="a", arguments="")
+ )
+ chunks = [_chunk(tool_call=second), _chunk(tool_call=first), _chunk(finish="tool_calls")]
+ provider = OpenAIProvider(client=_StreamClient(chunks))
+ turn = list(provider.stream(model="gpt-5.5", messages=[]))[-1].turn
+ assert [c.id for c in turn.tool_calls] == ["call_a", "call_b"]
+ assert turn.tool_calls[0].arguments == {} # empty accumulated args → {}
+
+
+def test_stream_skips_chunks_without_choices():
+ # Compat servers emit keep-alive/usage chunks with no choices; they must not crash.
+ empty = SimpleNamespace(choices=[])
+ chunks = [empty, _chunk(content="ok"), _chunk(finish="stop")]
+ provider = OpenAIProvider(client=_StreamClient(chunks))
+ out = list(provider.stream(model="gpt-5.5", messages=[]))
+ assert out[-1].turn.text == "ok"
+
+
+def test_stream_reasoning_attr_variant():
+ # xAI/OpenRouter put thinking text on `reasoning` (not `reasoning_content`).
+ delta = SimpleNamespace(content=None, tool_calls=None, reasoning="thinking…")
+ chunk = SimpleNamespace(
+ choices=[SimpleNamespace(delta=delta, finish_reason=None)]
+ )
+ chunks = [chunk, _chunk(content="hi"), _chunk(finish="stop")]
+ provider = OpenAIProvider(client=_StreamClient(chunks))
+ out = list(provider.stream(model="grok-4", messages=[]))
+ assert [c.reasoning_delta for c in out if c.reasoning_delta] == ["thinking…"]
+ turn = out[-1].turn
+ assert turn.reasoning == "thinking…"
+ assert turn.text == "hi"
+
+
+def test_complete_picks_up_reasoning_attr():
+ message = SimpleNamespace(content="answer", tool_calls=None, reasoning="because")
+ choice = SimpleNamespace(message=message, finish_reason="stop")
+ provider = OpenAIProvider(
+ client=_FakeClient(SimpleNamespace(choices=[choice]))
+ )
+ turn = provider.complete(model="grok-4", messages=[{"role": "user", "content": "?"}])
+ assert turn.reasoning == "because"
+ assert turn.text == "answer"