parseforge 0.2.5__tar.gz → 0.2.6__tar.gz

{parseforge-0.2.5/parseforge.egg-info → parseforge-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parseforge
-Version: 0.2.5
+Version: 0.2.6
 Summary: LLM-driven pipeline that forges, validates, and promotes TextFSM templates from network CLI output
 Author-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
 Maintainer-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
@@ -36,6 +36,30 @@ Requires-Dist: textfsm-ai[deepseek]>=0.6.1; extra == "deepseek"
 Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == "openai"
 Requires-Dist: textfsm-ai[openai]>=0.6.1; extra == "openai"
+Provides-Extra: groq
+Requires-Dist: openai>=1.0.0; extra == "groq"
+Requires-Dist: textfsm-ai[groq]>=0.6.1; extra == "groq"
+Provides-Extra: xai
+Requires-Dist: openai>=1.0.0; extra == "xai"
+Requires-Dist: textfsm-ai[xai]>=0.6.1; extra == "xai"
+Provides-Extra: together
+Requires-Dist: openai>=1.0.0; extra == "together"
+Requires-Dist: textfsm-ai[together]>=0.6.1; extra == "together"
+Provides-Extra: fireworks
+Requires-Dist: openai>=1.0.0; extra == "fireworks"
+Requires-Dist: textfsm-ai[fireworks]>=0.6.1; extra == "fireworks"
+Provides-Extra: perplexity
+Requires-Dist: openai>=1.0.0; extra == "perplexity"
+Requires-Dist: textfsm-ai[perplexity]>=0.6.1; extra == "perplexity"
+Provides-Extra: openrouter
+Requires-Dist: openai>=1.0.0; extra == "openrouter"
+Requires-Dist: textfsm-ai[openrouter]>=0.6.1; extra == "openrouter"
+Provides-Extra: moonshot
+Requires-Dist: openai>=1.0.0; extra == "moonshot"
+Requires-Dist: textfsm-ai[moonshot]>=0.6.1; extra == "moonshot"
+Provides-Extra: cerebras
+Requires-Dist: openai>=1.0.0; extra == "cerebras"
+Requires-Dist: textfsm-ai[cerebras]>=0.6.1; extra == "cerebras"
 Provides-Extra: sampling
 Requires-Dist: netmiko>=4.0; extra == "sampling"
 Provides-Extra: dev
@@ -86,11 +110,13 @@ pip install parseforge[anthropic]
 command that's pure local processing (`canonical`/`readable`/`recognizers`,
 `integration`, `promotion`) works with nothing further. Anything that calls an
 LLM (`name`, `check --provider`, `run`, `generate-template`, `trial`) needs the
-extra for whichever provider it uses: `anthropic`, `openai`, or `deepseek`.
-`--provider` defaults to `anthropic` wherever it isn't required, so that's the
-one most setups need. `pip install parseforge[sampling]` adds Netmiko for live
-device sampling; combine extras as needed, e.g.
-`pip install parseforge[anthropic,openai,deepseek,sampling]`.
+extra for whichever provider it uses: `anthropic`, `openai`, `deepseek`,
+`groq`, `xai`, `together`, `fireworks`, `perplexity`, `openrouter`,
+`moonshot`, or `cerebras`. `--provider` defaults to `anthropic` wherever it
+isn't required, so that's the one most setups need. `pip install
+parseforge[sampling]` adds Netmiko for live device sampling; combine extras
+as needed, e.g.
+`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,sampling]`.
 
 ## Development
 
