Cost Tracking

Set up Raindrop Cost Tracking in this repository.

Goal
- Make new model calls appear on Raindrop's Costs page with model, provider,
  project, token usage, and USD cost.
- Use an official Raindrop integration or the existing raw HTTP path. Do not
  add custom pricing logic.

Inspect first
1. Detect the language, package manager, installed Raindrop packages,
   existing Raindrop initialization, and model call sites. Use the existing
   package manager and do not duplicate instrumentation.
2. For an installed automatic JavaScript or TypeScript integration, upgrade
   it to at least the matching version:

   @raindrop-ai/ai-sdk           0.3.1  (Vercel AI SDK)
   @raindrop-ai/openrouter-agent 0.2.2  (OpenRouter)
   @raindrop-ai/pi-agent         0.1.3  (Pi)
   @raindrop-ai/azure-openai     0.1.1  (Azure OpenAI)
   @raindrop-ai/bedrock          0.1.1  (Amazon Bedrock)
   @raindrop-ai/vertex-ai        0.1.1  (Google Vertex)
   @raindrop-ai/opencode-plugin  0.1.3  (OpenCode)

Make the change
3. Upgrade each installed automatic integration that is below its minimum.
   Prefer the latest compatible release. Do not change its instrumentation.
4. For Python, upgrade raindrop-ai to at least 0.0.66. Confirm the existing
   setup emits LLM model spans with tracing enabled. Plain track_ai event
   properties alone are not the cost-tracking path.
5. If the TypeScript raindrop-ai base SDK is used directly without one of
   the automatic integrations above, upgrade it to at least 0.3.1 and pass
   model plus usage to the existing trackAi or finish call. Usage requires
   provider, inputTokens, and outputTokens; also pass cacheReadTokens,
   cacheWriteTokens, reasoningTokens, and providerReportedCost when the
   provider returns them. Copy the provider's raw counts without normalizing
   them. Do not add this when another integration instruments the same call.
6. If the app posts directly to /v1/events/track, preserve that request and
   add one OTLP/HTTP JSON LLM model span to /v1/traces for each model call.
   Use a standard resourceSpans envelope, a random 16-byte base64 trace ID,
   a random 8-byte base64 span ID, nanosecond timestamps, and the span name
   ai.model.usage. Authenticate with the existing Raindrop write key and use
   the same X-Raindrop-Project-Id header as the event request.
   Link it with traceloop.association.properties.event_id using the exact
   event_id from the event request. Include raindrop.usage.source=manual,
   gen_ai.provider.name, gen_ai.request.model, gen_ai.response.model,
   gen_ai.usage.input_tokens, and gen_ai.usage.output_tokens. Include the
   gen_ai.usage.cache_read_input_tokens,
   gen_ai.usage.cache_write_input_tokens, gen_ai.usage.reasoning_tokens,
   and gen_ai.usage.provider_reported_cost attributes only when available.
   Await the request or use the runtime's waitUntil mechanism.
7. If no supported Raindrop integration is installed and there is no existing
   HTTP path, identify the AI SDK or provider actually used by the
   application and follow the matching
   official guide at https://www.raindrop.ai/docs/integrations/overview.
   Do not guess at an unsupported wrapper.
8. Preserve the existing Raindrop API key, project configuration, event
   grouping, and model-call behavior. Do not add provider-specific token
   normalization, hard-coded model prices, or manual cost calculations.
9. Update the existing lockfile. Do not introduce a second package manager.

Verify
10. Run the repository's relevant typecheck, build, lint, and tests.
11. Confirm there is only one active instrumentation path around each model
   call and that no secret or API key was committed.
12. Report:
    - the integration package and version found
    - the version installed
    - every file changed
    - the verification commands and results
    - any model call path that could not be covered

Do not add a separate cost-tracking service or pricing catalog. Once the
supported integration is deployed, new model calls should populate
Raindrop's Costs page. Historical calls are not backfilled.