Method generate

paperflow/providers/llm.py:116–162

(
        self,
        prompt: str,
        *,
        system: Optional[str] = None,
        temperature: float = 0.0,
        max_tokens: int = 1024,
    )

        self._client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)

    def generate(
        self,
        prompt: str,
        *,
        system: Optional[str] = None,
        temperature: float = 0.0,
        max_tokens: int = 1024,
    ) -> LLMResponse:
        messages: list[dict[str, str]] = []
        if system:
            messages.append({"role": "system", "content": system})
        messages.append({"role": "user", "content": prompt})

        kwargs = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens,
        }
        efforts = _reasoning_effort_candidates()
        response = None
        last_reasoning_error: Optional[Exception] = None
        for effort in efforts:
            try:
                response = self._client.chat.completions.create(**{**kwargs, "reasoning_effort": effort})
                break
            except Exception as exc:
                if not _is_unsupported_reasoning_error(exc):
                    raise
                last_reasoning_error = exc
        if response is None:
            try:
                response = self._client.chat.completions.create(**kwargs)
            except Exception:
                if last_reasoning_error is not None:
                    raise
                raise

        choice = response.choices[0].message.content or ""
        usage = getattr(response, "usage", None)
        return LLMResponse(
            text=choice,
            model=self.model,
            provider=self.name,
            prompt_tokens=getattr(usage, "prompt_tokens", 0) or 0,
            completion_tokens=getattr(usage, "completion_tokens", 0) or 0,
        )

    def stream_generate(
        self,