refactor(workspace): enforce layered crate boundaries

crates/aether-data/adapters/postgres/src/usage/queries/apply_api_key_usage_delta_sql.sql

@@ -0,0 +1,24 @@
+UPDATE api_keys
+SET
+  total_requests = GREATEST(COALESCE(total_requests, 0) + $2, 0),
+  total_tokens = GREATEST(COALESCE(total_tokens, 0) + $3, 0),
+  total_cost_usd = CAST(
+    GREATEST(CAST(COALESCE(total_cost_usd, 0) AS DOUBLE PRECISION) + $4, 0) AS NUMERIC(20,8)
+  ),
+  last_used_at = CASE
+    WHEN $5::double precision IS NOT NULL THEN CASE
+      WHEN last_used_at IS NULL THEN TO_TIMESTAMP($5::double precision)
+      ELSE GREATEST(last_used_at, TO_TIMESTAMP($5::double precision))
+    END
+    WHEN $6::double precision IS NOT NULL
+      AND last_used_at IS NOT NULL
+      AND EXTRACT(EPOCH FROM last_used_at)::BIGINT = $6::BIGINT
+    THEN (
+      SELECT MAX(created_at)
+      FROM "usage"
+      WHERE api_key_id = $1
+        AND status NOT IN ('pending', 'streaming')
+    )
+    ELSE last_used_at
+  END
+WHERE id = $1

crates/aether-data/adapters/postgres/src/usage/queries/apply_global_model_usage_delta_sql.sql

@@ -0,0 +1,5 @@
+UPDATE global_models
+SET
+  usage_count = GREATEST(COALESCE(usage_count, 0) + $2, 0),
+  updated_at = NOW()
+WHERE name = $1

crates/aether-data/adapters/postgres/src/usage/queries/apply_provider_api_key_usage_delta_sql.sql

@@ -0,0 +1,27 @@
+UPDATE provider_api_keys
+SET
+  request_count = GREATEST(COALESCE(request_count, 0) + $2, 0),
+  success_count = GREATEST(COALESCE(success_count, 0) + $3, 0),
+  error_count = GREATEST(COALESCE(error_count, 0) + $4, 0),
+  total_tokens = GREATEST(total_tokens + $5, 0),
+  total_cost_usd = CAST(
+    GREATEST(CAST(total_cost_usd AS DOUBLE PRECISION) + $6, 0) AS NUMERIC(20,8)
+  ),
+  total_response_time_ms = GREATEST(COALESCE(total_response_time_ms, 0) + $7, 0),
+  last_used_at = CASE
+    WHEN $8::double precision IS NOT NULL THEN CASE
+      WHEN last_used_at IS NULL THEN TO_TIMESTAMP($8::double precision)
+      ELSE GREATEST(last_used_at, TO_TIMESTAMP($8::double precision))
+    END
+    WHEN $9::double precision IS NOT NULL
+      AND last_used_at IS NOT NULL
+      AND EXTRACT(EPOCH FROM last_used_at)::BIGINT = $9::BIGINT
+    THEN (
+      SELECT MAX(created_at)
+      FROM "usage"
+      WHERE provider_api_key_id = $1
+        AND status NOT IN ('pending', 'streaming')
+    )
+    ELSE last_used_at
+  END
+WHERE id = $1

crates/aether-data/adapters/postgres/src/usage/queries/delete_usage_body_blob_sql.sql

@@ -0,0 +1,2 @@
+DELETE FROM usage_body_blobs
+WHERE body_ref = $1

crates/aether-data/adapters/postgres/src/usage/queries/find_by_id_sql.sql

@@ -0,0 +1,178 @@
+SELECT
+  "usage".id,
+  "usage".request_id,
+  "usage".user_id,
+  "usage".api_key_id,
+  "usage".username,
+  "usage".api_key_name,
+  "usage".provider_name,
+  "usage".model,
+  "usage".target_model,
+  "usage".provider_id,
+  "usage".provider_endpoint_id,
+  "usage".provider_api_key_id,
+  "usage".request_type,
+  "usage".api_format,
+  "usage".api_family,
+  "usage".endpoint_kind,
+  "usage".endpoint_api_format,
+  "usage".provider_api_family,
+  "usage".provider_endpoint_kind,
+  COALESCE("usage".has_format_conversion, FALSE) AS has_format_conversion,
+  COALESCE("usage".is_stream, FALSE) AS is_stream,
+  CAST("usage".input_tokens AS INTEGER) AS input_tokens,
+  CAST(COALESCE(usage_settlement_snapshots.billing_output_tokens, "usage".output_tokens) AS INTEGER) AS output_tokens,
+  CAST(COALESCE(
+    CASE
+      WHEN usage_settlement_snapshots.billing_input_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_output_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_5m_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_1h_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_read_tokens IS NOT NULL
+      THEN COALESCE(usage_settlement_snapshots.billing_input_tokens, 0)
+        + COALESCE(usage_settlement_snapshots.billing_output_tokens, 0)
+        + COALESCE(
+            usage_settlement_snapshots.billing_cache_creation_tokens,
+            COALESCE(usage_settlement_snapshots.billing_cache_creation_5m_tokens, 0)
+              + COALESCE(usage_settlement_snapshots.billing_cache_creation_1h_tokens, 0),
+            0
+          )
+        + COALESCE(usage_settlement_snapshots.billing_cache_read_tokens, 0)
+    END,
+    "usage".total_tokens
+  ) AS INTEGER) AS total_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_tokens,
+    "usage".cache_creation_input_tokens,
+    0
+  ) AS INTEGER) AS cache_creation_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_5m_tokens,
+    "usage".cache_creation_input_tokens_5m,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_5m_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_1h_tokens,
+    "usage".cache_creation_input_tokens_1h,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_1h_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_read_tokens,
+    "usage".cache_read_input_tokens,
+    0
+  ) AS INTEGER) AS cache_read_input_tokens,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_creation_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_creation_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_read_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_read_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION),
+    CAST("usage".output_price_per_1m AS DOUBLE PRECISION)
+  ) AS output_price_per_1m,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS total_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".actual_total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS actual_total_cost_usd,
+  "usage".status_code,
+  "usage".error_message,
+  "usage".error_category,
+  "usage".response_time_ms,
+  "usage".first_byte_time_ms,
+  "usage".status,
+  COALESCE(usage_settlement_snapshots.billing_status, "usage".billing_status) AS billing_status,
+  COALESCE(
+    NULLIF(BTRIM("usage".request_metadata->'client_session_affinity'->>'client_family'), ''),
+    NULLIF(BTRIM("usage".request_metadata->>'client_family'), '')
+  ) AS client_family,
+  COALESCE(usage_http_audits.request_headers, "usage".request_headers) AS request_headers,
+  "usage".request_body,
+  "usage".request_body_compressed,
+  COALESCE(
+    usage_http_audits.provider_request_headers,
+    "usage".provider_request_headers
+  ) AS provider_request_headers,
+  "usage".provider_request_body,
+  "usage".provider_request_body_compressed,
+  COALESCE(usage_http_audits.response_headers, "usage".response_headers) AS response_headers,
+  "usage".response_body,
+  "usage".response_body_compressed,
+  COALESCE(
+    usage_http_audits.client_response_headers,
+    "usage".client_response_headers
+  ) AS client_response_headers,
+  "usage".client_response_body,
+  "usage".client_response_body_compressed,
+  "usage".request_metadata,
+  usage_http_audits.request_body_ref AS http_request_body_ref,
+  usage_http_audits.provider_request_body_ref AS http_provider_request_body_ref,
+  usage_http_audits.response_body_ref AS http_response_body_ref,
+  usage_http_audits.client_response_body_ref AS http_client_response_body_ref,
+  usage_routing_snapshots.candidate_id AS routing_candidate_id,
+  usage_routing_snapshots.candidate_index AS routing_candidate_index,
+  usage_routing_snapshots.key_name AS routing_key_name,
+  usage_routing_snapshots.planner_kind AS routing_planner_kind,
+  usage_routing_snapshots.route_family AS routing_route_family,
+  usage_routing_snapshots.route_kind AS routing_route_kind,
+  usage_routing_snapshots.execution_path AS routing_execution_path,
+  usage_routing_snapshots.local_execution_runtime_miss_reason AS routing_local_execution_runtime_miss_reason,
+  usage_settlement_snapshots.billing_snapshot_schema_version AS settlement_billing_snapshot_schema_version,
+  usage_settlement_snapshots.billing_snapshot_status AS settlement_billing_snapshot_status,
+  CAST(usage_settlement_snapshots.rate_multiplier AS DOUBLE PRECISION) AS settlement_rate_multiplier,
+  usage_settlement_snapshots.is_free_tier AS settlement_is_free_tier,
+  CAST(usage_settlement_snapshots.input_price_per_1m AS DOUBLE PRECISION) AS settlement_input_price_per_1m,
+  CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION) AS settlement_output_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_creation_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_creation_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_read_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_read_price_per_1m,
+  CAST(usage_settlement_snapshots.price_per_request AS DOUBLE PRECISION) AS settlement_price_per_request,
+  usage_settlement_snapshots.settlement_snapshot_schema_version AS settlement_snapshot_schema_version,
+  usage_settlement_snapshots.settlement_snapshot AS settlement_snapshot,
+  usage_settlement_snapshots.billing_dimensions AS settlement_billing_dimensions,
+  usage_settlement_snapshots.billing_input_tokens AS settlement_billing_input_tokens,
+  usage_settlement_snapshots.billing_effective_input_tokens AS settlement_billing_effective_input_tokens,
+  usage_settlement_snapshots.billing_output_tokens AS settlement_billing_output_tokens,
+  usage_settlement_snapshots.billing_cache_creation_tokens AS settlement_billing_cache_creation_tokens,
+  usage_settlement_snapshots.billing_cache_creation_5m_tokens AS settlement_billing_cache_creation_5m_tokens,
+  usage_settlement_snapshots.billing_cache_creation_1h_tokens AS settlement_billing_cache_creation_1h_tokens,
+  usage_settlement_snapshots.billing_cache_read_tokens AS settlement_billing_cache_read_tokens,
+  usage_settlement_snapshots.billing_total_input_context AS settlement_billing_total_input_context,
+  CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_creation_cost_usd,
+  CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_read_cost_usd,
+  CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_total_cost_usd,
+  CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_actual_total_cost_usd,
+  usage_settlement_snapshots.billing_pricing_source AS settlement_billing_pricing_source,
+  usage_settlement_snapshots.billing_rule_id AS settlement_billing_rule_id,
+  usage_settlement_snapshots.billing_rule_version AS settlement_billing_rule_version,
+  CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT) AS created_at_unix_ms,
+  GREATEST(
+    COALESCE(NULLIF("usage".updated_at_unix_secs, 0), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM usage_settlement_snapshots.finalized_at) AS BIGINT), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM "usage".finalized_at) AS BIGINT), 0),
+    CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT)
+  ) AS updated_at_unix_secs,
+  CAST(
+    EXTRACT(
+      EPOCH FROM COALESCE(usage_settlement_snapshots.finalized_at, "usage".finalized_at)
+    ) AS BIGINT
+  ) AS finalized_at_unix_secs
+FROM "usage"
+LEFT JOIN usage_http_audits
+  ON usage_http_audits.request_id = "usage".request_id
+LEFT JOIN usage_routing_snapshots
+  ON usage_routing_snapshots.request_id = "usage".request_id
+LEFT JOIN usage_settlement_snapshots
+  ON usage_settlement_snapshots.request_id = "usage".request_id
+WHERE "usage".id = $1
+LIMIT 1

