parseforge 0.2.5__tar.gz → 0.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parseforge
-Version: 0.2.5
+Version: 0.2.8
 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,36 @@ 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: mistral
+Requires-Dist: mistralai==1.10.0; extra == "mistral"
+Requires-Dist: textfsm-ai[mistral]>=0.6.1; extra == "mistral"
+Provides-Extra: cohere
+Requires-Dist: cohere==5.21.1; extra == "cohere"
+Requires-Dist: textfsm-ai[cohere]>=0.6.1; extra == "cohere"
 Provides-Extra: sampling
 Requires-Dist: netmiko>=4.0; extra == "sampling"
 Provides-Extra: dev
@@ -46,6 +76,8 @@ Requires-Dist: black>=24.0.0; extra == "dev"
 Requires-Dist: mypy>=1.10.0; extra == "dev"
 Requires-Dist: anthropic>=0.40.0; extra == "dev"
 Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: mistralai==1.10.0; extra == "dev"
+Requires-Dist: cohere==5.21.1; extra == "dev"
 Provides-Extra: release
 Requires-Dist: bump2version; extra == "release"
 Requires-Dist: build; extra == "release"
@@ -86,11 +118,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`, `cerebras`, `mistral`, or `cohere`. `--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,mistral,cohere,sampling]`.
 
 ## Development
 
@@ -98,10 +132,13 @@ device sampling; combine extras as needed, e.g.
 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`.
+`dev` already includes the `anthropic`, `openai`, `mistralai`, and `cohere`
+SDKs (tests exercise all thirteen providers — `anthropic`, `openai`,
+`deepseek`, `groq`, `xai`, `together`, `fireworks`, `perplexity`,
+`openrouter`, `moonshot`, `cerebras` share just the first two packages, and
+`mistral`/`cohere` each need their own native SDK — 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.8}/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`, `cerebras`, `mistral`, or `cohere`. `--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,mistral,cohere,sampling]`.
 
 ## Development
 
@@ -45,10 +47,13 @@ device sampling; combine extras as needed, e.g.
 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`.
+`dev` already includes the `anthropic`, `openai`, `mistralai`, and `cohere`
+SDKs (tests exercise all thirteen providers — `anthropic`, `openai`,
+`deepseek`, `groq`, `xai`, `together`, `fireworks`, `perplexity`,
+`openrouter`, `moonshot`, `cerebras` share just the first two packages, and
+`mistral`/`cohere` each need their own native SDK — 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.8/parseforge/__init__.py

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

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

@@ -23,8 +23,18 @@ from parseforge.cli import config as cli_config
 
 _BUILDERS: dict[str, type[naming.RegexBuilder]] = {
     "anthropic": naming.AnthropicRegexBuilder,
+    "cerebras": naming.CerebrasRegexBuilder,
+    "cohere": naming.CohereRegexBuilder,
     "deepseek": naming.DeepSeekRegexBuilder,
+    "fireworks": naming.FireworksRegexBuilder,
+    "groq": naming.GroqRegexBuilder,
+    "mistral": naming.MistralRegexBuilder,
+    "moonshot": naming.MoonshotRegexBuilder,
     "openai": naming.OpenAIRegexBuilder,
+    "openrouter": naming.OpenRouterRegexBuilder,
+    "perplexity": naming.PerplexityRegexBuilder,
+    "together": naming.TogetherRegexBuilder,
+    "xai": naming.XAIRegexBuilder,
 }
 
 _CONNECTORS = ("netmiko",)
@@ -199,8 +209,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, MISTRAL_API_KEY, "
+    "COHERE_API_KEY); only needed on a cache miss.",
 )
 @click.option(
     "--model",
@@ -268,8 +280,10 @@ 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", '
+    '"mistral", "cohere"). 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.8}/parseforge/naming/__init__.py

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

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

@@ -0,0 +1,29 @@
+from .anthropic import AnthropicRegexBuilder
+from .cerebras import CerebrasRegexBuilder
+from .cohere import CohereRegexBuilder
+from .deepseek import DeepSeekRegexBuilder
+from .fireworks import FireworksRegexBuilder
+from .groq import GroqRegexBuilder
+from .mistral import MistralRegexBuilder
+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",
+    "CohereRegexBuilder",
+    "DeepSeekRegexBuilder",
+    "FireworksRegexBuilder",
+    "GroqRegexBuilder",
+    "MistralRegexBuilder",
+    "MoonshotRegexBuilder",
+    "OpenAIRegexBuilder",
+    "OpenRouterRegexBuilder",
+    "PerplexityRegexBuilder",
+    "TogetherRegexBuilder",
+    "XAIRegexBuilder",
+]

parseforge-0.2.8/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.8/parseforge/naming/providers/cohere.py

