offerprinter 0.2.0__py3-none-any.whl

offerprinter/config.py

@@ -0,0 +1,183 @@
+"""Configuration loading.
+
+Precedence (highest wins):
+    1. Environment variables
+    2. config.toml (or a path passed explicitly)
+    3. Built-in defaults
+
+The only thing a user strictly has to provide is an API key. If the key is not
+in the file or the generic OFFERPRINTER_API_KEY var, we fall back to the
+standard per-provider env var (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...).
+
+The Ollama provider is the exception: it runs on your own machine and needs no
+key at all.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+try:  # Python 3.11+
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover - 3.10 fallback
+    import tomli as tomllib  # type: ignore
+
+from offerprinter.models.schemas import (
+    GenerationConfig,
+    LLMConfig,
+    Locale,
+    OutputConfig,
+    Provider,
+)
+from offerprinter.services.writer import SUPPORTED_FORMATS
+
+# Standard per-provider environment variables to fall back to for the key.
+_PROVIDER_KEY_ENV: dict[Provider, tuple[str, ...]] = {
+    Provider.ANTHROPIC: ("ANTHROPIC_API_KEY",),
+    Provider.OPENAI: ("OPENAI_API_KEY",),
+    Provider.GEMINI: ("GEMINI_API_KEY", "GOOGLE_API_KEY"),
+    Provider.KIMI: ("MOONSHOT_API_KEY", "KIMI_API_KEY"),
+    Provider.OLLAMA: ("OLLAMA_API_KEY",),
+}
+
+
+class Config:
+    """Fully-resolved runtime configuration."""
+
+    def __init__(
+        self,
+        llm: LLMConfig,
+        output: OutputConfig,
+        generation: GenerationConfig,
+        pricing: dict[str, tuple[float, float]] | None = None,
+    ) -> None:
+        self.llm = llm
+        self.output = output
+        self.generation = generation
+        #: model name/prefix -> (USD per 1M input, USD per 1M output)
+        self.pricing = pricing or {}
+
+
+def _read_toml(path: Path | None) -> dict:
+    """Load a TOML file if it exists; otherwise return an empty dict."""
+    candidates: list[Path] = []
+    if path is not None:
+        candidates.append(path)
+    else:
+        # Look for config.toml in the current directory by default.
+        candidates.append(Path("config.toml"))
+
+    for candidate in candidates:
+        if candidate.is_file():
+            with candidate.open("rb") as fh:
+                return tomllib.load(fh)
+    return {}
+
+
+def _first_env(*names: str) -> str | None:
+    for name in names:
+        val = os.environ.get(name)
+        if val:
+            return val
+    return None
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _clean_formats(raw: object) -> list[str]:
+    """Keep only formats we can actually write, preserving the user's order."""
+    values = [str(f).strip().lower().lstrip(".") for f in raw] if isinstance(raw, list) else []
+    formats = [f for f in values if f in SUPPORTED_FORMATS]
+    return formats or ["md", "docx"]
+
+
+def _parse_pricing(raw: object) -> dict[str, tuple[float, float]]:
+    """Parse a [pricing] table of {model = {input = x, output = y}}."""
+    if not isinstance(raw, dict):
+        return {}
+    parsed: dict[str, tuple[float, float]] = {}
+    for model, rates in raw.items():
+        if isinstance(rates, dict) and "input" in rates and "output" in rates:
+            try:
+                parsed[str(model).lower()] = (float(rates["input"]), float(rates["output"]))
+            except (TypeError, ValueError):
+                continue
+    return parsed
+
+
+def load_config(config_path: str | os.PathLike[str] | None = None) -> Config:
+    """Resolve configuration from file + environment.
+
+    Args:
+        config_path: Optional explicit path to a config.toml.
+    """
+    data = _read_toml(Path(config_path) if config_path else None)
+    llm_raw = data.get("llm", {})
+    out_raw = data.get("output", {})
+    gen_raw = data.get("generation", {})
+
+    # ---- provider ----------------------------------------------------------
+    provider_str = _first_env("OFFERPRINTER_PROVIDER") or llm_raw.get("provider", "anthropic")
+    provider = Provider(provider_str.lower())
+
+    # ---- model -------------------------------------------------------------
+    model = _first_env("OFFERPRINTER_MODEL") or llm_raw.get("model", "") or ""
+
+    # ---- api key -----------------------------------------------------------
+    api_key = (
+        _first_env("OFFERPRINTER_API_KEY")
+        or (llm_raw.get("api_key") or "")
+        or (_first_env(*_PROVIDER_KEY_ENV[provider]) or "")
+    )
+
+    # ---- base url ----------------------------------------------------------
+    base_url = _first_env("OFFERPRINTER_BASE_URL") or llm_raw.get("base_url", "") or ""
+
+    llm = LLMConfig(
+        provider=provider,
+        model=model,
+        api_key=api_key,
+        base_url=base_url,
+        temperature=float(llm_raw.get("temperature", 0.2)),
+        max_tokens=int(llm_raw.get("max_tokens", 4096)),
+        timeout=float(llm_raw.get("timeout", 120)),
+        max_retries=int(llm_raw.get("max_retries", 3)),
+        retry_backoff=float(llm_raw.get("retry_backoff", 1.5)),
+    )
+
+    # ---- output ------------------------------------------------------------
+    locale_str = _first_env("OFFERPRINTER_LOCALE") or out_raw.get("locale", "UK")
+    env_formats = _first_env("OFFERPRINTER_FORMATS")
+    output = OutputConfig(
+        locale=Locale(locale_str.upper()),
+        dir=_first_env("OFFERPRINTER_OUTPUT_DIR") or out_raw.get("dir", "./output"),
+        formats=_clean_formats(
+            env_formats.split(",") if env_formats else out_raw.get("formats", ["md", "docx"])
+        ),
+        track=_env_bool("OFFERPRINTER_TRACK", bool(out_raw.get("track", True))),
+    )
+
+    # ---- generation --------------------------------------------------------
+    generation = GenerationConfig(
+        tailored_cv=bool(gen_raw.get("tailored_cv", True)),
+        cover_letter=bool(gen_raw.get("cover_letter", True)),
+        fit_memo=bool(gen_raw.get("fit_memo", True)),
+        ats_report=bool(gen_raw.get("ats_report", True)),
+        interview_prep=bool(gen_raw.get("interview_prep", True)),
+        fit_score=bool(gen_raw.get("fit_score", True)),
+        parallel=_env_bool("OFFERPRINTER_PARALLEL", bool(gen_raw.get("parallel", True))),
+        max_workers=int(gen_raw.get("max_workers", 5)),
+    )
+
+    return Config(
+        llm=llm,
+        output=output,
+        generation=generation,
+        pricing=_parse_pricing(data.get("pricing")),
+    )