crates/aether-data/adapters/postgres/src/usage/queries/find_by_request_id_sql.sql

@@ -0,0 +1,182 @@
+SELECT
+  "usage".id,
+  "usage".request_id,
+  "usage".user_id,
+  "usage".api_key_id,
+  "usage".username,
+  "usage".api_key_name,
+  "usage".provider_name,
+  "usage".model,
+  "usage".target_model,
+  "usage".provider_id,
+  "usage".provider_endpoint_id,
+  "usage".provider_api_key_id,
+  "usage".request_type,
+  "usage".api_format,
+  "usage".api_family,
+  "usage".endpoint_kind,
+  "usage".endpoint_api_format,
+  "usage".provider_api_family,
+  "usage".provider_endpoint_kind,
+  COALESCE("usage".has_format_conversion, FALSE) AS has_format_conversion,
+  COALESCE("usage".is_stream, FALSE) AS is_stream,
+  CAST("usage".input_tokens AS INTEGER) AS input_tokens,
+  CAST(COALESCE(usage_settlement_snapshots.billing_output_tokens, "usage".output_tokens) AS INTEGER) AS output_tokens,
+  CAST(COALESCE(
+    CASE
+      WHEN usage_settlement_snapshots.billing_input_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_output_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_5m_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_1h_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_read_tokens IS NOT NULL
+      THEN COALESCE(usage_settlement_snapshots.billing_input_tokens, 0)
+        + COALESCE(usage_settlement_snapshots.billing_output_tokens, 0)
+        + COALESCE(
+            usage_settlement_snapshots.billing_cache_creation_tokens,
+            COALESCE(usage_settlement_snapshots.billing_cache_creation_5m_tokens, 0)
+              + COALESCE(usage_settlement_snapshots.billing_cache_creation_1h_tokens, 0),
+            0
+          )
+        + COALESCE(usage_settlement_snapshots.billing_cache_read_tokens, 0)
+    END,
+    "usage".total_tokens
+  ) AS INTEGER) AS total_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_tokens,
+    "usage".cache_creation_input_tokens,
+    0
+  ) AS INTEGER) AS cache_creation_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_5m_tokens,
+    "usage".cache_creation_input_tokens_5m,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_5m_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_1h_tokens,
+    "usage".cache_creation_input_tokens_1h,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_1h_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_read_tokens,
+    "usage".cache_read_input_tokens,
+    0
+  ) AS INTEGER) AS cache_read_input_tokens,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_creation_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_creation_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_read_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_read_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION),
+    CAST("usage".output_price_per_1m AS DOUBLE PRECISION)
+  ) AS output_price_per_1m,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS total_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".actual_total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS actual_total_cost_usd,
+  "usage".status_code,
+  "usage".error_message,
+  "usage".error_category,
+  "usage".response_time_ms,
+  "usage".first_byte_time_ms,
+  "usage".status,
+  COALESCE(usage_settlement_snapshots.billing_status, "usage".billing_status) AS billing_status,
+  COALESCE(
+    NULLIF(BTRIM("usage".request_metadata->'client_session_affinity'->>'client_family'), ''),
+    NULLIF(BTRIM("usage".request_metadata->>'client_family'), '')
+  ) AS client_family,
+  COALESCE(usage_http_audits.request_headers, "usage".request_headers) AS request_headers,
+  "usage".request_body,
+  "usage".request_body_compressed,
+  COALESCE(
+    usage_http_audits.provider_request_headers,
+    "usage".provider_request_headers
+  ) AS provider_request_headers,
+  "usage".provider_request_body,
+  "usage".provider_request_body_compressed,
+  COALESCE(usage_http_audits.response_headers, "usage".response_headers) AS response_headers,
+  "usage".response_body,
+  "usage".response_body_compressed,
+  COALESCE(
+    usage_http_audits.client_response_headers,
+    "usage".client_response_headers
+  ) AS client_response_headers,
+  "usage".client_response_body,
+  "usage".client_response_body_compressed,
+  "usage".request_metadata,
+  usage_http_audits.request_body_ref AS http_request_body_ref,
+  usage_http_audits.provider_request_body_ref AS http_provider_request_body_ref,
+  usage_http_audits.response_body_ref AS http_response_body_ref,
+  usage_http_audits.client_response_body_ref AS http_client_response_body_ref,
+  usage_http_audits.request_body_state AS http_request_body_state,
+  usage_http_audits.provider_request_body_state AS http_provider_request_body_state,
+  usage_http_audits.response_body_state AS http_response_body_state,
+  usage_http_audits.client_response_body_state AS http_client_response_body_state,
+  usage_routing_snapshots.candidate_id AS routing_candidate_id,
+  usage_routing_snapshots.candidate_index AS routing_candidate_index,
+  usage_routing_snapshots.key_name AS routing_key_name,
+  usage_routing_snapshots.planner_kind AS routing_planner_kind,
+  usage_routing_snapshots.route_family AS routing_route_family,
+  usage_routing_snapshots.route_kind AS routing_route_kind,
+  usage_routing_snapshots.execution_path AS routing_execution_path,
+  usage_routing_snapshots.local_execution_runtime_miss_reason AS routing_local_execution_runtime_miss_reason,
+  usage_settlement_snapshots.billing_snapshot_schema_version AS settlement_billing_snapshot_schema_version,
+  usage_settlement_snapshots.billing_snapshot_status AS settlement_billing_snapshot_status,
+  CAST(usage_settlement_snapshots.rate_multiplier AS DOUBLE PRECISION) AS settlement_rate_multiplier,
+  usage_settlement_snapshots.is_free_tier AS settlement_is_free_tier,
+  CAST(usage_settlement_snapshots.input_price_per_1m AS DOUBLE PRECISION) AS settlement_input_price_per_1m,
+  CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION) AS settlement_output_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_creation_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_creation_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_read_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_read_price_per_1m,
+  CAST(usage_settlement_snapshots.price_per_request AS DOUBLE PRECISION) AS settlement_price_per_request,
+  usage_settlement_snapshots.settlement_snapshot_schema_version AS settlement_snapshot_schema_version,
+  usage_settlement_snapshots.settlement_snapshot AS settlement_snapshot,
+  usage_settlement_snapshots.billing_dimensions AS settlement_billing_dimensions,
+  usage_settlement_snapshots.billing_input_tokens AS settlement_billing_input_tokens,
+  usage_settlement_snapshots.billing_effective_input_tokens AS settlement_billing_effective_input_tokens,
+  usage_settlement_snapshots.billing_output_tokens AS settlement_billing_output_tokens,
+  usage_settlement_snapshots.billing_cache_creation_tokens AS settlement_billing_cache_creation_tokens,
+  usage_settlement_snapshots.billing_cache_creation_5m_tokens AS settlement_billing_cache_creation_5m_tokens,
+  usage_settlement_snapshots.billing_cache_creation_1h_tokens AS settlement_billing_cache_creation_1h_tokens,
+  usage_settlement_snapshots.billing_cache_read_tokens AS settlement_billing_cache_read_tokens,
+  usage_settlement_snapshots.billing_total_input_context AS settlement_billing_total_input_context,
+  CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_creation_cost_usd,
+  CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_read_cost_usd,
+  CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_total_cost_usd,
+  CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_actual_total_cost_usd,
+  usage_settlement_snapshots.billing_pricing_source AS settlement_billing_pricing_source,
+  usage_settlement_snapshots.billing_rule_id AS settlement_billing_rule_id,
+  usage_settlement_snapshots.billing_rule_version AS settlement_billing_rule_version,
+  CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT) AS created_at_unix_ms,
+  GREATEST(
+    COALESCE(NULLIF("usage".updated_at_unix_secs, 0), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM usage_settlement_snapshots.finalized_at) AS BIGINT), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM "usage".finalized_at) AS BIGINT), 0),
+    CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT)
+  ) AS updated_at_unix_secs,
+  CAST(
+    EXTRACT(
+      EPOCH FROM COALESCE(usage_settlement_snapshots.finalized_at, "usage".finalized_at)
+    ) AS BIGINT
+  ) AS finalized_at_unix_secs
+FROM "usage"
+LEFT JOIN usage_http_audits
+  ON usage_http_audits.request_id = "usage".request_id
+LEFT JOIN usage_routing_snapshots
+  ON usage_routing_snapshots.request_id = "usage".request_id
+LEFT JOIN usage_settlement_snapshots
+  ON usage_settlement_snapshots.request_id = "usage".request_id
+WHERE "usage".request_id = $1
+LIMIT 1

crates/aether-data/adapters/postgres/src/usage/queries/list_recent_usage_audits_prefix.sql