@@ -99,9 +125,10 @@ pip install -e ".[dev,sampling]"
 pytest
 ```
 `dev` already includes both the `anthropic` and `openai` SDKs (tests exercise
-all three providers — `anthropic`, `openai`, `deepseek` share just those two
-packages — and never silently skip) — add `,anthropic`/`,openai`/`,deepseek`
-explicitly only if installing outside of `dev`.
+all eleven providers — `anthropic`, `openai`, `deepseek`, `groq`, `xai`,
+`together`, `fireworks`, `perplexity`, `openrouter`, `moonshot`, `cerebras`
+share just those two packages — and never silently skip) — add the specific
+`,<provider>` extra explicitly only if installing outside of `dev`.
 
 Linting/formatting/type-checking/docs run through tox instead of extras — see
 `tox.ini` (`tox -e lint`/`format`/`typecheck`/`docs`), each installing its own

{parseforge-0.2.5 → parseforge-0.2.6}/README.md

@@ -33,11 +33,13 @@ pip install parseforge[anthropic]
 command that's pure local processing (`canonical`/`readable`/`recognizers`,
 `integration`, `promotion`) works with nothing further. Anything that calls an
 LLM (`name`, `check --provider`, `run`, `generate-template`, `trial`) needs the
-extra for whichever provider it uses: `anthropic`, `openai`, or `deepseek`.
-`--provider` defaults to `anthropic` wherever it isn't required, so that's the
-one most setups need. `pip install parseforge[sampling]` adds Netmiko for live
-device sampling; combine extras as needed, e.g.
-`pip install parseforge[anthropic,openai,deepseek,sampling]`.
+extra for whichever provider it uses: `anthropic`, `openai`, `deepseek`,
+`groq`, `xai`, `together`, `fireworks`, `perplexity`, `openrouter`,
+`moonshot`, or `cerebras`. `--provider` defaults to `anthropic` wherever it
+isn't required, so that's the one most setups need. `pip install
+parseforge[sampling]` adds Netmiko for live device sampling; combine extras
+as needed, e.g.
+`pip install parseforge[anthropic,openai,deepseek,groq,xai,together,fireworks,perplexity,openrouter,moonshot,cerebras,sampling]`.
 
 ## Development
 
@@ -46,9 +48,10 @@ pip install -e ".[dev,sampling]"
 pytest
 ```
 `dev` already includes both the `anthropic` and `openai` SDKs (tests exercise
-all three providers — `anthropic`, `openai`, `deepseek` share just those two
-packages — and never silently skip) — add `,anthropic`/`,openai`/`,deepseek`
-explicitly only if installing outside of `dev`.
+all eleven providers — `anthropic`, `openai`, `deepseek`, `groq`, `xai`,
+`together`, `fireworks`, `perplexity`, `openrouter`, `moonshot`, `cerebras`
+share just those two packages — and never silently skip) — add the specific
+`,<provider>` extra explicitly only if installing outside of `dev`.
 
 Linting/formatting/type-checking/docs run through tox instead of extras — see
 `tox.ini` (`tox -e lint`/`format`/`typecheck`/`docs`), each installing its own

parseforge-0.2.6/parseforge/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.6"

{parseforge-0.2.5 → parseforge-0.2.6}/parseforge/cli/main.py

@@ -23,8 +23,16 @@ from parseforge.cli import config as cli_config
 
 _BUILDERS: dict[str, type[naming.RegexBuilder]] = {
     "anthropic": naming.AnthropicRegexBuilder,
+    "cerebras": naming.CerebrasRegexBuilder,
     "deepseek": naming.DeepSeekRegexBuilder,
+    "fireworks": naming.FireworksRegexBuilder,
+    "groq": naming.GroqRegexBuilder,
+    "moonshot": naming.MoonshotRegexBuilder,
     "openai": naming.OpenAIRegexBuilder,
+    "openrouter": naming.OpenRouterRegexBuilder,
+    "perplexity": naming.PerplexityRegexBuilder,
+    "together": naming.TogetherRegexBuilder,
+    "xai": naming.XAIRegexBuilder,
 }
 
 _CONNECTORS = ("netmiko",)
@@ -199,8 +207,10 @@ def main() -> None:
     "--api-key",
     default=None,
     help="Provider API key. Defaults to that provider's own API key environment "
