PL-135538: Replace real llama-server tests with in-process dummy engine

- Add src/skvaider/dummy_engine/ -- DummyModel with HTTP control API
  (POST /__control/set_response, GET /__control/last_request, POST /__control/reset)
- Add DummyModelConfig to inference config's AnyModelConfig discriminated union
- Wire DummyModel into inference server lifespan (lazy import, isinstance branch)
- Replace OpenAIServerMock with DummyModel-based fixture
- Rename gemma -> gemma_real, add gemma fixture using DummyModel (default)
- Rename embeddinggemma -> embeddinggemma_real for stability test
- Update 6 tests to use dummy engine (test_health, test_metrics, test_proxy,
  test_model_name_case_normalization, test_health_monitoring streaming)
- Add aiohttp dev dependency

Author: elikoga

pyproject.toml

@@ -64,7 +64,7 @@ module-name = ["aramaki", "skvaider"]
 typeCheckingMode = "strict"
 venvPath = "."
 venv = ".devenv/state/venv"
-exclude = ["doc/**"]
+exclude = ["doc/**", "scripts/**"]
 
 [[tool.basedpyright.executionEnvironments]]
 root = "src/skvaider/inference/tests"
@@ -74,11 +74,11 @@ reportPrivateUsage = "none"
 root = "src/skvaider/tests"
 reportPrivateUsage = "none"
 
-
 [dependency-groups]
 dev = [
     "pytest>=8.4.1",
     "pytest-asyncio>=1.1.0",
     "pytest-cov>=6.2.1",
     "pytest-timeout>=2.4.0",
+    "aiohttp>=3.9.0",
 ]

scripts/repro_fc55454.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Reproduction for FC-55454: tool calls not executed when stream=False.
+
+Uses the WHQ endpoint (ai.whq.fcio.net) via the config-whq.toml from
+skvaider_api_client. Compares streaming vs non-streaming behavior.
+"""
+
+import asyncio
+import os
+import sys
+
+from openai import AsyncOpenAI
+
+# ---------------------------------------------------------------------------
+# Config — loaded from skvaider_api_client/config-whq.toml
+# ---------------------------------------------------------------------------
+BASE_URL = "https://ai.dev.fcio.net/openai/v1"
+API_KEY = "eyJpZCI6IDYwLCAic2VjcmV0IjogIlRqUUlEbkdPdHQ1b1dsMktoMTdDYVNhUk82RTZya3VzY1ZoWHBIVXgifQ=="
+MODEL = "gpt-oss:20b"
+MESSAGES = [
+    {"role": "user", "content": "What's the weather like in Hamburg right now?"}
+]
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get the current weather for a location.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "City and country, e.g. 'Berlin, Germany'",
+                    },
+                    "unit": {
+                        "type": "string",
+                        "enum": ["celsius", "fahrenheit"],
+                        "description": "Temperature unit",
+                    },
+                },
+                "required": ["location"],
+            },
+        },
+    }
+]
+
+
+async def test_non_streaming():
+    """TEST A: Non-streaming (stream=False) — this is the broken path."""
+    print("=" * 70)
+    print("TEST A: NON-STREAMING (stream=False)")
+    print("=" * 70)
+
+    client = AsyncOpenAI(base_url=BASE_URL, api_key=API_KEY)
+
+    resp = await client.chat.completions.create(
+        model=MODEL,
+        messages=MESSAGES,
+        tools=TOOLS,
+        tool_choice="auto",
+        stream=False,
+    )
+
+    choice = resp.choices[0]
+    print(f"finish_reason: {choice.finish_reason}")
+    print(f"message.content: {choice.message.content!r}")
+    print(f"message.tool_calls: {choice.message.tool_calls}")
+
+    if choice.message.tool_calls:
+        print("[OK] Tool calls present in non-streaming response")
+        for tc in choice.message.tool_calls:
+            print(f"  - {tc.function.name}({tc.function.arguments})")
+        return True
+    else:
+        print("[FAIL] No tool_calls in non-streaming response")
+        if choice.message.content:
+            print(f"  Got content instead: {choice.message.content!r}")
+        return False
+
+
+async def test_streaming():
+    """TEST B: Streaming (stream=True) — this should work."""
+    print()
+    print("=" * 70)
+    print("TEST B: STREAMING (stream=True)")
+    print("=" * 70)
+
+    client = AsyncOpenAI(base_url=BASE_URL, api_key=API_KEY)
+
+    stream = await client.chat.completions.create(
+        model=MODEL,
+        messages=MESSAGES,
+        tools=TOOLS,
+        tool_choice="auto",
+        stream=True,
+    )
+
+    # Accumulate chunks and reconstruct the final message
+    content_parts = []
+    tool_calls = []
+    finish_reason = None
+    async for chunk in stream:
+        if not chunk.choices:
+            continue
+        delta = chunk.choices[0].delta
+        if delta.content:
+            content_parts.append(delta.content)
+        if delta.tool_calls:
+            for tc in delta.tool_calls:
+                # Merge incremental tool call deltas
+                idx = tc.index
+                while len(tool_calls) <= idx:
+                    tool_calls.append(
+                        {"id": "", "function": {"name": "", "arguments": ""}}
+                    )
+                if tc.id:
+                    tool_calls[idx]["id"] = tc.id
+                if tc.function:
+                    if tc.function.name:
+                        tool_calls[idx]["function"]["name"] = tc.function.name
+                    if tc.function.arguments:
+                        tool_calls[idx]["function"]["arguments"] += (
+                            tc.function.arguments
+                        )
+        if chunk.choices[0].finish_reason:
+            finish_reason = chunk.choices[0].finish_reason
+
+    content = "".join(content_parts)
+    print(f"finish_reason: {finish_reason}")
+    print(f"message.content: {content!r}")
+    print(f"tool_calls: {tool_calls}")
+
+    if tool_calls:
+        print("[OK] Tool calls present in streaming response")
+        for tc in tool_calls:
+            print(
+                f"  - {tc['function']['name']}({tc['function']['arguments']})"
+            )
+        return True
+    else:
+        print("[FAIL] No tool_calls in streaming response")
+        if content:
+            print(f"  Got content instead: {content!r}")
+        return False
+
+
+async def main():
+    a_pass = await test_non_streaming()
+    b_pass = await test_streaming()
+
+    print()
+    print("=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+    print(f"  Non-streaming: {'PASS' if a_pass else 'FAIL'}")
+    print(f"  Streaming:     {'PASS' if b_pass else 'FAIL'}")
+
+    if not a_pass and b_pass:
+        print()
+        print(
+            "CONFIRMED: Bug FC-55454 — tool calls missing in non-streaming mode."
+        )
+        return 1
+    elif a_pass and b_pass:
+        print()
+        print("Both modes work — bug may be fixed or model-dependent.")
+        return 0
+    else:
+        print()
+        print("Both failed — check model availability / API key.")
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))