nighthawk-python 0.1.0__py3-none-any.whl

nighthawk/backends/claude_code_sdk.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from datetime import datetime
+from typing import Any, Literal
+
+from opentelemetry import context as otel_context
+from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic_ai.builtin_tools import AbstractBuiltinTool
+from pydantic_ai.exceptions import UnexpectedModelBehavior, UserError
+from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart
+from pydantic_ai.models import ModelRequestParameters
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.settings import ModelSettings
+from pydantic_ai.usage import RequestUsage
+
+from ..json_renderer import to_jsonable_value
+from ..tools.registry import get_visible_tools
+from .base import BackendModelBase
+from .mcp_boundary import call_tool_for_claude_code_sdk
+from .tool_bridge import ToolHandler
+
+type PermissionMode = Literal["default", "acceptEdits", "plan", "bypassPermissions"]
+
+type SettingSource = Literal["user", "project", "local"]
+
+
+def _normalize_timestamp(value: object) -> datetime:
+    if isinstance(value, datetime):
+        return value
+    return datetime.now(tz=datetime.now().astimezone().tzinfo)
+
+
+class ClaudeCodeSdkModelSettings(BaseModel):
+    """Settings for the Claude Code SDK backend.
+
+    Attributes:
+        permission_mode: Claude Code permission mode.
+        setting_sources: Configuration sources to load.
+        allowed_tool_names: Nighthawk tool names exposed to the model.
+        claude_allowed_tool_names: Additional Claude Code native tool names to allow.
+        claude_max_turns: Maximum conversation turns.
+        working_directory: Absolute path to the working directory for Claude Code.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    permission_mode: PermissionMode = "default"
+    setting_sources: list[SettingSource] | None = None
+    allowed_tool_names: tuple[str, ...] | None = None
+    claude_allowed_tool_names: tuple[str, ...] | None = None
+    claude_max_turns: int = 50
+    working_directory: str = ""
+
+    @field_validator("claude_max_turns")
+    @classmethod
+    def _validate_claude_max_turns(cls, value: int) -> int:
+        if value <= 0:
+            raise ValueError("claude_max_turns must be greater than 0")
+        return value
+
+    @field_validator("working_directory")
+    @classmethod
+    def _validate_working_directory(cls, value: str) -> str:
+        if value and not os.path.isabs(value):
+            raise ValueError("working_directory must be an absolute path")
+        return value
+
+
+def _get_claude_code_sdk_model_settings(model_settings: ModelSettings | None) -> ClaudeCodeSdkModelSettings:
+    if model_settings is None:
+        return ClaudeCodeSdkModelSettings()
+    try:
+        return ClaudeCodeSdkModelSettings.model_validate(model_settings)
+    except Exception as exception:
+        raise UserError(str(exception)) from exception
+
+
+def _build_json_schema_output_format(model_request_parameters: ModelRequestParameters) -> dict[str, Any] | None:
+    output_object = model_request_parameters.output_object
+    if output_object is None:
+        return None
+
+    schema = dict(output_object.json_schema)
+    if output_object.name:
+        schema["title"] = output_object.name
+    if output_object.description:
+        schema["description"] = output_object.description
+
+    return {"type": "json_schema", "schema": schema}
+
+
+def _normalize_claude_code_sdk_usage_to_request_usage(usage: object) -> RequestUsage:
+    request_usage = RequestUsage()
+    if not isinstance(usage, dict):
+        return request_usage
+
+    input_tokens = usage.get("input_tokens")
+    if isinstance(input_tokens, int):
+        request_usage.input_tokens = input_tokens
+
+    output_tokens = usage.get("output_tokens")
+    if isinstance(output_tokens, int):
+        request_usage.output_tokens = output_tokens
+
+    cache_read_input_tokens = usage.get("cache_read_input_tokens")
+    if isinstance(cache_read_input_tokens, int):
+        request_usage.cache_read_tokens = cache_read_input_tokens
+
+    cache_creation_input_tokens = usage.get("cache_creation_input_tokens")
+    if isinstance(cache_creation_input_tokens, int):
+        request_usage.cache_write_tokens = cache_creation_input_tokens
+
+    return request_usage
+
+
+def _serialize_result_message_to_json(result_message: object) -> str:
+    result_message_model_dump_json = getattr(result_message, "model_dump_json", None)
+    if callable(result_message_model_dump_json):
+        try:
+            result_message_json = result_message_model_dump_json()
+            if isinstance(result_message_json, str):
+                return result_message_json
+        except Exception:
+            pass
+
+    result_message_model_dump = getattr(result_message, "model_dump", None)
+    if callable(result_message_model_dump):
+        with contextlib.suppress(Exception):
+            result_message = result_message_model_dump()
+
+    try:
+        return json.dumps(to_jsonable_value(result_message), ensure_ascii=False)
+    except Exception:
+        return json.dumps({"result_message_repr": repr(result_message)}, ensure_ascii=False)
+
+
+class ClaudeCodeSdkModel(BackendModelBase):
+    """Pydantic AI model that delegates to Claude Code via the Claude Agent SDK."""
+
+    def __init__(self, *, model_name: str | None = None) -> None:
+        super().__init__(
+            backend_label="Claude Code SDK backend",
+            profile=ModelProfile(
+                supports_tools=True,
+                supports_json_schema_output=True,
+                supports_json_object_output=False,
+                supports_image_output=False,
+                default_structured_output_mode="native",
+                supported_builtin_tools=frozenset([AbstractBuiltinTool]),
+            ),
+        )
+        self._model_name = model_name
+
+    @property
+    def model_name(self) -> str:
+        return f"claude-code-sdk:{self._model_name or 'default'}"
+
+    @property
+    def system(self) -> str:
+        return "anthropic"
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ModelResponse:
+        from claude_agent_sdk import (
+            ClaudeAgentOptions,
+            ClaudeSDKClient,
+            SdkMcpTool,
+            create_sdk_mcp_server,
+        )
+        from claude_agent_sdk.types import AssistantMessage, Message, ResultMessage  # pyright: ignore[reportMissingImports]
+
+        model_settings, model_request_parameters = self.prepare_request(model_settings, model_request_parameters)
+
+        parent_otel_context = otel_context.get_current()
+
+        _, system_prompt_text, user_prompt_text = self._prepare_common_request_parts(
+            messages=messages,
+            model_request_parameters=model_request_parameters,
+        )
+
+        claude_code_model_settings = _get_claude_code_sdk_model_settings(model_settings)
+
+        tool_name_to_tool_definition, tool_name_to_handler, allowed_tool_names = await self._prepare_allowed_tools(
+            model_request_parameters=model_request_parameters,
+            configured_allowed_tool_names=claude_code_model_settings.allowed_tool_names,
+            visible_tools=get_visible_tools(),
+        )
+
+        mcp_tools: list[Any] = []
+        for tool_name, handler in tool_name_to_handler.items():
+            tool_definition = tool_name_to_tool_definition.get(tool_name)
+            if tool_definition is None:
+                raise UnexpectedModelBehavior(f"Tool definition missing for {tool_name!r}")
+
+            async def wrapped_handler(
+                arguments: dict[str, Any],
+                *,
+                tool_handler: ToolHandler = handler,
+                bound_tool_name: str = tool_name,
+            ) -> dict[str, Any]:
+                return await call_tool_for_claude_code_sdk(
+                    tool_name=bound_tool_name,
+                    arguments=arguments,
+                    tool_handler=tool_handler,
+                    parent_otel_context=parent_otel_context,
+                )
+
+            mcp_tools.append(
+                SdkMcpTool(
+                    name=tool_name,
+                    description=tool_definition.description or "",
+                    input_schema=tool_definition.parameters_json_schema,
+                    handler=wrapped_handler,
+                )
+            )
+
+        sdk_server = create_sdk_mcp_server("nighthawk", tools=mcp_tools)
+
+        allowed_tools_for_claude = [f"mcp__nighthawk__{tool_name}" for tool_name in allowed_tool_names]
+
+        claude_allowed_tool_names = claude_code_model_settings.claude_allowed_tool_names or ()
+        merged_allowed_tools: list[str] = []
+        seen_allowed_tools: set[str] = set()
+        for tool_name in [*claude_allowed_tool_names, *allowed_tools_for_claude]:
+            if tool_name in seen_allowed_tools:
+                continue
+            merged_allowed_tools.append(tool_name)
+            seen_allowed_tools.add(tool_name)
+
+        working_directory = claude_code_model_settings.working_directory
+
+        if allowed_tool_names:
+            system_prompt_text = "\n".join(
+                [
+                    system_prompt_text,
+                    "",
+                    "Tool access:",
+                    "- Nighthawk tools are exposed via MCP; tool names are prefixed with: mcp__nighthawk__",
+                    "- Example: to call nh_exec(...), use: mcp__nighthawk__nh_exec",
+                ]
+            )
+
+        options_keyword_arguments: dict[str, Any] = {
+            "tools": {
+                "type": "preset",
+                "preset": "claude_code",
+            },
+            "allowed_tools": merged_allowed_tools,
+            "system_prompt": {
+                "type": "preset",
+                "preset": "claude_code",
+                "append": system_prompt_text,
+            },
+            "mcp_servers": {"nighthawk": sdk_server},
+            "permission_mode": claude_code_model_settings.permission_mode,
+            "model": self._model_name,
+            "setting_sources": claude_code_model_settings.setting_sources,
+            "max_turns": claude_code_model_settings.claude_max_turns,
+            "output_format": _build_json_schema_output_format(model_request_parameters),
+        }
+
+        if working_directory:
+            options_keyword_arguments["cwd"] = working_directory
+
+        options = ClaudeAgentOptions(**options_keyword_arguments)
+
+        assistant_model_name: str | None = None
+        result_message: ResultMessage | None = None
+        result_messages: list[Message] = []
+
+        # Claude Code sets the CLAUDECODE environment variable for nested sessions.
+        # When the variable is set, the Claude Code CLI refuses to launch.
+        # This modifies the process-global environment, which is unavoidable because
+        # the Claude Agent SDK inherits environment variables from the parent process.
+        saved_claudecode_value = os.environ.pop("CLAUDECODE", None)
+
+        try:
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(user_prompt_text)
+
+                async for message in client.receive_response():
+                    if isinstance(message, AssistantMessage):
+                        assistant_model_name = message.model
+                    elif isinstance(message, ResultMessage):
+                        result_message = message
+                    result_messages.append(message)
+        finally:
+            if saved_claudecode_value is not None:
+                os.environ["CLAUDECODE"] = saved_claudecode_value
+
+        if result_message is None:
+            raise UnexpectedModelBehavior("Claude Code backend did not produce a result message")
+
+        if result_message.is_error:
+            error_text = result_message.result or "Claude Code backend reported an error"
+            result_messages_json = _serialize_result_message_to_json(result_messages)
+            raise UnexpectedModelBehavior(
+                f"{error_text}\nresult_message_json={result_messages_json}\noutput_format={options_keyword_arguments['output_format']}"
+            )
+
+        structured_output = result_message.structured_output
+        if structured_output is None:
+            if model_request_parameters.output_object is not None:
+                result_messages_json = _serialize_result_message_to_json(result_messages)
+                raise UnexpectedModelBehavior(f"Claude Code backend did not return structured output\nresult_message_json={result_messages_json}")
+
+            if result_message.result is None:
+                raise UnexpectedModelBehavior("Claude Code backend did not return text output")
+            output_text = result_message.result
+        else:
+            output_text = json.dumps(structured_output, ensure_ascii=False)
+
+        return ModelResponse(
+            parts=[TextPart(content=output_text)],
+            model_name=assistant_model_name,
+            timestamp=_normalize_timestamp(getattr(result_message, "timestamp", None)),
+            usage=_normalize_claude_code_sdk_usage_to_request_usage(getattr(result_message, "usage", None)),
+        )

nighthawk/backends/codex.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import tempfile
+from dataclasses import replace
+from pathlib import Path
+from typing import IO, Any, Literal, TypedDict
+
+from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic_ai.builtin_tools import AbstractBuiltinTool
+from pydantic_ai.exceptions import UnexpectedModelBehavior, UserError
+from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart
+from pydantic_ai.models import ModelRequestParameters
+from pydantic_ai.profiles import InlineDefsJsonSchemaTransformer, ModelProfile
+from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer
+from pydantic_ai.settings import ModelSettings
+from pydantic_ai.usage import RequestUsage
+
+from ..tools.registry import get_visible_tools
+from .base import BackendModelBase
+from .mcp_server import mcp_server_if_needed
+
+
+class _CodexJsonSchemaTransformer(OpenAIJsonSchemaTransformer):
+    def __init__(self, schema: dict[str, Any], *, strict: bool | None = None):
+        schema = InlineDefsJsonSchemaTransformer(schema, strict=strict).walk()
+        super().__init__(schema, strict=strict)
+
+    def transform(self, schema: dict[str, Any]) -> dict[str, Any]:
+        if not schema:
+            schema = {"type": "object"}
+        elif "properties" in schema and "type" not in schema:
+            schema = dict(schema)
+            schema["type"] = "object"
+        return super().transform(schema)
+
+
+type SandboxMode = Literal["read-only", "workspace-write", "danger-full-access"]
+type ModelReasoningEffort = Literal["minimal", "low", "medium", "high", "xhigh"]
+
+
+class CodexModelSettings(BaseModel):
+    """Settings for the Codex backend.
+
+    Attributes:
+        allowed_tool_names: Nighthawk tool names exposed to the model.
+        codex_executable: Path or name of the Codex CLI executable.
+        model_reasoning_effort: Reasoning effort level for the model.
+        sandbox_mode: Codex sandbox isolation mode.
+        working_directory: Absolute path to the working directory for Codex.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    allowed_tool_names: tuple[str, ...] | None = None
+    codex_executable: str = "codex"
+    model_reasoning_effort: ModelReasoningEffort | None = None
+    sandbox_mode: SandboxMode | None = None
+    working_directory: str = ""
+
+    @field_validator("codex_executable")
+    @classmethod
+    def _validate_codex_executable(cls, value: str) -> str:
+        if value.strip() == "":
+            raise ValueError("codex_executable must be a non-empty string")
+        return value
+
+    @field_validator("working_directory")
+    @classmethod
+    def _validate_working_directory(cls, value: str) -> str:
+        if value and not Path(value).is_absolute():
+            raise ValueError("working_directory must be an absolute path")
+        return value
+
+
+def _get_codex_model_settings(model_settings: ModelSettings | None) -> CodexModelSettings:
+    if model_settings is None:
+        return CodexModelSettings()
+    try:
+        return CodexModelSettings.model_validate(model_settings)
+    except Exception as exception:
+        raise UserError(str(exception)) from exception
+
+
+class _CodexTurnOutcome(TypedDict):
+    output_text: str
+    thread_id: str | None
+    usage: RequestUsage
+
+
+def _render_toml_value_text(value: object) -> str:
+    # Codex CLI accepts `--config key=value` where values are TOML literals.
+    # Using JSON serialization for strings/arrays produces TOML-compatible literals for the cases we need here.
+    if isinstance(value, str):
+        return json.dumps(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        return json.dumps(value)
+    if isinstance(value, dict):
+        return json.dumps(value)
+    raise TypeError(f"Unsupported config value type: {type(value).__name__}")
+
+
+def _build_codex_config_arguments(configuration_overrides: dict[str, object]) -> list[str]:
+    arguments: list[str] = []
+    for key, value in configuration_overrides.items():
+        arguments.extend(["--config", f"{key}={_render_toml_value_text(value)}"])
+    return arguments
+
+
+def _parse_codex_jsonl_lines(jsonl_lines: list[str]) -> _CodexTurnOutcome:
+    output_text: str | None = None
+    thread_id: str | None = None
+    most_recent_stream_error_message: str | None = None
+
+    usage = RequestUsage()
+
+    for line in jsonl_lines:
+        try:
+            event = json.loads(line)
+        except Exception as exception:
+            raise UnexpectedModelBehavior("Codex CLI produced invalid JSONL output") from exception
+
+        if not isinstance(event, dict) or "type" not in event:
+            raise UnexpectedModelBehavior("Codex CLI produced an unexpected event")
+
+        event_type = event.get("type")
+        if event_type == "thread.started":
+            thread_id_value = event.get("thread_id")
+            if isinstance(thread_id_value, str):
+                thread_id = thread_id_value
+        elif event_type == "turn.completed":
+            usage_value = event.get("usage")
+            if isinstance(usage_value, dict):
+                input_tokens = usage_value.get("input_tokens")
+                cached_input_tokens = usage_value.get("cached_input_tokens")
+                output_tokens = usage_value.get("output_tokens")
+
+                if isinstance(input_tokens, int):
+                    usage.input_tokens = input_tokens
+                if isinstance(cached_input_tokens, int):
+                    usage.cache_read_tokens = cached_input_tokens
+                if isinstance(output_tokens, int):
+                    usage.output_tokens = output_tokens
+        elif event_type == "turn.failed":
+            error_value = event.get("error")
+            if isinstance(error_value, dict) and isinstance(error_value.get("message"), str):
+                raise UnexpectedModelBehavior(str(error_value.get("message")))
+            raise UnexpectedModelBehavior("Codex CLI reported a failed turn")
+        elif event_type == "error":
+            # Codex CLI can emit transient reconnect progress as `error` events.
+            # Preserve the latest message and only fail if no usable response is produced.
+            message_value = event.get("message")
+            most_recent_stream_error_message = message_value if isinstance(message_value, str) else "Codex CLI reported a stream error"
+        elif event_type == "item.completed":
+            item_value = event.get("item")
+            if isinstance(item_value, dict) and item_value.get("type") == "agent_message":
+                text_value = item_value.get("text")
+                if isinstance(text_value, str):
+                    output_text = text_value
+
+    if output_text is None:
+        if most_recent_stream_error_message is not None:
+            raise UnexpectedModelBehavior(most_recent_stream_error_message)
+        raise UnexpectedModelBehavior("Codex CLI did not produce an agent message")
+
+    return {
+        "output_text": output_text,
+        "thread_id": thread_id,
+        "usage": usage,
+    }
+
+
+class CodexModel(BackendModelBase):
+    """Pydantic AI model that delegates to the Codex CLI."""
+
+    def __init__(self, *, model_name: str | None = None) -> None:
+        super().__init__(
+            backend_label="Codex backend",
+            profile=ModelProfile(
+                supports_tools=True,
+                supports_json_schema_output=True,
+                supports_json_object_output=False,
+                supports_image_output=False,
+                default_structured_output_mode="native",
+                supported_builtin_tools=frozenset([AbstractBuiltinTool]),
+                json_schema_transformer=_CodexJsonSchemaTransformer,
+            ),
+        )
+        self._model_name = model_name
+
+    @property
+    def model_name(self) -> str:
+        return f"codex:{self._model_name or 'default'}"
+
+    @property
+    def system(self) -> str:
+        return "openai"
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ModelResponse:
+        if model_request_parameters.output_object is not None:
+            model_request_parameters = replace(
+                model_request_parameters,
+                output_object=replace(model_request_parameters.output_object, strict=True),
+            )
+        model_settings, model_request_parameters = self.prepare_request(model_settings, model_request_parameters)
+
+        output_schema_file: IO[str] | None = None
+
+        try:
+            _, system_prompt_text, user_prompt_text = self._prepare_common_request_parts(
+                messages=messages,
+                model_request_parameters=model_request_parameters,
+            )
+
+            prompt_parts = [p for p in [system_prompt_text, user_prompt_text] if p]
+            prompt_text = "\n\n".join(prompt_parts)
+
+            codex_model_settings = _get_codex_model_settings(model_settings)
+
+            tool_name_to_tool_definition, tool_name_to_handler, allowed_tool_names = await self._prepare_allowed_tools(
+                model_request_parameters=model_request_parameters,
+                configured_allowed_tool_names=codex_model_settings.allowed_tool_names,
+                visible_tools=get_visible_tools(),
+            )
+
+            output_object = model_request_parameters.output_object
+            if output_object is None:
+                output_schema_file = None
+            else:
+                output_schema_file = tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8", prefix="nighthawk-codex-output-schema-", suffix=".json")  # noqa: SIM115
+                output_schema_file.write(json.dumps(dict(output_object.json_schema)))
+                output_schema_file.flush()
+            async with mcp_server_if_needed(
+                tool_name_to_tool_definition=tool_name_to_tool_definition,
+                tool_name_to_handler=tool_name_to_handler,
+            ) as mcp_server_url:
+                configuration_overrides: dict[str, object] = {}
+
+                if self._model_name is not None:
+                    configuration_overrides["model"] = self._model_name
+
+                if mcp_server_url is not None:
+                    configuration_overrides["mcp_servers.nighthawk.url"] = mcp_server_url
+                    configuration_overrides["mcp_servers.nighthawk.enabled_tools"] = list(allowed_tool_names)
+                model_reasoning_effort = codex_model_settings.model_reasoning_effort
+                if model_reasoning_effort is not None:
+                    configuration_overrides["model_reasoning_effort"] = model_reasoning_effort
+
+                codex_arguments = [
+                    codex_model_settings.codex_executable,
+                    "exec",
+                    "--experimental-json",
+                    "--skip-git-repo-check",
+                ]
+                sandbox_mode = codex_model_settings.sandbox_mode
+                if sandbox_mode is not None:
+                    codex_arguments.extend(["--sandbox", sandbox_mode])
+                codex_arguments.extend(_build_codex_config_arguments(configuration_overrides))
+
+                if output_schema_file is not None:
+                    codex_arguments.extend(["--output-schema", output_schema_file.name])
+
+                working_directory = codex_model_settings.working_directory
+                if working_directory:
+                    codex_arguments.extend(["--cd", working_directory])
+
+                process = await asyncio.create_subprocess_exec(
+                    *codex_arguments,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                if process.stdin is None or process.stdout is None or process.stderr is None:
+                    raise UnexpectedModelBehavior("Codex CLI subprocess streams are unexpectedly None")
+
+                process.stdin.write(prompt_text.encode("utf-8"))
+                await process.stdin.drain()
+                process.stdin.close()
+
+                jsonl_lines: list[str] = []
+
+                process_stderr = process.stderr
+
+                async def read_stderr() -> bytes:
+                    if process_stderr is None:
+                        return b""
+                    return await process_stderr.read()
+
+                stderr_task = asyncio.create_task(read_stderr())
+
+                async for line_bytes in process.stdout:
+                    line_text = line_bytes.decode("utf-8").rstrip("\n")
+                    if line_text:
+                        jsonl_lines.append(line_text)
+
+                return_code = await process.wait()
+                stderr_bytes = await stderr_task
+
+                if return_code != 0:
+                    stderr_text = stderr_bytes.decode("utf-8", errors="replace").strip()
+                    detail_parts: list[str] = []
+
+                    if stderr_text:
+                        detail_parts.append(f"stderr={stderr_text[:2000]}")
+
+                    recent_jsonl_lines = jsonl_lines[-8:]
+                    if recent_jsonl_lines:
+                        recent_jsonl_text = "\n".join(recent_jsonl_lines)
+                        detail_parts.append(f"recent_jsonl_events={recent_jsonl_text[:4000]}")
+
+                    if not detail_parts:
+                        detail_parts.append("no stderr or JSONL events were captured")
+
+                    detail = " | ".join(detail_parts)
+                    raise UnexpectedModelBehavior(f"Codex CLI exited with non-zero status. {detail}")
+
+                turn_outcome = _parse_codex_jsonl_lines(jsonl_lines)
+
+                output_text = turn_outcome["output_text"]
+
+                provider_details: dict[str, Any] = {
+                    "codex": {
+                        "thread_id": turn_outcome["thread_id"],
+                    }
+                }
+
+                return ModelResponse(
+                    parts=[TextPart(content=output_text)],
+                    usage=turn_outcome["usage"],
+                    model_name=self.model_name,
+                    provider_name="codex",
+                    provider_details=provider_details,
+                )
+        except (UserError, UnexpectedModelBehavior, ValueError):
+            raise
+        except Exception as exception:
+            raise UnexpectedModelBehavior("Codex backend failed") from exception
+        finally:
+            if output_schema_file is not None:
+                with contextlib.suppress(Exception):
+                    output_schema_file.close()