@@ -0,0 +1,173 @@
+"""Cohere-backed RegexBuilder implementation.
+
+Like Mistral, Cohere's official Python SDK is not built on the OpenAI
+client library — it has its own generated client shape. Unlike Mistral's
+single client (which exposes both complete()/complete_async() on one
+object), Cohere exposes genuinely separate ``ClientV2``/``AsyncClientV2``
+classes; this builder only ever needs the sync ``ClientV2``, since
+``RegexBuilder.build_pattern()`` is a synchronous call.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
+from .cost import estimate_cost
+from .models import default_model
+from .text import extract_pattern
+
+if TYPE_CHECKING:
+    import cohere as cohere_sdk
+
+DEFAULT_MODEL = default_model("cohere")
+
+_DEFAULT_MAX_TOKENS = 1024
+
+# HTTP statuses where retrying the exact same request can't succeed —
+# mirrors providers/errors.py's NON_RETRYABLE class-name set (BadRequest,
+# Authentication, PermissionDenied, NotFound, Conflict, RequestTooLarge,
+# UnprocessableEntity). The cohere SDK raises a family of named exception
+# classes (BadRequestError, UnauthorizedError, ForbiddenError, ...), but
+# those names don't line up with OpenAI/Anthropic's naming, and every one
+# of them carries its status on exc.status_code (see
+# cohere.core.api_error.ApiError, their shared base) — so classification
+# here is done by status code instead of exception class name.
+_NON_RETRYABLE_STATUSES = frozenset({400, 401, 403, 404, 409, 413, 422})
+
+
+def _import_cohere() -> Any:
+    """Deferred import — cohere is an optional extra (parseforge[cohere]);
+    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 cohere
+        import cohere.core.api_error  # noqa: F401  (makes cohere.core.api_error.ApiError reachable off the returned module)
+    except ImportError as exc:
+        raise ImportError(
+            "the cohere package is required to use CohereRegexBuilder — "
+            "install it via `pip install parseforge[cohere]`"
+        ) from exc
+    return cohere
+
+
+def _status_code(exc: Any) -> int | None:
+    return getattr(exc, "status_code", None)
+
+
+def _is_retryable(exc: Any) -> bool:
+    return _status_code(exc) not in _NON_RETRYABLE_STATUSES
+
+
+def _format_error_reason(exc: Any) -> str:
+    return f"LLM-ERROR-cohere_sdk-{_status_code(exc)}-{exc}"
+
+
+def _extract_text(content: Any) -> str:
+    """Cohere's AssistantMessageResponse.content is a list of content
+    blocks (text and/or thinking blocks), unlike Mistral/OpenAI's plain
+    string — join the text blocks' .text, same as textfsm-ai's own
+    CohereProvider._parse_cohere_response()."""
+    if isinstance(content, str):
+        return content
+    return "".join(getattr(block, "text", "") for block in content or [])
+
+
+class CohereRegexBuilder:
+    """Builds a cli-name regex pattern by prompting a Cohere-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 ``COHERE_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
+    ``COHERE_API_KEY`` environment variable (the SDK's own default).
+    """
+
+    provider = "cohere"
+
+    def __init__(self, model: str = DEFAULT_MODEL, api_key: str | None = None) -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: cohere_sdk.ClientV2 | None = None
+
+    def _get_client(self) -> cohere_sdk.ClientV2:
+        if self._client is None:
+            cohere = _import_cohere()
+            api_key = self._api_key or os.environ.get("COHERE_API_KEY")
+            if not api_key:
+                raise RuntimeError(
+                    "no Cohere API key — pass api_key or set COHERE_API_KEY"
+                )
+            self._client = cohere.ClientV2(api_key=api_key)
+        return self._client
+
+    def build_pattern(
+        self, command: str, context: CliContext, **kwargs: Any
+    ) -> LLMCLIResponse:
+        cohere = _import_cohere()
+        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(
+                model=self.model,
+                max_tokens=max_tokens,
+                # cast: cohere's generated stubs want a precise
+                # UserChatMessageV2/... union or matching TypedDict, but a
+                # plain {"role": "user", "content": ...} dict is exactly
+                # that shape.
+                messages=cast(Any, [{"role": "user", "content": prompt}]),
+                **kwargs,
+            )
+        except cohere.core.api_error.ApiError 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_error_reason(exc),
+                ready=False,
+            )
+        duration_ms = (time.monotonic() - start) * 1000
+
+        text = _extract_text(response.message.content)
+        # usage/usage.tokens are both Optional, and input_tokens/
+        # output_tokens are typed float — unlike every openai-compat
+        # provider, Cohere's usage.tokens has no total_tokens field at
+        # all, so it's computed here rather than read off the response.
+        tokens = response.usage.tokens if response.usage else None
+        input_tokens = int(tokens.input_tokens or 0) if tokens else 0
+        output_tokens = int(tokens.output_tokens or 0) if tokens else 0
+        total_tokens = input_tokens + output_tokens
+
+        return LLMCLIResponse(
+            content=extract_pattern(text),
+            raw=response,
+            usage=TokenUsage(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                estimated_cost=estimate_cost(
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total_tokens,
+                    provider=self.provider,
+                    model=self.model,
+                ),
+            ),
+            duration_ms=duration_ms,
+            reason=response.finish_reason or "",
+            ready=response.finish_reason == "COMPLETE",
+        )

parseforge-0.2.8/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",
+        )