Создана первоначальная структура обращения к языковым моделям

llm/config.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from typing import Annotated, Literal
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class CodexConfig(BaseModel):
+    provider: Literal["codex"]
+    model: str = "gpt-5.6-luna"
+
+    credential_path: Path | None = None
+
+
+class OpenAiConfig(BaseModel):
+    provider: Literal["openai"]
+    model: str
+
+    api_key_env: str = "API_KEY"
+    base_url_env: str = "BASE_URL"
+
+
+LLMConfig = Annotated[
+    CodexConfig | OpenAiConfig,
+    Field(discriminator="provider")
+]
+
+
+class AppConfig(BaseModel):
+    llm: LLMConfig
+
+
+def load_config(path: str | Path = "config.yaml") -> AppConfig:
+    path = Path(path)
+
+    with path.open("r", encoding="utf-8") as file:
+        data = yaml.safe_load(file)
+
+    return AppConfig.model_validate(data)

llm/credentials.py

@@ -0,0 +1,44 @@
+import json
+from dataclasses import asdict
+from pathlib import Path
+
+from pydantic_ai.providers.openai_codex import (
+    OpenAICodexCredentials,
+    OpenAICodexCredentialSource,
+)
+
+
+class FileCodexCredentionalSource(OpenAICodexCredentialSource):
+    def __init__(self, 
+                 path: Path,
+                 encoding: str="utf-8",
+                 ensure_ascii: bool=False,
+                 indent: int=2):
+        super().__init__()
+        self._path = path
+        self._encoding=encoding
+        self._ensure_ascii=ensure_ascii
+        self._indent=indent
+
+    @property
+    def path(self):
+        return self._path
+
+    async def load(self) -> OpenAICodexCredentials:
+        return OpenAICodexCredentials(
+            **json.loads(
+                self._path.read_text(encoding=self._encoding)
+                )
+            )
+
+    async def save(self, credentials: OpenAICodexCredentials) -> None:
+        self._path.write_text(
+            json.dumps(
+                asdict(credentials),
+                ensure_ascii=self._ensure_ascii,
+                indent=self._indent
+                ),
+                encoding=self._encoding
+            )
+
+        

llm/factory.py

@@ -0,0 +1,84 @@
+import os
+import webbrowser
+from pathlib import Path
+
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.models.openai_codex import OpenAICodexModel
+from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.providers.openai_codex import (
+    OpenAICodexOAuthFlow,
+    OpenAICodexProvider,
+)
+
+from .config import CodexConfig, LLMConfig, OpenAiConfig
+from .credentials import FileCodexCredentionalSource
+
+
+class LLMModelProvider:
+
+    @staticmethod
+    def create_openai_compatible(model_name: str,
+                                 api_key: str,
+                                 base_url: str
+                                ) -> OpenAICodexModel:
+
+        provider = OpenAIProvider(base_url=base_url,
+                                api_key=api_key)
+
+        return OpenAIChatModel(model_name=model_name,
+                            provider=provider)
+
+    @staticmethod
+    async def create_codex(model_name: str='gpt-5.6-luna',
+                           credentional_path: str | Path | None=None
+                           ) -> OpenAICodexModel:
+
+        if credentional_path is None:
+            credentional_path = Path.cwd() / ".config" / "codex-credentials.json"
+
+        
+        source  = FileCodexCredentionalSource(credentional_path)
+
+        if not source.path.exists():
+            flow = OpenAICodexOAuthFlow()
+            webbrowser.open(flow.authorization_url())
+            credentials = await flow.exchange_code_from_callback()
+            await source.save(credentials)
+
+        provider = OpenAICodexProvider(credential_source=source)
+
+        return OpenAICodexModel(model_name=model_name,
+                                provider=provider)
+
+    @staticmethod
+    async def create_from_config(config: LLMConfig):
+
+        if isinstance(config, CodexConfig):
+            return await LLMModelProvider.create_codex(
+                model_name=config.model,
+                credentional_path=config.credential_path
+            )
+
+        if isinstance(config, OpenAiConfig):
+            api_key = os.getenv(config.api_key_env)
+            base_url=os.getenv(config.base_url_env)
+
+            if not api_key:
+                raise ValueError(
+                    f"Environment variable "
+                    f"{config.api_key_env!r} is not set"
+                )
+
+            if not base_url:
+                raise ValueError(
+                    f"Environment variable "
+                    f"{config.base_url_env!r} is not set"
+                )
+
+            return LLMModelProvider.create_openai_compatible(
+                model_name=config.model,
+                api_key=api_key,
+                base_url=base_url
+            )
+
+        raise ValueError(f"Unsupported LLM config: {type(config)}")