ouroboros-ai 0.26.6.dev2__tar.gz → 0.26.7.dev2__tar.gz

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "ouroboros",
       "description": "Transform vague ideas into validated seed specifications through Socratic questioning and ontological analysis",
-      "version": "0.26.5",
+      "version": "0.26.6",
       "author": {
         "name": "Q00",
         "email": "jqyu.lee@gmail.com"

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ouroboros",
-  "version": "0.26.5",
+  "version": "0.26.6",
   "description": "Self-improving AI workflow system. Crystallize requirements before execution with Socratic interview, ambiguity scoring, and 3-stage evaluation.",
   "author": {
     "name": "Q00",

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.6.dev2
+Version: 0.26.7.dev2
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/skills/setup/SKILL.md

@@ -246,7 +246,7 @@ A backup will be created: CLAUDE.md.bak
 **If "Preview first", show:**
 ````markdown
 <!-- ooo:START -->
-<!-- ooo:VERSION:0.26.5 -->
+<!-- ooo:VERSION:0.26.6 -->
 # Ouroboros — Specification-First AI Development
 
 > Before telling AI what to build, define what should be built.

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.6.dev2'
-__version_tuple__ = version_tuple = (0, 26, 6, 'dev2')
+__version__ = version = '0.26.7.dev2'
+__version_tuple__ = version_tuple = (0, 26, 7, 'dev2')
 
 __commit_id__ = commit_id = None

ouroboros_ai-0.26.7.dev2/src/ouroboros/core/json_utils.py

@@ -0,0 +1,93 @@
+"""Shared JSON extraction utilities for evaluation modules.
+
+Provides a robust bracket-matching JSON extractor used by semantic,
+consensus, and QA evaluation stages.
+"""
+
+import json
+import re
+
+
+def extract_json_payload(text: str) -> str | None:
+    """Extract the first valid JSON object or array from text.
+
+    Tries each ``{`` or ``[`` position via bracket-depth counting and
+    validates with ``json.loads``.  This handles LLM responses that
+    contain prose before the actual JSON payload.
+
+    Args:
+        text: Raw text potentially containing a JSON object or array
+
+    Returns:
+        Extracted JSON string, or None if no valid JSON is found
+    """
+    # Strip code fences first (```json ... ```)
+    fence_match = re.search(r"```(?:json)?\s*([\[{][\s\S]*?[}\]])\s*```", text)
+    if fence_match:
+        text = fence_match.group(1)
+
+    pos = 0
+    while True:
+        # Find the next { or [ opener
+        obj_start = text.find("{", pos)
+        arr_start = text.find("[", pos)
+
+        if obj_start == -1 and arr_start == -1:
+            return None
+
+        # Pick whichever comes first
+        if obj_start == -1:
+            start = arr_start
+        elif arr_start == -1:
+            start = obj_start
+        else:
+            start = min(obj_start, arr_start)
+
+        candidate = _bracket_extract(text, start)
+        if candidate is not None:
+            try:
+                json.loads(candidate)
+                return candidate
+            except (json.JSONDecodeError, ValueError):
+                pass
+
+        pos = start + 1
+
+
+def _bracket_extract(text: str, start: int) -> str | None:
+    """Extract a bracket-balanced substring starting at *start*.
+
+    Supports both ``{}`` (objects) and ``[]`` (arrays).  Returns the
+    substring ``text[start:end+1]`` where *end* is the position of
+    the matching closer, or ``None`` if brackets never balance.
+    """
+    open_char = text[start]
+    close_char = "}" if open_char == "{" else "]"
+    depth = 0
+    in_string = False
+    escape_next = False
+
+    for i, char in enumerate(text[start:], start=start):
+        if escape_next:
+            escape_next = False
+            continue
+
+        if char == "\\":
+            escape_next = True
+            continue
+
+        if char == '"' and not escape_next:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char == open_char:
+            depth += 1
+        elif char == close_char:
+            depth -= 1
+            if depth == 0:
+                return text[start : i + 1]
+
+    return None

ouroboros_ai-0.26.7.dev2/src/ouroboros/evaluation/json_utils.py

@@ -0,0 +1,5 @@
+"""Backwards-compatible re-export. Canonical location: ouroboros.core.json_utils."""
+
+from ouroboros.core.json_utils import extract_json_payload
+
+__all__ = ["extract_json_payload"]

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/src/ouroboros/mcp/tools/evaluation_handlers.py

@@ -409,10 +409,12 @@ class EvaluateHandler:
                 constraints=constraints,
             )
 
-            # Use injected or create services
+            # Use injected or create services.
+            # Evaluation reads multiple spec files (one Read call per AC), so
+            # max_turns must be well above 1.
             llm_adapter = self.llm_adapter or create_llm_adapter(
                 backend=self.llm_backend,
-                max_turns=1,
+                max_turns=20,
             )
             working_dir_str = arguments.get("working_dir")
             working_dir = Path(working_dir_str).resolve() if working_dir_str else Path.cwd()

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/src/ouroboros/providers/claude_code_adapter.py

@@ -35,6 +35,7 @@ from pathlib import Path
 import structlog
 
 from ouroboros.core.errors import ProviderError
+from ouroboros.core.json_utils import extract_json_payload
 from ouroboros.core.types import Result
 from ouroboros.providers.base import (
     CompletionConfig,
@@ -48,6 +49,7 @@ log = structlog.get_logger(__name__)
 
 # Retry configuration for transient API errors
 _MAX_RETRIES = 5
+_MAX_JSON_RETRIES = 3  # Extra retries when response_format requires JSON but LLM returns prose
 _INITIAL_BACKOFF_SECONDS = 2.0  # Increased for custom CLI startup
 _RETRYABLE_ERROR_PATTERNS = (
     "concurrency",
@@ -244,13 +246,35 @@ class ClaudeCodeAdapter:
         # output. When callers request a schema, reinforce the requirement in the
         # prompt text and let downstream parsers extract JSON from the plain-text
         # response rather than depending on SDK-level structured_output.
-        if config.response_format and config.response_format.get("type") == "json_schema":
-            schema = config.response_format.get("json_schema", {})
-            schema_instruction = (
-                "Respond with ONLY a valid JSON object that matches this schema. "
-                "Do not use markdown fences, headers, or explanatory text.\n\n"
-                f"JSON schema:\n{json.dumps(schema, indent=2, sort_keys=True)}"
-            )
+        requires_json = bool(
+            config.response_format
+            and config.response_format.get("type") in ("json_schema", "json_object")
+        )
+        if requires_json:
+            fmt_type = config.response_format.get("type")
+            if fmt_type == "json_schema":
+                schema = config.response_format.get("json_schema", {})
+                # Derive the expected top-level type from the schema so the
+                # prompt instruction matches the schema contract (object, array, etc.)
+                top_type = schema.get("type", "object")
+                if top_type == "array":
+                    type_noun = "JSON array"
+                elif top_type == "object":
+                    type_noun = "JSON object"
+                else:
+                    # Primitive schemas (string, number, boolean, null)
+                    type_noun = "JSON value"
+                schema_instruction = (
+                    f"Respond with ONLY a valid {type_noun} that matches this schema. "
+                    "Do not use markdown fences, headers, or explanatory text.\n\n"
+                    f"JSON schema:\n{json.dumps(schema, indent=2, sort_keys=True)}"
+                )
+            else:
+                # json_object — no schema, but still steer toward JSON
+                schema_instruction = (
+                    "Respond with ONLY a valid JSON object. "
+                    "Do not use markdown fences, headers, or explanatory text."
+                )
             if system_prompt:
                 system_prompt = f"{system_prompt}\n\n{schema_instruction}"
             else:
@@ -269,6 +293,98 @@ class ClaudeCodeAdapter:
             has_system_prompt=system_prompt is not None,
         )
 
+        result = await self._complete_with_transient_retry(prompt, config, system_prompt)
+
+        # JSON enforcement layer: if response_format requires JSON,
+        # normalize or retry until we get valid JSON.
+        if requires_json and result.is_ok:
+            result = await self._enforce_json(result, prompt, config, system_prompt)
+
+        return result
+
+    def _normalize_json_content(
+        self, result: Result[CompletionResponse, ProviderError]
+    ) -> Result[CompletionResponse, ProviderError] | None:
+        """Try to extract and normalize JSON from a successful result.
+
+        Returns:
+            Normalized result if JSON found, None if no valid JSON in content.
+        """
+        if result.is_err:
+            return result
+        extracted = extract_json_payload(result.value.content)
+        if extracted:
+            result.value.content = extracted
+            return result
+        return None
+
+    async def _enforce_json(
+        self,
+        result: Result[CompletionResponse, ProviderError],
+        prompt: str,
+        config: CompletionConfig,
+        system_prompt: str | None,
+    ) -> Result[CompletionResponse, ProviderError]:
+        """Normalize JSON content or retry until valid JSON is obtained.
+
+        If the response contains valid JSON (even wrapped in prose/fences),
+        extract and return just the JSON. If no valid JSON, retry up to
+        _MAX_JSON_RETRIES times. If all retries fail, return an error.
+        """
+        # Try to normalize the initial result
+        normalized = self._normalize_json_content(result)
+        if normalized is not None:
+            return normalized
+
+        log.warning(
+            "claude_code_adapter.json_not_found",
+            max_json_retries=_MAX_JSON_RETRIES,
+            response_preview=result.value.content[:120],
+        )
+
+        for json_attempt in range(1, _MAX_JSON_RETRIES + 1):
+            log.info(
+                "claude_code_adapter.json_retry",
+                attempt=json_attempt,
+                max_json_retries=_MAX_JSON_RETRIES,
+            )
+            result = await self._complete_with_transient_retry(prompt, config, system_prompt)
+            if result.is_err:
+                return result
+            normalized = self._normalize_json_content(result)
+            if normalized is not None:
+                return normalized
+
+        # All retries exhausted — return error instead of prose
+        log.error(
+            "claude_code_adapter.json_retries_exhausted",
+            max_json_retries=_MAX_JSON_RETRIES,
+            response_preview=result.value.content[:120] if result.is_ok else "N/A",
+        )
+        return Result.err(
+            ProviderError(
+                message=(
+                    f"JSON format required but LLM returned prose after {_MAX_JSON_RETRIES} retries"
+                ),
+                details={
+                    "last_response_preview": (
+                        result.value.content[:200] if result.is_ok else "N/A"
+                    ),
+                },
+            )
+        )
+
+    async def _complete_with_transient_retry(
+        self,
+        prompt: str,
+        config: CompletionConfig,
+        system_prompt: str | None,
+    ) -> Result[CompletionResponse, ProviderError]:
+        """Inner retry loop for transient API errors (rate limits, timeouts, etc.).
+
+        This handles infrastructure-level failures only. JSON format
+        enforcement is handled by the caller.
+        """
         last_error: ProviderError | None = None
 
         for attempt in range(_MAX_RETRIES):

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/tests/unit/evaluation/test_json_utils.py

@@ -99,3 +99,51 @@ class TestExtractJsonPayload:
         result = extract_json_payload(text)
         assert result is not None
         assert '"valid": true' in result
+
+
+class TestExtractJsonArray:
+    """extract_json_payload must also handle top-level JSON arrays."""
+
+    def test_pure_array(self):
+        text = '[{"a": 1}, {"b": 2}]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert '"a": 1' in result
+        assert result.startswith("[")
+
+    def test_array_in_code_fence(self):
+        text = '```json\n[{"item": "value"}]\n```'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result.startswith("[")
+
+    def test_prose_before_array(self):
+        text = 'Here are the results:\n[{"score": 0.9}, {"score": 0.8}]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result.startswith("[")
+        assert '"score": 0.9' in result
+
+    def test_object_before_array_returns_object(self):
+        """When both object and array exist, return whichever comes first."""
+        text = '{"first": true} [1, 2, 3]'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert '"first": true' in result
+
+    def test_array_before_object_returns_array(self):
+        text = '[1, 2] {"second": true}'
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result == "[1, 2]"
+
+    def test_empty_array(self):
+        text = "prefix [] suffix"
+        result = extract_json_payload(text)
+        assert result == "[]"
+
+    def test_nested_array(self):
+        text = "[[1, 2], [3, 4]]"
+        result = extract_json_payload(text)
+        assert result is not None
+        assert result == "[[1, 2], [3, 4]]"

ouroboros_ai-0.26.7.dev2/tests/unit/mcp/tools/test_evaluation_handler.py

@@ -0,0 +1,148 @@
+"""Tests for EvaluateHandler — adapter creation parameters (max_turns).
+
+Regression coverage for the bug where ooo evaluate always fails with
+``error_max_turns`` or ``exit code 1`` when invoked inside an active Claude
+Code session:
+
+  - Bug: ``max_turns=1`` caused the evaluator subprocess to hit the agentic
+    loop limit on the very first tool call (``Read`` to inspect a spec file).
+    Each AC check requires at least one file read, so ``max_turns=1`` was
+    never sufficient.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from ouroboros.core.types import Result
+from ouroboros.evaluation.models import (
+    CheckResult,
+    CheckType,
+    EvaluationResult,
+    MechanicalResult,
+    SemanticResult,
+)
+from ouroboros.mcp.tools.evaluation_handlers import EvaluateHandler
+from ouroboros.providers.base import CompletionResponse, UsageInfo
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+_MINIMAL_SEED = """\
+goal: Verify the system works correctly.
+acceptance_criteria:
+  - AC-01: Output exists
+"""
+
+_BASE_ARGUMENTS: dict = {
+    "session_id": "test-exec-001",
+    "artifact": "stub evaluation artifact",
+    "artifact_type": "docs",
+    "seed_content": _MINIMAL_SEED,  # goal present → skips EventStore DB lookup
+    "acceptance_criterion": None,
+    "working_dir": None,
+    "trigger_consensus": False,
+}
+
+
+def _make_mock_adapter() -> MagicMock:
+    """Return a mock LLMAdapter with a successful complete() response."""
+    adapter = MagicMock()
+    adapter.complete = AsyncMock(
+        return_value=Result.ok(
+            CompletionResponse(
+                content="{}",
+                model="test-model",
+                usage=UsageInfo(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            )
+        )
+    )
+    return adapter
+
+
+def _make_approved_eval_result() -> EvaluationResult:
+    """Return a minimal approved EvaluationResult for pipeline mocking."""
+    mechanical = MechanicalResult(
+        passed=True,
+        checks=(
+            CheckResult(
+                check_type=CheckType.LINT,
+                passed=True,
+                message="skipped",
+                details={"skipped": True},
+            ),
+        ),
+    )
+    semantic = SemanticResult(
+        score=0.9,
+        ac_compliance=True,
+        goal_alignment=0.9,
+        drift_score=0.05,
+        uncertainty=0.1,
+        reasoning="All ACs verified.",
+    )
+    return EvaluationResult(
+        execution_id="test-exec-001",
+        final_approved=True,
+        stage1_result=mechanical,
+        stage2_result=semantic,
+        stage3_result=None,
+    )
+
+
+def _patch_pipeline():
+    """Context manager: patch EvaluationPipeline to return an approved result."""
+    mock_pipeline = MagicMock()
+    mock_pipeline.evaluate = AsyncMock(return_value=Result.ok(_make_approved_eval_result()))
+    return patch(
+        "ouroboros.evaluation.EvaluationPipeline",
+        return_value=mock_pipeline,
+    )
+
+
+# ── Tests ─────────────────────────────────────────────────────────────────────
+
+
+class TestEvaluateHandlerAdapterCreation:
+    """Verify that the handler creates an adapter suited for headless evaluation."""
+
+    async def test_creates_adapter_with_sufficient_max_turns(self):
+        """Adapter must allow enough turns for the evaluator to read spec files.
+
+        Regression: max_turns=1 caused error_max_turns on the first tool call.
+        Evaluating N acceptance criteria requires at least N Read tool calls,
+        so max_turns must be well above 1.
+        """
+        captured: dict = {}
+
+        def _capture(**kwargs):
+            captured.update(kwargs)
+            return _make_mock_adapter()
+
+        handler = EvaluateHandler(llm_adapter=None)
+
+        with (
+            patch(
+                "ouroboros.mcp.tools.evaluation_handlers.create_llm_adapter",
+                side_effect=_capture,
+            ),
+            _patch_pipeline(),
+        ):
+            await handler.handle(_BASE_ARGUMENTS)
+
+        assert "max_turns" in captured, "create_llm_adapter was not called"
+        assert captured["max_turns"] >= 10, (
+            f"max_turns={captured['max_turns']} is too low — the evaluator needs "
+            "at least one turn per AC file read. Use max_turns >= 10."
+        )
+
+    async def test_injected_adapter_skips_create_llm_adapter(self):
+        """When an adapter is injected (e.g. in tests), create_llm_adapter is not called."""
+        handler = EvaluateHandler(llm_adapter=_make_mock_adapter())
+
+        with (
+            patch("ouroboros.mcp.tools.evaluation_handlers.create_llm_adapter") as mock_create,
+            _patch_pipeline(),
+        ):
+            await handler.handle(_BASE_ARGUMENTS)
+
+        mock_create.assert_not_called()

{ouroboros_ai-0.26.6.dev2 → ouroboros_ai-0.26.7.dev2}/tests/unit/providers/test_claude_code_adapter.py

@@ -243,8 +243,9 @@ class TestExecuteSingleRequestSystemPrompt:
             },
         )
 
-        mock_execute = AsyncMock()
-        mock_execute.return_value = MagicMock(is_ok=True)
+        mock_response = MagicMock(is_ok=True, is_err=False)
+        mock_response.value.content = '{"score": 0.9}'
+        mock_execute = AsyncMock(return_value=mock_response)
         adapter._execute_single_request = mock_execute
 
         with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
@@ -254,6 +255,139 @@ class TestExecuteSingleRequestSystemPrompt:
         assert "Respond with ONLY a valid JSON object" in prompt_arg
         assert '"score"' in prompt_arg
 
+    @pytest.mark.asyncio
+    async def test_json_retry_on_prose_response(self) -> None:
+        """When response_format requires JSON but LLM returns prose, adapter retries."""
+        adapter = ClaudeCodeAdapter()
+        messages = [Message(role=MessageRole.USER, content="Evaluate this")]
+        config = CompletionConfig(
+            model="claude-sonnet-4-6",
+            response_format={
+                "type": "json_schema",
+                "json_schema": {"type": "object", "properties": {"score": {"type": "number"}}},
+            },
+        )
+
+        prose_response = MagicMock(is_ok=True, is_err=False)
+        prose_response.value.content = "Let me verify the acceptance criteria..."
+
+        json_response = MagicMock(is_ok=True, is_err=False)
+        json_response.value.content = '{"score": 0.85}'
+
+        mock_execute = AsyncMock(side_effect=[prose_response, json_response])
+        adapter._execute_single_request = mock_execute
+
+        with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
+            result = await adapter.complete(messages, config)
+
+        assert result.is_ok
+        assert result.value.content == '{"score": 0.85}'
+        assert mock_execute.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_json_retry_exhausted_returns_error(self) -> None:
+        """When all JSON retries fail, return a ProviderError, not prose."""
+        adapter = ClaudeCodeAdapter()
+        messages = [Message(role=MessageRole.USER, content="Evaluate this")]
+        config = CompletionConfig(
+            model="claude-sonnet-4-6",
+            response_format={
+                "type": "json_schema",
+                "json_schema": {"type": "object", "properties": {"score": {"type": "number"}}},
+            },
+        )
+
+        prose_response = MagicMock(is_ok=True, is_err=False)
+        prose_response.value.content = "I cannot produce JSON right now"
+
+        # 1 initial + 3 retries = 4 calls total
+        mock_execute = AsyncMock(return_value=prose_response)
+        adapter._execute_single_request = mock_execute
+
+        with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
+            result = await adapter.complete(messages, config)
+
+        assert result.is_err
+        assert "JSON format required" in result.error.message
+        assert mock_execute.call_count == 4  # 1 initial + 3 retries
+
+    @pytest.mark.asyncio
+    async def test_json_extracted_from_prose_wrapped_response(self) -> None:
+        """When response contains valid JSON wrapped in prose, extract and normalize."""
+        adapter = ClaudeCodeAdapter()
+        messages = [Message(role=MessageRole.USER, content="Evaluate this")]
+        config = CompletionConfig(
+            model="claude-sonnet-4-6",
+            response_format={
+                "type": "json_schema",
+                "json_schema": {"type": "object", "properties": {"score": {"type": "number"}}},
+            },
+        )
+
+        mixed_response = MagicMock(is_ok=True, is_err=False)
+        mixed_response.value.content = 'Here is the result:\n{"score": 0.85}\nDone.'
+
+        mock_execute = AsyncMock(return_value=mixed_response)
+        adapter._execute_single_request = mock_execute
+
+        with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
+            result = await adapter.complete(messages, config)
+
+        assert result.is_ok
+        assert result.value.content == '{"score": 0.85}'
+        assert mock_execute.call_count == 1  # No retry needed
+
+    @pytest.mark.asyncio
+    async def test_json_schema_array_gets_correct_prompt_steering(self) -> None:
+        """json_schema with top-level array should say 'JSON array', not 'JSON object'."""
+        adapter = ClaudeCodeAdapter()
+        messages = [Message(role=MessageRole.USER, content="List items")]
+        config = CompletionConfig(
+            model="claude-sonnet-4-6",
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "type": "array",
+                    "items": {"type": "object", "properties": {"name": {"type": "string"}}},
+                },
+            },
+        )
+
+        mock_response = MagicMock(is_ok=True, is_err=False)
+        mock_response.value.content = '[{"name": "a"}]'
+        mock_execute = AsyncMock(return_value=mock_response)
+        adapter._execute_single_request = mock_execute
+
+        with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
+            result = await adapter.complete(messages, config)
+
+        prompt_arg = mock_execute.call_args.args[0]
+        assert "JSON array" in prompt_arg
+        assert "JSON object" not in prompt_arg
+        assert result.is_ok
+        assert result.value.content == '[{"name": "a"}]'
+
+    @pytest.mark.asyncio
+    async def test_json_object_format_gets_prompt_steering(self) -> None:
+        """json_object response_format should also get prompt steering."""
+        adapter = ClaudeCodeAdapter()
+        messages = [Message(role=MessageRole.USER, content="Return data")]
+        config = CompletionConfig(
+            model="claude-sonnet-4-6",
+            response_format={"type": "json_object"},
+        )
+
+        mock_response = MagicMock(is_ok=True, is_err=False)
+        mock_response.value.content = '{"data": "value"}'
+        mock_execute = AsyncMock(return_value=mock_response)
+        adapter._execute_single_request = mock_execute
+
+        with patch.dict("sys.modules", {"claude_agent_sdk": MagicMock()}):
+            await adapter.complete(messages, config)
+
+        prompt_arg = mock_execute.call_args.args[0]
+        assert "Respond with ONLY a valid JSON object" in prompt_arg
+
     @pytest.mark.asyncio
     async def test_execute_single_request_omits_output_format(self) -> None:
         """SDK options should not include output_format for json_schema requests."""