Add Fireworks AI Python SDK integration for chat, completion, embedding, and rerank instrumentation (1,011,799 weekly downloads)

[AbhiPrasad]

Summary

The Fireworks AI Python SDK (fireworks-ai) is a major inference provider SDK with ~250k daily PyPI downloads that is not currently instrumented by Braintrust on main. Fireworks provides an OpenAI-compatible REST API (endpoints at https://api.fireworks.ai/inference/v1), and its Python SDK response models directly reuse OpenAI types (openai.types.chat.chat_completion.Choice, openai.types.completion_usage.CompletionUsage). However, the SDK ships its own client classes (Fireworks, AsyncFireworks) with a distinct API surface that is not an openai.OpenAI subclass, so the existing Braintrust OpenAI wrapper does not automatically cover it.

While users can point a raw openai.OpenAI(base_url="https://api.fireworks.ai/inference/v1") client at Fireworks and get tracing via the OpenAI wrapper, this only covers chat completions and text completions. It does not cover the native fireworks-ai SDK client, embeddings, reranking, image generation, or the legacy module-level API. A dedicated integration is needed for full tracing coverage of the native SDK.

What is missing

No Braintrust integration or wrapper exists for the fireworks-ai Python SDK on main. The following execution APIs have no tracing spans:

Client-instance API (Fireworks / AsyncFireworks)

• client.chat.completions.create() — chat completions (OpenAI-compatible message format, supports streaming via stream=True, tool use, structured output)
• client.chat.completions.acreate() — async chat completions (streaming by default)
• client.completion.create() / client.completions.create() — text completions (supports streaming)
• client.completion.acreate() / client.completions.acreate() — async text completions
• client.embeddings.create() — text embeddings
• client.embeddings.acreate() — async text embeddings
• client.rerank.create() — document reranking for RAG pipelines
• client.rerank.acreate() — async document reranking

Legacy module-level API

• fireworks.client.ChatCompletion.create() / .acreate() — module-level chat completion (classmethod)
• fireworks.client.Completion.create() / .acreate() — module-level text completion (classmethod)
• fireworks.client.Embedding.create() / .acreate() — module-level embeddings (classmethod)

Image generation API (lower priority)

• ImageInference.text_to_image() / .text_to_image_async() — text-to-image generation
• ImageInference.image_to_image() / .image_to_image_async() — image-to-image generation
• ImageInference.image_to_video() / .image_to_video_async() — image-to-video generation
• ImageInference.control_net() / .control_net_async() — ControlNet image generation

SDK architecture notes

• Package: fireworks-ai on PyPI (current version: 0.19.x, MIT license)
• Depends on openai: response Pydantic models (fireworks.ChatCompletion, fireworks.ChatCompletionChunk) reuse openai.types.chat.chat_completion.Choice and openai.types.completion_usage.CompletionUsage directly
• HTTP transport: httpx.Client / httpx.AsyncClient under the hood (via FireworksClient)
• Two API styles:
  1. Instance-based: Fireworks(api_key=...) → client.chat.completions.create(...) (similar shape to OpenAI's client but not a subclass)
  2. Legacy module-level: fireworks.client.ChatCompletion.create(model, messages=...) (classmethods using a global API key)
• Class hierarchy: ChatCompletionV2 → ChatCompletion → BaseCompletion; CompletionV2 → Completion → BaseCompletion; EmbeddingV1 → Embedding; RerankV1 → Rerank
• Streaming: stream=True on create() returns a generator; acreate() defaults to stream=True and returns an async generator

Braintrust docs status

not_found — Fireworks is not mentioned on the Braintrust tracing guide or the integrations directory.

Upstream sources

• Fireworks AI Python SDK on PyPI: https://pypi.org/project/fireworks-ai/
• Fireworks AI Python SDK documentation: https://docs.fireworks.ai/tools-sdks/python-sdk
• Fireworks AI API reference: https://docs.fireworks.ai/api-reference/
• Fireworks AI Chat Completions API: https://docs.fireworks.ai/api-reference/post-chatcompletions
• Fireworks AI Embeddings API: https://docs.fireworks.ai/api-reference/post-embeddings
• PyPI download stats: https://pypistats.org/packages/fireworks-ai (~250k daily downloads)

Local repo files inspected

• py/src/braintrust/integrations/ — no fireworks/ directory exists on main
• py/src/braintrust/wrappers/ — no Fireworks wrapper
• py/noxfile.py — no test_fireworks session
• py/src/braintrust/integrations/__init__.py — Fireworks not listed in integration registry
• py/src/braintrust/integrations/versioning.py — no Fireworks version matrix

Relationship to existing work

• No prior PRs or implementation attempts exist for Fireworks instrumentation.
• Since Fireworks response types reuse OpenAI Pydantic models, span shaping logic may be partially reusable from the existing OpenAI integration. However, the client classes themselves are distinct and require dedicated patching.
• Users can work around the gap today by using openai.OpenAI(base_url="https://api.fireworks.ai/inference/v1") with the existing OpenAI wrapper, but this loses access to Fireworks-specific features (reranking, image generation, the native SDK's retry/timeout config) and does not trace usage through the fireworks-ai package.

[AbhiPrasad]

Spec compliance review

Automated review of the requirements stated in this issue against the Braintrust instrumentation specification (braintrust-spec → skills/instrumentation-spec/references/instrumentation-guide.md and references/features/). This reviews the issue text, not any implementation.

Verdict: NEEDS REVISION — the issue's SDK architecture section describes a package line that no longer ships, and it specifies no span shape, metadata allowlist, or metrics contract at all.
Category: completion API (plus embeddings, rerank, and image generation as proposed)
Already implemented in this repo: no — no py/src/braintrust/integrations/fireworks/, no wrapper under py/src/braintrust/wrappers/, no [tool.braintrust.matrix.fireworks-ai] key, no test_fireworks nox session. A grep -ri fireworks over the repo returns zero hits.

---

⚠️ Lead finding: the issue targets a fireworks-ai version that no longer exists

I verified against the live PyPI metadata for fireworks-ai and by downloading and unpacking fireworks_ai-1.2.6-py3-none-any.whl (https://pypi.org/pypi/fireworks-ai/json, then reading the wheel's module list and create() signatures directly).

Current stable is fireworks-ai 1.2.6, released 2026-08-03. The issue says:

Package: fireworks-ai on PyPI (current version: 0.19.x, MIT license)

That was accurate when the issue was filed (2026-03-27) — 0.19.20 (2025-10-17) was the last stable release of the old line, with 1.0.0aNN prereleases flowing at the time. It is no longer accurate. The 1.x line is a complete regeneration (Stainless-style, from fw-ai-external/python-sdk), and it invalidates most of the issue's architecture section:

Issue claim	Reality in fireworks-ai 1.2.6
> Depends on openai: response Pydantic models (fireworks.ChatCompletion, fireworks.ChatCompletionChunk) reuse openai.types.chat.chat_completion.Choice and openai.types.completion_usage.CompletionUsage directly	No openai dependency. requires_dist is aiohttp, anyio, distro, httpx, httpx-aiohttp, pydantic, sniffio, typing-extensions. The "span shaping is partially reusable because the types are OpenAI types" premise is dead.
> client.embeddings.create() — text embeddings > client.embeddings.acreate() — async text embeddings	No embeddings resource exists. Not in fireworks/resources/, not anywhere in the wheel.
> client.rerank.create() — document reranking for RAG pipelines > client.rerank.acreate() — async document reranking	No rerank resource exists.
> ImageInference.text_to_image() / .image_to_image() / .image_to_video() / .control_net()	No ImageInference class exists. The only image-adjacent artifact in the wheel is fireworks/types/request_image_block_param.py (an input content-block type).
> fireworks.client.ChatCompletion.create() / .acreate() (and Completion, Embedding) — legacy module-level API	No fireworks/client.py module exists. The legacy classmethod API is gone.
> Class hierarchy: ChatCompletionV2 → ChatCompletion → BaseCompletion; CompletionV2 → Completion → BaseCompletion; EmbeddingV1 → Embedding; RerankV1 → Rerank	None of these classes exist.

Roughly 60% of the instrumentation targets enumerated in this issue cannot be instrumented, because the APIs are not in the package.

What the surface actually is

Top-level package is fireworks (clients Fireworks(SyncAPIClient) and AsyncFireworks(AsyncAPIClient) in fireworks/_client.py). Inference resources under fireworks/resources/:

• chat/completions.py → chat.completions.create(*, messages, model, ...)
• completions.py → completions.create(*, model, prompt, ...)
• messages.py → messages.create(*, messages, model, system=..., thinking=..., tools=..., tool_choice=..., stop_sequences=..., ...) — an Anthropic-compatible Messages surface that this issue does not mention at all. It is a first-class inference endpoint and needs its own span-shape requirements (see Conflicts fix: Declare merged_git_metadata_settings before usage #10 below).

Everything else in fireworks/resources/ is control plane, not inference: accounts, api_keys, batch_inference_jobs, datasets, deployments, deployment_shapes, deployment_shape_versions, dpo_jobs, evaluation_jobs, evaluators, lora, models, reinforcement_fine_tuning_jobs, reinforcement_fine_tuning_steps, secrets, supervised_fine_tuning_jobs, users. None of these are LLM calls and none should produce llm spans.

Import-name collision hazard

The PyPI distribution is fireworks-ai but it imports as fireworks, which collides with the completely unrelated FireWorks workflow-management package (PyPI name fireworks, currently 2.1.3, "FireWorks workflow software"). Patcher module targeting and version detection must key off the distribution fireworks-ai, not the importable module name, or the integration can mis-detect and attempt to patch an unrelated scientific-workflow library. Worth an explicit line in py/src/braintrust/integrations/versioning.py handling.

---

Conflicts with the spec

1. Rerank is proposed as a first-class span surface, but the spec has no rerank span shape. The issue lists:

   client.rerank.create() — document reranking for RAG pipelines

   instrumentation-guide.md §TODO (line 1109) explicitly lists reranking as unspecified: "Reranking APIs — instrumentation for reranking endpoints (e.g. Cohere rerank, Jina Reranker), including input/output structure and relevance score metrics". Combined with §Data capturing policy — "Instrumentation MUST NOT capture any data or fields unless this guide explicitly requires or allows them… New captured fields MUST be added to this specification before SDKs emit them" — rerank instrumentation cannot be built to spec today. Correction: drop rerank from scope (it is also absent from the package, per the lead finding). Do not treat cohere/tracing.py:337 _rerank_output (a {index, relevance_score} list) as sanctioned precedent — it predates the capture policy.

2. Embeddings are listed as "just another surface" with no reference to the canonical embedding shape. features/embeddings.md §Canonical input requires input to be { inputs: [{ content }], output_dimensions? }, and §Canonical output requires output to be { count: number } only, with an explicit MUST NOT list covering "raw vector values", "prefixes or samples of vector values", "vector hashes", "vector dimensions, including the actual returned dimension", and "Provider-native embedding responses MUST NOT be logged." Correction: if embeddings are ever back in scope, state the canonical shape in the issue and explicitly forbid the existing prior art — openrouter/tracing.py:244 _embeddings_output emits {embedding_length, embeddings_count} and cohere/tracing.py _embed_output emits {embedding_count, embedding_length}. Both violate the vector-dimension prohibition and must not be used as the template for a new integration.

3. Embedding metrics are unaddressed. features/embeddings.md §Metrics: completion_tokens, completion_audio_tokens, completion_image_tokens, and time_to_first_token do not apply to embedding spans and MUST be omitted; "Instrumentation MUST NOT fabricate completion_tokens: 0." The issue's instruction to reuse OpenAI span-shaping logic would carry generative-token handling straight into embedding spans.

4. "Reusable from the existing OpenAI integration" implies the wrong metadata.provider. The issue says:

   Since Fireworks response types reuse OpenAI Pydantic models, span shaping logic may be partially reusable from the existing OpenAI integration.

   features/token-and-cost-metrics.md §Span identity makes metadata.provider a MUST, defined as "the provider, gateway, or reseller whose pricing applies to the call", and stresses it is required precisely because resellers and gateways price the same model differently. Correction: the issue must state metadata.provider = "fireworks" (never "openai", never a framework name — cf. §Completion-style frameworks), and metadata.model must be the resolved model string returned by the API (§Metadata: "The model field SHOULD use the model string from the API response … rather than the string the user passed in the request").

5. The base_url workaround claim needs a conformance correction. The issue says:

   Users can work around the gap today by using openai.OpenAI(base_url="https://api.fireworks.ai/inference/v1") with the existing OpenAI wrapper, but this loses access to Fireworks-specific features…

   Spans are emitted on that path, but py/src/braintrust/integrations/openai/tracing.py:166 hardcodes:

   metadata: dict[str, Any] = {"provider": "openai"}

   So every Fireworks call routed through the OpenAI client is logged as provider: "openai", mis-attributing it to OpenAI pricing and violating features/token-and-cost-metrics.md §Span identity and §Cost computation semantics. This is a materially stronger argument for a dedicated integration than the "native retry/timeout config" reason currently given in the issue, and the workaround paragraph should say so.

6. The legacy text-completion surface takes a raw prompt and the issue never mentions conversion. The current signature is completions.create(*, model, prompt: Union[str, SequenceNotStr[str], Iterable[int], Iterable[Iterable[int]]], ...). §Input capture → "Default: OpenAI Chat Completions format" requires the input to be "an ordered array of OpenAI-style message objects" for any provider without a dedicated UI normalizer. Correction: require prompt → [{"role": "user", "content": <prompt>}], and require the response to be logged as the choices array rather than as an extracted choices[0].text string.

7. The issue never states that output must be the choices ARRAY. §Canonical payload format names Fireworks by name as a provider without a UI normalizer: "For all other providers (Mistral, Cohere, Groq, Fireworks, Together, xAI, Perplexity, custom providers, etc.), instrumentation MUST convert payloads into the OpenAI Chat Completions format so that the UI can render them." §Output capture then requires:

   [
    {
    "index": 0,
    "finish_reason": "stop",
    "message": { "role": "assistant", "content": "The capital of France is Paris." }
    }
   ]

   Correction: spell out the array-of-choices requirement with index (SHOULD), finish_reason (MUST), and message (MUST). An extracted content string is non-conformant.

8. Image/video generation surfaces are listed with no attachment requirements. §Multimodal / Attachments requires inline media in output to be replaced with braintrust_attachment references at the exact field that formerly contained the data ("Do not generate braintrust.attachments, metadata.attachments, or a top-level attachments field"), and §Multimodal API surfaces defines "One llm span per model execution. Input prompt/reference images are logged in input; generated images are attachments in output." Correction: scope image/video out entirely (they do not exist in 1.2.6 anyway) or state the attachment contract explicitly.

9. No allowlist discipline on request metadata — and the Fireworks surface is unusually wide. §Metadata permits only temperature, top_p, max_tokens, frequency_penalty, presence_penalty, stop, and response_format as request-config keys, plus model, provider, tools, tool_choice, parallel_tool_calls, max_tool_calls, and prompt, closing with: "Any additional metadata field requires a specification update before SDKs emit it."

   The current chat.completions.create / completions.create signatures expose roughly 35 parameters. All of the following are unsanctioned and MUST NOT be emitted as metadata: min_p, top_k, repetition_penalty, mirostat_lr, mirostat_target, reasoning_effort, reasoning_history, context_length_exceeded_behavior, prompt_cache_key, prompt_cache_isolation_key, prompt_truncate_len, service_tier, n, seed, logit_bias, logprobs, echo, echo_last, ignore_eos, speculation, prediction, raw_output, return_token_ids, safe_tokenization, perf_metrics_in_response, images, and the request-level metadata dict.

   Note also that the openrouter prior art has drifted from this policy and must not be used as the metadata template: openrouter/tracing.py _CHAT_REQUEST_KEYS includes top_k, min_p, repetition_penalty, seed, logit_bias, n, service_tier, transforms, route, plugins; _CHAT_RESPONSE_KEYS adds id/object/created/system_fingerprint; and it emits invented keys provider_routing, is_byok, and embedding_model.

10. The unmentioned messages.create (Anthropic-compatible) surface must be converted, not passed through. §Canonical payload format grants provider-native passthrough only to the three providers Braintrust ships UI normalizers for (OpenAI, Anthropic, Google), and the UI selects the normalizer from metadata.provider. A span carrying provider: "fireworks" with Anthropic-native content blocks will not be normalized and will render incorrectly. Correction: messages.create input and output must be converted to the OpenAI Chat Completions format, including:

    • system (a separate parameter, Union[str, Iterable[RequestTextBlockParam]]) folded into the messages array as a role: "system" entry — §Input capture: "If the provider exposes the system prompt as a separate parameter (rather than as a message), the SDK MUST insert it into the messages array as a role: \"system\" entry."
    • tool_use content blocks → OpenAI tool_calls, with function.arguments as a JSON-encoded STRING, not a JSON object (§Tool call object fields: "The arguments as a JSON-encoded string (not a JSON object)… The string MAY be malformed JSON if the model produced invalid output — in which case it MUST be passed through as-is rather than dropped"). This is the single easiest thing to get wrong when converting from an Anthropic-shaped payload, where input is natively an object.
    • tool_result blocks in follow-up turns → {"role": "tool", "tool_call_id": ..., "content": ...} per §Tool result messages (multi-turn).
    • stop_reason → finish_reason on the choice object.

11. perf_metrics_in_response is a metrics trap. §Metrics Reference is explicit: "SDKs MUST NOT add metrics beyond the keys listed in this guide. Add new metric keys to this specification before emitting them." Fireworks' perf-metrics payload (queue / prefill / generation timings) has no sanctioned metric key. The issue should state that Fireworks perf metrics are not emitted into metrics.

---

Missing requirements

The issue enumerates API surfaces but states no span requirements whatsoever. All of the following are spec MUSTs or SHOULDs that the issue omits:

1. One span per call. §Completion API Instrumentation: "Each discrete API call MUST produce exactly one llm span. A streaming call produces a single span that closes when the stream finishes, not one span per chunk." (And, for embeddings, features/embeddings.md §Span model: "Instrumentation MUST NOT emit one span per returned embedding.")

2. span_attributes.type = "llm" on every model-call span (features/token-and-cost-metrics.md §Span identity), and a span-naming convention (§Span naming — SDKs MAY define names for additional providers; prior art uses e.g. openrouter.chat.send, cohere.rerank, so fireworks.chat.completions.create / fireworks.completions.create / fireworks.messages.create would be consistent).

3. Required token metrics. §Metrics (Completion APIs): tokens, prompt_tokens, completion_tokens MUST be captured; §Metrics Reference: "All metric values MUST be non-negative numbers" and "Missing values MUST be omitted rather than fabricated."

4. Streaming. The issue describes streaming as an SDK behavior:

   Streaming: stream=True on create() returns a generator; acreate() defaults to stream=True and returns an async generator

   but states no instrumentation requirement. §Streaming requires chunk accumulation into a single complete input/output ("The user MUST NOT need to do anything different to get complete logged data for streamed responses") and time_to_first_token MUST be captured for all streaming calls, measured by the SDK. §Token counts from stream metadata requires token metrics to be pulled from the stream's usage metadata. Because acreate() historically defaulted to streaming, this is the common path for Fireworks, not an edge case.

5. Tool metadata. The issue mentions tool use in passing ("supports streaming via stream=True, tool use, structured output") but omits §Available tool definitions: metadata.tools MUST be present on every llm span whose request makes tools available, as OpenAI-shaped tool objects ({type: "function", function: {name, description, parameters, strict}}); metadata.tool_choice MUST be normalized to the OpenAI vocabulary ("auto" / "none" / "required" / {type: "function", function: {name}}); metadata.parallel_tool_calls and metadata.max_tool_calls MUST be preserved when supplied; and metadata.tools MUST be omitted (not an empty array) when no tools were passed. Note that chat.completions.create also exposes the deprecated functions / function_call params — the spec defines no shape for those; they must be normalized into the tools shape or dropped.

6. Reasoning tokens. Fireworks exposes reasoning_effort and reasoning_history (and messages.create exposes thinking). §Reasoning Models requires completion_reasoning_tokens to be captured when the provider reports it.

7. Prompt-cache metrics. Fireworks exposes prompt_cache_key / prompt_cache_isolation_key. §Token Caching: prompt_cached_tokens and prompt_cache_creation_tokens SHOULD be captured when the provider reports them.

8. Error handling. No mention of populating the span's top-level error field on provider failure, or of ending the span on stream error/early close. (features/embeddings.md §Errors and partial responses also requires that provider-native output not be logged alongside an error.)

9. context.span_origin provenance. §Context: "Braintrust-created spans MUST also include span-origin provenance", with span_origin.instrumentation.name identifying "the stable module, package, plugin, or OTel instrumentation scope that created the span", and notes that provider SDKs like openai "are not the span origin and SHOULD continue to appear in metadata.provider". Prior art wires this via start_span(internal={"instrumentation": "openrouter-auto"}) → logger.py:4488 merge_span_origin_context. The issue should require fireworks-auto or equivalent.

10. Multimodal / attachments on inputs. chat.completions.create accepts image content blocks and completions.create accepts an images= parameter. §Multimodal / Attachments requires inline media (data URLs, raw base64 with a known MIME type, bytes/file-likes) to be converted to braintrust_attachment references before export, with the original payload preserved and no exception raised if conversion fails.

11. Repo conventions (not spec, but required by CLAUDE.md for any new integration): a [tool.braintrust.matrix.fireworks-ai] entry in py/pyproject.toml pinning latest plus at least one older version, a test_fireworks session in py/noxfile.py, a [tool.braintrust.cassette-dirs] entry, registration in py/src/braintrust/integrations/__init__.py and auto_instrument(), and VCR-backed cassette tests (mock-first coverage for provider behavior is explicitly disallowed).

---

Blocked on spec changes (braintrustdata/braintrust-spec)

1. Reranking span shape — hard blocker for that portion of this issue. instrumentation-guide.md §TODO line 1109 leaves reranking APIs unspecified, including "input/output structure and relevance score metrics". A features/rerank.md (or equivalent) must land in braintrustdata/braintrust-spec before any SDK emits a rerank span, per §Data capturing policy. (Moot for fireworks-ai 1.2.6 specifically, since the resource does not exist — but it blocks the Cohere-style precedent generally.)
2. Legacy text-completion input normalization is only implicit. The spec mandates an OpenAI message array but never defines how to represent a raw completion prompt, a list of prompts, or a token-ID prompt (Iterable[int] / Iterable[Iterable[int]]), nor how n > 1 multi-choice text completions map onto the choices array. Fireworks, Together, and others all expose /v1/completions, so this warrants a short spec addendum rather than per-integration improvisation.
3. A non-Anthropic provider serving the Anthropic wire format. §Canonical payload format ties native-format passthrough to the three normalizer providers, not to the wire format. Fireworks' messages.create is Anthropic-shaped but must carry provider: "fireworks". The safe reading is "convert to OpenAI format" (see Conflicts fix: Declare merged_git_metadata_settings before usage #10), but the spec should say so explicitly, because this pattern is spreading (Bedrock, Vertex, and several gateways all expose Anthropic-shaped endpoints under non-Anthropic provider identities).
4. No canonical vocabulary for metadata.provider values. The spec makes provider a MUST and makes cost attribution depend on it, but defines no registry of legal strings. "fireworks" needs to match whatever the backend pricing registry expects; that mapping is currently undocumented in the spec.

---

Suggested edits to this issue

• Re-audit against fireworks-ai 1.2.6 before anything else. Replace the entire "SDK architecture notes" section: current version is 1.2.6 (not 0.19.x), it is a Stainless-style regeneration from fw-ai-external/python-sdk, clients are Fireworks / AsyncFireworks in fireworks._client, and there is no openai dependency.
• Rewrite the surface list to the three inference surfaces that actually exist, each in sync and async form, streaming and non-streaming: chat.completions.create, completions.create, and messages.create (currently missing from the issue entirely). Explicitly note that the remaining fireworks/resources/ modules are control-plane APIs that must not produce llm spans.
• Cut rerank — blocked on the spec TODO (line 1109) and absent from the package.
• Cut embeddings and image/video generation — absent from the package. If Fireworks reintroduces embeddings, file it separately and scope it against features/embeddings.md ({inputs: [{content}]} in, {count} out, no dimensions).
• Cut the legacy module-level API section (fireworks.client.ChatCompletion etc.) — fireworks/client.py no longer exists.
• Add an explicit span contract section: exactly one llm span per call; span_attributes.type = "llm"; input = OpenAI message array (with system folded in as a role: "system" message and a raw prompt wrapped as a user message); output = the choices array with index, finish_reason, and message; function.arguments as a JSON-encoded string.
• Add metadata.provider = "fireworks" and metadata.model = the resolved model from the response, with a note that reusing OpenAI shaping must not carry over the hardcoded provider: "openai" at py/src/braintrust/integrations/openai/tracing.py:166.
• Add an explicit metadata allowlist (model, provider, temperature, top_p, max_tokens, frequency_penalty, presence_penalty, stop, response_format, tools, tool_choice, parallel_tool_calls, max_tool_calls) plus a sentence forbidding the ~25 Fireworks-specific params listed in Conflicts chore: Bump version to 0.6.0 for new release #9 absent a spec change, and a warning not to copy openrouter/tracing.py's key lists.
• Add the metrics contract: prompt_tokens / completion_tokens / tokens when reported; time_to_first_token MUST for streaming; completion_reasoning_tokens and prompt_cache* when reported; nothing else — explicitly no Fireworks perf metrics from perf_metrics_in_response.
• Add streaming accumulation, top-level error on failure, and context.span_origin.instrumentation.name = "fireworks-auto".
• Correct the workaround paragraph to lead with the provider: "openai" mis-attribution rather than "loses access to Fireworks-specific features" — the cost-attribution defect is the real justification for a dedicated integration.
• Add the import-name collision note: distribution fireworks-ai imports as fireworks, colliding with the unrelated FireWorks workflow package (PyPI fireworks, 2.1.3). Version detection and patcher targeting must key off the distribution name.
• Add the repo-convention checklist from CLAUDE.md: [tool.braintrust.matrix.fireworks-ai] pins, a test_fireworks nox session, a [tool.braintrust.cassette-dirs] entry, auto_instrument() wiring, and VCR cassette-backed tests under py/src/braintrust/integrations/fireworks/cassettes/<version>/.
• Update the download-count framing in the title — the ~250k daily / 1,011,799 weekly figures span both the EOL 0.19.x line and the new 1.x line; worth confirming how much traffic is on the regenerated SDK before sizing the work.