offerprinter/controllers/__init__.py

@@ -0,0 +1,5 @@
+"""Controller layer: orchestrates services into the end-to-end pipeline."""
+
+from offerprinter.controllers.pipeline import Pipeline, PipelineEvent
+
+__all__ = ["Pipeline", "PipelineEvent"]

offerprinter/controllers/pipeline.py

@@ -0,0 +1,135 @@
+"""The end-to-end pipeline controller.
+
+One entry point — `Pipeline.run(...)` — takes a CV and a job description and
+produces (and optionally writes) the full application package. It emits progress
+events so both the CLI and the Streamlit UI can show live status with the same
+code path.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from pathlib import Path
+
+from offerprinter.config import Config
+from offerprinter.llm import build_provider
+from offerprinter.models.schemas import (
+    ApplicationPackage,
+    Artifact,
+    FitScore,
+    JobDescription,
+    ResumeInput,
+    Usage,
+)
+from offerprinter.services.generator import Generator, _slugify
+from offerprinter.services.tracker import ApplicationRecord, Tracker, utc_now
+from offerprinter.services.writer import write_package
+
+
+@dataclass
+class PipelineEvent:
+    """A progress update emitted while the pipeline runs."""
+
+    kind: str  # "meta" | "artifact" | "fit" | "written" | "done"
+    message: str
+    artifact: Artifact | None = None
+    package: ApplicationPackage | None = None
+    written: dict[str, list[Path]] | None = None
+    fit: FitScore | None = None
+    achievements: list[str] | None = None
+
+
+class Pipeline:
+    """Runs the full generation flow for one (CV, JD) pair."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.provider = build_provider(config.llm, config.pricing)
+        self.generator = Generator(
+            self.provider,
+            locale=config.output.locale,
+            generation=config.generation,
+        )
+
+    def stream(self, cv: ResumeInput, jd: JobDescription) -> Iterator[PipelineEvent]:
+        """Run the pipeline, yielding a PipelineEvent at each step."""
+        # 1. Identify company + role.
+        company = jd.company or ""
+        role = jd.role or ""
+        if not (company and role):
+            company, role = self.generator.extract_meta(jd)
+        jd.company, jd.role = company, role
+        slug = f"{_slugify(company)}-{_slugify(role)}"
+        yield PipelineEvent(kind="meta", message=f"{role} at {company}")
+
+        package = ApplicationPackage(company=company, role=role, slug=slug)
+
+        # 2. Generate each enabled artifact, streaming as we go. In parallel
+        #    mode these arrive in completion order, so we re-sort afterwards.
+        for artifact in self.generator.iter_generate(cv, jd, company, role):
+            package.artifacts.append(artifact)
+            yield PipelineEvent(kind="artifact", message=artifact.title, artifact=artifact)
+        package.sort_artifacts()
+
+        # 3. Score the fit, if enabled.
+        if self.config.generation.fit_score:
+            fit = self.generator.score_fit(cv, jd, company, role)
+            package.fit = fit
+            yield PipelineEvent(kind="fit", message=f"{fit.score}/100 — {fit.band}", fit=fit)
+
+        # 4. Account for what the run cost.
+        package.usage = Usage(**self.provider.usage.model_dump())
+
+        # 5. Write to disk.
+        written = write_package(package, self.config.output.dir, self.config.output.formats)
+        out_dir = Path(self.config.output.dir) / slug
+        yield PipelineEvent(
+            kind="written",
+            message=str(out_dir),
+            package=package,
+            written=written,
+        )
+
+        # 6. Record it locally, so `offerprinter list` and `stats` can see it.
+        achievements = self._track(package, out_dir)
+
+        yield PipelineEvent(
+            kind="done",
+            message="Done",
+            package=package,
+            written=written,
+            achievements=achievements,
+        )
+
+    def _track(self, package: ApplicationPackage, out_dir: Path) -> list[str]:
+        """Append this run to the local history. Never fatal if it fails."""
+        if not self.config.output.track:
+            return []
+        try:
+            return Tracker().record(
+                ApplicationRecord(
+                    slug=package.slug,
+                    company=package.company,
+                    role=package.role,
+                    printed_at=utc_now(),
+                    provider=self.config.llm.provider.value,
+                    model=self.provider.model,
+                    fit_score=package.fit.score if package.fit else None,
+                    fit_band=package.fit.band if package.fit else "",
+                    cost_usd=package.usage.cost_usd,
+                    total_tokens=package.usage.total_tokens,
+                    output_dir=str(out_dir),
+                )
+            )
+        except OSError:
+            return []  # a read-only home directory should never fail a run
+
+    def run(self, cv: ResumeInput, jd: JobDescription) -> ApplicationPackage:
+        """Convenience wrapper that runs the pipeline to completion."""
+        package: ApplicationPackage | None = None
+        for event in self.stream(cv, jd):
+            if event.package is not None:
+                package = event.package
+        assert package is not None  # the "done" event always carries the package
+        return package