@@ -0,0 +1,239 @@
+SELECT
+  "usage".id,
+  "usage".request_id,
+  "usage".user_id,
+  "usage".api_key_id,
+  "usage".username,
+  "usage".api_key_name,
+  "usage".provider_name,
+  "usage".model,
+  "usage".target_model,
+  "usage".provider_id,
+  "usage".provider_endpoint_id,
+  "usage".provider_api_key_id,
+  "usage".request_type,
+  "usage".api_format,
+  "usage".api_family,
+  "usage".endpoint_kind,
+  "usage".endpoint_api_format,
+  "usage".provider_api_family,
+  "usage".provider_endpoint_kind,
+  COALESCE("usage".has_format_conversion, FALSE) AS has_format_conversion,
+  COALESCE("usage".is_stream, FALSE) AS is_stream,
+  CAST("usage".input_tokens AS INTEGER) AS input_tokens,
+  CAST(COALESCE(usage_settlement_snapshots.billing_output_tokens, "usage".output_tokens) AS INTEGER) AS output_tokens,
+  CAST(COALESCE(
+    CASE
+      WHEN usage_settlement_snapshots.billing_input_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_output_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_5m_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_1h_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_read_tokens IS NOT NULL
+      THEN COALESCE(usage_settlement_snapshots.billing_input_tokens, 0)
+        + COALESCE(usage_settlement_snapshots.billing_output_tokens, 0)
+        + COALESCE(
+            usage_settlement_snapshots.billing_cache_creation_tokens,
+            COALESCE(usage_settlement_snapshots.billing_cache_creation_5m_tokens, 0)
+              + COALESCE(usage_settlement_snapshots.billing_cache_creation_1h_tokens, 0),
+            0
+          )
+        + COALESCE(usage_settlement_snapshots.billing_cache_read_tokens, 0)
+    END,
+    "usage".total_tokens
+  ) AS INTEGER) AS total_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_tokens,
+    "usage".cache_creation_input_tokens,
+    0
+  ) AS INTEGER) AS cache_creation_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_5m_tokens,
+    "usage".cache_creation_input_tokens_5m,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_5m_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_1h_tokens,
+    "usage".cache_creation_input_tokens_1h,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_1h_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_read_tokens,
+    "usage".cache_read_input_tokens,
+    0
+  ) AS INTEGER) AS cache_read_input_tokens,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_creation_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_creation_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_read_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_read_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION),
+    CAST("usage".output_price_per_1m AS DOUBLE PRECISION)
+  ) AS output_price_per_1m,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS total_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".actual_total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS actual_total_cost_usd,
+  "usage".status_code,
+  "usage".error_message,
+  "usage".error_category,
+  "usage".response_time_ms,
+  "usage".first_byte_time_ms,
+  "usage".status,
+  COALESCE(usage_settlement_snapshots.billing_status, "usage".billing_status) AS billing_status,
+  COALESCE(
+    NULLIF(BTRIM("usage".request_metadata->'client_session_affinity'->>'client_family'), ''),
+    NULLIF(BTRIM("usage".request_metadata->>'client_family'), '')
+  ) AS client_family,
+  NULL::json AS request_headers,
+  NULL::json AS request_body,
+  NULL::bytea AS request_body_compressed,
+  NULL::json AS provider_request_headers,
+  NULL::json AS provider_request_body,
+  NULL::bytea AS provider_request_body_compressed,
+  NULL::json AS response_headers,
+  NULL::json AS response_body,
+  NULL::bytea AS response_body_compressed,
+  NULL::json AS client_response_headers,
+  NULL::json AS client_response_body,
+  NULL::bytea AS client_response_body_compressed,
+  CASE
+    WHEN NULLIF(BTRIM("usage".request_metadata->>'client_ip'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'user_agent'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'request_path'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'request_path_and_query'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_reasoning_effort'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_service_tier'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_actual_service_tier'), '') IS NOT NULL
+      OR ("usage".request_metadata->>'client_requested_stream') IN ('true', 'false')
+      OR ("usage".request_metadata->>'upstream_is_stream') IN ('true', 'false')
+      THEN jsonb_strip_nulls(jsonb_build_object(
+        'client_ip',
+        NULLIF(BTRIM("usage".request_metadata->>'client_ip'), ''),
+        'user_agent',
+        NULLIF(BTRIM("usage".request_metadata->>'user_agent'), ''),
+        'request_path',
+        NULLIF(BTRIM("usage".request_metadata->>'request_path'), ''),
+        'request_path_and_query',
+        NULLIF(BTRIM("usage".request_metadata->>'request_path_and_query'), ''),
+        'provider_reasoning_effort',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_reasoning_effort'), ''),
+        'provider_service_tier',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_service_tier'), ''),
+        'provider_actual_service_tier',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_actual_service_tier'), ''),
+        'client_requested_stream',
+        CASE
+          WHEN ("usage".request_metadata->>'client_requested_stream') IN ('true', 'false')
+            THEN ("usage".request_metadata->>'client_requested_stream')::boolean
+          ELSE NULL
+        END,
+        'upstream_is_stream',
+        CASE
+          WHEN ("usage".request_metadata->>'upstream_is_stream') IN ('true', 'false')
+            THEN ("usage".request_metadata->>'upstream_is_stream')::boolean
+          ELSE NULL
+        END
+      ))::json
+    ELSE NULL::json
+  END AS request_metadata,
+  NULL::varchar AS http_request_body_ref,
+  NULL::varchar AS http_provider_request_body_ref,
+  NULL::varchar AS http_response_body_ref,
+  NULL::varchar AS http_client_response_body_ref,
+  NULL::varchar AS http_request_body_state,
+  NULL::varchar AS http_provider_request_body_state,
+  NULL::varchar AS http_response_body_state,
+  NULL::varchar AS http_client_response_body_state,
+  COALESCE(
+    usage_routing_snapshots.candidate_id,
+    NULLIF(BTRIM("usage".request_metadata->>'candidate_id'), '')
+  ) AS routing_candidate_id,
+  COALESCE(
+    usage_routing_snapshots.candidate_index,
+    CASE
+      WHEN ("usage".request_metadata->>'candidate_index') ~ '^[0-9]+$'
+        THEN ("usage".request_metadata->>'candidate_index')::integer
+      ELSE NULL
+    END
+  ) AS routing_candidate_index,
+  COALESCE(
+    usage_routing_snapshots.key_name,
+    NULLIF(BTRIM("usage".request_metadata->>'key_name'), '')
+  ) AS routing_key_name,
+  COALESCE(
+    usage_routing_snapshots.planner_kind,
+    NULLIF(BTRIM("usage".request_metadata->>'planner_kind'), '')
+  ) AS routing_planner_kind,
+  COALESCE(
+    usage_routing_snapshots.route_family,
+    NULLIF(BTRIM("usage".request_metadata->>'route_family'), '')
+  ) AS routing_route_family,
+  COALESCE(
+    usage_routing_snapshots.route_kind,
+    NULLIF(BTRIM("usage".request_metadata->>'route_kind'), '')
+  ) AS routing_route_kind,
+  COALESCE(
+    usage_routing_snapshots.execution_path,
+    NULLIF(BTRIM("usage".request_metadata->>'execution_path'), '')
+  ) AS routing_execution_path,
+  COALESCE(
+    usage_routing_snapshots.local_execution_runtime_miss_reason,
+    NULLIF(BTRIM("usage".request_metadata->>'local_execution_runtime_miss_reason'), '')
+  ) AS routing_local_execution_runtime_miss_reason,
+  usage_settlement_snapshots.billing_snapshot_schema_version AS settlement_billing_snapshot_schema_version,
+  usage_settlement_snapshots.billing_snapshot_status AS settlement_billing_snapshot_status,
+  CAST(usage_settlement_snapshots.rate_multiplier AS DOUBLE PRECISION) AS settlement_rate_multiplier,
+  usage_settlement_snapshots.is_free_tier AS settlement_is_free_tier,
+  CAST(usage_settlement_snapshots.input_price_per_1m AS DOUBLE PRECISION) AS settlement_input_price_per_1m,
+  CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION) AS settlement_output_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_creation_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_creation_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_read_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_read_price_per_1m,
+  CAST(usage_settlement_snapshots.price_per_request AS DOUBLE PRECISION) AS settlement_price_per_request,
+  usage_settlement_snapshots.settlement_snapshot_schema_version AS settlement_snapshot_schema_version,
+  usage_settlement_snapshots.settlement_snapshot AS settlement_snapshot,
+  usage_settlement_snapshots.billing_dimensions AS settlement_billing_dimensions,
+  usage_settlement_snapshots.billing_input_tokens AS settlement_billing_input_tokens,
+  usage_settlement_snapshots.billing_effective_input_tokens AS settlement_billing_effective_input_tokens,
+  usage_settlement_snapshots.billing_output_tokens AS settlement_billing_output_tokens,
+  usage_settlement_snapshots.billing_cache_creation_tokens AS settlement_billing_cache_creation_tokens,
+  usage_settlement_snapshots.billing_cache_creation_5m_tokens AS settlement_billing_cache_creation_5m_tokens,
+  usage_settlement_snapshots.billing_cache_creation_1h_tokens AS settlement_billing_cache_creation_1h_tokens,
+  usage_settlement_snapshots.billing_cache_read_tokens AS settlement_billing_cache_read_tokens,
+  usage_settlement_snapshots.billing_total_input_context AS settlement_billing_total_input_context,
+  CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_creation_cost_usd,
+  CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_read_cost_usd,
+  CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_total_cost_usd,
+  CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_actual_total_cost_usd,
+  usage_settlement_snapshots.billing_pricing_source AS settlement_billing_pricing_source,
+  usage_settlement_snapshots.billing_rule_id AS settlement_billing_rule_id,
+  usage_settlement_snapshots.billing_rule_version AS settlement_billing_rule_version,
+  CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT) AS created_at_unix_ms,
+  GREATEST(
+    COALESCE(NULLIF("usage".updated_at_unix_secs, 0), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM usage_settlement_snapshots.finalized_at) AS BIGINT), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM "usage".finalized_at) AS BIGINT), 0),
+    CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT)
+  ) AS updated_at_unix_secs,
+  CAST(
+    EXTRACT(
+      EPOCH FROM COALESCE(usage_settlement_snapshots.finalized_at, "usage".finalized_at)
+    ) AS BIGINT
+  ) AS finalized_at_unix_secs
+FROM "usage"
+LEFT JOIN usage_routing_snapshots
+  ON usage_routing_snapshots.request_id = "usage".request_id
+LEFT JOIN usage_settlement_snapshots
+  ON usage_settlement_snapshots.request_id = "usage".request_id

crates/aether-data/adapters/postgres/src/usage/queries/list_usage_audits_prefix.sql