-    "variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY); only needed "
-    "on a cache miss.",
+    "variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GROQ_API_KEY, "
+    "XAI_API_KEY, TOGETHER_API_KEY, FIREWORKS_API_KEY, PERPLEXITY_API_KEY, "
+    "OPENROUTER_API_KEY, MOONSHOT_API_KEY, CEREBRAS_API_KEY); only needed on a "
+    "cache miss.",
 )
 @click.option(
     "--model",
@@ -268,8 +278,9 @@ def name_cmd(
     "--provider",
     required=True,
     help="LLM provider for template generation (textfsm-ai's own registry, "
-    'e.g. "anthropic", "openai", "deepseek"). Naming uses its own separate '
-    "--naming-provider, not this one.",
+    'e.g. "anthropic", "openai", "deepseek", "groq", "xai", "together", '
+    '"fireworks", "perplexity", "openrouter", "moonshot", "cerebras"). Naming '
+    "uses its own separate --naming-provider, not this one.",
 )
 @click.option("--api-key", required=True, help="API key for the generation LLM call.")
 @click.option("--model", required=True, help="Model for the generation LLM call.")

{parseforge-0.2.5 → parseforge-0.2.6}/parseforge/naming/__init__.py

@@ -8,7 +8,19 @@ from .llm import (
     UnimplementedRegexBuilder,
     build_prompt,
 )
-from .providers import AnthropicRegexBuilder, DeepSeekRegexBuilder, OpenAIRegexBuilder
+from .providers import (
+    AnthropicRegexBuilder,
+    CerebrasRegexBuilder,
+    DeepSeekRegexBuilder,
+    FireworksRegexBuilder,
+    GroqRegexBuilder,
+    MoonshotRegexBuilder,
+    OpenAIRegexBuilder,
+    OpenRouterRegexBuilder,
+    PerplexityRegexBuilder,
+    TogetherRegexBuilder,
+    XAIRegexBuilder,
+)
 from .resolver import NamingResolution, cli_name, resolve_cli_name
 
 __all__ = [
@@ -19,8 +31,16 @@ __all__ = [
     "RegexBuilder",
     "UnimplementedRegexBuilder",
     "AnthropicRegexBuilder",
+    "CerebrasRegexBuilder",
     "DeepSeekRegexBuilder",
+    "FireworksRegexBuilder",
+    "GroqRegexBuilder",
+    "MoonshotRegexBuilder",
     "OpenAIRegexBuilder",
+    "OpenRouterRegexBuilder",
+    "PerplexityRegexBuilder",
+    "TogetherRegexBuilder",
+    "XAIRegexBuilder",
     "LLMCLIResponse",
     "TokenUsage",
     "build_prompt",

parseforge-0.2.6/parseforge/naming/providers/__init__.py

@@ -0,0 +1,25 @@
+from .anthropic import AnthropicRegexBuilder
+from .cerebras import CerebrasRegexBuilder
+from .deepseek import DeepSeekRegexBuilder
+from .fireworks import FireworksRegexBuilder
+from .groq import GroqRegexBuilder
+from .moonshot import MoonshotRegexBuilder
+from .openai import OpenAIRegexBuilder
+from .openrouter import OpenRouterRegexBuilder
+from .perplexity import PerplexityRegexBuilder
+from .together import TogetherRegexBuilder
+from .xai import XAIRegexBuilder
+
+__all__ = [
+    "AnthropicRegexBuilder",
+    "CerebrasRegexBuilder",
+    "DeepSeekRegexBuilder",
+    "FireworksRegexBuilder",
+    "GroqRegexBuilder",
+    "MoonshotRegexBuilder",
+    "OpenAIRegexBuilder",
+    "OpenRouterRegexBuilder",
+    "PerplexityRegexBuilder",
+    "TogetherRegexBuilder",
+    "XAIRegexBuilder",
+]

parseforge-0.2.6/parseforge/naming/providers/cerebras.py

@@ -0,0 +1,128 @@
+"""Cerebras-backed RegexBuilder implementation.
+
+Cerebras' API mirrors OpenAI's chat.completions surface (same request/
+response format), so this uses the `openai` SDK pointed at Cerebras'
+base URL rather than a dedicated Cerebras client.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .errors import format_llm_error_reason, is_retryable
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import openai as openai_sdk
+
+DEFAULT_MODEL = default_model("cerebras")
+
+_BASE_URL = "https://api.cerebras.ai/v1"
+
+_DEFAULT_MAX_TOKENS = 1024
+
+
+def _import_openai() -> Any:
+    """Deferred import — openai is an optional extra (parseforge[cerebras]);
+    nothing else in this module (or a cache-hit lookup, which never reaches
+    build_pattern at all — see resolver.cli_name) should require it to be
+    installed."""
+    try:
+        import openai
+    except ImportError as exc:
+        raise ImportError(
+            "the openai package is required to use CerebrasRegexBuilder — "
+            "install it via `pip install parseforge[cerebras]`"
+        ) from exc
+    return openai
+
+
+class CerebrasRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Cerebras-hosted model.
+
+    The client is constructed lazily, on the first actual call — not in
+    ``__init__`` — so this can be used as a default RegexBuilder without
+    requiring ``CEREBRAS_API_KEY`` to be set for cache-hit lookups, which
+    never reach the LLM at all (see resolver.cli_name).
+
+    API key resolves from the ``api_key`` argument if given, otherwise the
+    ``CEREBRAS_API_KEY`` environment variable (unlike Anthropic/OpenAI's
+    own SDKs, the ``openai`` package has no built-in notion of Cerebras'
+    key, so this is resolved explicitly rather than left to the SDK).
+    """
+
+    provider = "cerebras"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: openai_sdk.OpenAI | None = None
+
+    def _get_client(self) -> openai_sdk.OpenAI:
+        if self._client is None:
+            openai = _import_openai()
+            api_key = self._api_key or os.environ.get("CEREBRAS_API_KEY")
+            if not api_key:
+                raise RuntimeError(
+                    "no Cerebras API key — pass api_key or set CEREBRAS_API_KEY"
+                )
+            self._client = openai.OpenAI(api_key=api_key, base_url=_BASE_URL)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        openai = _import_openai()
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().chat.completions.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}],
+                **kwargs,
+            )
+        except openai.OpenAIError as exc:
+            if not is_retryable(exc):
+                # Same request would fail the same way again — stop rather
+                # than let a caller burn another attempt on it.
+                raise
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(
+                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
+                ),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=format_llm_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        choice = response.choices[0]
+        return LLMCLIResponse(
+            content=extract_pattern(choice.message.content or ""),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=response.usage.prompt_tokens,
+                    output_tokens=response.usage.completion_tokens,
+                    total_tokens=response.usage.total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=choice.finish_reason or "",
+            ready=choice.finish_reason == "stop",
+        )