offerprinter/llm/__init__.py

@@ -0,0 +1,11 @@
+"""Provider-agnostic LLM layer.
+
+A single interface — `LLMProvider.complete(system, user)` — with concrete
+implementations for Anthropic, OpenAI, Gemini and Moonshot Kimi. Use
+`build_provider(llm_config)` to get the right one from config.
+"""
+
+from offerprinter.llm.base import LLMError, LLMProvider
+from offerprinter.llm.factory import build_provider
+
+__all__ = ["LLMProvider", "LLMError", "build_provider"]

offerprinter/llm/anthropic_provider.py

@@ -0,0 +1,41 @@
+"""Anthropic (Claude) provider — the default."""
+
+from __future__ import annotations
+
+from offerprinter.llm.base import LLMError, LLMProvider
+
+
+class AnthropicProvider(LLMProvider):
+    """Calls the Anthropic Messages API (https://api.anthropic.com/v1/messages)."""
+
+    default_model = "claude-haiku-4-5-20251001"
+
+    def complete(self, system: str, user: str) -> str:
+        key = self._require_key()
+        base = self.config.base_url or "https://api.anthropic.com"
+        url = f"{base.rstrip('/')}/v1/messages"
+        headers = {
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }
+        payload = {
+            "model": self.model,
+            "max_tokens": self.config.max_tokens,
+            "temperature": self.config.temperature,
+            "system": system,
+            "messages": [{"role": "user", "content": user}],
+        }
+        data = self._post(url, headers, payload)
+
+        usage = data.get("usage") or {}
+        self._record_usage(
+            int(usage.get("input_tokens", 0)),
+            int(usage.get("output_tokens", 0)),
+        )
+
+        try:
+            blocks = data["content"]
+            return "".join(b.get("text", "") for b in blocks if b.get("type") == "text")
+        except (KeyError, TypeError) as exc:
+            raise LLMError(f"Unexpected Anthropic response shape: {data}") from exc

