What each source can carry
A way into Provantix is only as good as what it sends. This table says, for each source, whether it can carry the five cost tags (department, cost_center, product, project, environment), cached and reasoning token counts, a cost figure of its own, and the person a call acted for. Yes means a test sends it through that source and finds it on the stored record. Partial says what is missing. No and Not applicable are stated, not left blank.
| Source | Cost tags | Cached tokens | Reasoning tokens | Cost the source reports | Person identity |
|---|---|---|---|---|---|
| Node.js SDK | Yes: tags on the record; the five standard names or any other |
Yes: model.tokensCacheRead, tokensCacheWrite |
Yes: model.tokensReasoning |
Yes: model.reportedCostUsd, kept beside the estimate |
Yes: onBehalfOf, stored as a keyed handle made by the SDK emitter |
| Ingest API (signed batches) | Yes: ext.tags in the record |
Yes: model.tokens_cache_read, tokens_cache_write |
Yes: model.tokens_reasoning |
Yes: model.reported_cost_usd |
Yes: on_behalf_of, as the handle the sender made |
| OpenTelemetry traces | Yes: provantix.cost.<name>, provantix.tag.<name>, deployment.environment.name, and attribute names an admin lists |
Yes: gen_ai.usage.cache_read.input_tokens, gen_ai.usage.cache_creation.input_tokens |
Yes: gen_ai.usage.reasoning.output_tokens |
Partial: only provantix.usage.cost_usd; other cost attributes do not state their unit and are not read |
Yes: user.id, stored as a handle |
| Hosted intake (OTLP webhook, for example OpenRouter Broadcast) | Yes: as OpenTelemetry traces: it is the same reader | Yes: as OpenTelemetry traces | Yes: as OpenTelemetry traces | Partial: as OpenTelemetry traces | Yes: user.id, stored as a handle |
| LangChain over OpenTelemetry (LangSmith export, OpenInference, OpenLLMetry) | Partial: a standard name in run metadata is read (langsmith.metadata.department, traceloop.association.properties.department, metadata); any other key only if an admin lists it; tag lists are not read |
Partial: where the instrumentation sends a cache count (llm.token_count.prompt_details.cache_read); many send none |
Partial: where the instrumentation sends it; many send none | No: none of these send a cost in a stated unit | Partial: user.id where the instrumentation sets it (OpenInference does) |
| Langfuse import | Yes: metadata with a standard name and Langfuse's environment with no setup; its tags, other metadata, user, session and release through the admin mapping | Yes: input_cached_tokens, input_cache_creation |
Yes: output_reasoning_tokens |
Yes: Langfuse's cost, kept as reported by Langfuse | Yes: userId, stored as a keyed handle made by the SDK emitter |
| LangSmith import | Yes: run metadata with a standard name with no setup; its tags, other metadata and fields through the admin mapping | Yes: input_token_details.cache_read, cache_creation |
Yes: output_token_details.reasoning |
Yes: LangSmith's total_cost, kept as reported by LangSmith |
Partial: LangSmith has no user field; the admin names the metadata key that holds the person |
| Claude Code (log events, and beta traces) | Yes: OTEL_RESOURCE_ATTRIBUTES such as department=engineering,cost_center=eng-123, set once per machine; or provantix.cost.<name> |
Yes: cache_read_tokens, cache_creation_tokens; its input_tokens leaves the cache out, so the parts are added back |
No: Claude Code reports none | Yes: cost_usd on each request, kept as reported by Claude Code (log events only; the trace spans carry no cost) |
Yes: user.email, else user.id, stored as a handle |
| OpenAI Codex (log events) | Partial: provantix.cost.<name> where Codex puts the setting on its events; its documentation describes [otel.span_attributes] for spans, not events |
Yes: cached_token_count |
Yes: reasoning_token_count |
No: Codex reports no cost | Yes: user.email, else user.account_id, stored as a handle |
| Provantix MCP server | Not applicable: read-only: it shows evidence and records no agent calls, so there is nothing to tag | Not applicable: as tags | Not applicable: as tags | Not applicable: as tags | Not applicable: as tags |
How to read it
- Cost the source reports is what the source says a call cost, in US dollars. Provantix keeps it as reported by that source beside its own estimate from your price table. It never replaces the estimate. The two are shown side by side so a difference can be seen and explained.
- Person identity is stored as a handle, never the address. Through OpenTelemetry and the hosted intake it is the same one-way code the people directory computes from an email or employee id, so calls are placed in a department automatically. Through the SDK, the ingest API and the imports, the SDK emitter makes its own keyed handle with your key; the directory cannot compute it, so put those handles in the upload's
handlecolumn. - A token kind a provider does not have (a model with no cache, no reasoning) is not a gap.
- Written from each project's published conventions. LangChain's instrumentations, LangSmith's export, OpenInference and OpenLLMetry have not been checked against live exports.
How far each source is proven
A source is tested when automated tests send payloads through it into the real ingest. It is checked on a live session only when someone has run the real tool and compared what arrived with what the adapter expects, and the version and date are written here. Until then it says so.
| Source | State | Version checked against | Live check |
|---|---|---|---|
| Node.js SDK | Tested end to end against the ingest in this repository | this release | automated tests |
| Ingest API (signed batches) | Tested end to end against the ingest in this repository | this release | automated tests |
| OpenTelemetry traces and hosted intake | Tested with payloads shaped from the OpenTelemetry GenAI conventions; OpenRouter Broadcast has delivered to it | GenAI conventions as published | automated tests |
| LangChain over OpenTelemetry | Built from documentation, not checked against a live export | LangSmith export, OpenInference and OpenLLMetry as documented | not yet |
| Langfuse import | Built from documentation, not checked against a live project | public API and usage keys as documented | not yet |
| LangSmith import | Built from documentation, not checked against a live project | runs API as documented | not yet |
| Claude Code | Built from documentation, not checked on a live session | documentation for versions up to 2.1.324, read 2026-11-15 | not yet |
| OpenAI usage and cost reports (provider usage) | Built from the OpenAI API reference, tested with responses shaped from it, not checked against a live organization | API reference read 2026-11-15 | not yet |
| Anthropic usage and cost reports (provider usage) | Built from the Anthropic documentation, tested with responses shaped from it, not checked against a live organization | documentation read 2026-11-15; the legacy Usage and Cost API, version header 2026-10-21 | not yet |
| Kimi Admin API (provider usage) | Built from the Kimi Admin API documentation (a beta), tested with responses shaped from it, not checked against a live organization | documentation read 2026-11-15; the currency of the bills is not stated by Kimi | not yet |
| OpenRouter activity report (provider usage) | Built from the OpenRouter API reference, tested with responses shaped from it, not checked against a live account | API reference read 2026-11-15; community notes for the 30-day window | not yet |
| GLM, DeepSeek (no usage report offered) | No usage report available from the provider; estimate from telemetry only, plus an invoice total entered by hand | documentation read 2026-11-15 | nothing to check |
| Gemini, AWS Bedrock, Vertex AI, Azure OpenAI, gateways | Not connected: cost comes through the cloud account's billing data, which is not built yet | Gemini read 2026-11-15; the others not read | not yet |
| OpenAI Codex | Built from documentation and third-party descriptions of its events, not checked on a live session | documentation read 2026-11-15; no version stated for the telemetry | not yet |
Find the source that is not tagging
Settings, Cost tab, Source coverage shows, for the last 30 days and for each source, the share of its model calls that carry each tag (as the source sent it, and from any place) and each token kind, the share that name a person, and the share that carry the source's own cost. A source that sends no project shows 0% for it, which is how the gap is found.
Tags your company already uses
Many companies already tag spans their own way. An admin can list attribute names and the tag each one means (Settings, Cost tab, Cost tags): for example acme.team means department. The five documented names always win over a listed one.
For frameworks that carry run metadata, a key with one of the five standard names is read with no setup, from langsmith.metadata.<name>, traceloop.association.properties.<name> and a metadata JSON attribute. Any other key is a tag only if an admin lists it, for example metadata.team.
Spans written by other instrumentations are read as OpenTelemetry GenAI spans: OpenInference's llm.model_name, llm.system, llm.token_count.prompt and llm.token_count.completion, and the older gen_ai.usage.prompt_tokens and completion_tokens. Nothing the GenAI names already say is overwritten.
Imports
Langfuse and LangSmith imports take a tagMap that says which of the platform's tags, metadata and fields are cost tags. See Importing from Langfuse and LangSmith.