parseforge-0.2.6/parseforge/naming/providers/fireworks.py

@@ -0,0 +1,128 @@
+"""Fireworks AI-backed RegexBuilder implementation.
+
+Fireworks' API mirrors OpenAI's chat.completions surface (same request/
+response format), so this uses the `openai` SDK pointed at Fireworks'
+base URL rather than a dedicated Fireworks client.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .errors import format_llm_error_reason, is_retryable
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import openai as openai_sdk
+
+DEFAULT_MODEL = default_model("fireworks")
+
+_BASE_URL = "https://api.fireworks.ai/inference/v1"
+
+_DEFAULT_MAX_TOKENS = 1024
+
+
+def _import_openai() -> Any:
+    """Deferred import — openai is an optional extra (parseforge[fireworks]);
+    nothing else in this module (or a cache-hit lookup, which never reaches
+    build_pattern at all — see resolver.cli_name) should require it to be
+    installed."""
+    try:
+        import openai
+    except ImportError as exc:
+        raise ImportError(
+            "the openai package is required to use FireworksRegexBuilder — "
+            "install it via `pip install parseforge[fireworks]`"
+        ) from exc
+    return openai
+
+
+class FireworksRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Fireworks-hosted model.
+
+    The client is constructed lazily, on the first actual call — not in
+    ``__init__`` — so this can be used as a default RegexBuilder without
+    requiring ``FIREWORKS_API_KEY`` to be set for cache-hit lookups, which
+    never reach the LLM at all (see resolver.cli_name).
+
+    API key resolves from the ``api_key`` argument if given, otherwise the
+    ``FIREWORKS_API_KEY`` environment variable (unlike Anthropic/OpenAI's
+    own SDKs, the ``openai`` package has no built-in notion of Fireworks'
+    key, so this is resolved explicitly rather than left to the SDK).
+    """
+
+    provider = "fireworks"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: openai_sdk.OpenAI | None = None
+
+    def _get_client(self) -> openai_sdk.OpenAI:
+        if self._client is None:
+            openai = _import_openai()
+            api_key = self._api_key or os.environ.get("FIREWORKS_API_KEY")
+            if not api_key:
+                raise RuntimeError(
+                    "no Fireworks API key — pass api_key or set FIREWORKS_API_KEY"
+                )
+            self._client = openai.OpenAI(api_key=api_key, base_url=_BASE_URL)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        openai = _import_openai()
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().chat.completions.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}],
+                **kwargs,
+            )
+        except openai.OpenAIError as exc:
+            if not is_retryable(exc):
+                # Same request would fail the same way again — stop rather
+                # than let a caller burn another attempt on it.
+                raise
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(
+                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
+                ),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=format_llm_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        choice = response.choices[0]
+        return LLMCLIResponse(
+            content=extract_pattern(choice.message.content or ""),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=response.usage.prompt_tokens,
+                    output_tokens=response.usage.completion_tokens,
+                    total_tokens=response.usage.total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=choice.finish_reason or "",
+            ready=choice.finish_reason == "stop",
+        )