offerprinter/llm/base.py

@@ -0,0 +1,125 @@
+"""The single interface every provider implements.
+
+The whole rest of the app talks to LLMs through `LLMProvider.complete()`. Adding
+a new provider means writing one subclass — nothing else in the codebase changes.
+
+Two things are handled once, here, for every provider:
+
+* **Retries** — a single 429 or a 503 should not kill a five-document run, so
+  `_post` retries with exponential backoff and honours `Retry-After`.
+* **Token accounting** — providers report usage in their responses; we
+  accumulate it thread-safely so a run can report what it cost.
+"""
+
+from __future__ import annotations
+
+import abc
+import random
+import threading
+import time
+
+import httpx
+
+from offerprinter.models.schemas import LLMConfig, Usage
+from offerprinter.pricing import estimate_cost
+
+#: Status codes worth trying again — rate limits, overload, and gateway blips.
+RETRYABLE_STATUS = {408, 409, 425, 429, 500, 502, 503, 504}
+
+
+class LLMError(RuntimeError):
+    """Raised when a provider call fails (network, auth, or API error)."""
+
+
+class LLMProvider(abc.ABC):
+    """Abstract base class for a chat-completion provider."""
+
+    #: The model used when the user leaves `model` blank in config.
+    default_model: str = ""
+    #: Set False for providers that run locally and need no credentials.
+    requires_key: bool = True
+
+    def __init__(self, config: LLMConfig) -> None:
+        self.config = config
+        self.model = config.model or self.default_model
+        self.usage = Usage()
+        self.price_overrides: dict[str, tuple[float, float]] = {}
+        self._usage_lock = threading.Lock()
+
+    @property
+    def name(self) -> str:
+        return type(self).__name__.replace("Provider", "").lower()
+
+    @abc.abstractmethod
+    def complete(self, system: str, user: str) -> str:
+        """Return the model's text completion for a system + user prompt."""
+        raise NotImplementedError
+
+    # -- shared helpers -----------------------------------------------------
+
+    def _require_key(self) -> str:
+        if not self.requires_key:
+            return self.config.api_key or "not-required"
+        if not self.config.api_key:
+            raise LLMError(
+                f"No API key found for provider '{self.name}'. Set it in config.toml "
+                f"or via an environment variable (see config.example.toml)."
+            )
+        return self.config.api_key
+
+    def _record_usage(self, input_tokens: int, output_tokens: int) -> None:
+        """Accumulate token counts and estimated spend for this run."""
+        cost = estimate_cost(self.model, input_tokens, output_tokens, self.price_overrides)
+        with self._usage_lock:
+            self.usage.input_tokens += input_tokens
+            self.usage.output_tokens += output_tokens
+            self.usage.calls += 1
+            self.usage.cost_usd += cost
+
+    @staticmethod
+    def _retry_after(resp: httpx.Response) -> float | None:
+        """Seconds to wait per the server's Retry-After header, if sane."""
+        raw = resp.headers.get("retry-after")
+        if not raw:
+            return None
+        try:
+            wait = float(raw)
+        except ValueError:
+            return None
+        return wait if 0 <= wait <= 60 else None
+
+    def _post(self, url: str, headers: dict, json: dict) -> dict:
+        """POST JSON and return the parsed response, retrying transient failures."""
+        attempts = max(1, self.config.max_retries + 1)
+        last_error: str = ""
+
+        for attempt in range(attempts):
+            resp: httpx.Response | None = None
+            try:
+                with httpx.Client(timeout=self.config.timeout) as client:
+                    resp = client.post(url, headers=headers, json=json)
+            except httpx.HTTPError as exc:  # network-level failure
+                last_error = f"Network error calling {self.name}: {exc}"
+            else:
+                if resp.status_code < 400:
+                    try:
+                        return resp.json()
+                    except ValueError as exc:
+                        raise LLMError(f"{self.name} returned non-JSON response.") from exc
+
+                last_error = f"{self.name} API returned {resp.status_code}: {resp.text[:500]}"
+                if resp.status_code not in RETRYABLE_STATUS:
+                    # Auth errors, bad requests: retrying cannot help.
+                    raise LLMError(last_error)
+
+            if attempt == attempts - 1:
+                break
+
+            server_hint = self._retry_after(resp) if resp is not None else None
+            # Exponential backoff with jitter, so parallel artifacts don't all
+            # come back and hammer the API on the same tick.
+            backoff = self.config.retry_backoff * (2**attempt)
+            delay = server_hint if server_hint is not None else backoff
+            time.sleep(delay + random.uniform(0, 0.25))
+
+        raise LLMError(f"{last_error} (gave up after {attempts} attempts)")