@@ -0,0 +1,239 @@
+SELECT
+  "usage".id,
+  "usage".request_id,
+  "usage".user_id,
+  "usage".api_key_id,
+  "usage".username,
+  "usage".api_key_name,
+  "usage".provider_name,
+  "usage".model,
+  "usage".target_model,
+  "usage".provider_id,
+  "usage".provider_endpoint_id,
+  "usage".provider_api_key_id,
+  "usage".request_type,
+  "usage".api_format,
+  "usage".api_family,
+  "usage".endpoint_kind,
+  "usage".endpoint_api_format,
+  "usage".provider_api_family,
+  "usage".provider_endpoint_kind,
+  COALESCE("usage".has_format_conversion, FALSE) AS has_format_conversion,
+  COALESCE("usage".is_stream, FALSE) AS is_stream,
+  CAST("usage".input_tokens AS INTEGER) AS input_tokens,
+  CAST(COALESCE(usage_settlement_snapshots.billing_output_tokens, "usage".output_tokens) AS INTEGER) AS output_tokens,
+  CAST(COALESCE(
+    CASE
+      WHEN usage_settlement_snapshots.billing_input_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_output_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_5m_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_creation_1h_tokens IS NOT NULL
+        OR usage_settlement_snapshots.billing_cache_read_tokens IS NOT NULL
+      THEN COALESCE(usage_settlement_snapshots.billing_input_tokens, 0)
+        + COALESCE(usage_settlement_snapshots.billing_output_tokens, 0)
+        + COALESCE(
+            usage_settlement_snapshots.billing_cache_creation_tokens,
+            COALESCE(usage_settlement_snapshots.billing_cache_creation_5m_tokens, 0)
+              + COALESCE(usage_settlement_snapshots.billing_cache_creation_1h_tokens, 0),
+            0
+          )
+        + COALESCE(usage_settlement_snapshots.billing_cache_read_tokens, 0)
+    END,
+    "usage".total_tokens
+  ) AS INTEGER) AS total_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_tokens,
+    "usage".cache_creation_input_tokens,
+    0
+  ) AS INTEGER) AS cache_creation_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_5m_tokens,
+    "usage".cache_creation_input_tokens_5m,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_5m_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_creation_1h_tokens,
+    "usage".cache_creation_input_tokens_1h,
+    0
+  ) AS INTEGER) AS cache_creation_ephemeral_1h_input_tokens,
+  CAST(COALESCE(
+    usage_settlement_snapshots.billing_cache_read_tokens,
+    "usage".cache_read_input_tokens,
+    0
+  ) AS INTEGER) AS cache_read_input_tokens,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_creation_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_creation_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".cache_read_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS cache_read_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION),
+    CAST("usage".output_price_per_1m AS DOUBLE PRECISION)
+  ) AS output_price_per_1m,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS total_cost_usd,
+  COALESCE(
+    CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION),
+    CAST("usage".actual_total_cost_usd AS DOUBLE PRECISION),
+    0
+  ) AS actual_total_cost_usd,
+  "usage".status_code,
+  "usage".error_message,
+  "usage".error_category,
+  "usage".response_time_ms,
+  "usage".first_byte_time_ms,
+  "usage".status,
+  COALESCE(usage_settlement_snapshots.billing_status, "usage".billing_status) AS billing_status,
+  COALESCE(
+    NULLIF(BTRIM("usage".request_metadata->'client_session_affinity'->>'client_family'), ''),
+    NULLIF(BTRIM("usage".request_metadata->>'client_family'), '')
+  ) AS client_family,
+  NULL::json AS request_headers,
+  NULL::json AS request_body,
+  NULL::bytea AS request_body_compressed,
+  NULL::json AS provider_request_headers,
+  NULL::json AS provider_request_body,
+  NULL::bytea AS provider_request_body_compressed,
+  NULL::json AS response_headers,
+  NULL::json AS response_body,
+  NULL::bytea AS response_body_compressed,
+  NULL::json AS client_response_headers,
+  NULL::json AS client_response_body,
+  NULL::bytea AS client_response_body_compressed,
+  CASE
+    WHEN NULLIF(BTRIM("usage".request_metadata->>'client_ip'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'user_agent'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'request_path'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'request_path_and_query'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_reasoning_effort'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_service_tier'), '') IS NOT NULL
+      OR NULLIF(BTRIM("usage".request_metadata->>'provider_actual_service_tier'), '') IS NOT NULL
+      OR ("usage".request_metadata->>'client_requested_stream') IN ('true', 'false')
+      OR ("usage".request_metadata->>'upstream_is_stream') IN ('true', 'false')
+      THEN jsonb_strip_nulls(jsonb_build_object(
+        'client_ip',
+        NULLIF(BTRIM("usage".request_metadata->>'client_ip'), ''),
+        'user_agent',
+        NULLIF(BTRIM("usage".request_metadata->>'user_agent'), ''),
+        'request_path',
+        NULLIF(BTRIM("usage".request_metadata->>'request_path'), ''),
+        'request_path_and_query',
+        NULLIF(BTRIM("usage".request_metadata->>'request_path_and_query'), ''),
+        'provider_reasoning_effort',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_reasoning_effort'), ''),
+        'provider_service_tier',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_service_tier'), ''),
+        'provider_actual_service_tier',
+        NULLIF(BTRIM("usage".request_metadata->>'provider_actual_service_tier'), ''),
+        'client_requested_stream',
+        CASE
+          WHEN ("usage".request_metadata->>'client_requested_stream') IN ('true', 'false')
+            THEN ("usage".request_metadata->>'client_requested_stream')::boolean
+          ELSE NULL
+        END,
+        'upstream_is_stream',
+        CASE
+          WHEN ("usage".request_metadata->>'upstream_is_stream') IN ('true', 'false')
+            THEN ("usage".request_metadata->>'upstream_is_stream')::boolean
+          ELSE NULL
+        END
+      ))::json
+    ELSE NULL::json
+  END AS request_metadata,
+  NULL::varchar AS http_request_body_ref,
+  NULL::varchar AS http_provider_request_body_ref,
+  NULL::varchar AS http_response_body_ref,
+  NULL::varchar AS http_client_response_body_ref,
+  NULL::varchar AS http_request_body_state,
+  NULL::varchar AS http_provider_request_body_state,
+  NULL::varchar AS http_response_body_state,
+  NULL::varchar AS http_client_response_body_state,
+  COALESCE(
+    usage_routing_snapshots.candidate_id,
+    NULLIF(BTRIM("usage".request_metadata->>'candidate_id'), '')
+  ) AS routing_candidate_id,
+  COALESCE(
+    usage_routing_snapshots.candidate_index,
+    CASE
+      WHEN ("usage".request_metadata->>'candidate_index') ~ '^[0-9]+$'
+        THEN ("usage".request_metadata->>'candidate_index')::integer
+      ELSE NULL
+    END
+  ) AS routing_candidate_index,
+  COALESCE(
+    usage_routing_snapshots.key_name,
+    NULLIF(BTRIM("usage".request_metadata->>'key_name'), '')
+  ) AS routing_key_name,
+  COALESCE(
+    usage_routing_snapshots.planner_kind,
+    NULLIF(BTRIM("usage".request_metadata->>'planner_kind'), '')
+  ) AS routing_planner_kind,
+  COALESCE(
+    usage_routing_snapshots.route_family,
+    NULLIF(BTRIM("usage".request_metadata->>'route_family'), '')
+  ) AS routing_route_family,
+  COALESCE(
+    usage_routing_snapshots.route_kind,
+    NULLIF(BTRIM("usage".request_metadata->>'route_kind'), '')
+  ) AS routing_route_kind,
+  COALESCE(
+    usage_routing_snapshots.execution_path,
+    NULLIF(BTRIM("usage".request_metadata->>'execution_path'), '')
+  ) AS routing_execution_path,
+  COALESCE(
+    usage_routing_snapshots.local_execution_runtime_miss_reason,
+    NULLIF(BTRIM("usage".request_metadata->>'local_execution_runtime_miss_reason'), '')
+  ) AS routing_local_execution_runtime_miss_reason,
+  usage_settlement_snapshots.billing_snapshot_schema_version AS settlement_billing_snapshot_schema_version,
+  usage_settlement_snapshots.billing_snapshot_status AS settlement_billing_snapshot_status,
+  CAST(usage_settlement_snapshots.rate_multiplier AS DOUBLE PRECISION) AS settlement_rate_multiplier,
+  usage_settlement_snapshots.is_free_tier AS settlement_is_free_tier,
+  CAST(usage_settlement_snapshots.input_price_per_1m AS DOUBLE PRECISION) AS settlement_input_price_per_1m,
+  CAST(usage_settlement_snapshots.output_price_per_1m AS DOUBLE PRECISION) AS settlement_output_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_creation_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_creation_price_per_1m,
+  CAST(usage_settlement_snapshots.cache_read_price_per_1m AS DOUBLE PRECISION) AS settlement_cache_read_price_per_1m,
+  CAST(usage_settlement_snapshots.price_per_request AS DOUBLE PRECISION) AS settlement_price_per_request,
+  usage_settlement_snapshots.settlement_snapshot_schema_version AS settlement_snapshot_schema_version,
+  usage_settlement_snapshots.settlement_snapshot AS settlement_snapshot,
+  usage_settlement_snapshots.billing_dimensions AS settlement_billing_dimensions,
+  usage_settlement_snapshots.billing_input_tokens AS settlement_billing_input_tokens,
+  usage_settlement_snapshots.billing_effective_input_tokens AS settlement_billing_effective_input_tokens,
+  usage_settlement_snapshots.billing_output_tokens AS settlement_billing_output_tokens,
+  usage_settlement_snapshots.billing_cache_creation_tokens AS settlement_billing_cache_creation_tokens,
+  usage_settlement_snapshots.billing_cache_creation_5m_tokens AS settlement_billing_cache_creation_5m_tokens,
+  usage_settlement_snapshots.billing_cache_creation_1h_tokens AS settlement_billing_cache_creation_1h_tokens,
+  usage_settlement_snapshots.billing_cache_read_tokens AS settlement_billing_cache_read_tokens,
+  usage_settlement_snapshots.billing_total_input_context AS settlement_billing_total_input_context,
+  CAST(usage_settlement_snapshots.billing_cache_creation_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_creation_cost_usd,
+  CAST(usage_settlement_snapshots.billing_cache_read_cost_usd AS DOUBLE PRECISION) AS settlement_billing_cache_read_cost_usd,
+  CAST(usage_settlement_snapshots.billing_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_total_cost_usd,
+  CAST(usage_settlement_snapshots.billing_actual_total_cost_usd AS DOUBLE PRECISION) AS settlement_billing_actual_total_cost_usd,
+  usage_settlement_snapshots.billing_pricing_source AS settlement_billing_pricing_source,
+  usage_settlement_snapshots.billing_rule_id AS settlement_billing_rule_id,
+  usage_settlement_snapshots.billing_rule_version AS settlement_billing_rule_version,
+  CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT) AS created_at_unix_ms,
+  GREATEST(
+    COALESCE(NULLIF("usage".updated_at_unix_secs, 0), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM usage_settlement_snapshots.finalized_at) AS BIGINT), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM "usage".finalized_at) AS BIGINT), 0),
+    CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT)
+  ) AS updated_at_unix_secs,
+  CAST(
+    EXTRACT(
+      EPOCH FROM COALESCE(usage_settlement_snapshots.finalized_at, "usage".finalized_at)
+    ) AS BIGINT
+  ) AS finalized_at_unix_secs
+FROM "usage"
+LEFT JOIN usage_routing_snapshots
+  ON usage_routing_snapshots.request_id = "usage".request_id
+LEFT JOIN usage_settlement_snapshots
+  ON usage_settlement_snapshots.request_id = "usage".request_id

crates/aether-data/adapters/postgres/src/usage/queries/lock_usage_request_id_sql.sql

@@ -0,0 +1 @@
+SELECT pg_advisory_xact_lock(hashtext($1)::BIGINT)

crates/aether-data/adapters/postgres/src/usage/queries/rebuild_api_key_usage_stats_sql.sql

@@ -0,0 +1,29 @@
+WITH aggregated AS (
+  SELECT
+    api_key_id,
+    COUNT(*)::BIGINT AS total_requests,
+    COALESCE(SUM(
+      GREATEST(
+        COALESCE(
+          total_tokens,
+          COALESCE(input_tokens, 0) + COALESCE(output_tokens, 0)
+        ),
+        0
+      )::BIGINT
+    ), 0)::BIGINT AS total_tokens,
+    COALESCE(SUM(COALESCE(total_cost_usd, 0)), 0)::NUMERIC(20,8) AS total_cost_usd,
+    MAX(created_at) AS last_used_at
+  FROM usage_billing_facts AS "usage"
+  WHERE api_key_id IS NOT NULL
+    AND BTRIM(api_key_id) <> ''
+    AND status NOT IN ('pending', 'streaming')
+  GROUP BY api_key_id
+)
+UPDATE api_keys
+SET
+  total_requests = aggregated.total_requests,
+  total_tokens = aggregated.total_tokens,
+  total_cost_usd = aggregated.total_cost_usd,
+  last_used_at = aggregated.last_used_at
+FROM aggregated
+WHERE api_keys.id = aggregated.api_key_id

crates/aether-data/adapters/postgres/src/usage/queries/rebuild_provider_api_key_codex_window_usage_stats_sql.sql

@@ -0,0 +1,168 @@
+WITH target_keys AS (
+  SELECT
+    id,
+    COALESCE(status_snapshot::jsonb, '{}'::jsonb) AS snapshot
+  FROM provider_api_keys
+  WHERE jsonb_typeof((status_snapshot::jsonb) -> 'quota' -> 'windows') = 'array'
+    AND lower(BTRIM(COALESCE((status_snapshot::jsonb) -> 'quota' ->> 'provider_type', ''))) = 'codex'
+),
+window_items AS (
+  SELECT
+    target_keys.id,
+    window_rows.window_item,
+    window_rows.window_ordinality
+  FROM target_keys
+  CROSS JOIN LATERAL jsonb_array_elements(target_keys.snapshot -> 'quota' -> 'windows')
+    WITH ORDINALITY AS window_rows(window_item, window_ordinality)
+),
+parsed_windows AS (
+  SELECT
+    window_items.id,
+    window_items.window_item,
+    window_items.window_ordinality,
+    lower(BTRIM(COALESCE(window_items.window_item ->> 'code', ''))) AS window_code,
+    CASE
+      WHEN text_values.reset_at_text ~ '^[0-9]+$'
+           AND (
+             length(text_values.reset_at_text) < 19
+             OR (
+               length(text_values.reset_at_text) = 19
+               AND text_values.reset_at_text <= '9223372036854775807'
+             )
+           )
+      THEN text_values.reset_at_text::BIGINT
+      ELSE NULL
+    END AS reset_at,
+    CASE
+      WHEN text_values.window_minutes_text ~ '^[0-9]+$'
+           AND (
+             length(text_values.window_minutes_text) < 19
+             OR (
+               length(text_values.window_minutes_text) = 19
+               AND text_values.window_minutes_text <= '9223372036854775807'
+             )
+           )
+      THEN text_values.window_minutes_text::BIGINT
+      ELSE CASE lower(BTRIM(COALESCE(window_items.window_item ->> 'code', '')))
+        WHEN '5h' THEN 300
+        WHEN 'weekly' THEN 10080
+        ELSE NULL
+      END
+    END AS window_minutes,
+    CASE
+      WHEN text_values.usage_reset_at_text ~ '^[0-9]+$'
+           AND (
+             length(text_values.usage_reset_at_text) < 19
+             OR (
+               length(text_values.usage_reset_at_text) = 19
+               AND text_values.usage_reset_at_text <= '9223372036854775807'
+             )
+           )
+      THEN text_values.usage_reset_at_text::BIGINT
+      ELSE NULL
+    END AS usage_reset_at
+  FROM window_items
+  CROSS JOIN LATERAL (
+    SELECT
+      BTRIM(COALESCE(window_items.window_item ->> 'reset_at', '')) AS reset_at_text,
+      BTRIM(COALESCE(window_items.window_item ->> 'window_minutes', '')) AS window_minutes_text,
+      BTRIM(COALESCE(window_items.window_item ->> 'usage_reset_at', '')) AS usage_reset_at_text
+  ) AS text_values
+),
+window_usage AS (
+  SELECT
+    parsed_windows.*,
+    CASE
+      WHEN parsed_windows.window_minutes BETWEEN 0 AND 153722867280912930
+      THEN parsed_windows.window_minutes * 60
+      ELSE NULL
+    END AS window_seconds
+  FROM parsed_windows
+),
+window_bounds AS (
+  SELECT
+    window_usage.*,
+    CASE
+      WHEN window_usage.window_code IN ('5h', 'weekly')
+           AND window_usage.reset_at IS NOT NULL
+           AND window_usage.window_seconds IS NOT NULL
+           AND window_usage.reset_at >= window_usage.window_seconds
+      THEN GREATEST(
+        window_usage.reset_at - window_usage.window_seconds,
+        COALESCE(window_usage.usage_reset_at, 0)
+      )
+      ELSE NULL
+    END AS window_start,
+    CASE
+      WHEN window_usage.window_code IN ('5h', 'weekly')
+           AND window_usage.reset_at IS NOT NULL
+           AND window_usage.window_seconds IS NOT NULL
+           AND window_usage.reset_at >= window_usage.window_seconds
+      THEN window_usage.reset_at
+      ELSE NULL
+    END AS window_end
+  FROM window_usage
+),
+aggregated AS (
+  SELECT
+    window_bounds.id,
+    window_bounds.window_ordinality,
+    COUNT("usage".id)::BIGINT AS request_count,
+    COALESCE(SUM(GREATEST(COALESCE("usage".total_tokens, 0), 0)::BIGINT), 0)::BIGINT AS total_tokens,
+    CAST(COALESCE(SUM(COALESCE("usage".total_cost_usd, 0)), 0) AS DOUBLE PRECISION) AS total_cost_usd
+  FROM window_bounds
+  LEFT JOIN usage_billing_facts AS "usage"
+    ON window_bounds.window_start IS NOT NULL
+   AND window_bounds.window_end IS NOT NULL
+   AND "usage".provider_api_key_id = window_bounds.id
+   AND "usage".created_at >= to_timestamp(window_bounds.window_start::DOUBLE PRECISION)
+   AND "usage".created_at < to_timestamp(window_bounds.window_end::DOUBLE PRECISION)
+  GROUP BY
+    window_bounds.id,
+    window_bounds.window_ordinality
+),
+updated_windows AS (
+  SELECT
+    window_bounds.id,
+    jsonb_agg(
+      CASE
+        WHEN window_bounds.window_start IS NOT NULL
+             AND window_bounds.window_end IS NOT NULL
+        THEN jsonb_set(
+          window_bounds.window_item,
+          '{usage}',
+          jsonb_build_object(
+            'request_count',
+            COALESCE(aggregated.request_count, 0),
+            'total_tokens',
+            COALESCE(aggregated.total_tokens, 0),
+            'total_cost_usd',
+            to_char(
+              GREATEST(COALESCE(aggregated.total_cost_usd, 0), 0),
+              'FM999999999999999990.00000000'
+            )
+          ),
+          true
+        )
+        ELSE window_bounds.window_item
+      END
+      ORDER BY window_bounds.window_ordinality
+    ) AS windows
+  FROM window_bounds
+  LEFT JOIN aggregated
+    ON aggregated.id = window_bounds.id
+   AND aggregated.window_ordinality = window_bounds.window_ordinality
+  GROUP BY window_bounds.id
+)
+UPDATE provider_api_keys AS keys
+SET
+  status_snapshot = jsonb_set(
+    target_keys.snapshot,
+    '{quota,windows}',
+    updated_windows.windows,
+    true
+  )::json,
+  updated_at = NOW()
+FROM target_keys
+JOIN updated_windows ON updated_windows.id = target_keys.id
+WHERE keys.id = target_keys.id

crates/aether-data/adapters/postgres/src/usage/queries/rebuild_provider_api_key_usage_stats_sql.sql

@@ -0,0 +1,70 @@
+WITH aggregated AS (
+  SELECT
+    provider_api_key_id,
+    COUNT(*)::BIGINT AS request_count,
+    COALESCE(SUM(
+      CASE
+        WHEN status IN ('completed', 'success', 'ok', 'billed', 'settled')
+             AND (status_code IS NULL OR status_code < 400)
+             AND NULLIF(BTRIM(error_message), '') IS NULL
+        THEN 1
+        ELSE 0
+      END
+    ), 0)::BIGINT AS success_count,
+    COALESCE(SUM(
+      CASE
+        WHEN status NOT IN ('pending', 'streaming')
+             AND NOT (
+               status IN ('completed', 'success', 'ok', 'billed', 'settled')
+               AND (status_code IS NULL OR status_code < 400)
+               AND NULLIF(BTRIM(error_message), '') IS NULL
+             )
+        THEN 1
+        ELSE 0
+      END
+    ), 0)::BIGINT AS error_count,
+    COALESCE(SUM(
+      CASE
+        WHEN status IN ('pending', 'streaming') THEN 0
+        ELSE GREATEST(
+          COALESCE(
+            total_tokens,
+            COALESCE(input_tokens, 0) + COALESCE(output_tokens, 0)
+          ),
+          0
+        )::BIGINT
+      END
+    ), 0)::BIGINT AS total_tokens,
+    COALESCE(SUM(
+      CASE
+        WHEN status IN ('pending', 'streaming') THEN 0
+        ELSE COALESCE(total_cost_usd, 0)
+      END
+    ), 0)::NUMERIC(20,8) AS total_cost_usd,
+    COALESCE(SUM(
+      CASE
+        WHEN status IN ('completed', 'success', 'ok', 'billed', 'settled')
+             AND (status_code IS NULL OR status_code < 400)
+             AND NULLIF(BTRIM(error_message), '') IS NULL
+             AND response_time_ms IS NOT NULL
+        THEN GREATEST(response_time_ms, 0)
+        ELSE 0
+      END
+    ), 0)::BIGINT AS total_response_time_ms,
+    MAX(created_at) AS last_used_at
+  FROM usage_billing_facts AS "usage"
+  WHERE provider_api_key_id IS NOT NULL
+    AND BTRIM(provider_api_key_id) <> ''
+  GROUP BY provider_api_key_id
+)
+UPDATE provider_api_keys
+SET
+  request_count = aggregated.request_count,
+  success_count = aggregated.success_count,
+  error_count = aggregated.error_count,
+  total_tokens = aggregated.total_tokens,
+  total_cost_usd = aggregated.total_cost_usd,
+  total_response_time_ms = aggregated.total_response_time_ms,
+  last_used_at = aggregated.last_used_at
+FROM aggregated
+WHERE provider_api_keys.id = aggregated.provider_api_key_id

crates/aether-data/adapters/postgres/src/usage/queries/reset_api_key_usage_stats_sql.sql

@@ -0,0 +1,6 @@
+UPDATE api_keys
+SET
+  total_requests = 0,
+  total_tokens = 0,
+  total_cost_usd = 0,
+  last_used_at = NULL

crates/aether-data/adapters/postgres/src/usage/queries/reset_provider_api_key_usage_stats_sql.sql

@@ -0,0 +1,9 @@
+UPDATE provider_api_keys
+SET
+  request_count = 0,
+  success_count = 0,
+  error_count = 0,
+  total_tokens = 0,
+  total_cost_usd = 0,
+  total_response_time_ms = 0,
+  last_used_at = NULL

crates/aether-data/adapters/postgres/src/usage/queries/reset_stale_void_usage_settlement_snapshot_sql.sql

@@ -0,0 +1,7 @@
+UPDATE usage_settlement_snapshots
+SET
+  billing_status = 'pending',
+  finalized_at = NULL,
+  updated_at = NOW()
+WHERE request_id = $1
+  AND billing_status = 'void'

crates/aether-data/adapters/postgres/src/usage/queries/reset_stale_void_usage_sql.sql

@@ -0,0 +1,7 @@
+UPDATE "usage"
+SET
+  billing_status = 'pending',
+  finalized_at = NULL
+WHERE request_id = $1
+  AND billing_status = 'void'
+  AND status IN ('failed', 'cancelled')

crates/aether-data/adapters/postgres/src/usage/queries/summarize_provider_api_key_window_usage_sql.sql

@@ -0,0 +1,36 @@
+WITH requested AS (
+  SELECT
+    request_row.provider_api_key_id,
+    request_row.window_code,
+    request_row.start_unix_secs,
+    request_row.end_unix_secs,
+    request_row.ordinality
+  FROM UNNEST(
+    $1::TEXT[],
+    $2::TEXT[],
+    $3::BIGINT[],
+    $4::BIGINT[]
+  ) WITH ORDINALITY AS request_row(
+    provider_api_key_id,
+    window_code,
+    start_unix_secs,
+    end_unix_secs,
+    ordinality
+  )
+)
+SELECT
+  requested.provider_api_key_id,
+  requested.window_code,
+  COUNT("usage".id)::BIGINT AS request_count,
+  COALESCE(SUM("usage".total_tokens), 0)::BIGINT AS total_tokens,
+  CAST(COALESCE(SUM("usage".total_cost_usd), 0) AS DOUBLE PRECISION) AS total_cost_usd
+FROM requested
+LEFT JOIN usage_billing_facts AS "usage"
+  ON "usage".provider_api_key_id = requested.provider_api_key_id
+ AND "usage".created_at >= to_timestamp(requested.start_unix_secs::DOUBLE PRECISION)
+ AND "usage".created_at < to_timestamp(requested.end_unix_secs::DOUBLE PRECISION)
+GROUP BY
+  requested.provider_api_key_id,
+  requested.window_code,
+  requested.ordinality
+ORDER BY requested.ordinality ASC

crates/aether-data/adapters/postgres/src/usage/queries/summarize_provider_usage_since_sql.sql

@@ -0,0 +1,9 @@
+SELECT
+  COALESCE(SUM(total_requests), 0) AS total_requests,
+  COALESCE(SUM(successful_requests), 0) AS successful_requests,
+  COALESCE(SUM(failed_requests), 0) AS failed_requests,
+  COALESCE(AVG(avg_response_time_ms), 0) AS avg_response_time_ms,
+  COALESCE(SUM(total_cost_usd), 0) AS total_cost_usd
+FROM provider_usage_tracking
+WHERE provider_id = $1
+  AND window_start >= TO_TIMESTAMP($2::double precision)

crates/aether-data/adapters/postgres/src/usage/queries/summarize_total_tokens_by_api_key_ids_sql.sql

@@ -0,0 +1,15 @@
+SELECT
+  api_key_id,
+  COALESCE(
+    SUM(
+      COALESCE(
+        total_tokens,
+        COALESCE(input_tokens, 0) + COALESCE(output_tokens, 0)
+      )
+    ),
+    0
+  ) AS total_tokens
+FROM usage_billing_facts AS "usage"
+WHERE api_key_id = ANY($1::TEXT[])
+GROUP BY api_key_id
+ORDER BY api_key_id ASC

crates/aether-data/adapters/postgres/src/usage/queries/summarize_usage_by_provider_api_key_ids_sql.sql

@@ -0,0 +1,10 @@
+SELECT
+  id AS provider_api_key_id,
+  COALESCE(request_count, 0)::BIGINT AS request_count,
+  COALESCE(total_tokens, 0)::BIGINT AS total_tokens,
+  CAST(COALESCE(total_cost_usd, 0) AS DOUBLE PRECISION) AS total_cost_usd,
+  CAST(EXTRACT(EPOCH FROM last_used_at) AS BIGINT) AS last_used_at_unix_secs
+FROM provider_api_keys
+WHERE id = ANY($1::TEXT[])
+  AND COALESCE(request_count, 0) > 0
+ORDER BY id ASC

crates/aether-data/adapters/postgres/src/usage/queries/summarize_usage_totals_by_user_ids_sql.sql

@@ -0,0 +1,10 @@
+SELECT
+  "usage".user_id,
+  COUNT(*)::BIGINT AS request_count,
+  COALESCE(SUM(GREATEST(COALESCE("usage".total_tokens, 0), 0)), 0)::BIGINT AS total_tokens
+FROM usage_billing_facts AS "usage"
+WHERE "usage".user_id = ANY($1::TEXT[])
+  AND "usage".status NOT IN ('pending', 'streaming')
+  AND "usage".provider_name NOT IN ('unknown', 'pending')
+GROUP BY "usage".user_id
+ORDER BY "usage".user_id ASC

crates/aether-data/adapters/postgres/src/usage/queries/upsert_sql.sql

