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.exampleindex 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.mdindex 3de19947..e1e0c93c 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -668,8 +668,10 @@ Cloudflare uses itsaccount-scoped Workers AI OpenAI-compatible Chat Completions endpoint for`@cf/...` model IDs, while account ID composition, model search, andCloudflare-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 nativeConverse/Invoke transports are outside that provider contract. Wafer, Kimi API,Kimi Code, MiniMax, Fireworks, and Z.ai use ordinarydiff --git a/pyproject.toml b/pyproject.tomlindex 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.pyindex 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.pyindex 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 turndiff --git a/smoke/lib/http.py b/smoke/lib/http.pyindex 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__.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 Nonediff --git a/src/free_claude_code/providers/model_listing.py b/src/free_claude_code/providers/model_listing.pyindex 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.pyindex 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 ProviderModelInfofrom 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 ReasoningEffortfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom 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_infosfrom 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__.pyindex 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_replayfrom .request_policy import OpenAIChatRequestPolicy, build_openai_chat_request_bodyfrom .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.pyindex 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 = Falseuser_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.pyindex 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_capfrom .profiles import OpenAIChatProfile+from .reasoning_details import StructuredReasoningStreamfrom .request_policy import build_openai_chat_request_bodyfrom .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 payloaddef _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 eventfor 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.pynew file mode 100644index 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.pyindex 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.pyindex 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 CloudflareProviderfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom free_claude_code.providers.gemini import GeminiProviderfrom free_claude_code.providers.github_models import GitHubModelsProvider+from free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.lmstudio import LMStudioProviderfrom free_claude_code.providers.mistral import MistralProviderfrom 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.pyindex 888fc31b..eedf9af8 100644--- a/tests/contracts/test_smoke_child_process.py+++ b/tests/contracts/test_smoke_child_process.py@@ -1,8 +1,11 @@import subprocessfrom pathlib import Path+from unittest.mock import MagicMockfrom free_claude_code.config.settings import Settingsfrom smoke.lib import child_process+from smoke.lib import e2e as smoke_e2e+from smoke.lib import http as smoke_httpfrom smoke.lib import server as smoke_serverfrom 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 RunningServerdef 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 == 0assert 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.pyindex 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) -> Noneassert 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.pyindex 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, patchimport pytest+from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import KILO_DEFAULT_BASEfrom 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 ReasoningPolicyfrom free_claude_code.providers.base import ProviderConfig+from free_claude_code.providers.kilo import KiloProvider+from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (immediate_admission,- profiled_provider,reasoning_for,)@@ -28,18 +38,52 @@ def kilo_config():@pytest.fixturedef 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.asyncioasync 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.pyindex 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 MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,text_content,+ thinking_content,)from free_claude_code.providers.base import ProviderConfigfrom 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_textassert "opaque" in event_text- assert "done" in text_content(parse_sse_text(event_text))+ assert text_content(parsed) == "done"assert stream.closeddiff --git a/tests/providers/test_provider_runtime.py b/tests/providers/test_provider_runtime.pyindex 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 CloudflareProviderfrom free_claude_code.providers.deepseek import DeepSeekProviderfrom free_claude_code.providers.gemini import GeminiProviderfrom free_claude_code.providers.github_models import GitHubModelsProvider+from free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.lmstudio import LMStudioProviderfrom free_claude_code.providers.mistral import MistralProviderfrom 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.lockindex 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" },