parseforge-0.2.6/parseforge/naming/providers/groq.py

@@ -0,0 +1,126 @@
+"""Groq-backed RegexBuilder implementation.
+
+Groq's API mirrors OpenAI's chat.completions surface (same request/
+response format), so this uses the `openai` SDK pointed at Groq's base
+URL rather than a dedicated Groq client.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .errors import format_llm_error_reason, is_retryable
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import openai as openai_sdk
+
+DEFAULT_MODEL = default_model("groq")
+
+_BASE_URL = "https://api.groq.com/openai/v1"
+
+_DEFAULT_MAX_TOKENS = 1024
+
+
+def _import_openai() -> Any:
+    """Deferred import — openai is an optional extra (parseforge[groq]);
+    nothing else in this module (or a cache-hit lookup, which never reaches
+    build_pattern at all — see resolver.cli_name) should require it to be
+    installed."""
+    try:
+        import openai
+    except ImportError as exc:
+        raise ImportError(
+            "the openai package is required to use GroqRegexBuilder — "
+            "install it via `pip install parseforge[groq]`"
+        ) from exc
+    return openai
+
+
+class GroqRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Groq-hosted model.
+
+    The client is constructed lazily, on the first actual call — not in
+    ``__init__`` — so this can be used as a default RegexBuilder without
+    requiring ``GROQ_API_KEY`` to be set for cache-hit lookups, which
+    never reach the LLM at all (see resolver.cli_name).
+
+    API key resolves from the ``api_key`` argument if given, otherwise the
+    ``GROQ_API_KEY`` environment variable (unlike Anthropic/OpenAI's own
+    SDKs, the ``openai`` package has no built-in notion of Groq's key, so
+    this is resolved explicitly rather than left to the SDK).
+    """
+
+    provider = "groq"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: openai_sdk.OpenAI | None = None
+
+    def _get_client(self) -> openai_sdk.OpenAI:
+        if self._client is None:
+            openai = _import_openai()
+            api_key = self._api_key or os.environ.get("GROQ_API_KEY")
+            if not api_key:
+                raise RuntimeError("no Groq API key — pass api_key or set GROQ_API_KEY")
+            self._client = openai.OpenAI(api_key=api_key, base_url=_BASE_URL)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        openai = _import_openai()
+        prompt = build_prompt(command, context)
+        max_tokens = kwargs.pop("max_tokens", None) or _DEFAULT_MAX_TOKENS
+
+        start = time.monotonic()
+        try:
+            response = self._get_client().chat.completions.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{"role": "user", "content": prompt}],
+                **kwargs,
+            )
+        except openai.OpenAIError as exc:
+            if not is_retryable(exc):
+                # Same request would fail the same way again — stop rather
+                # than let a caller burn another attempt on it.
+                raise
+            return LLMCLIResponse(
+                content="",
+                raw=exc,
+                usage=TokenUsage(
+                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
+                ),
+                duration_ms=(time.monotonic() - start) * 1000,
+                reason=format_llm_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        choice = response.choices[0]
+        return LLMCLIResponse(
+            content=extract_pattern(choice.message.content or ""),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=response.usage.prompt_tokens,
+                output_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=response.usage.prompt_tokens,
+                    output_tokens=response.usage.completion_tokens,
+                    total_tokens=response.usage.total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=choice.finish_reason or "",
+            ready=choice.finish_reason == "stop",
+        )