kolega-code 0.8.0__tar.gz → 0.8.1__tar.gz

{kolega_code-0.8.0 → kolega_code-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.8.0
+Version: 0.8.1
 Summary: Local-first AI coding agent for the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/__init__.py

@@ -18,6 +18,7 @@ from .agent.planningagent import PlanningAgent
 from .agent.compression import HistoryCompressor
 from .agent.context import AgentContext, AgentServices, Telemetry, WorkspaceInfo
 from .agent.conversation import Conversation
+from .agent.errors import AgentError, MaxAgentIterationsExceeded
 from .events import AgentEventEmitter
 
 # Configuration
@@ -86,6 +87,8 @@ __all__ = [
     "AgentContext",
     "AgentServices",
     "Telemetry",
+    "AgentError",
+    "MaxAgentIterationsExceeded",
     "WorkspaceInfo",
     "Conversation",
     "HistoryCompressor",
@@ -148,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/__init__.py

@@ -8,6 +8,9 @@ from .browseragent import BrowserAgent
 from .generalagent import GeneralAgent
 from .planningagent import PlanningAgent
 
+# Export agent errors
+from .errors import AgentError, MaxAgentIterationsExceeded
+
 # Export agent models
 from kolega_code.events import AgentStatus, AgentEvent
 
@@ -25,6 +28,8 @@ __all__ = [
     "BrowserAgent",
     "GeneralAgent",
     "PlanningAgent",
+    "AgentError",
+    "MaxAgentIterationsExceeded",
     "AgentStatus",
     "AgentEvent",
     "AgentConfig",
@@ -39,4 +44,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/baseagent.py

@@ -12,6 +12,7 @@ from typing import Any, AsyncGenerator, Dict, List, Optional
 
 from .common import LogMixin
 from .compression import CompactionResult, HistoryCompressor
+from .errors import MaxAgentIterationsExceeded
 from kolega_code.config import AgentConfig, ModelProvider
 from kolega_code.events import AgentConnectionManager
 from .context import AgentContext, AgentServices, Telemetry, WorkspaceInfo
@@ -119,6 +120,7 @@ class BaseAgent(LogMixin):
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[HookDispatcher] = None,
         context: Optional[AgentContext] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         """
         Initialize a new BaseAgent instance.
@@ -203,7 +205,11 @@ class BaseAgent(LogMixin):
         if hook_dispatcher is not None:
             context.hook_dispatcher = hook_dispatcher
 
+        if max_iterations is not None and max_iterations < 1:
+            raise ValueError("max_iterations must be a positive integer or None")
+
         self.context = context
+        self.max_iterations = max_iterations
 
         # Flat attributes kept for compatibility with subclasses, tools, and hosts.
         self.project_path = context.workspace.project_path
@@ -1282,7 +1288,15 @@ class BaseAgent(LogMixin):
 
         stop_reason = None
         stop_overrides = 0
+        iterations = 0
         while stop_reason not in ["end_turn", "max_tokens", "stop_sequence"]:
+            iterations += 1
+            if self.max_iterations is not None and iterations > self.max_iterations:
+                raise MaxAgentIterationsExceeded(
+                    f"Agent '{self.agent_name}' exceeded max_iterations={self.max_iterations} "
+                    "without reaching a terminal stop reason"
+                )
+
             self.mark_cache_checkpoint()
 
             try:

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/browseragent.py

@@ -45,6 +45,7 @@ class BrowserAgent(BaseAgent):
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         """
         Initialize a new BrowserAgent instance.
@@ -97,6 +98,7 @@ class BrowserAgent(BaseAgent):
             usage_recorder=usage_recorder,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
+            max_iterations=max_iterations,
         )
 
         self.tool_collection = ToolCollection(

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/coder.py

@@ -49,6 +49,7 @@ class CoderAgent(BaseAgent, LogMixin):
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         """
         Initialize a new CoderAgent instance.
@@ -104,6 +105,7 @@ class CoderAgent(BaseAgent, LogMixin):
             usage_recorder=usage_recorder,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
+            max_iterations=max_iterations,
         )
 
         # Configure tool collection with custom coder agent tools

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/conversation.py

@@ -16,6 +16,7 @@ from kolega_code.llm.models import (
     Message,
     MessageHistory,
     RedactedThinkingBlock,
+    ResponsesReasoningBlock,
     TextBlock,
     ThinkingBlock,
     ToolCall,
@@ -113,8 +114,21 @@ def replace_image_blocks_with_placeholders(messages: List[Message], model_name:
     return result
 
 
+# Groups of providers whose reasoning is mutually replayable. The api-key
+# `openai` and the ChatGPT-subscription `openai_chatgpt` are both the OpenAI
+# Responses API, so encrypted reasoning produced by one replays cleanly to the
+# other — the one exception to "only replay reasoning to the same provider".
+_REASONING_COMPATIBLE_GROUPS: tuple[frozenset[str], ...] = (frozenset({"openai", "openai_chatgpt"}),)
+
+
 def _preserve_reasoning_block(block: Any, *, source_provider: str, target_provider: str) -> bool:
-    return bool(source_provider) and source_provider == target_provider
+    if not source_provider:
+        return False
+    if source_provider == target_provider:
+        return True
+    return any(
+        source_provider in group and target_provider in group for group in _REASONING_COMPATIBLE_GROUPS
+    )
 
 
 def _reasoning_placeholder(block: Any, source_provider: str) -> TextBlock:
@@ -134,7 +148,7 @@ def _adapt_content_blocks_for_provider(
         if isinstance(block, ImageBlock) and not supports_vision:
             adapted.append(TextBlock(text=_image_placeholder(block.media_type, target_model)))
             changed = True
-        elif isinstance(block, (ThinkingBlock, RedactedThinkingBlock)):
+        elif isinstance(block, (ThinkingBlock, RedactedThinkingBlock, ResponsesReasoningBlock)):
             if _preserve_reasoning_block(block, source_provider=source_provider, target_provider=target_provider):
                 adapted.append(block)
             else:

kolega_code-0.8.1/kolega_code/agent/errors.py

@@ -0,0 +1,9 @@
+"""Exceptions raised by agent runtime loops."""
+
+
+class AgentError(RuntimeError):
+    """Base class for catchable agent runtime errors."""
+
+
+class MaxAgentIterationsExceeded(AgentError):
+    """Raised when an opt-in agent loop iteration cap is exceeded."""

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/generalagent.py

@@ -47,6 +47,7 @@ class GeneralAgent(BaseAgent):
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         """
         Initialize a new GeneralAgent instance.
@@ -99,6 +100,7 @@ class GeneralAgent(BaseAgent):
             usage_recorder=usage_recorder,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
+            max_iterations=max_iterations,
         )
 
         # Full coder-style toolset, minus sub-agent dispatch (a dispatched agent

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/investigationagent.py

@@ -45,6 +45,7 @@ class InvestigationAgent(BaseAgent):
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         """
         Initialize a new InvestigationAgent instance.
@@ -97,6 +98,7 @@ class InvestigationAgent(BaseAgent):
             usage_recorder=usage_recorder,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
+            max_iterations=max_iterations,
         )
 
         self.tool_collection = ToolCollection(

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/planningagent.py

@@ -44,6 +44,7 @@ class PlanningAgent(BaseAgent):
         usage_recorder: Optional[Any] = None,
         sub_agent_recorder: Optional[Any] = None,
         hook_dispatcher: Optional[Any] = None,
+        max_iterations: Optional[int] = None,
     ) -> None:
         super().__init__(
             project_path,
@@ -70,6 +71,7 @@ class PlanningAgent(BaseAgent):
             usage_recorder=usage_recorder,
             sub_agent_recorder=sub_agent_recorder,
             hook_dispatcher=hook_dispatcher,
+            max_iterations=max_iterations,
         )
 
         self._completed_plan: Optional[str] = None

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/tests/llm/test_chatgpt_oauth_provider.py

@@ -13,6 +13,7 @@ from kolega_code.llm.models import (
     ImageBlock,
     Message,
     MessageHistory,
+    ResponsesReasoningBlock,
     TextBlock,
     ToolCall,
     ToolDefinition,
@@ -149,6 +150,32 @@ def test_to_responses_input_multiple_tool_outputs_before_image_followups():
     assert any(part.get("type") == "input_image" for part in items[2]["content"])
 
 
+def test_to_responses_input_resends_reasoning_before_tool_call():
+    # A prior assistant turn carrying captured reasoning must resend it as a
+    # reasoning item that *precedes* the function_call it belongs to.
+    history = MessageHistory(
+        [
+            Message(
+                role="assistant",
+                content=[
+                    ResponsesReasoningBlock(encrypted_content="ENC", summary=["thinking..."], item_id="rs_1"),
+                    ToolCall(id="call_1", name="read_file", input={"path": "a.py"}),
+                ],
+            ),
+        ]
+    )
+    items = to_responses_input(history)
+    assert items[0] == {
+        "type": "reasoning",
+        "summary": [{"type": "summary_text", "text": "thinking..."}],
+        "encrypted_content": "ENC",
+    }
+    # The opaque server id is intentionally not resent (matches Codex, store=false).
+    assert "id" not in items[0]
+    assert items[1]["type"] == "function_call"
+    assert items[1]["call_id"] == "call_1"
+
+
 def test_responses_tools_flattens_function_shape():
     tool = ToolDefinition(
         name="read_file",
@@ -231,6 +258,9 @@ async def test_responses_stream_wrapper_text_tools_and_usage():
     assert tool_calls[0].input == {"path": "a.py"}
     assert message.usage_metadata["prompt_tokens"] == 12
     assert message.usage_metadata["completion_tokens"] == 4
+    # Messages must be tagged with the real provider so history adaptation treats
+    # them as openai_chatgpt (not the api-key "openai" provider).
+    assert message.usage_metadata["provider"] == "openai_chatgpt"
 
 
 @pytest.mark.asyncio
@@ -313,6 +343,86 @@ async def test_responses_stream_wrapper_max_tokens_stop_reason():
     assert message.stop_reason == "max_tokens"
 
 
+@pytest.mark.asyncio
+async def test_responses_stream_wrapper_captures_reasoning_for_continuity():
+    # With include=["reasoning.encrypted_content"], the backend emits a completed
+    # reasoning item carrying the encrypted blob. We capture it (leading the
+    # assistant message) so it round-trips into the next request for continuity.
+    completed = _ns(output=[], usage=None, status="completed", incomplete_details=None)
+    events = [
+        _ns(
+            type="response.output_item.done",
+            item=_ns(
+                type="reasoning",
+                id="rs_1",
+                encrypted_content="ENC",
+                summary=[_ns(type="summary_text", text="planning")],
+            ),
+        ),
+        _ns(
+            type="response.output_item.done",
+            item=_ns(type="function_call", id="fc_1", call_id="call_1", name="read_file", arguments='{"path": "a.py"}'),
+        ),
+        _ns(type="response.completed", response=completed),
+    ]
+    wrapper = ResponsesStreamWrapper(_FakeStream(events))
+    async with wrapper as stream:
+        async for _chunk in stream:
+            pass
+    message = await wrapper.get_final_message()
+
+    # Reasoning leads the assistant content so it precedes the tool call on resend.
+    assert isinstance(message.content[0], ResponsesReasoningBlock)
+    assert message.content[0].encrypted_content == "ENC"
+    assert message.content[0].summary == ["planning"]
+
+    items = to_responses_input(MessageHistory([message]))
+    assert items[0]["type"] == "reasoning"
+    assert items[0]["encrypted_content"] == "ENC"
+    assert items[1]["type"] == "function_call"
+
+
+@pytest.mark.asyncio
+async def test_responses_stream_wrapper_reasoning_from_final_output_fallback():
+    # Some backends populate reasoning only on the final response output, not via
+    # output_item.done events. The fallback path must still capture it.
+    completed = _ns(
+        output=[
+            _ns(type="reasoning", id="rs_1", encrypted_content="ENC2", summary=[]),
+            _ns(type="message", content=[_ns(type="output_text", text="hi")]),
+        ],
+        usage=None,
+        status="completed",
+        incomplete_details=None,
+    )
+    wrapper = ResponsesStreamWrapper(_FakeStream([_ns(type="response.completed", response=completed)]))
+    async with wrapper as stream:
+        async for _chunk in stream:
+            pass
+    message = await wrapper.get_final_message()
+    reasoning = [b for b in message.content if isinstance(b, ResponsesReasoningBlock)]
+    assert reasoning and reasoning[0].encrypted_content == "ENC2"
+    assert reasoning[0].summary == []
+
+
+@pytest.mark.asyncio
+async def test_responses_stream_wrapper_skips_reasoning_without_encrypted_content():
+    # A reasoning item lacking encrypted_content is useless for continuity (and
+    # would be rejected on resend), so it must be dropped.
+    completed = _ns(output=[], usage=None, status="completed", incomplete_details=None)
+    events = [
+        _ns(type="response.output_item.done", item=_ns(type="reasoning", id="rs_1", encrypted_content=None, summary=[])),
+        _ns(type="response.output_text.delta", delta="ok"),
+        _ns(type="response.completed", response=completed),
+    ]
+    wrapper = ResponsesStreamWrapper(_FakeStream(events))
+    async with wrapper as stream:
+        async for _chunk in stream:
+            pass
+    message = await wrapper.get_final_message()
+    assert not [b for b in message.content if isinstance(b, ResponsesReasoningBlock)]
+
+
 # --- provider request building (no network) -------------------------------------
 
 
@@ -347,12 +457,18 @@ async def test_provider_generate_builds_codex_shaped_request():
     )
 
     assert message.get_text_content() == "hi"
+    assert message.usage_metadata["provider"] == "openai_chatgpt"
     kwargs = fake.last_kwargs
     assert kwargs["model"] == "gpt-5.5"
     assert kwargs["store"] is False
     assert kwargs["stream"] is True  # backend is SSE-only; generate streams too
     assert kwargs["instructions"] == "sys"
+    # summary="auto" so the backend streams a reasoning summary for the thinking
+    # display; this is independent of continuity, which rides on `include` below.
     assert kwargs["reasoning"] == {"effort": "high", "summary": "auto"}
+    # Reasoning continuity: ask the backend for the encrypted reasoning blob so it
+    # can be resent next turn (matches Codex; the cause of the long-thinking gap).
+    assert kwargs["include"] == ["reasoning.encrypted_content"]
     assert kwargs["tool_choice"] == "auto"
     assert kwargs["parallel_tool_calls"] is False
     assert "prompt_cache_key" in kwargs
@@ -361,6 +477,26 @@ async def test_provider_generate_builds_codex_shaped_request():
     assert kwargs["input"] == [{"role": "user", "content": [{"type": "input_text", "text": "hello"}]}]
 
 
+@pytest.mark.asyncio
+async def test_provider_generate_omits_reasoning_and_include_without_thinking():
+    provider = ChatGPTOAuthProvider(token_manager=ChatGPTTokenManager(_tokens()))
+    completed = _ns(
+        output=[_ns(type="message", content=[_ns(type="output_text", text="hi")])],
+        usage=None,
+        status="completed",
+        incomplete_details=None,
+    )
+    fake = _FakeResponses(_FakeStream([_ns(type="response.completed", response=completed)]))
+    provider.async_client = _ns(responses=fake)
+    await provider.generate(
+        MessageHistory([Message(role="user", content=[TextBlock(text="hello")])]),
+        params=GenerationParams(),  # no thinking effort
+        model="gpt-5.5",
+    )
+    assert "reasoning" not in fake.last_kwargs
+    assert "include" not in fake.last_kwargs
+
+
 @pytest.mark.asyncio
 async def test_provider_stream_returns_wrapper():
     provider = ChatGPTOAuthProvider(token_manager=ChatGPTTokenManager(_tokens()))

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/tests/llm/test_error_boundary.py

@@ -318,8 +318,9 @@ class TestProviderInitialization:
 
     def test_provider_initialization_with_error(self):
         """Test that provider initialization errors are properly wrapped."""
-        # Mock the provider class to raise an error during initialization
-        with patch("kolega_code.llm.client.OpenAIProvider") as MockProvider:
+        # The api-key `openai` provider now uses the Responses provider, so mock
+        # that class to raise during initialization.
+        with patch("kolega_code.llm.client.OpenAIResponsesProvider") as MockProvider:
             MockProvider.side_effect = RuntimeError("Provider init failed")
 
             with pytest.raises(LLMInternalServerError) as exc_info:

kolega_code-0.8.1/kolega_code/agent/tests/llm/test_openai_responses_provider.py

@@ -0,0 +1,163 @@
+"""Tests for the api-key OpenAI Responses provider and its routing.
+
+gpt-5.x reject ``function tools + reasoning_effort`` on Chat Completions, so the
+api-key ``openai`` provider routes to the Responses API. The OpenAI-compatible
+providers (fireworks, xai, …) keep using the Chat Completions ``OpenAIProvider``.
+"""
+
+import types
+
+import pytest
+
+from kolega_code.llm.client import LLMClient
+from kolega_code.llm.models import (
+    Message,
+    MessageHistory,
+    ResponsesReasoningBlock,
+    TextBlock,
+    ToolDefinition,
+    ToolParameter,
+)
+from kolega_code.llm.providers.models import GenerationParams
+from kolega_code.llm.providers.openai import OpenAIProvider
+from kolega_code.llm.providers.openai_responses import OpenAIResponsesProvider
+
+
+def _ns(**kwargs):
+    return types.SimpleNamespace(**kwargs)
+
+
+class _FakeStream:
+    def __init__(self, events):
+        self._events = events
+
+    def __aiter__(self):
+        async def gen():
+            for event in self._events:
+                yield event
+
+        return gen()
+
+
+class _FakeResponses:
+    def __init__(self, result):
+        self._result = result
+        self.last_kwargs = None
+
+    async def create(self, **kwargs):
+        self.last_kwargs = kwargs
+        return self._result
+
+
+# --- routing --------------------------------------------------------------------
+
+
+def test_llmclient_routes_openai_to_responses_provider():
+    client = LLMClient(provider="openai", api_key="sk-test")
+    assert isinstance(client.provider, OpenAIResponsesProvider)
+    assert client.provider.provider_name == "openai"
+
+
+def test_llmclient_routes_compatible_provider_to_chat_completions():
+    client = LLMClient(provider="fireworks", api_key="sk-test")
+    assert isinstance(client.provider, OpenAIProvider)
+    assert not isinstance(client.provider, OpenAIResponsesProvider)
+
+
+# --- request building (no network) ----------------------------------------------
+
+
+def test_build_request_is_responses_shaped_with_reasoning():
+    provider = OpenAIResponsesProvider(api_key="sk-test")
+    tool = ToolDefinition(
+        name="read_file",
+        description="Read a file",
+        parameters=[ToolParameter(name="path", type="string", description="path", required=True)],
+    )
+    params = GenerationParams(tools=[tool], thinking="high", max_completion_tokens=256, temperature=0.5)
+    request = provider._build_request(
+        MessageHistory([Message(role="user", content=[TextBlock(text="hello")])]),
+        Message(role="system", content=[TextBlock(text="sys")]),
+        params,
+        {"model": "gpt-5.5"},
+    )
+
+    assert request["model"] == "gpt-5.5"
+    assert request["stream"] is True
+    assert request["store"] is False
+    assert request["tool_choice"] == "auto"
+    assert request["instructions"] == "sys"
+    assert request["reasoning"] == {"effort": "high", "summary": "auto"}
+    assert request["include"] == ["reasoning.encrypted_content"]
+    assert request["tools"][0]["type"] == "function"
+    assert request["tools"][0]["name"] == "read_file"
+    assert request["input"] == [{"role": "user", "content": [{"type": "input_text", "text": "hello"}]}]
+    # The Responses path must NOT send Chat-Completions-only fields.
+    assert "temperature" not in request
+    assert "max_completion_tokens" not in request
+    assert "max_output_tokens" not in request
+
+
+def test_build_request_default_model_and_no_reasoning_without_thinking():
+    provider = OpenAIResponsesProvider(api_key="sk-test")
+    request = provider._build_request(
+        MessageHistory([Message(role="user", content=[TextBlock(text="hi")])]),
+        None,
+        GenerationParams(),
+        {},
+    )
+    assert request["model"] == "gpt-5.5"
+    assert "reasoning" not in request
+    assert "include" not in request
+
+
+# --- generate / stream (no network) ---------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_generate_tags_openai_provider_and_sends_include():
+    provider = OpenAIResponsesProvider(api_key="sk-test")
+    completed = _ns(
+        output=[_ns(type="message", content=[_ns(type="output_text", text="hi")])],
+        usage=_ns(input_tokens=3, output_tokens=2, total_tokens=5, input_tokens_details=None),
+        status="completed",
+        incomplete_details=None,
+    )
+    fake = _FakeResponses(_FakeStream([_ns(type="response.completed", response=completed)]))
+    provider.async_client = _ns(responses=fake)
+
+    msg = await provider.generate(
+        MessageHistory([Message(role="user", content=[TextBlock(text="hello")])]),
+        params=GenerationParams(thinking="medium"),
+        model="gpt-5.5",
+    )
+
+    assert msg.get_text_content() == "hi"
+    assert msg.usage_metadata["provider"] == "openai"
+    assert fake.last_kwargs["include"] == ["reasoning.encrypted_content"]
+    assert fake.last_kwargs["reasoning"] == {"effort": "medium", "summary": "auto"}
+
+
+@pytest.mark.asyncio
+async def test_stream_captures_reasoning_for_continuity():
+    provider = OpenAIResponsesProvider(api_key="sk-test")
+    completed = _ns(output=[], usage=None, status="completed", incomplete_details=None)
+    events = [
+        _ns(type="response.output_item.done", item=_ns(type="reasoning", id="rs_1", encrypted_content="ENC", summary=[])),
+        _ns(type="response.output_text.delta", delta="hi"),
+        _ns(type="response.completed", response=completed),
+    ]
+    provider.async_client = _ns(responses=_FakeResponses(_FakeStream(events)))
+
+    wrapper = await provider.stream(
+        MessageHistory([Message(role="user", content=[TextBlock(text="x")])]),
+        params=GenerationParams(thinking="high"),
+        model="gpt-5.5",
+    )
+    async with wrapper as stream:
+        async for _chunk in stream:
+            pass
+    message = await wrapper.get_final_message()
+
+    assert isinstance(message.content[0], ResponsesReasoningBlock)
+    assert message.content[0].encrypted_content == "ENC"

{kolega_code-0.8.0 → kolega_code-0.8.1}/kolega_code/agent/tests/llm/test_thinking_effort.py

@@ -149,13 +149,17 @@ def test_google_gemini_3_pro_uses_thinking_level() -> None:
 
 
 def test_openai_reasoning_effort_is_sent_for_reasoning_models() -> None:
+    # The api-key `openai` provider's gpt-5.x models now use the Responses API
+    # (served by OpenAIResponsesProvider), so effort serializes to a nested
+    # reasoning object rather than a flat reasoning_effort field.
     provider = OpenAIProvider(api_key="test-key")
     generation_params = provider._prepare_generation_params(GenerationParams(thinking="high"))
     generation_params["model"] = "gpt-5.5"
 
     provider._apply_thinking_params(generation_params, GenerationParams(thinking="high"))
 
-    assert generation_params["reasoning_effort"] == "high"
+    assert generation_params["reasoning"] == {"effort": "high", "summary": "auto"}
+    assert "reasoning_effort" not in generation_params
 
 
 def test_numeric_thinking_budget_is_rejected() -> None: