Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Make Kilo discovery and reasoning protocol-correct (#1274)

Ali Khokharcc9fc53c4ae1
diff --git a/.env.example b/.env.example
index 04bc7329..5427ff7c 100644
--- a/.env.example
+++ b/.env.example
@@ -154,6 +154,7 @@ FCC_SMOKE_MODEL_GEMINI=
FCC_SMOKE_MODEL_VERTEX=
FCC_SMOKE_MODEL_GROQ=
FCC_SMOKE_MODEL_SAMBANOVA=
+FCC_SMOKE_MODEL_KILO=
FCC_SMOKE_MODEL_CEREBRAS=
FCC_SMOKE_NIM_MODELS=
FCC_SMOKE_NIM_EXTRA_MODELS=
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 3de19947..e1e0c93c 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -668,8 +668,10 @@ Cloudflare uses its
account-scoped Workers AI OpenAI-compatible Chat Completions endpoint for
`@cf/...` model IDs, while account ID composition, model search, and
Cloudflare-specific reasoning deltas stay in the Cloudflare provider client.
-OpenRouter remains specialized for model filtering and reasoning-detail stream
-events. Amazon Bedrock Mantle uses an ordinary profile with a region-specific,
+OpenRouter and Kilo remain specialized for capability-aware model filtering and
+structured reasoning-detail stream events. Kilo excludes image-output and
+Responses-only models from Chat Completions discovery while keeping direct model
+execution upstream-authoritative. Amazon Bedrock Mantle uses an ordinary profile with a region-specific,
configurable OpenAI base URL and bearer API key; AWS SigV4 and native
Converse/Invoke transports are outside that provider contract. Wafer, Kimi API,
Kimi Code, MiniMax, Fireworks, and Z.ai use ordinary
diff --git a/pyproject.toml b/pyproject.toml
index 9af86e6e..5509ab4d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
[project]
name = "free-claude-code"
-version = "4.13.0"
+version = "4.13.1"
description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"
readme = "README.md"
requires-python = ">=3.14.0"
diff --git a/smoke/lib/config.py b/smoke/lib/config.py
index 4fd77a53..530a9819 100644
--- a/smoke/lib/config.py
+++ b/smoke/lib/config.py
@@ -69,6 +69,7 @@ PROVIDER_SMOKE_DEFAULT_MODELS: dict[str, str] = {
"vertex": "vertex/google/gemini-3.5-flash",
"groq": "groq/llama-3.3-70b-versatile",
"sambanova": "sambanova/Meta-Llama-3.3-70B-Instruct",
+ "kilo": "kilo/kilo-auto/free",
"cerebras": "cerebras/llama3.1-8b",
"cloudflare": "cloudflare/@cf/moonshotai/kimi-k2.6",
}
diff --git a/smoke/lib/e2e.py b/smoke/lib/e2e.py
index 21222f4b..cd551e0c 100644
--- a/smoke/lib/e2e.py
+++ b/smoke/lib/e2e.py
@@ -118,11 +118,12 @@ class ConversationDriver:
headers: dict[str, str] | None = None,
) -> ConversationTurn:
request_headers = headers or auth_headers()
+ stream_payload = {**payload, "stream": True}
with httpx.stream(
"POST",
f"{self.server.base_url}/v1/messages",
headers=request_headers,
- json=payload,
+ json=stream_payload,
timeout=self.config.timeout_s,
) as response:
if response.status_code != 200:
@@ -132,7 +133,7 @@ class ConversationDriver:
)
events = parse_sse_lines(response.iter_lines())
assert_anthropic_stream_contract(events)
- turn = ConversationTurn(payload, events)
+ turn = ConversationTurn(stream_payload, events)
self.turns.append(turn)
return turn
diff --git a/smoke/lib/http.py b/smoke/lib/http.py
index e8811bbc..7eb1759a 100644
--- a/smoke/lib/http.py
+++ b/smoke/lib/http.py
@@ -53,11 +53,12 @@ def collect_message_stream(
headers: dict[str, str] | None = None,
) -> list[SSEEvent]:
request_headers = headers or auth_headers()
+ stream_payload = {**payload, "stream": True}
with httpx.stream(
"POST",
f"{server.base_url}/v1/messages",
headers=request_headers,
- json=payload,
+ json=stream_payload,
timeout=config.timeout_s,
) as response:
if response.status_code != 200:
diff --git a/src/free_claude_code/providers/kilo/__init__.py b/src/free_claude_code/providers/kilo/__init__.py
new file mode 100644
index 00000000..6439211a
--- /dev/null
+++ b/src/free_claude_code/providers/kilo/__init__.py
@@ -0,0 +1,5 @@
+"""Kilo.ai provider exports."""
+
+from .client import KiloProvider
+
+__all__ = ["KiloProvider"]
diff --git a/src/free_claude_code/providers/kilo/client.py b/src/free_claude_code/providers/kilo/client.py
new file mode 100644
index 00000000..86a9ccbc
--- /dev/null
+++ b/src/free_claude_code/providers/kilo/client.py
@@ -0,0 +1,47 @@
+"""Kilo.ai provider implementation."""
+
+from free_claude_code.application.model_metadata import ProviderModelInfo
+from free_claude_code.core.anthropic import ReasoningReplayMode
+from free_claude_code.core.reasoning import ReasoningEffort
+from free_claude_code.providers.admission import ProviderAdmissionController
+from free_claude_code.providers.base import ProviderConfig
+from free_claude_code.providers.openai_chat import (
+ OpenAIChatProfile,
+ OpenAIChatProvider,
+ OpenAIChatRequestPolicy,
+ ReasoningObject,
+ apply_reasoning_details_replay,
+ validate_extra_body_does_not_override_canonical_fields,
+)
+
+from .models import extract_kilo_model_infos
+
+_PROFILE = OpenAIChatProfile(
+ OpenAIChatRequestPolicy(
+ provider_name="KILO",
+ reasoning_replay=ReasoningReplayMode.REASONING_CONTENT,
+ include_extra_body=True,
+ extra_body_validator=validate_extra_body_does_not_override_canonical_fields,
+ ),
+ ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),
+ postprocessors=(apply_reasoning_details_replay,),
+ reasoning_delta_field="reasoning",
+ structured_reasoning_details=True,
+)
+
+
+class KiloProvider(OpenAIChatProvider):
+ """Kilo gateway adapter with capability-aware discovery and reasoning."""
+
+ def __init__(
+ self, config: ProviderConfig, *, admission: ProviderAdmissionController
+ ) -> None:
+ super().__init__(config, profile=_PROFILE, admission=admission)
+
+ async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
+ """Advertise Kilo chat models that can execute FCC agent requests."""
+ payload = await self._list_models_payload()
+ return extract_kilo_model_infos(
+ payload,
+ provider_name=self._provider_name,
+ )
diff --git a/src/free_claude_code/providers/kilo/models.py b/src/free_claude_code/providers/kilo/models.py
new file mode 100644
index 00000000..c1b05023
--- /dev/null
+++ b/src/free_claude_code/providers/kilo/models.py
@@ -0,0 +1,60 @@
+"""Kilo.ai model-catalog interpretation."""
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from free_claude_code.application.model_metadata import ProviderModelInfo
+from free_claude_code.providers.model_listing import (
+ extract_tool_capable_model_infos,
+ model_list_items,
+)
+
+
+def extract_kilo_model_infos(
+ payload: Any, *, provider_name: str
+) -> frozenset[ProviderModelInfo]:
+ """Return chat/tool Kilo models with their advertised reasoning support."""
+ tool_models = extract_tool_capable_model_infos(
+ payload,
+ provider_name=provider_name,
+ )
+ excluded_ids = {
+ model_id
+ for item in model_list_items(payload, provider_name=provider_name)
+ if (model_id := _model_id(item)) is not None
+ and (_produces_images(item) or _requires_responses_api(item))
+ }
+ return frozenset(info for info in tool_models if info.model_id not in excluded_ids)
+
+
+def _produces_images(item: Any) -> bool:
+ architecture = _field(item, "architecture")
+ modalities = _string_values(_field(architecture, "output_modalities"))
+ return modalities is not None and "image" in modalities
+
+
+def _requires_responses_api(item: Any) -> bool:
+ opencode = _field(item, "opencode")
+ provider = _field(opencode, "ai_sdk_provider")
+ return isinstance(provider, str) and provider.casefold() == "openai"
+
+
+def _model_id(item: Any) -> str | None:
+ value = _field(item, "id")
+ return value if isinstance(value, str) and value.strip() else None
+
+
+def _string_values(value: Any) -> set[str] | None:
+ if not isinstance(value, Sequence) or isinstance(value, str | bytes | bytearray):
+ return None
+ return {item.casefold() for item in value if isinstance(item, str)}
+
+
+def _field(item: Any, name: str) -> Any:
+ if isinstance(item, Mapping):
+ return item.get(name)
+ value = getattr(item, name, None)
+ if value is not None:
+ return value
+ extra = getattr(item, "model_extra", None)
+ return extra.get(name) if isinstance(extra, Mapping) else None
diff --git a/src/free_claude_code/providers/model_listing.py b/src/free_claude_code/providers/model_listing.py
index 13d4a5bd..1120a34a 100644
--- a/src/free_claude_code/providers/model_listing.py
+++ b/src/free_claude_code/providers/model_listing.py
@@ -31,12 +31,8 @@ def extract_openai_model_infos(
payload: Any, *, provider_name: str
) -> frozenset[_ProviderModelInfo]:
"""Extract model metadata from an OpenAI-compatible ``/models`` response."""
- data = _field(payload, "data")
- if not _is_sequence(data):
- raise _malformed(provider_name, "expected top-level data array")
-
model_ids: set[str] = set()
- for item in data:
+ for item in model_list_items(payload, provider_name=provider_name):
model_id = _field(item, "id")
if not isinstance(model_id, str) or not model_id.strip():
raise _malformed(provider_name, "expected every data item to include id")
@@ -47,13 +43,11 @@ def extract_openai_model_infos(
return model_infos_from_ids(model_ids)
-def extract_openrouter_tool_model_infos(
+def extract_tool_capable_model_infos(
payload: Any, *, provider_name: str
) -> frozenset[_ProviderModelInfo]:
- """Extract OpenRouter tool-capable model ids with thinking capability metadata."""
- data = _field(payload, "data")
- if not _is_sequence(data):
- raise _malformed(provider_name, "expected top-level data array")
+ """Extract tool-capable models with ``supported_parameters`` metadata."""
+ data = model_list_items(payload, provider_name=provider_name)
model_infos: set[_ProviderModelInfo] = set()
for item in data:
@@ -79,6 +73,14 @@ def extract_openrouter_tool_model_infos(
return frozenset(model_infos)
+def model_list_items(payload: Any, *, provider_name: str) -> tuple[Any, ...]:
+ """Return a validated OpenAI-shaped model-list data array."""
+ data = _field(payload, "data")
+ if not _is_sequence(data):
+ raise _malformed(provider_name, "expected top-level data array")
+ return tuple(data)
+
+
def _field(item: Any, name: str) -> Any:
if isinstance(item, Mapping):
return item.get(name)
diff --git a/src/free_claude_code/providers/open_router/client.py b/src/free_claude_code/providers/open_router/client.py
index 9f8c53bf..7410f4cb 100644
--- a/src/free_claude_code/providers/open_router/client.py
+++ b/src/free_claude_code/providers/open_router/client.py
@@ -1,26 +1,18 @@
"""OpenRouter provider implementation."""
-import json
-from collections.abc import Iterator, Mapping, Sequence
-from typing import Any
-
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from free_claude_code.core.anthropic import (
- ReasoningReplayMode,
- is_synthetic_openai_tool_turn_boundary,
-)
-from free_claude_code.core.anthropic.models import MessagesRequest
-from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger
-from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
+from free_claude_code.core.anthropic import ReasoningReplayMode
+from free_claude_code.core.reasoning import ReasoningEffort
from free_claude_code.providers.admission import ProviderAdmissionController
from free_claude_code.providers.base import ProviderConfig
-from free_claude_code.providers.model_listing import extract_openrouter_tool_model_infos
+from free_claude_code.providers.model_listing import extract_tool_capable_model_infos
from free_claude_code.providers.openai_chat import (
OpenAIChatProfile,
OpenAIChatProvider,
OpenAIChatRequestPolicy,
ReasoningObject,
+ apply_reasoning_details_replay,
validate_extra_body_does_not_override_canonical_fields,
)
@@ -48,158 +40,14 @@ class OpenRouterProvider(OpenAIChatProvider):
async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
"""Advertise OpenRouter tool models with reasoning capability metadata."""
payload = await self._list_models_payload()
- return extract_openrouter_tool_model_infos(
+ return extract_tool_capable_model_infos(
payload, provider_name=self._provider_name
)
- async def _list_models_payload(self) -> Any:
- return await self._admission.run_with_retry(
- self._client.models.list,
- provider_failure_override=self._provider_failure_override,
- )
-
- def _handle_extra_reasoning(
- self, delta: Any, ledger: AnthropicStreamLedger, *, output_reasoning: bool
- ) -> Iterator[str]:
- """Map OpenRouter reasoning details onto Anthropic thinking blocks."""
- if not output_reasoning:
- return iter(())
- return _iter_openrouter_reasoning_detail_events(delta, ledger)
-
-
-def _apply_openrouter_reasoning_details_replay(
- body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy
-) -> None:
- assistant_details = _assistant_reasoning_details(request.messages)
- if not assistant_details:
- return
- messages = body.get("messages")
- if not isinstance(messages, list):
- return
-
- cursor = 0
- for details in assistant_details:
- for index in range(cursor, len(messages)):
- message = messages[index]
- if (
- not isinstance(message, dict)
- or message.get("role") != "assistant"
- or is_synthetic_openai_tool_turn_boundary(message)
- ):
- continue
- existing = message.get("reasoning_details")
- if isinstance(existing, list):
- existing.extend(details)
- else:
- message["reasoning_details"] = list(details)
- cursor = index + 1
- break
-
_PROFILE = OpenAIChatProfile(
_REQUEST_POLICY,
ReasoningObject(tuple((effort, effort.value) for effort in ReasoningEffort)),
- postprocessors=(_apply_openrouter_reasoning_details_replay,),
+ postprocessors=(apply_reasoning_details_replay,),
+ structured_reasoning_details=True,
)
-
-
-def _assistant_reasoning_details(messages: Any) -> list[list[dict[str, Any]]]:
- if not _is_sequence(messages):
- return []
- result: list[list[dict[str, Any]]] = []
- for message in messages:
- if _field(message, "role") != "assistant":
- continue
- details = _redacted_reasoning_details(_field(message, "content"))
- if details:
- result.append(details)
- return result
-
-
-def _redacted_reasoning_details(content: Any) -> list[dict[str, Any]]:
- if not _is_sequence(content):
- return []
- details: list[dict[str, Any]] = []
- for block in content:
- if _field(block, "type") != "redacted_thinking":
- continue
- data = _field(block, "data")
- if not isinstance(data, str) or not data:
- continue
- parsed = _json_payload(data)
- if isinstance(parsed, list):
- details.extend(item for item in parsed if isinstance(item, dict))
- elif isinstance(parsed, dict):
- details.append(parsed)
- else:
- details.append({"type": "reasoning.encrypted", "data": data})
- return details
-
-
-def _iter_openrouter_reasoning_detail_events(
- delta: Any, ledger: AnthropicStreamLedger
-) -> Iterator[str]:
- details = _field(delta, "reasoning_details")
- if details is None:
- extra = _field(delta, "model_extra")
- if isinstance(extra, Mapping):
- details = extra.get("reasoning_details")
- if not _is_sequence(details):
- return
-
- native_reasoning = _field(delta, "reasoning_content")
- has_native_reasoning = isinstance(native_reasoning, str) and bool(native_reasoning)
- for detail in details:
- encrypted = _reasoning_detail_encrypted(detail)
- if encrypted:
- yield from ledger.close_content_blocks()
- index = ledger.blocks.allocate_index()
- yield ledger.content_block_start(index, "redacted_thinking", data=encrypted)
- yield ledger.content_block_stop(index)
- continue
- if has_native_reasoning:
- continue
- text = _reasoning_detail_text(detail)
- if not text:
- continue
- yield from ledger.ensure_thinking_block()
- yield ledger.emit_thinking_delta(text)
-
-
-def _reasoning_detail_text(detail: Any) -> str | None:
- kind = str(_field(detail, "type") or "").lower()
- if "encrypted" in kind or "redacted" in kind:
- return None
- for key in ("text", "content", "reasoning"):
- value = _field(detail, key)
- if isinstance(value, str) and value:
- return value
- return None
-
-
-def _reasoning_detail_encrypted(detail: Any) -> str | None:
- kind = str(_field(detail, "type") or "").lower()
- if "encrypted" not in kind and "redacted" not in kind and "summary" not in kind:
- return None
- if isinstance(detail, Mapping):
- return json.dumps(dict(detail), separators=(",", ":"))
- return None
-
-
-def _json_payload(value: str) -> Any:
- try:
- return json.loads(value)
- except json.JSONDecodeError:
- return None
-
-
-def _field(item: Any, name: str) -> Any:
- if isinstance(item, Mapping):
- return item.get(name)
- return getattr(item, name, None)
-
-
-def _is_sequence(value: Any) -> bool:
- return isinstance(value, Sequence) and not isinstance(
- value, str | bytes | bytearray
- )
diff --git a/src/free_claude_code/providers/openai_chat/__init__.py b/src/free_claude_code/providers/openai_chat/__init__.py
index b4ccf3a1..fcf8b146 100644
--- a/src/free_claude_code/providers/openai_chat/__init__.py
+++ b/src/free_claude_code/providers/openai_chat/__init__.py
@@ -16,6 +16,7 @@ from .reasoning import (
NamedEffortReasoning,
ReasoningObject,
)
+from .reasoning_details import apply_reasoning_details_replay
from .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_body
from .usage import usage_int
@@ -49,6 +50,7 @@ __all__ = [
"OpenAIChatProvider",
"OpenAIChatRequestPolicy",
"ReasoningObject",
+ "apply_reasoning_details_replay",
"build_openai_chat_request_body",
"create_openai_chat_provider",
"openai_v1_base_url",
diff --git a/src/free_claude_code/providers/openai_chat/profiles.py b/src/free_claude_code/providers/openai_chat/profiles.py
index 2e58b901..0cd70486 100644
--- a/src/free_claude_code/providers/openai_chat/profiles.py
+++ b/src/free_claude_code/providers/openai_chat/profiles.py
@@ -65,6 +65,7 @@ class OpenAIChatProfile:
reasoning_delta_field: Literal["reasoning_content", "reasoning"] = (
"reasoning_content"
)
+ structured_reasoning_details: bool = False
user_agent: str | None = None
@property
@@ -295,15 +296,6 @@ OPENAI_CHAT_PROFILES: dict[str, OpenAIChatProfile] = {
enabled_value="medium",
),
),
- "kilo": OpenAIChatProfile(
- _policy(
- "KILO",
- ReasoningReplayMode.REASONING_CONTENT,
- include_extra_body=True,
- extra_body_validator=validate_extra_body_does_not_override_reasoning_fields,
- ),
- ReasoningObject(_ALL_EFFORTS),
- ),
"fireworks": OpenAIChatProfile(
_policy(
"FIREWORKS",
diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.py
index 3f994f4f..bf5378bc 100644
--- a/src/free_claude_code/providers/openai_chat/provider.py
+++ b/src/free_claude_code/providers/openai_chat/provider.py
@@ -57,6 +57,7 @@ from free_claude_code.providers.stream_recovery import (
from .output_cap import clamp_output_tokens, parse_output_token_cap
from .profiles import OpenAIChatProfile
+from .reasoning_details import StructuredReasoningStream
from .request_policy import build_openai_chat_request_body
from .tool_calls import (
OpenAIToolCallAssembler,
@@ -138,11 +139,16 @@ class OpenAIChatProvider(BaseProvider):
async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
"""Return model metadata from the OpenAI-compatible models endpoint."""
+ payload = await self._list_models_payload()
+ return extract_openai_model_infos(payload, provider_name=self._provider_name)
+
+ async def _list_models_payload(self) -> Any:
+ """Fetch one OpenAI-compatible model-list payload with shared retries."""
payload = await self._admission.run_with_retry(
self._client.models.list,
provider_failure_override=self._provider_failure_override,
)
- return extract_openai_model_infos(payload, provider_name=self._provider_name)
+ return payload
def _build_request_body(
self,
@@ -402,6 +408,11 @@ class _OpenAIChatStreamRunner:
tool_argument_alias_buffers: dict[int, str] = {}
while True:
+ structured_reasoning = (
+ StructuredReasoningStream()
+ if self._provider._profile.structured_reasoning_details
+ else None
+ )
if not ledger.message_started:
for event in hold_event(ledger.message_start()):
yield event
@@ -435,14 +446,23 @@ class _OpenAIChatStreamRunner:
logger.debug("{} finish_reason: {}", tag, finish_reason)
reasoning = self._provider._profile.reasoning_delta(delta)
- if output_reasoning and reasoning is not None:
- for event in hold_events(ledger.ensure_thinking_block()):
- yield event
- if reasoning:
- for event in hold_event(
- ledger.emit_thinking_delta(reasoning)
+ if output_reasoning:
+ if structured_reasoning is not None:
+ for event in structured_reasoning.events(
+ delta,
+ ledger,
+ native_reasoning=reasoning,
):
+ for out_event in hold_event(event):
+ yield out_event
+ elif reasoning is not None:
+ for event in hold_events(ledger.ensure_thinking_block()):
yield event
+ if reasoning:
+ for event in hold_event(
+ ledger.emit_thinking_delta(reasoning)
+ ):
+ yield event
for event in self._provider._handle_extra_reasoning(
delta,
diff --git a/src/free_claude_code/providers/openai_chat/reasoning_details.py b/src/free_claude_code/providers/openai_chat/reasoning_details.py
new file mode 100644
index 00000000..be576681
--- /dev/null
+++ b/src/free_claude_code/providers/openai_chat/reasoning_details.py
@@ -0,0 +1,174 @@
+"""OpenRouter-format structured reasoning replay and stream conversion."""
+
+import json
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, Literal
+
+from free_claude_code.core.anthropic import (
+ is_synthetic_openai_tool_turn_boundary,
+)
+from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger
+from free_claude_code.core.reasoning import ReasoningPolicy
+
+
+def apply_reasoning_details_replay(
+ body: dict[str, Any], request: MessagesRequest, _policy: ReasoningPolicy
+) -> None:
+ """Replay opaque reasoning details on their converted assistant messages."""
+ assistant_details = _assistant_reasoning_details(request.messages)
+ if not assistant_details:
+ return
+ messages = body.get("messages")
+ if not isinstance(messages, list):
+ return
+
+ cursor = 0
+ for details in assistant_details:
+ for index in range(cursor, len(messages)):
+ message = messages[index]
+ if (
+ not isinstance(message, dict)
+ or message.get("role") != "assistant"
+ or is_synthetic_openai_tool_turn_boundary(message)
+ ):
+ continue
+ existing = message.get("reasoning_details")
+ if isinstance(existing, list):
+ existing.extend(details)
+ else:
+ message["reasoning_details"] = list(details)
+ cursor = index + 1
+ break
+
+
+class StructuredReasoningStream:
+ """Reconcile alternate plaintext reasoning representations for one stream."""
+
+ def __init__(self) -> None:
+ self._text_source: Literal["native", "details"] | None = None
+
+ def events(
+ self,
+ delta: Any,
+ ledger: AnthropicStreamLedger,
+ *,
+ native_reasoning: str | None,
+ ) -> Iterator[str]:
+ """Emit plaintext once while preserving every opaque reasoning detail."""
+ details = _reasoning_details(delta)
+ if self._text_source is None:
+ if native_reasoning:
+ self._text_source = "native"
+ elif any(_reasoning_detail_text(detail) for detail in details):
+ self._text_source = "details"
+
+ if self._text_source == "native" and native_reasoning:
+ yield from ledger.ensure_thinking_block()
+ yield ledger.emit_thinking_delta(native_reasoning)
+
+ for detail in details:
+ preserved = _preserved_reasoning_detail(detail)
+ if preserved:
+ yield from ledger.close_content_blocks()
+ index = ledger.blocks.allocate_index()
+ yield ledger.content_block_start(
+ index,
+ "redacted_thinking",
+ data=preserved,
+ )
+ yield ledger.content_block_stop(index)
+ continue
+ if self._text_source != "details":
+ continue
+ text = _reasoning_detail_text(detail)
+ if not text:
+ continue
+ yield from ledger.ensure_thinking_block()
+ yield ledger.emit_thinking_delta(text)
+
+
+def _reasoning_details(delta: Any) -> Sequence[Any]:
+ details = _field(delta, "reasoning_details")
+ if details is None:
+ extra = _field(delta, "model_extra")
+ if isinstance(extra, Mapping):
+ details = extra.get("reasoning_details")
+ return details if _is_sequence(details) else ()
+
+
+def _assistant_reasoning_details(messages: Any) -> list[list[dict[str, Any]]]:
+ if not _is_sequence(messages):
+ return []
+ result: list[list[dict[str, Any]]] = []
+ for message in messages:
+ if _field(message, "role") != "assistant":
+ continue
+ details = _redacted_reasoning_details(_field(message, "content"))
+ if details:
+ result.append(details)
+ return result
+
+
+def _redacted_reasoning_details(content: Any) -> list[dict[str, Any]]:
+ if not _is_sequence(content):
+ return []
+ details: list[dict[str, Any]] = []
+ for block in content:
+ if _field(block, "type") != "redacted_thinking":
+ continue
+ data = _field(block, "data")
+ if not isinstance(data, str) or not data:
+ continue
+ parsed = _json_payload(data)
+ if isinstance(parsed, list):
+ details.extend(item for item in parsed if isinstance(item, dict))
+ elif isinstance(parsed, dict):
+ details.append(parsed)
+ else:
+ details.append({"type": "reasoning.encrypted", "data": data})
+ return details
+
+
+def _reasoning_detail_text(detail: Any) -> str | None:
+ kind = str(_field(detail, "type") or "").lower()
+ if "encrypted" in kind or "redacted" in kind:
+ return None
+ for key in ("text", "content", "reasoning"):
+ value = _field(detail, key)
+ if isinstance(value, str) and value:
+ return value
+ return None
+
+
+def _preserved_reasoning_detail(detail: Any) -> str | None:
+ if not isinstance(detail, Mapping):
+ return None
+ kind = str(_field(detail, "type") or "").lower()
+ if (
+ "encrypted" in kind
+ or "redacted" in kind
+ or "summary" in kind
+ or _reasoning_detail_text(detail) is None
+ ):
+ return json.dumps(dict(detail), separators=(",", ":"))
+ return None
+
+
+def _json_payload(value: str) -> Any:
+ try:
+ return json.loads(value)
+ except json.JSONDecodeError:
+ return None
+
+
+def _field(item: Any, name: str) -> Any:
+ if isinstance(item, Mapping):
+ return item.get(name)
+ return getattr(item, name, None)
+
+
+def _is_sequence(value: Any) -> bool:
+ return isinstance(value, Sequence) and not isinstance(
+ value, str | bytes | bytearray
+ )
diff --git a/src/free_claude_code/providers/runtime/factory.py b/src/free_claude_code/providers/runtime/factory.py
index e6e547bd..c2793b33 100644
--- a/src/free_claude_code/providers/runtime/factory.py
+++ b/src/free_claude_code/providers/runtime/factory.py
@@ -53,6 +53,16 @@ def _create_mistral(
return MistralProvider(config, admission=admission)
+def _create_kilo(
+ config: ProviderConfig,
+ _settings: Settings,
+ admission: ProviderAdmissionController,
+) -> BaseProvider:
+ from free_claude_code.providers.kilo import KiloProvider
+
+ return KiloProvider(config, admission=admission)
+
+
def _create_deepseek(
config: ProviderConfig,
_settings: Settings,
@@ -126,6 +136,7 @@ _SPECIAL_PROVIDER_FACTORIES: dict[str, ProviderFactory] = {
"nvidia_nim": _create_nvidia_nim,
"open_router": _create_open_router,
"mistral": _create_mistral,
+ "kilo": _create_kilo,
"deepseek": _create_deepseek,
"lmstudio": _create_lmstudio,
"cloudflare": _create_cloudflare,
diff --git a/tests/contracts/test_feature_manifest.py b/tests/contracts/test_feature_manifest.py
index 29d1cc69..9afba6e0 100644
--- a/tests/contracts/test_feature_manifest.py
+++ b/tests/contracts/test_feature_manifest.py
@@ -8,6 +8,7 @@ from free_claude_code.providers.cloudflare import CloudflareProvider
from free_claude_code.providers.deepseek import DeepSeekProvider
from free_claude_code.providers.gemini import GeminiProvider
from free_claude_code.providers.github_models import GitHubModelsProvider
+from free_claude_code.providers.kilo import KiloProvider
from free_claude_code.providers.lmstudio import LMStudioProvider
from free_claude_code.providers.mistral import MistralProvider
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
@@ -95,6 +96,7 @@ def test_provider_and_platform_registries_include_advertised_builtins() -> None:
"open_router": OpenRouterProvider,
"mistral": MistralProvider,
"deepseek": DeepSeekProvider,
+ "kilo": KiloProvider,
"cloudflare": CloudflareProvider,
"lmstudio": LMStudioProvider,
"github_models": GitHubModelsProvider,
diff --git a/tests/contracts/test_smoke_child_process.py b/tests/contracts/test_smoke_child_process.py
index 888fc31b..eedf9af8 100644
--- a/tests/contracts/test_smoke_child_process.py
+++ b/tests/contracts/test_smoke_child_process.py
@@ -1,8 +1,11 @@
import subprocess
from pathlib import Path
+from unittest.mock import MagicMock
from free_claude_code.config.settings import Settings
from smoke.lib import child_process
+from smoke.lib import e2e as smoke_e2e
+from smoke.lib import http as smoke_http
from smoke.lib import server as smoke_server
from smoke.lib.child_process import (
cmd_fcc_server,
@@ -10,6 +13,9 @@ from smoke.lib.child_process import (
run_captured_text,
)
from smoke.lib.config import SmokeConfig
+from smoke.lib.e2e import ConversationDriver
+from smoke.lib.http import collect_message_stream
+from smoke.lib.server import RunningServer
def test_fcc_server_command_uses_cli_entrypoint() -> None:
@@ -63,6 +69,53 @@ def test_start_server_disables_cli_admin_browser(monkeypatch, tmp_path: Path) ->
assert env["PORT"] == "4567"
+def test_collect_message_stream_explicitly_requests_sse(
+ monkeypatch, tmp_path: Path
+) -> None:
+ captured: dict[str, object] = {}
+
+ def fake_stream(_method: str, _url: str, **kwargs: object):
+ captured.update(kwargs)
+ return _FakeStreamResponse()
+
+ monkeypatch.setattr(smoke_http.httpx, "stream", fake_stream)
+ payload = {"model": "m", "messages": [], "stream": False}
+
+ events = collect_message_stream(
+ _running_server(tmp_path),
+ payload,
+ _smoke_config(tmp_path),
+ headers={"authorization": "Bearer test"},
+ )
+
+ assert captured["json"] == {**payload, "stream": True}
+ assert payload["stream"] is False
+ assert events[-1].event == "message_stop"
+
+
+def test_conversation_driver_explicitly_requests_sse(
+ monkeypatch, tmp_path: Path
+) -> None:
+ captured: dict[str, object] = {}
+
+ def fake_stream(_method: str, _url: str, **kwargs: object):
+ captured.update(kwargs)
+ return _FakeStreamResponse()
+
+ monkeypatch.setattr(smoke_e2e.httpx, "stream", fake_stream)
+ payload = {"model": "m", "messages": [], "stream": False}
+
+ turn = ConversationDriver(
+ _running_server(tmp_path),
+ _smoke_config(tmp_path),
+ ).stream(payload, headers={"authorization": "Bearer test"})
+
+ assert captured["json"] == {**payload, "stream": True}
+ assert payload["stream"] is False
+ assert turn.request["stream"] is True
+ assert turn.events[-1].event == "message_stop"
+
+
def test_run_captured_text_uses_utf8_replacement(monkeypatch, tmp_path: Path) -> None:
calls: dict[str, object] = {}
@@ -114,3 +167,61 @@ def test_run_captured_text_replaces_invalid_utf8_bytes(tmp_path: Path) -> None:
assert result.returncode == 0
assert result.stdout == "\ufffd"
assert result.stderr == "\ufffd"
+
+
+class _FakeStreamResponse:
+ status_code = 200
+
+ def __enter__(self) -> _FakeStreamResponse:
+ return self
+
+ def __exit__(self, *_args: object) -> None:
+ return
+
+ def iter_lines(self):
+ return iter(
+ (
+ "event: message_start",
+ 'data: {"type":"message_start","message":{}}',
+ "",
+ "event: content_block_start",
+ 'data: {"type":"content_block_start","index":0,'
+ '"content_block":{"type":"text","text":""}}',
+ "",
+ "event: content_block_delta",
+ 'data: {"type":"content_block_delta","index":0,'
+ '"delta":{"type":"text_delta","text":"ok"}}',
+ "",
+ "event: content_block_stop",
+ 'data: {"type":"content_block_stop","index":0}',
+ "",
+ "event: message_stop",
+ 'data: {"type":"message_stop"}',
+ "",
+ )
+ )
+
+
+def _smoke_config(tmp_path: Path) -> SmokeConfig:
+ return SmokeConfig(
+ root=tmp_path,
+ results_dir=tmp_path / "results",
+ live=False,
+ interactive=False,
+ targets=frozenset(),
+ provider_matrix=frozenset(),
+ timeout_s=1.0,
+ prompt="",
+ claude_bin="claude",
+ worker_id="test",
+ settings=Settings(),
+ )
+
+
+def _running_server(tmp_path: Path) -> RunningServer:
+ return RunningServer(
+ base_url="http://127.0.0.1:1234",
+ port=1234,
+ log_path=tmp_path / "server.log",
+ process=MagicMock(spec=subprocess.Popen),
+ )
diff --git a/tests/contracts/test_smoke_config.py b/tests/contracts/test_smoke_config.py
index c5d2b9e8..77c483ed 100644
--- a/tests/contracts/test_smoke_config.py
+++ b/tests/contracts/test_smoke_config.py
@@ -45,6 +45,7 @@ def _settings(**overrides):
"cohere_api_key": "",
"github_models_token": "",
"zai_api_key": "",
+ "kilo_api_key": "",
"gemini_api_key": "",
"vertex_project_id": "",
"vertex_location": "global",
@@ -159,6 +160,19 @@ def test_openrouter_provider_smoke_uses_concrete_free_model(monkeypatch) -> None
assert models[0].source == "provider_default"
+def test_kilo_provider_smoke_uses_concrete_free_model(monkeypatch) -> None:
+ monkeypatch.delenv("FCC_SMOKE_MODEL_KILO", raising=False)
+ config = _smoke_config(
+ settings=_settings(kilo_api_key="anonymous", ollama_base_url="")
+ )
+
+ models = config.provider_smoke_models()
+
+ assert [model.provider for model in models] == ["kilo"]
+ assert models[0].full_model == "kilo/kilo-auto/free"
+ assert models[0].source == "provider_default"
+
+
def test_bedrock_provider_configuration_uses_official_api_key(monkeypatch) -> None:
monkeypatch.delenv("FCC_SMOKE_MODEL_BEDROCK", raising=False)
config = _smoke_config(
diff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.py
index fc7a4ff7..fb6e9c58 100644
--- a/tests/providers/test_kilo.py
+++ b/tests/providers/test_kilo.py
@@ -1,17 +1,27 @@
"""Tests for the Kilo.ai OpenAI-chat provider."""
-from unittest.mock import AsyncMock, MagicMock
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from free_claude_code.application.errors import InvalidRequestError
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.config.provider_catalog import KILO_DEFAULT_BASE
from free_claude_code.core.anthropic.models import Message, MessagesRequest
+from free_claude_code.core.anthropic.stream_contracts import (
+ parse_sse_text,
+ text_content,
+ thinking_content,
+)
+from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.base import ProviderConfig
+from free_claude_code.providers.kilo import KiloProvider
+from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from tests.providers.support import (
immediate_admission,
- profiled_provider,
reasoning_for,
)
@@ -28,18 +38,52 @@ def kilo_config():
@pytest.fixture
def kilo_provider(kilo_config):
- return profiled_provider(
- "kilo",
+ return KiloProvider(
kilo_config,
- admission=immediate_admission(),
+ admission=immediate_admission(provider_name="kilo"),
+ )
+
+
+class AsyncStream:
+ def __init__(self, chunks):
+ self._chunks = chunks
+ self.closed = False
+
+ def __aiter__(self):
+ return self._iter()
+
+ async def _iter(self):
+ for chunk in self._chunks:
+ yield chunk
+
+ async def aclose(self):
+ self.closed = True
+
+
+def _chunk(
+ *,
+ content: str | None = None,
+ reasoning: str | None = None,
+ reasoning_details: list[dict] | None = None,
+ finish_reason: str | None = None,
+):
+ delta = SimpleNamespace(
+ content=content,
+ reasoning=reasoning,
+ tool_calls=None,
)
+ if reasoning_details is not None:
+ delta.reasoning_details = reasoning_details
+ choice = SimpleNamespace(delta=delta, finish_reason=finish_reason)
+ return SimpleNamespace(choices=[choice], usage=None)
def test_default_base_url():
assert KILO_DEFAULT_BASE == "https://api.kilo.ai/api/gateway"
-def test_init_uses_openai_chat_provider(kilo_provider):
+def test_init_uses_specialized_openai_chat_provider(kilo_provider):
+ assert isinstance(kilo_provider, KiloProvider)
assert isinstance(kilo_provider, OpenAIChatProvider)
assert kilo_provider._api_key == "test_kilo_key"
assert kilo_provider._base_url == KILO_DEFAULT_BASE
@@ -76,6 +120,30 @@ def test_build_request_body_forwards_caller_extra_body(kilo_provider):
assert body.get("extra_body", {}).get("custom_field") == "value"
+ "field",
+ [
+ "model",
+ "messages",
+ "tools",
+ "stream",
+ "max_tokens",
+ "reasoning",
+ ],
+)
+def test_extra_body_cannot_override_canonical_request_fields(kilo_provider, field):
+ request = MessagesRequest.model_validate(
+ {
+ "model": "m",
+ "messages": [{"role": "user", "content": "hi"}],
+ "extra_body": {field: "hijack"},
+ }
+ )
+
+ with pytest.raises(InvalidRequestError, match=field):
+ kilo_provider._build_request_body(request, reasoning=reasoning_for(request))
+
+
def test_build_request_body_sends_reasoning_object(kilo_provider):
request = MessagesRequest.model_validate(
{
@@ -91,8 +159,6 @@ def test_build_request_body_sends_reasoning_object(kilo_provider):
def test_build_request_body_sends_reasoning_disabled(kilo_provider):
- from free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy
-
request = MessagesRequest.model_validate(
{
"model": "m",
@@ -102,33 +168,276 @@ def test_build_request_body_sends_reasoning_disabled(kilo_provider):
body = kilo_provider._build_request_body(
request,
- reasoning=ReasoningPolicy(control=ReasoningControl.OFF),
+ reasoning=ReasoningPolicy.off(),
)
assert body["extra_body"]["reasoning"] == {"enabled": False}
+def test_build_request_body_replays_opaque_reasoning_details_on_tool_turn(
+ kilo_provider,
+):
+ detail = {
+ "type": "reasoning.opaque",
+ "data": {"signature": "opaque-value"},
+ }
+ request = MessagesRequest.model_validate(
+ {
+ "model": "m",
+ "messages": [
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "redacted_thinking",
+ "data": json.dumps(detail),
+ },
+ {
+ "type": "tool_use",
+ "id": "call_read",
+ "name": "Read",
+ "input": {},
+ },
+ ],
+ },
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "tool_result",
+ "tool_use_id": "call_read",
+ "content": "contents",
+ }
+ ],
+ },
+ ],
+ }
+ )
+
+ body = kilo_provider._build_request_body(
+ request,
+ reasoning=reasoning_for(request),
+ )
+
+ assistant = next(msg for msg in body["messages"] if msg["role"] == "assistant")
+ assert assistant["reasoning_details"] == [detail]
+
+
+ "reasoning_chunks",
+ [
+ [
+ _chunk(
+ reasoning="plan ",
+ reasoning_details=[{"type": "reasoning.text", "text": "plan "}],
+ )
+ ],
+ [
+ _chunk(reasoning="plan "),
+ _chunk(reasoning_details=[{"type": "reasoning.text", "text": "plan "}]),
+ ],
+ ],
+ ids=["same-delta", "cross-delta"],
+)
+async def test_stream_uses_reasoning_field_without_duplicating_plain_details(
+ kilo_provider,
+ reasoning_chunks,
+):
+ encrypted = {"type": "reasoning.encrypted", "data": "opaque"}
+ stream = AsyncStream(
+ [
+ *reasoning_chunks,
+ _chunk(reasoning_details=[encrypted]),
+ _chunk(content="done", finish_reason="stop"),
+ ]
+ )
+ request = MessagesRequest.model_validate(
+ {
+ "model": "kilo-auto/free",
+ "messages": [{"role": "user", "content": "Hello"}],
+ }
+ )
+ with patch.object(
+ kilo_provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream,
+ ):
+ event_text = "".join(
+ [event async for event in kilo_provider.stream_response(request)]
+ )
+
+ events = parse_sse_text(event_text)
+ assert thinking_content(events) == "plan "
+ assert text_content(events) == "done"
+ redacted_blocks = [
+ event.data["content_block"]
+ for event in events
+ if event.event == "content_block_start"
+ and event.data.get("content_block", {}).get("type") == "redacted_thinking"
+ ]
+ assert len(redacted_blocks) == 1
+ assert json.loads(redacted_blocks[0]["data"]) == encrypted
+ assert stream.closed
+
+
+async def test_stream_restarts_reasoning_reconciliation_after_early_retry(
+ kilo_provider,
+):
+ abandoned = AsyncStream([_chunk(reasoning="discarded ")])
+ recovered = AsyncStream(
+ [
+ _chunk(reasoning_details=[{"type": "reasoning.text", "text": "plan "}]),
+ _chunk(content="done", finish_reason="stop"),
+ ]
+ )
+ request = MessagesRequest.model_validate(
+ {
+ "model": "kilo-auto/free",
+ "messages": [{"role": "user", "content": "Hello"}],
+ }
+ )
+ with patch.object(
+ kilo_provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ side_effect=[abandoned, recovered],
+ ) as create:
+ event_text = "".join(
+ [event async for event in kilo_provider.stream_response(request)]
+ )
+
+ events = parse_sse_text(event_text)
+ assert thinking_content(events) == "plan "
+ assert text_content(events) == "done"
+ assert create.await_count == 2
+ assert abandoned.closed
+ assert recovered.closed
+
+
@pytest.mark.asyncio
-async def test_model_list_uses_openai_client_models_endpoint(kilo_provider):
+async def test_stream_omits_all_reasoning_representations_when_disabled(
+ kilo_provider,
+):
+ stream = AsyncStream(
+ [
+ _chunk(
+ reasoning="plan ",
+ reasoning_details=[
+ {"type": "reasoning.text", "text": "plan "},
+ {"type": "reasoning.encrypted", "data": "opaque"},
+ ],
+ ),
+ _chunk(content="done", finish_reason="stop"),
+ ]
+ )
+ request = MessagesRequest.model_validate(
+ {
+ "model": "kilo-auto/free",
+ "messages": [{"role": "user", "content": "Hello"}],
+ }
+ )
+ with patch.object(
+ kilo_provider._client.chat.completions,
+ "create",
+ new_callable=AsyncMock,
+ return_value=stream,
+ ):
+ event_text = "".join(
+ [
+ event
+ async for event in kilo_provider.stream_response(
+ request,
+ reasoning=ReasoningPolicy.off(),
+ )
+ ]
+ )
+
+ events = parse_sse_text(event_text)
+ assert thinking_content(events) == ""
+ assert text_content(events) == "done"
+ assert all(
+ event.data.get("content_block", {}).get("type") != "redacted_thinking"
+ for event in events
+ if event.event == "content_block_start"
+ )
+ assert stream.closed
+
+
+async def test_model_list_filters_to_chat_tool_models_with_capabilities(kilo_provider):
kilo_provider._client.models.list = AsyncMock(
- return_value=MagicMock(
+ return_value=SimpleNamespace(
data=[
- MagicMock(id="anthropic/claude-sonnet-4.5"),
- MagicMock(id="openai/gpt-5.4"),
+ {
+ "id": "anthropic/tool-reasoning",
+ "supported_parameters": ["tools", "reasoning"],
+ "architecture": {"output_modalities": ["text"]},
+ "opencode": {"ai_sdk_provider": "anthropic"},
+ },
+ {
+ "id": "plain-tool",
+ "supported_parameters": ["tool_choice"],
+ "architecture": {"output_modalities": ["text"]},
+ "opencode": {},
+ },
+ {
+ "id": "missing-optional-metadata",
+ "supported_parameters": ["tools"],
+ },
+ {
+ "id": "chat-only",
+ "supported_parameters": ["reasoning"],
+ },
+ {
+ "id": "image-output",
+ "supported_parameters": ["tools"],
+ "architecture": {"output_modalities": ["text", "image"]},
+ },
+ {
+ "id": "responses-only",
+ "supported_parameters": ["tools", "reasoning"],
+ "opencode": {"ai_sdk_provider": "openai"},
+ },
+ {
+ "id": "missing-tool-metadata",
+ "supported_parameters": None,
+ },
]
)
)
assert await kilo_provider.list_model_infos() == frozenset(
{
- ProviderModelInfo("anthropic/claude-sonnet-4.5"),
- ProviderModelInfo("openai/gpt-5.4"),
+ ProviderModelInfo("anthropic/tool-reasoning", supports_thinking=True),
+ ProviderModelInfo("plain-tool", supports_thinking=False),
+ ProviderModelInfo(
+ "missing-optional-metadata",
+ supports_thinking=False,
+ ),
}
)
kilo_provider._client.models.list.assert_awaited_once_with()
+ "payload",
+ [
+ SimpleNamespace(data="not-an-array"),
+ SimpleNamespace(data=[SimpleNamespace(id="", supported_parameters=["tools"])]),
+ ],
+)
+async def test_model_list_rejects_malformed_payload(kilo_provider, payload):
+ kilo_provider._client.models.list = AsyncMock(return_value=payload)
+
+ with pytest.raises(ModelListResponseError, match="KILO model-list"):
+ await kilo_provider.list_model_infos()
+
+
@pytest.mark.asyncio
async def test_cleanup_closes_openai_client(kilo_provider):
kilo_provider._client = MagicMock()
diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.py
index 88866652..dd612ac1 100644
--- a/tests/providers/test_open_router.py
+++ b/tests/providers/test_open_router.py
@@ -12,6 +12,7 @@ from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import (
parse_sse_text,
text_content,
+ thinking_content,
)
from free_claude_code.providers.base import ProviderConfig
from free_claude_code.providers.open_router import OpenRouterProvider
@@ -304,6 +305,7 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):
redacted = {"type": "reasoning.encrypted", "data": "opaque"}
stream = AsyncStream(
[
+ _chunk(reasoning_details=[{"type": "reasoning.text", "text": "plan "}]),
_chunk(reasoning_content="plan "),
_chunk(reasoning_details=[redacted]),
_chunk(content="done", finish_reason="stop"),
@@ -321,11 +323,11 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):
]
event_text = "".join(events)
- assert "thinking_delta" in event_text
- assert "plan " in event_text
+ parsed = parse_sse_text(event_text)
+ assert thinking_content(parsed) == "plan "
assert "redacted_thinking" in event_text
assert "opaque" in event_text
- assert "done" in text_content(parse_sse_text(event_text))
+ assert text_content(parsed) == "done"
assert stream.closed
diff --git a/tests/providers/test_provider_runtime.py b/tests/providers/test_provider_runtime.py
index bb4b5077..f2f6dfcb 100644
--- a/tests/providers/test_provider_runtime.py
+++ b/tests/providers/test_provider_runtime.py
@@ -25,6 +25,7 @@ from free_claude_code.providers.cloudflare import CloudflareProvider
from free_claude_code.providers.deepseek import DeepSeekProvider
from free_claude_code.providers.gemini import GeminiProvider
from free_claude_code.providers.github_models import GitHubModelsProvider
+from free_claude_code.providers.kilo import KiloProvider
from free_claude_code.providers.lmstudio import LMStudioProvider
from free_claude_code.providers.mistral import MistralProvider
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
@@ -441,7 +442,7 @@ def test_create_provider_instantiates_each_builtin():
"vertex": VertexProvider,
"groq": OpenAIChatProvider,
"sambanova": OpenAIChatProvider,
- "kilo": OpenAIChatProvider,
+ "kilo": KiloProvider,
"cerebras": OpenAIChatProvider,
}
sentinel_admission = MagicMock(spec=ProviderAdmissionController)
diff --git a/uv.lock b/uv.lock
index 2d350f9a..586e635b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -620,7 +620,7 @@ wheels = [
[[package]]
name = "free-claude-code"
-version = "4.13.0"
+version = "4.13.1"
source = { editable = "." }
dependencies = [
{ name = "aiohttp" },