offerprinter/llm/factory.py

@@ -0,0 +1,33 @@
+"""Map a provider name in config to the concrete provider implementation."""
+
+from __future__ import annotations
+
+from offerprinter.llm.anthropic_provider import AnthropicProvider
+from offerprinter.llm.base import LLMProvider
+from offerprinter.llm.gemini_provider import GeminiProvider
+from offerprinter.llm.kimi_provider import KimiProvider
+from offerprinter.llm.ollama_provider import OllamaProvider
+from offerprinter.llm.openai_provider import OpenAIProvider
+from offerprinter.models.schemas import LLMConfig, Provider
+
+_REGISTRY: dict[Provider, type[LLMProvider]] = {
+    Provider.ANTHROPIC: AnthropicProvider,
+    Provider.OPENAI: OpenAIProvider,
+    Provider.GEMINI: GeminiProvider,
+    Provider.KIMI: KimiProvider,
+    Provider.OLLAMA: OllamaProvider,
+}
+
+
+def build_provider(
+    config: LLMConfig,
+    price_overrides: dict[str, tuple[float, float]] | None = None,
+) -> LLMProvider:
+    """Instantiate the provider named in `config`."""
+    cls = _REGISTRY.get(config.provider)
+    if cls is None:  # pragma: no cover - guarded by the Provider enum
+        raise ValueError(f"Unknown provider: {config.provider}")
+    provider = cls(config)
+    if price_overrides:
+        provider.price_overrides = price_overrides
+    return provider

offerprinter/llm/gemini_provider.py