@@ -0,0 +1,373 @@
+INSERT INTO "usage" (
+  id,
+  request_id,
+  user_id,
+  api_key_id,
+  username,
+  api_key_name,
+  provider_name,
+  model,
+  target_model,
+  provider_id,
+  provider_endpoint_id,
+  provider_api_key_id,
+  request_type,
+  api_format,
+  api_family,
+  endpoint_kind,
+  endpoint_api_format,
+  provider_api_family,
+  provider_endpoint_kind,
+  has_format_conversion,
+  is_stream,
+  upstream_is_stream,
+  input_tokens,
+  output_tokens,
+  total_tokens,
+  input_output_total_tokens,
+  input_context_tokens,
+  cache_creation_input_tokens,
+  cache_creation_input_tokens_5m,
+  cache_creation_input_tokens_1h,
+  cache_read_input_tokens,
+  cache_creation_cost_usd,
+  cache_read_cost_usd,
+  output_price_per_1m,
+  total_cost_usd,
+  actual_total_cost_usd,
+  status_code,
+  error_message,
+  error_category,
+  response_time_ms,
+  first_byte_time_ms,
+  status,
+  billing_status,
+  request_headers,
+  request_body,
+  request_body_compressed,
+  provider_request_headers,
+  provider_request_body,
+  provider_request_body_compressed,
+  response_headers,
+  response_body,
+  response_body_compressed,
+  client_response_headers,
+  client_response_body,
+  client_response_body_compressed,
+  request_metadata,
+  finalized_at,
+  created_at,
+  updated_at_unix_secs
+) VALUES (
+  $1,
+  $2,
+  $3,
+  $4,
+  $5,
+  $6,
+  $7,
+  $8,
+  $9,
+  $10,
+  $11,
+  $12,
+  $13,
+  $14,
+  $15,
+  $16,
+  $17,
+  $18,
+  $19,
+  COALESCE($20, FALSE),
+  COALESCE($21, FALSE),
+  COALESCE(
+    CASE
+      WHEN ($53::json->>'upstream_is_stream') IN ('true', 'false')
+      THEN ($53::json->>'upstream_is_stream')::boolean
+      ELSE NULL
+    END,
+    COALESCE($21, FALSE)
+  ),
+  COALESCE($22, 0),
+  COALESCE($23, 0),
+  COALESCE(
+    $24,
+    COALESCE($22, 0)
+      + COALESCE($23, 0)
+      + COALESCE(
+        NULLIF(COALESCE($25, 0), 0),
+        COALESCE($26, 0) + COALESCE($27, 0),
+        0
+      )
+      + COALESCE($28, 0)
+  ),
+  COALESCE($22, 0) + COALESCE($23, 0),
+  COALESCE(
+    COALESCE($22, 0)
+      + COALESCE(
+        NULLIF(COALESCE($25, 0), 0),
+        COALESCE($26, 0) + COALESCE($27, 0),
+        0
+      )
+      + COALESCE($28, 0),
+    0
+  ),
+  COALESCE($25, 0),
+  COALESCE($26, 0),
+  COALESCE($27, 0),
+  COALESCE($28, 0),
+  COALESCE($29, 0),
+  $30,
+  COALESCE($31, 0),
+  COALESCE($32, 0),
+  $33,
+  $34,
+  $35,
+  $36,
+  $37,
+  $38,
+  $39,
+  $40,
+  $41::json,
+  $42::json,
+  $43,
+  $44::json,
+  $45::json,
+  $46,
+  $47::json,
+  $48::json,
+  $49,
+  $50::json,
+  $51::json,
+  $52,
+  $53::json,
+  CASE
+    WHEN $54 IS NULL THEN NULL
+    ELSE TO_TIMESTAMP($54::double precision)
+  END,
+  COALESCE(TO_TIMESTAMP($55::double precision), NOW()),
+  COALESCE(
+    NULLIF($56::bigint, 0),
+    CAST(EXTRACT(EPOCH FROM COALESCE(TO_TIMESTAMP($55::double precision), NOW())) AS BIGINT)
+  )
+)
+ON CONFLICT (request_id)
+DO UPDATE SET
+  user_id = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.user_id, "usage".user_id) ELSE "usage".user_id END,
+  api_key_id = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.api_key_id, "usage".api_key_id) ELSE "usage".api_key_id END,
+  username = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.username, "usage".username) ELSE "usage".username END,
+  api_key_name = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.api_key_name, "usage".api_key_name) ELSE "usage".api_key_name END,
+  provider_name = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.provider_name, "usage".provider_name) ELSE "usage".provider_name END,
+  model = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.model, "usage".model) ELSE "usage".model END,
+  target_model = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.target_model, "usage".target_model) ELSE "usage".target_model END,
+  provider_id = CASE WHEN "usage".billing_status = 'pending' OR ("usage".provider_id IS NULL AND ("usage".provider_endpoint_id IS NULL OR "usage".provider_endpoint_id = EXCLUDED.provider_endpoint_id) AND ("usage".provider_api_key_id IS NULL OR "usage".provider_api_key_id = EXCLUDED.provider_api_key_id)) THEN COALESCE(EXCLUDED.provider_id, "usage".provider_id) ELSE "usage".provider_id END,
+  provider_endpoint_id = CASE WHEN "usage".billing_status = 'pending' OR ("usage".provider_endpoint_id IS NULL AND ("usage".provider_id IS NULL OR "usage".provider_id = EXCLUDED.provider_id) AND ("usage".provider_api_key_id IS NULL OR "usage".provider_api_key_id = EXCLUDED.provider_api_key_id)) THEN COALESCE(EXCLUDED.provider_endpoint_id, "usage".provider_endpoint_id) ELSE "usage".provider_endpoint_id END,
+  provider_api_key_id = CASE WHEN "usage".billing_status = 'pending' OR ("usage".provider_api_key_id IS NULL AND ("usage".provider_id IS NULL OR "usage".provider_id = EXCLUDED.provider_id) AND ("usage".provider_endpoint_id IS NULL OR "usage".provider_endpoint_id = EXCLUDED.provider_endpoint_id)) THEN COALESCE(EXCLUDED.provider_api_key_id, "usage".provider_api_key_id) ELSE "usage".provider_api_key_id END,
+  request_type = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.request_type, "usage".request_type) ELSE "usage".request_type END,
+  api_format = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.api_format, "usage".api_format) ELSE "usage".api_format END,
+  api_family = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.api_family, "usage".api_family) ELSE "usage".api_family END,
+  endpoint_kind = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.endpoint_kind, "usage".endpoint_kind) ELSE "usage".endpoint_kind END,
+  endpoint_api_format = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.endpoint_api_format, "usage".endpoint_api_format) ELSE "usage".endpoint_api_format END,
+  provider_api_family = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.provider_api_family, "usage".provider_api_family) ELSE "usage".provider_api_family END,
+  provider_endpoint_kind = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.provider_endpoint_kind, "usage".provider_endpoint_kind) ELSE "usage".provider_endpoint_kind END,
+  has_format_conversion = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.has_format_conversion, "usage".has_format_conversion) ELSE "usage".has_format_conversion END,
+  is_stream = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.is_stream, "usage".is_stream) ELSE "usage".is_stream END,
+  upstream_is_stream = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.upstream_is_stream, "usage".upstream_is_stream, "usage".is_stream, false) ELSE "usage".upstream_is_stream END,
+  input_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".input_tokens, EXCLUDED.input_tokens) ELSE "usage".input_tokens END,
+  output_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".output_tokens, EXCLUDED.output_tokens) ELSE "usage".output_tokens END,
+  total_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".total_tokens, EXCLUDED.total_tokens) ELSE "usage".total_tokens END,
+  input_output_total_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".input_output_total_tokens, EXCLUDED.input_output_total_tokens) ELSE "usage".input_output_total_tokens END,
+  input_context_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".input_context_tokens, EXCLUDED.input_context_tokens) ELSE "usage".input_context_tokens END,
+  cache_creation_input_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_creation_input_tokens, EXCLUDED.cache_creation_input_tokens) ELSE "usage".cache_creation_input_tokens END,
+  cache_creation_input_tokens_5m = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_creation_input_tokens_5m, EXCLUDED.cache_creation_input_tokens_5m) ELSE "usage".cache_creation_input_tokens_5m END,
+  cache_creation_input_tokens_1h = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_creation_input_tokens_1h, EXCLUDED.cache_creation_input_tokens_1h) ELSE "usage".cache_creation_input_tokens_1h END,
+  cache_read_input_tokens = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_read_input_tokens, EXCLUDED.cache_read_input_tokens) ELSE "usage".cache_read_input_tokens END,
+  cache_creation_cost_usd = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_creation_cost_usd, EXCLUDED.cache_creation_cost_usd) ELSE "usage".cache_creation_cost_usd END,
+  cache_read_cost_usd = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".cache_read_cost_usd, EXCLUDED.cache_read_cost_usd) ELSE "usage".cache_read_cost_usd END,
+  output_price_per_1m = NULL,
+  total_cost_usd = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".total_cost_usd, EXCLUDED.total_cost_usd) ELSE "usage".total_cost_usd END,
+  actual_total_cost_usd = CASE WHEN "usage".billing_status = 'pending' AND EXCLUDED.status IN ('completed', 'failed', 'cancelled') THEN GREATEST("usage".actual_total_cost_usd, EXCLUDED.actual_total_cost_usd) ELSE "usage".actual_total_cost_usd END,
+  status_code = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".status_code
+    WHEN "usage".status = 'streaming' AND EXCLUDED.status = 'pending' THEN "usage".status_code
+    WHEN "usage".status = 'streaming' AND EXCLUDED.status = 'streaming' AND EXCLUDED.status_code IS NULL THEN "usage".status_code
+    WHEN EXCLUDED.status IN ('pending', 'streaming', 'completed', 'cancelled') AND EXCLUDED.status_code IS NULL THEN NULL
+    ELSE COALESCE(EXCLUDED.status_code, "usage".status_code)
+  END ELSE "usage".status_code END,
+  error_message = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".error_message
+    WHEN "usage".status = 'streaming' AND EXCLUDED.status = 'pending' THEN "usage".error_message
+    WHEN EXCLUDED.status IN ('pending', 'streaming', 'completed', 'cancelled') THEN EXCLUDED.error_message
+    ELSE COALESCE(EXCLUDED.error_message, "usage".error_message)
+  END ELSE "usage".error_message END,
+  error_category = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".error_category
+    WHEN "usage".status = 'streaming' AND EXCLUDED.status = 'pending' THEN "usage".error_category
+    WHEN EXCLUDED.status IN ('pending', 'streaming', 'completed', 'cancelled') THEN EXCLUDED.error_category
+    ELSE COALESCE(EXCLUDED.error_category, "usage".error_category)
+  END ELSE "usage".error_category END,
+  response_time_ms = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".response_time_ms
+    WHEN EXCLUDED.response_time_ms IS NULL OR EXCLUDED.response_time_ms = 0 THEN COALESCE("usage".response_time_ms, EXCLUDED.response_time_ms)
+    ELSE EXCLUDED.response_time_ms
+  END ELSE "usage".response_time_ms END,
+  first_byte_time_ms = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".first_byte_time_ms
+    WHEN EXCLUDED.first_byte_time_ms IS NULL OR EXCLUDED.first_byte_time_ms = 0 THEN COALESCE("usage".first_byte_time_ms, EXCLUDED.first_byte_time_ms)
+    ELSE EXCLUDED.first_byte_time_ms
+  END ELSE "usage".first_byte_time_ms END,
+  status = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN "usage".status IN ('completed', 'failed', 'cancelled') AND EXCLUDED.status IN ('pending', 'streaming') THEN "usage".status
+    WHEN "usage".status = 'streaming' AND EXCLUDED.status = 'pending' THEN "usage".status
+    ELSE EXCLUDED.status
+  END ELSE "usage".status END,
+  billing_status = CASE WHEN "usage".billing_status = 'pending' THEN EXCLUDED.billing_status ELSE "usage".billing_status END,
+  request_headers = NULL,
+  request_body = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.request_body_compressed IS NOT NULL OR $57 THEN NULL
+    ELSE COALESCE(EXCLUDED.request_body, "usage".request_body)
+  END ELSE "usage".request_body END,
+  request_body_compressed = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.request_body IS NOT NULL OR $57 THEN NULL
+    ELSE COALESCE(EXCLUDED.request_body_compressed, "usage".request_body_compressed)
+  END ELSE "usage".request_body_compressed END,
+  provider_request_headers = NULL,
+  provider_request_body = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.provider_request_body_compressed IS NOT NULL OR $58 THEN NULL
+    ELSE COALESCE(EXCLUDED.provider_request_body, "usage".provider_request_body)
+  END ELSE "usage".provider_request_body END,
+  provider_request_body_compressed = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.provider_request_body IS NOT NULL OR $58 THEN NULL
+    ELSE COALESCE(EXCLUDED.provider_request_body_compressed, "usage".provider_request_body_compressed)
+  END ELSE "usage".provider_request_body_compressed END,
+  response_headers = NULL,
+  response_body = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.response_body_compressed IS NOT NULL OR $59 THEN NULL
+    ELSE COALESCE(EXCLUDED.response_body, "usage".response_body)
+  END ELSE "usage".response_body END,
+  response_body_compressed = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.response_body IS NOT NULL OR $59 THEN NULL
+    ELSE COALESCE(EXCLUDED.response_body_compressed, "usage".response_body_compressed)
+  END ELSE "usage".response_body_compressed END,
+  client_response_headers = NULL,
+  client_response_body = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.client_response_body_compressed IS NOT NULL OR $60 THEN NULL
+    ELSE COALESCE(EXCLUDED.client_response_body, "usage".client_response_body)
+  END ELSE "usage".client_response_body END,
+  client_response_body_compressed = CASE WHEN "usage".billing_status = 'pending' THEN CASE
+    WHEN EXCLUDED.client_response_body IS NOT NULL OR $60 THEN NULL
+    ELSE COALESCE(EXCLUDED.client_response_body_compressed, "usage".client_response_body_compressed)
+  END ELSE "usage".client_response_body_compressed END,
+  request_metadata = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.request_metadata, "usage".request_metadata) ELSE "usage".request_metadata END,
+  finalized_at = CASE WHEN "usage".billing_status = 'pending' THEN COALESCE(EXCLUDED.finalized_at, "usage".finalized_at) ELSE "usage".finalized_at END,
+  updated_at_unix_secs = CASE WHEN "usage".billing_status = 'pending' THEN
+    GREATEST(
+      COALESCE(NULLIF("usage".updated_at_unix_secs, 0), 0),
+      COALESCE(NULLIF(EXCLUDED.updated_at_unix_secs, 0), 0),
+      CAST(EXTRACT(EPOCH FROM "usage".created_at) AS BIGINT)
+    )
+  ELSE "usage".updated_at_unix_secs END
+RETURNING
+  id,
+  request_id,
+  user_id,
+  api_key_id,
+  username,
+  api_key_name,
+  provider_name,
+  model,
+  target_model,
+  provider_id,
+  provider_endpoint_id,
+  provider_api_key_id,
+  request_type,
+  api_format,
+  api_family,
+  endpoint_kind,
+  endpoint_api_format,
+  provider_api_family,
+  provider_endpoint_kind,
+  COALESCE(has_format_conversion, FALSE) AS has_format_conversion,
+  COALESCE(is_stream, FALSE) AS is_stream,
+  input_tokens,
+  output_tokens,
+  total_tokens,
+  COALESCE(cache_creation_input_tokens, 0) AS cache_creation_input_tokens,
+  COALESCE(cache_creation_input_tokens_5m, 0) AS cache_creation_ephemeral_5m_input_tokens,
+  COALESCE(cache_creation_input_tokens_1h, 0) AS cache_creation_ephemeral_1h_input_tokens,
+  COALESCE(cache_read_input_tokens, 0) AS cache_read_input_tokens,
+  COALESCE(CAST(cache_creation_cost_usd AS DOUBLE PRECISION), 0) AS cache_creation_cost_usd,
+  COALESCE(CAST(cache_read_cost_usd AS DOUBLE PRECISION), 0) AS cache_read_cost_usd,
+  CAST(output_price_per_1m AS DOUBLE PRECISION) AS output_price_per_1m,
+  COALESCE(CAST(total_cost_usd AS DOUBLE PRECISION), 0) AS total_cost_usd,
+  COALESCE(CAST(actual_total_cost_usd AS DOUBLE PRECISION), 0) AS actual_total_cost_usd,
+  status_code,
+  error_message,
+  error_category,
+  response_time_ms,
+  first_byte_time_ms,
+  status,
+  billing_status,
+  request_headers,
+  request_body,
+  request_body_compressed,
+  provider_request_headers,
+  provider_request_body,
+  provider_request_body_compressed,
+  response_headers,
+  response_body,
+  response_body_compressed,
+  client_response_headers,
+  client_response_body,
+  client_response_body_compressed,
+  request_metadata,
+  NULL::varchar AS http_request_body_ref,
+  NULL::varchar AS http_provider_request_body_ref,
+  NULL::varchar AS http_response_body_ref,
+  NULL::varchar AS http_client_response_body_ref,
+  NULL::varchar AS http_request_body_state,
+  NULL::varchar AS http_provider_request_body_state,
+  NULL::varchar AS http_response_body_state,
+  NULL::varchar AS http_client_response_body_state,
+  NULL::varchar AS routing_candidate_id,
+  NULL::integer AS routing_candidate_index,
+  NULL::varchar AS routing_key_name,
+  NULL::varchar AS routing_planner_kind,
+  NULL::varchar AS routing_route_family,
+  NULL::varchar AS routing_route_kind,
+  NULL::varchar AS routing_execution_path,
+  NULL::varchar AS routing_local_execution_runtime_miss_reason,
+  NULL::varchar AS settlement_billing_snapshot_schema_version,
+  NULL::varchar AS settlement_billing_snapshot_status,
+  NULL::double precision AS settlement_rate_multiplier,
+  NULL::boolean AS settlement_is_free_tier,
+  NULL::double precision AS settlement_input_price_per_1m,
+  NULL::double precision AS settlement_output_price_per_1m,
+  NULL::double precision AS settlement_cache_creation_price_per_1m,
+  NULL::double precision AS settlement_cache_read_price_per_1m,
+  NULL::double precision AS settlement_price_per_request,
+  NULL::varchar AS settlement_snapshot_schema_version,
+  NULL::jsonb AS settlement_snapshot,
+  NULL::jsonb AS settlement_billing_dimensions,
+  NULL::bigint AS settlement_billing_input_tokens,
+  NULL::bigint AS settlement_billing_effective_input_tokens,
+  NULL::bigint AS settlement_billing_output_tokens,
+  NULL::bigint AS settlement_billing_cache_creation_tokens,
+  NULL::bigint AS settlement_billing_cache_creation_5m_tokens,
+  NULL::bigint AS settlement_billing_cache_creation_1h_tokens,
+  NULL::bigint AS settlement_billing_cache_read_tokens,
+  NULL::bigint AS settlement_billing_total_input_context,
+  NULL::double precision AS settlement_billing_cache_creation_cost_usd,
+  NULL::double precision AS settlement_billing_cache_read_cost_usd,
+  NULL::double precision AS settlement_billing_total_cost_usd,
+  NULL::double precision AS settlement_billing_actual_total_cost_usd,
+  NULL::varchar AS settlement_billing_pricing_source,
+  NULL::varchar AS settlement_billing_rule_id,
+  NULL::varchar AS settlement_billing_rule_version,
+  CAST(EXTRACT(EPOCH FROM created_at) AS BIGINT) AS created_at_unix_ms,
+  GREATEST(
+    COALESCE(NULLIF(updated_at_unix_secs, 0), 0),
+    COALESCE(CAST(EXTRACT(EPOCH FROM finalized_at) AS BIGINT), 0),
+    CAST(EXTRACT(EPOCH FROM created_at) AS BIGINT)
+  ) AS updated_at_unix_secs,
+  CAST(EXTRACT(EPOCH FROM finalized_at) AS BIGINT) AS finalized_at_unix_secs

crates/aether-data/adapters/postgres/src/usage/queries/upsert_usage_body_blob_sql.sql

@@ -0,0 +1,15 @@
+INSERT INTO usage_body_blobs (
+  body_ref,
+  request_id,
+  body_field,
+  payload_gzip
+) VALUES (
+  $1,
+  $2,
+  $3,
+  $4
+)
+ON CONFLICT (body_ref)
+DO UPDATE SET
+  payload_gzip = EXCLUDED.payload_gzip,
+  updated_at = NOW()

crates/aether-data/adapters/postgres/src/usage/queries/upsert_usage_http_audit_sql.sql

