| from __future__ import annotations |
|
|
| import json |
| import os |
| from typing import Any |
|
|
| from .schemas import ( |
| AuditorOutput, |
| PlannerOutput, |
| auditor_json_schema, |
| planner_json_schema, |
| ) |
|
|
|
|
| class OpenAICompatibleClient: |
| """OpenAI SDK client using strict structured outputs with chat fallback.""" |
|
|
| def __init__( |
| self, |
| *, |
| api_key: str, |
| model: str, |
| base_url: str | None = None, |
| provider: str = "openai", |
| timeout: float = 60.0, |
| ) -> None: |
| try: |
| from openai import OpenAI |
| except ModuleNotFoundError as exc: |
| raise RuntimeError("The openai package is required for OpenAICompatibleClient.") from exc |
|
|
| self.provider = provider |
| self.model = model |
| self.failure_count = 0 |
| kwargs: dict[str, Any] = {"api_key": api_key, "timeout": timeout} |
| if base_url: |
| kwargs["base_url"] = base_url |
| self._client = OpenAI(**kwargs) |
|
|
| def plan_structured(self, messages: list[dict[str, str]]) -> PlannerOutput: |
| try: |
| return self._responses_parse(messages, PlannerOutput) |
| except Exception: |
| try: |
| return PlannerOutput.model_validate( |
| self._chat_json_schema(messages, "planner_output", planner_json_schema()) |
| ) |
| except Exception: |
| self.failure_count += 1 |
| raise |
|
|
| def audit_structured(self, messages: list[dict[str, str]]) -> AuditorOutput: |
| try: |
| return self._responses_parse(messages, AuditorOutput) |
| except Exception: |
| try: |
| return AuditorOutput.model_validate( |
| self._chat_json_schema(messages, "auditor_output", auditor_json_schema()) |
| ) |
| except Exception: |
| self.failure_count += 1 |
| raise |
|
|
| def _responses_parse(self, messages: list[dict[str, str]], model_type: type[Any]) -> Any: |
| response = self._client.responses.parse( |
| model=self.model, |
| input=messages, |
| text_format=model_type, |
| ) |
| parsed = getattr(response, "output_parsed", None) |
| if parsed is None: |
| raise ValueError("Responses structured parse returned no parsed output.") |
| return parsed |
|
|
| def _chat_json_schema(self, messages: list[dict[str, str]], schema_name: str, schema: dict[str, Any]) -> dict[str, Any]: |
| response = self._client.chat.completions.create( |
| model=self.model, |
| messages=messages, |
| response_format={ |
| "type": "json_schema", |
| "json_schema": { |
| "name": schema_name, |
| "strict": True, |
| "schema": schema, |
| }, |
| }, |
| temperature=0, |
| ) |
| message = response.choices[0].message |
| refusal = getattr(message, "refusal", None) |
| if refusal: |
| raise ValueError(f"Structured output refusal: {refusal}") |
| content = message.content |
| if not content: |
| raise ValueError("Structured output response was empty.") |
| return json.loads(content) |
|
|
|
|
| def make_llm_client( |
| *, |
| provider: str | None = None, |
| model: str | None = None, |
| base_url: str | None = None, |
| api_key: str | None = None, |
| ) -> OpenAICompatibleClient: |
| resolved_provider = provider or os.getenv("SOLARCHAIN_LLM_PROVIDER") or "openai" |
| resolved_api_key = api_key or os.getenv("SOLARCHAIN_LLM_API_KEY") or os.getenv("OPENAI_API_KEY") |
| resolved_base_url = base_url or os.getenv("SOLARCHAIN_LLM_BASE_URL") or os.getenv("OPENAI_BASE_URL") |
| resolved_model = model or os.getenv("SOLARCHAIN_LLM_MODEL") or os.getenv("OPENAI_MODEL") |
|
|
| if not resolved_api_key: |
| raise RuntimeError( |
| "LLM API key is required for --planner llm or --auditor llm. " |
| "Set SOLARCHAIN_LLM_API_KEY or OPENAI_API_KEY." |
| ) |
| if not resolved_model: |
| raise RuntimeError( |
| "LLM model is required for --planner llm or --auditor llm. " |
| "Set SOLARCHAIN_LLM_MODEL or OPENAI_MODEL." |
| ) |
|
|
| return OpenAICompatibleClient( |
| api_key=resolved_api_key, |
| model=resolved_model, |
| base_url=resolved_base_url, |
| provider=resolved_provider, |
| ) |
|
|