@@ -0,0 +1,38 @@
+"""Google Gemini provider."""
+
+from __future__ import annotations
+
+from offerprinter.llm.base import LLMError, LLMProvider
+
+
+class GeminiProvider(LLMProvider):
+    """Calls the Gemini generateContent API."""
+
+    default_model = "gemini-1.5-flash"
+
+    def complete(self, system: str, user: str) -> str:
+        key = self._require_key()
+        base = self.config.base_url or "https://generativelanguage.googleapis.com"
+        url = f"{base.rstrip('/')}/v1beta/models/{self.model}:generateContent"
+        headers = {"Content-Type": "application/json", "x-goog-api-key": key}
+        payload = {
+            "systemInstruction": {"parts": [{"text": system}]},
+            "contents": [{"role": "user", "parts": [{"text": user}]}],
+            "generationConfig": {
+                "temperature": self.config.temperature,
+                "maxOutputTokens": self.config.max_tokens,
+            },
+        }
+        data = self._post(url, headers, payload)
+
+        usage = data.get("usageMetadata") or {}
+        self._record_usage(
+            int(usage.get("promptTokenCount", 0)),
+            int(usage.get("candidatesTokenCount", 0)),
+        )
+
+        try:
+            parts = data["candidates"][0]["content"]["parts"]
+            return "".join(p.get("text", "") for p in parts)
+        except (KeyError, IndexError, TypeError) as exc:
+            raise LLMError(f"Unexpected Gemini response shape: {data}") from exc

offerprinter/llm/kimi_provider.py

@@ -0,0 +1,16 @@
+"""Moonshot Kimi provider.
+
+Moonshot exposes an OpenAI-compatible Chat Completions API, so this is a thin
+subclass of OpenAIProvider with a different default base URL and model.
+"""
+
+from __future__ import annotations
+
+from offerprinter.llm.openai_provider import OpenAIProvider
+
+
+class KimiProvider(OpenAIProvider):
+    """Calls Moonshot's OpenAI-compatible endpoint."""
+
+    default_model = "moonshot-v1-8k"
+    default_base_url = "https://api.moonshot.cn"

offerprinter/llm/ollama_provider.py

@@ -0,0 +1,24 @@
+"""Ollama provider — run OfferPrinter entirely on your own machine.
+
+Ollama exposes an OpenAI-compatible Chat Completions endpoint at
+``http://localhost:11434/v1``, so this is a thin subclass of OpenAIProvider with
+a local default base URL, a local default model, and no API key requirement.
+
+With this provider your CV never leaves your laptop at all — not even to an LLM
+vendor. Get started with:
+
+    ollama pull llama3.1
+    offerprinter --provider ollama --cv cv.pdf --jd-file jd.txt
+"""
+
+from __future__ import annotations
+
+from offerprinter.llm.openai_provider import OpenAIProvider
+
+
+class OllamaProvider(OpenAIProvider):
+    """Calls a local Ollama server through its OpenAI-compatible API."""
+
+    default_model = "llama3.1"
+    default_base_url = "http://localhost:11434"
+    requires_key = False

offerprinter/llm/openai_provider.py

@@ -0,0 +1,42 @@
+"""OpenAI provider (also the base for any OpenAI-compatible endpoint)."""
+
+from __future__ import annotations
+
+from offerprinter.llm.base import LLMError, LLMProvider
+
+
+class OpenAIProvider(LLMProvider):
+    """Calls the OpenAI Chat Completions API."""
+
+    default_model = "gpt-4o-mini"
+    default_base_url = "https://api.openai.com"
+
+    def complete(self, system: str, user: str) -> str:
+        key = self._require_key()
+        base = self.config.base_url or self.default_base_url
+        url = f"{base.rstrip('/')}/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": self.model,
+            "max_tokens": self.config.max_tokens,
+            "temperature": self.config.temperature,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+        }
+        data = self._post(url, headers, payload)
+
+        usage = data.get("usage") or {}
+        self._record_usage(
+            int(usage.get("prompt_tokens", 0)),
+            int(usage.get("completion_tokens", 0)),
+        )
+
+        try:
+            return data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError) as exc:
+            raise LLMError(f"Unexpected OpenAI response shape: {data}") from exc

offerprinter/models/__init__.py

@@ -0,0 +1,21 @@
+"""Typed data models that flow through the OfferPrinter pipeline."""
+
+from offerprinter.models.schemas import (
+    ApplicationPackage,
+    Artifact,
+    GenerationConfig,
+    JobDescription,
+    LLMConfig,
+    OutputConfig,
+    ResumeInput,
+)
+
+__all__ = [
+    "Artifact",
+    "ApplicationPackage",
+    "GenerationConfig",
+    "JobDescription",
+    "LLMConfig",
+    "OutputConfig",
+    "ResumeInput",
+]