@@ -0,0 +1,75 @@
+INSERT INTO usage_http_audits (
+  request_id,
+  request_headers,
+  provider_request_headers,
+  response_headers,
+  client_response_headers,
+  request_body_ref,
+  provider_request_body_ref,
+  response_body_ref,
+  client_response_body_ref,
+  request_body_state,
+  provider_request_body_state,
+  response_body_state,
+  client_response_body_state,
+  body_capture_mode
+) VALUES (
+  $1,
+  $2::json,
+  $3::json,
+  $4::json,
+  $5::json,
+  $6,
+  $7,
+  $8,
+  $9,
+  $10,
+  $11,
+  $12,
+  $13,
+  $14
+)
+ON CONFLICT (request_id)
+DO UPDATE SET
+  request_headers = COALESCE(EXCLUDED.request_headers, usage_http_audits.request_headers),
+  provider_request_headers = COALESCE(
+    EXCLUDED.provider_request_headers,
+    usage_http_audits.provider_request_headers
+  ),
+  response_headers = COALESCE(EXCLUDED.response_headers, usage_http_audits.response_headers),
+  client_response_headers = COALESCE(
+    EXCLUDED.client_response_headers,
+    usage_http_audits.client_response_headers
+  ),
+  request_body_ref = COALESCE(EXCLUDED.request_body_ref, usage_http_audits.request_body_ref),
+  provider_request_body_ref = COALESCE(
+    EXCLUDED.provider_request_body_ref,
+    usage_http_audits.provider_request_body_ref
+  ),
+  response_body_ref = COALESCE(EXCLUDED.response_body_ref, usage_http_audits.response_body_ref),
+  client_response_body_ref = COALESCE(
+    EXCLUDED.client_response_body_ref,
+    usage_http_audits.client_response_body_ref
+  ),
+  request_body_state = COALESCE(
+    EXCLUDED.request_body_state,
+    usage_http_audits.request_body_state
+  ),
+  provider_request_body_state = COALESCE(
+    EXCLUDED.provider_request_body_state,
+    usage_http_audits.provider_request_body_state
+  ),
+  response_body_state = COALESCE(
+    EXCLUDED.response_body_state,
+    usage_http_audits.response_body_state
+  ),
+  client_response_body_state = COALESCE(
+    EXCLUDED.client_response_body_state,
+    usage_http_audits.client_response_body_state
+  ),
+  body_capture_mode = COALESCE(
+    NULLIF(EXCLUDED.body_capture_mode, 'none'),
+    usage_http_audits.body_capture_mode,
+    'none'
+  ),
+  updated_at = NOW()

crates/aether-data/adapters/postgres/src/usage/queries/upsert_usage_routing_snapshot_sql.sql

@@ -0,0 +1,62 @@
+INSERT INTO usage_routing_snapshots (
+  request_id,
+  candidate_id,
+  candidate_index,
+  key_name,
+  planner_kind,
+  route_family,
+  route_kind,
+  execution_path,
+  local_execution_runtime_miss_reason,
+  selected_provider_id,
+  selected_endpoint_id,
+  selected_provider_api_key_id,
+  has_format_conversion
+) VALUES (
+  $1,
+  $2,
+  $3,
+  $4,
+  $5,
+  $6,
+  $7,
+  $8,
+  $9,
+  $10,
+  $11,
+  $12,
+  $13
+)
+ON CONFLICT (request_id)
+DO UPDATE SET
+  candidate_id = COALESCE(EXCLUDED.candidate_id, usage_routing_snapshots.candidate_id),
+  candidate_index = COALESCE(
+    EXCLUDED.candidate_index,
+    usage_routing_snapshots.candidate_index
+  ),
+  key_name = COALESCE(EXCLUDED.key_name, usage_routing_snapshots.key_name),
+  planner_kind = COALESCE(EXCLUDED.planner_kind, usage_routing_snapshots.planner_kind),
+  route_family = COALESCE(EXCLUDED.route_family, usage_routing_snapshots.route_family),
+  route_kind = COALESCE(EXCLUDED.route_kind, usage_routing_snapshots.route_kind),
+  execution_path = COALESCE(EXCLUDED.execution_path, usage_routing_snapshots.execution_path),
+  local_execution_runtime_miss_reason = COALESCE(
+    EXCLUDED.local_execution_runtime_miss_reason,
+    usage_routing_snapshots.local_execution_runtime_miss_reason
+  ),
+  selected_provider_id = COALESCE(
+    EXCLUDED.selected_provider_id,
+    usage_routing_snapshots.selected_provider_id
+  ),
+  selected_endpoint_id = COALESCE(
+    EXCLUDED.selected_endpoint_id,
+    usage_routing_snapshots.selected_endpoint_id
+  ),
+  selected_provider_api_key_id = COALESCE(
+    EXCLUDED.selected_provider_api_key_id,
+    usage_routing_snapshots.selected_provider_api_key_id
+  ),
+  has_format_conversion = COALESCE(
+    EXCLUDED.has_format_conversion,
+    usage_routing_snapshots.has_format_conversion
+  ),
+  updated_at = NOW()

crates/aether-data/adapters/postgres/src/usage/queries/upsert_usage_settlement_pricing_snapshot_sql.sql

@@ -0,0 +1,172 @@
+INSERT INTO usage_settlement_snapshots (
+  request_id,
+  billing_status,
+  billing_snapshot_schema_version,
+  billing_snapshot_status,
+  settlement_snapshot_schema_version,
+  settlement_snapshot,
+  billing_dimensions,
+  billing_input_tokens,
+  billing_effective_input_tokens,
+  billing_output_tokens,
+  billing_cache_creation_tokens,
+  billing_cache_creation_5m_tokens,
+  billing_cache_creation_1h_tokens,
+  billing_cache_read_tokens,
+  billing_total_input_context,
+  billing_cache_creation_cost_usd,
+  billing_cache_read_cost_usd,
+  billing_total_cost_usd,
+  billing_actual_total_cost_usd,
+  billing_pricing_source,
+  billing_rule_id,
+  billing_rule_version,
+  rate_multiplier,
+  is_free_tier,
+  input_price_per_1m,
+  output_price_per_1m,
+  cache_creation_price_per_1m,
+  cache_read_price_per_1m,
+  price_per_request
+) VALUES (
+  $1,
+  $2,
+  $3,
+  $4,
+  $5,
+  $6,
+  $7,
+  $8,
+  $9,
+  $10,
+  $11,
+  $12,
+  $13,
+  $14,
+  $15,
+  $16,
+  $17,
+  $18,
+  $19,
+  $20,
+  $21,
+  $22,
+  $23,
+  $24,
+  $25,
+  $26,
+  $27,
+  $28,
+  $29
+)
+ON CONFLICT (request_id)
+DO UPDATE SET
+  billing_snapshot_schema_version = COALESCE(
+    EXCLUDED.billing_snapshot_schema_version,
+    usage_settlement_snapshots.billing_snapshot_schema_version
+  ),
+  billing_snapshot_status = COALESCE(
+    EXCLUDED.billing_snapshot_status,
+    usage_settlement_snapshots.billing_snapshot_status
+  ),
+  settlement_snapshot_schema_version = COALESCE(
+    EXCLUDED.settlement_snapshot_schema_version,
+    usage_settlement_snapshots.settlement_snapshot_schema_version
+  ),
+  settlement_snapshot = COALESCE(
+    EXCLUDED.settlement_snapshot,
+    usage_settlement_snapshots.settlement_snapshot
+  ),
+  billing_dimensions = COALESCE(
+    EXCLUDED.billing_dimensions,
+    usage_settlement_snapshots.billing_dimensions
+  ),
+  billing_input_tokens = COALESCE(
+    EXCLUDED.billing_input_tokens,
+    usage_settlement_snapshots.billing_input_tokens
+  ),
+  billing_effective_input_tokens = COALESCE(
+    EXCLUDED.billing_effective_input_tokens,
+    usage_settlement_snapshots.billing_effective_input_tokens
+  ),
+  billing_output_tokens = COALESCE(
+    EXCLUDED.billing_output_tokens,
+    usage_settlement_snapshots.billing_output_tokens
+  ),
+  billing_cache_creation_tokens = COALESCE(
+    EXCLUDED.billing_cache_creation_tokens,
+    usage_settlement_snapshots.billing_cache_creation_tokens
+  ),
+  billing_cache_creation_5m_tokens = COALESCE(
+    EXCLUDED.billing_cache_creation_5m_tokens,
+    usage_settlement_snapshots.billing_cache_creation_5m_tokens
+  ),
+  billing_cache_creation_1h_tokens = COALESCE(
+    EXCLUDED.billing_cache_creation_1h_tokens,
+    usage_settlement_snapshots.billing_cache_creation_1h_tokens
+  ),
+  billing_cache_read_tokens = COALESCE(
+    EXCLUDED.billing_cache_read_tokens,
+    usage_settlement_snapshots.billing_cache_read_tokens
+  ),
+  billing_total_input_context = COALESCE(
+    EXCLUDED.billing_total_input_context,
+    usage_settlement_snapshots.billing_total_input_context
+  ),
+  billing_cache_creation_cost_usd = COALESCE(
+    EXCLUDED.billing_cache_creation_cost_usd,
+    usage_settlement_snapshots.billing_cache_creation_cost_usd
+  ),
+  billing_cache_read_cost_usd = COALESCE(
+    EXCLUDED.billing_cache_read_cost_usd,
+    usage_settlement_snapshots.billing_cache_read_cost_usd
+  ),
+  billing_total_cost_usd = COALESCE(
+    EXCLUDED.billing_total_cost_usd,
+    usage_settlement_snapshots.billing_total_cost_usd
+  ),
+  billing_actual_total_cost_usd = COALESCE(
+    EXCLUDED.billing_actual_total_cost_usd,
+    usage_settlement_snapshots.billing_actual_total_cost_usd
+  ),
+  billing_pricing_source = COALESCE(
+    EXCLUDED.billing_pricing_source,
+    usage_settlement_snapshots.billing_pricing_source
+  ),
+  billing_rule_id = COALESCE(
+    EXCLUDED.billing_rule_id,
+    usage_settlement_snapshots.billing_rule_id
+  ),
+  billing_rule_version = COALESCE(
+    EXCLUDED.billing_rule_version,
+    usage_settlement_snapshots.billing_rule_version
+  ),
+  rate_multiplier = COALESCE(
+    EXCLUDED.rate_multiplier,
+    usage_settlement_snapshots.rate_multiplier
+  ),
+  is_free_tier = COALESCE(
+    EXCLUDED.is_free_tier,
+    usage_settlement_snapshots.is_free_tier
+  ),
+  input_price_per_1m = COALESCE(
+    EXCLUDED.input_price_per_1m,
+    usage_settlement_snapshots.input_price_per_1m
+  ),
+  output_price_per_1m = COALESCE(
+    EXCLUDED.output_price_per_1m,
+    usage_settlement_snapshots.output_price_per_1m
+  ),
+  cache_creation_price_per_1m = COALESCE(
+    EXCLUDED.cache_creation_price_per_1m,
+    usage_settlement_snapshots.cache_creation_price_per_1m
+  ),
+  cache_read_price_per_1m = COALESCE(
+    EXCLUDED.cache_read_price_per_1m,
+    usage_settlement_snapshots.cache_read_price_per_1m
+  ),
+  price_per_request = COALESCE(
+    EXCLUDED.price_per_request,
+    usage_settlement_snapshots.price_per_request
+  ),
+  updated_at = NOW()