@geraldmaron/construct 1.0.0 → 1.0.2

package/lib/telemetry/backends/local.mjs

@@ -0,0 +1,62 @@
+/**
+ * lib/telemetry/backends/local.mjs — Local JSONL trace backend.
+ *
+ * Reads trace events from ~/.cx/traces/*.jsonl files.
+ * No remote calls. Always available. Used when CONSTRUCT_TRACE_BACKEND=local.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export const name = 'local';
+
+const TRACES_DIR = join(homedir(), '.cx', 'traces');
+
+export async function isAvailable() {
+  return true;
+}
+
+/**
+ * Fetch traces from local JSONL files within a time window.
+ *
+ * @param {string} teamId - The overlay/team ID to filter by.
+ * @param {number} windowMs - Lookback window in milliseconds.
+ * @returns {Promise<object[]>}
+ */
+export async function listTraces(teamId, windowMs) {
+  if (!existsSync(TRACES_DIR)) return [];
+
+  const since = Date.now() - windowMs;
+  const files = readdirSync(TRACES_DIR)
+    .filter((f) => f.endsWith('.jsonl'))
+    .sort()
+    .reverse()
+    .slice(0, 7); // last 7 days of files
+
+  const traces = [];
+  for (const file of files) {
+    const lines = readFileSync(join(TRACES_DIR, file), 'utf8')
+      .split('\n')
+      .filter(Boolean);
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        if (new Date(event.createdAt).getTime() < since) continue;
+        if (teamId && event.project && event.project !== teamId) continue;
+        traces.push({
+          id: event.traceId ?? event.spanId,
+          teamId: event.project ?? teamId,
+          agentName: event.role ?? event.eventType ?? 'unknown',
+          status: 'local',
+          latencyMs: null,
+          qualityScore: null,
+          createdAt: event.createdAt,
+          blockers: [],
+          handoffs: 0,
+        });
+      } catch { /* skip malformed lines */ }
+    }
+  }
+  return traces;
+}

package/lib/telemetry/backends/{langfuse.mjs → remote.mjs}

@@ -1,28 +1,38 @@
 /**
- * lib/telemetry/backends/langfuse.mjs — Langfuse trace backend adapter.
+ * lib/telemetry/backends/remote.mjs — Remote telemetry backend adapter.
  *
- * Reads LANGFUSE_BASEURL, LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY from env.
+ * Reads CONSTRUCT_TELEMETRY_URL, CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+ * CONSTRUCT_TELEMETRY_SECRET_KEY from env.
  * Implements the TraceBackend interface: listTraces(teamId, windowMs) → Trace[].
+ *
+ * The HTTP protocol is compatible with open trace ingestion APIs.
+ * Point CONSTRUCT_TELEMETRY_URL at any compatible backend.
  */
 
-export const name = 'langfuse';
+export const name = 'remote';
 
-function baseHeaders() {
-  const key = process.env.LANGFUSE_PUBLIC_KEY;
-  const secret = process.env.LANGFUSE_SECRET_KEY;
-  if (!key || !secret) throw new Error('LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY must be set.');
+export function telemetryHeaders(env = process.env) {
+  const key = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
+  const secret = env.CONSTRUCT_TELEMETRY_SECRET_KEY;
+  if (!key || !secret)
+    throw new Error(
+      'CONSTRUCT_TELEMETRY_PUBLIC_KEY and CONSTRUCT_TELEMETRY_SECRET_KEY must be set.',
+    );
   return {
     Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
     'Content-Type': 'application/json',
   };
 }
 
-function baseUrl() {
-  return (process.env.LANGFUSE_BASEURL ?? 'https://cloud.langfuse.com').replace(/\/$/, '');
+export function telemetryBaseUrl(env = process.env) {
+  return (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
 }
 
 export async function isAvailable() {
-  return Boolean(process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY);
+  return Boolean(
+    (process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY) &&
+      (process.env.CONSTRUCT_TELEMETRY_SECRET_KEY),
+  );
 }
 
 /**
@@ -35,12 +45,13 @@ export async function isAvailable() {
  */
 export async function listTraces(teamId, windowMs) {
   const since = new Date(Date.now() - windowMs).toISOString();
-  const url = `${baseUrl()}/api/public/traces?tags=${encodeURIComponent(teamId)}&fromTimestamp=${since}&limit=100`;
+  const base = telemetryBaseUrl();
+  const url = `${base}/api/public/traces?tags=${encodeURIComponent(teamId)}&fromTimestamp=${since}&limit=100`;
 
-  const resp = await fetch(url, { headers: baseHeaders() });
+  const resp = await fetch(url, { headers: telemetryHeaders() });
   if (!resp.ok) {
     const body = await resp.text();
-    throw new Error(`Langfuse API error ${resp.status}: ${body}`);
+    throw new Error(`Telemetry backend API error ${resp.status}: ${body}`);
   }
   const json = await resp.json();
 
@@ -49,10 +60,12 @@ export async function listTraces(teamId, windowMs) {
     teamId,
     agentName: t.metadata?.agentName ?? t.name ?? 'unknown',
     status: t.metadata?.status ?? 'unknown',
-    latencyMs: t.latency != null ? Math.round(t.latency * 1000) : null, // Langfuse returns seconds
+    latencyMs: t.latency != null ? Math.round(t.latency * 1000) : null,
     qualityScore: t.scores?.find((s) => s.name === 'quality')?.value ?? null,
     createdAt: t.timestamp,
     blockers: t.metadata?.blockers ?? [],
     handoffs: t.metadata?.handoffs ?? 0,
   }));
 }
+
+

package/lib/telemetry/backfill.mjs

@@ -0,0 +1,180 @@
+/**
+ * lib/telemetry/backfill.mjs — Sparse telemetry trace backfill.
+ *
+ * Fetches the most recent sparse traces from the telemetry backend and posts a synthetic
+ * EVENT observation against each one so it graduates from sparse → partial.
+ * Safe to call repeatedly — observations are idempotent (same deterministic ID).
+ *
+ * Consumed by:
+ *   • lib/status.mjs         — auto-triggered when sparse coverage is detected.
+ *   • bin/construct           — `construct telemetry-backfill` CLI command.
+ */
+import { randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
+import { createIngestClient } from "./ingest.mjs";
+
+const DEFAULT_LIMIT = 10;
+const SPARSE_THRESHOLD = 0.35;
+
+/**
+ * Derive a stable observation ID from a trace ID so repeated backfills are
+ * idempotent from the caller's perspective (de-duped by ID on upsert).
+ */
+function stableObservationId(traceId) {
+  return createHash("sha256").update(`backfill:${traceId}`).digest("hex").slice(0, 32);
+}
+
+function classifySparseTrace(trace) {
+  const observationCount = Number(
+    trace?.observationCount ?? trace?.observations?.length ?? trace?.spanCount ?? trace?.generationCount ?? 0
+  ) || 0;
+  const hasInput = trace?.input != null;
+  const hasOutput = trace?.output != null;
+  const metaKeys = trace?.metadata && typeof trace.metadata === "object"
+    ? Object.keys(trace.metadata).length
+    : 0;
+  const hasRichMetadata = metaKeys >= 5;
+  const hasPayload = hasInput || hasOutput || metaKeys > 0;
+
+  if ((hasInput || hasOutput) && (observationCount >= 1 || hasRichMetadata)) return "rich";
+  if (hasPayload || observationCount >= 1) return "partial";
+  return "sparse";
+}
+
+/**
+ * Fetch recent traces from the telemetry backend and return only the sparse ones.
+ */
+async function fetchSparseTraces({
+  baseUrl,
+  headers,
+  limit = DEFAULT_LIMIT,
+  signal,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const url = `${baseUrl}/api/public/traces?limit=${limit * 3}`;
+  const res = await fetchImpl(url, { headers, signal });
+  if (!res.ok) throw new Error(`telemetry traces ${res.status}`);
+  const json = await res.json().catch(() => ({}));
+  const traces = Array.isArray(json.data) ? json.data : [];
+  return traces
+    .filter((t) => classifySparseTrace(t) === "sparse")
+    .slice(0, limit);
+}
+
+/**
+ * Post a backfill EVENT observation against a trace.
+ */
+function buildBackfillObservation(traceId, { healReason = "auto", source = "construct-backfill" } = {}) {
+  return {
+    id: stableObservationId(traceId),
+    traceId,
+    type: "EVENT",
+    name: "construct.backfill",
+    startTime: new Date().toISOString(),
+    metadata: {
+      heal_reason: healReason,
+      source,
+      backfilledAt: new Date().toISOString(),
+    },
+  };
+}
+
+/**
+ * Backfill sparse traces. Returns a result summary.
+ *
+ * @param {object} opts
+ * @param {string} [opts.baseUrl]
+ * @param {string} [opts.publicKey]
+ * @param {string} [opts.secretKey]
+ * @param {number} [opts.limit]
+ * @param {boolean} [opts.bestEffort]  - skip individual failures instead of throwing
+ * @param {Function} [opts.fetchImpl]
+ * @returns {{ backfilled: number, skipped: number, errors: string[] }}
+ */
+export async function backfillSparseTraces({
+  baseUrl = (process.env.CONSTRUCT_TELEMETRY_URL ?? "").replace(/\/$/, ""),
+  publicKey = process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+  secretKey = process.env.CONSTRUCT_TELEMETRY_SECRET_KEY,
+  limit = DEFAULT_LIMIT,
+  bestEffort = false,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  if (!publicKey || !secretKey || !fetchImpl) {
+    return { backfilled: 0, skipped: 0, errors: ["Telemetry credentials not configured"] };
+  }
+
+  const headers = {
+    Authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}`,
+    "Content-Type": "application/json",
+  };
+
+  const errors = [];
+  let sparseTraces;
+
+  try {
+    sparseTraces = await fetchSparseTraces({ baseUrl, headers, limit, fetchImpl });
+  } catch (err) {
+    return { backfilled: 0, skipped: 0, errors: [err.message] };
+  }
+
+  if (!sparseTraces.length) {
+    return { backfilled: 0, skipped: 0, errors: [] };
+  }
+
+  const client = createIngestClient({ baseUrl, publicKey, secretKey, fetchImpl });
+  let backfilled = 0;
+  let skipped = 0;
+
+  for (const trace of sparseTraces) {
+    const traceId = trace.id;
+    if (!traceId) { skipped += 1; continue; }
+    try {
+      client.event(buildBackfillObservation(traceId));
+      backfilled += 1;
+    } catch (err) {
+      if (bestEffort) {
+        errors.push(`${traceId}: ${err.message}`);
+        skipped += 1;
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  await client.flush();
+  return { backfilled, skipped, errors };
+}
+
+/**
+ * Auto-heal trigger: run backfill only when telemetry coverage is below threshold.
+ * Fire-and-forget — errors are swallowed. Intended for background use from buildStatus.
+ */
+export function triggerAutoBackfillIfSparse(telemetryRichness, opts = {}) {
+  const coverage = telemetryRichness?.coverage ?? 1;
+  const total = telemetryRichness?.total ?? 0;
+  if (total === 0 || coverage >= SPARSE_THRESHOLD) return;
+
+  backfillSparseTraces({ ...opts, bestEffort: true }).catch(() => {});
+}
+
+/**
+ * CLI entrypoint for `construct telemetry-backfill`.
+ */
+export async function runTelemetryBackfillCli(args = []) {
+  const limitArg = args.find((a) => a.startsWith("--limit="));
+  const limit = limitArg ? parseInt(limitArg.split("=")[1], 10) || DEFAULT_LIMIT : DEFAULT_LIMIT;
+  const bestEffort = args.includes("--best-effort");
+
+  process.stdout.write(`Backfilling sparse telemetry traces (limit: ${limit})…\n`);
+
+  const result = await backfillSparseTraces({ limit, bestEffort });
+
+  if (result.errors.length && !bestEffort) {
+    process.stderr.write(`Backfill error: ${result.errors[0]}\n`);
+    process.exit(1);
+  }
+
+  process.stdout.write(
+    `Done. backfilled=${result.backfilled} skipped=${result.skipped}${result.errors.length ? ` errors=${result.errors.length}` : ""}\n`
+  );
+}

package/lib/telemetry/eval-datasets.mjs

@@ -0,0 +1,203 @@
+/**
+ * lib/telemetry/eval-datasets.mjs — Telemetry eval dataset writer.
+ *
+ * Reads recent scored traces from the telemetry backend, groups them by agent + workCategory,
+ * and upserts structured dataset items so prompt changes can be evaluated in
+ * the telemetry backend Datasets feature.
+ *
+ * One dataset per agent (e.g. "construct-cx-engineer"). Each dataset item is one
+ * trace: input = agent goal, expected_output = score+comment, metadata = promptHash.
+ *
+ * Closes the loop:
+ *   agent runs → cx_score called → score written to telemetry backend
+ *   → eval-datasets job reads scores → upserts dataset items
+ *   → Telemetry Datasets UI shows score distribution per prompt version
+ *   → prompt author can see whether a change improved or regressed quality
+ *
+ * Consumed by:
+ *   • lib/embed/daemon.mjs  — scheduled every 6h as 'eval-dataset-sync' job
+ *   • bin/construct          — `construct eval-datasets` CLI command
+ */
+
+const MAX_TRACES = 100;
+const MIN_SCORE_TO_INCLUDE = 0;   // include all scores — 0.0 failures are valuable
+
+function baseHeaders(publicKey, secretKey) {
+  return {
+    Authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString('base64')}`,
+    'Content-Type': 'application/json',
+  };
+}
+
+function baseUrl(env = process.env) {
+  return (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
+}
+
+/**
+ * Fetch recent traces that have at least one quality score.
+ * Returns array of { traceId, name, input, metadata, scores[] }.
+ */
+async function fetchScoredTraces({ url, headers, limit = MAX_TRACES, fetchImpl = globalThis.fetch }) {
+  const res = await fetchImpl(`${url}/api/public/scores?name=quality&limit=${limit}`, { headers });
+  if (!res.ok) throw new Error(`Telemetry scores fetch ${res.status}`);
+  const json = await res.json().catch(() => ({}));
+  const scores = Array.isArray(json.data) ? json.data : [];
+  if (!scores.length) return [];
+
+  // De-duplicate by traceId — take the latest score per trace
+  const byTrace = new Map();
+  for (const score of scores) {
+    if (!score.traceId) continue;
+    const existing = byTrace.get(score.traceId);
+    if (!existing || new Date(score.timestamp) > new Date(existing.timestamp)) {
+      byTrace.set(score.traceId, score);
+    }
+  }
+
+  // Fetch trace details in parallel (up to 10 at a time)
+  const traceIds = [...byTrace.keys()].slice(0, limit);
+  const BATCH = 10;
+  const enriched = [];
+  for (let i = 0; i < traceIds.length; i += BATCH) {
+    const batch = traceIds.slice(i, i + BATCH);
+    const results = await Promise.allSettled(
+      batch.map((id) =>
+        fetchImpl(`${url}/api/public/traces/${id}`, { headers })
+          .then((r) => r.ok ? r.json() : null)
+          .catch(() => null)
+      )
+    );
+    for (let j = 0; j < batch.length; j++) {
+      const trace = results[j].status === 'fulfilled' ? results[j].value : null;
+      if (!trace) continue;
+      const score = byTrace.get(batch[j]);
+      enriched.push({ trace, score });
+    }
+  }
+  return enriched;
+}
+
+/**
+ * Upsert a dataset item in the telemetry backend.
+ * Creates the dataset if it does not exist (returns 200 on existing datasets).
+ */
+async function upsertDatasetItem({ url, headers, datasetName, item, fetchImpl = globalThis.fetch }) {
+  // Create dataset (idempotent)
+  await fetchImpl(`${url}/api/public/datasets`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ name: datasetName, description: `Auto-generated eval dataset for ${datasetName}` }),
+  }).catch(() => {});
+
+  // Upsert item — use traceId as the stable ID so reruns are idempotent
+  const res = await fetchImpl(`${url}/api/public/dataset-items`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(item),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`dataset-items ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return res.json().catch(() => ({}));
+}
+
+/**
+ * Derive a dataset name from a trace.
+ * Uses agentName from trace metadata, falling back to trace.name.
+ */
+function datasetNameForTrace(trace) {
+  const agent = trace?.metadata?.agentName || trace?.name || 'construct';
+  const workCategory = trace?.metadata?.routeWorkCategory || null;
+  const base = `construct-${agent}`;
+  return workCategory ? `${base}-${workCategory}` : base;
+}
+
+/**
+ * Main entrypoint. Reads scored traces from the telemetry backend and upserts dataset items.
+ * Returns { synced, skipped, errors }.
+ */
+export async function syncEvalDatasets({
+  publicKey = process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+  secretKey = process.env.CONSTRUCT_TELEMETRY_SECRET_KEY,
+  env = process.env,
+  limit = MAX_TRACES,
+  bestEffort = true,
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  if (!publicKey || !secretKey) {
+    return { synced: 0, skipped: 0, errors: ['Telemetry credentials not configured'] };
+  }
+
+  const url = baseUrl(env);
+  const headers = baseHeaders(publicKey, secretKey);
+  const errors = [];
+  let synced = 0;
+  let skipped = 0;
+
+  let scoredTraces;
+  try {
+    scoredTraces = await fetchScoredTraces({ url, headers, limit, fetchImpl });
+  } catch (err) {
+    return { synced: 0, skipped: 0, errors: [err.message] };
+  }
+
+  for (const { trace, score } of scoredTraces) {
+    try {
+      const datasetName = datasetNameForTrace(trace);
+      const promptHash = trace?.metadata?.composedPromptHash ?? null;
+      const promptVersion = trace?.metadata?.composedPromptVersion ?? null;
+
+      const item = {
+        // Use traceId as external ID so upserts are idempotent
+        id: `trace-${trace.id}`,
+        datasetName,
+        input: trace.input ?? trace?.metadata?.goal ?? '',
+        expectedOutput: {
+          qualityScore: score.value,
+          comment: score.comment ?? null,
+          agentName: trace?.metadata?.agentName ?? trace?.name ?? null,
+          workCategory: trace?.metadata?.routeWorkCategory ?? null,
+        },
+        metadata: {
+          traceId: trace.id,
+          traceName: trace.name,
+          promptHash,
+          promptVersion,
+          routeIntent: trace?.metadata?.routeIntent ?? null,
+          routeTrack: trace?.metadata?.routeTrack ?? null,
+          fragmentTypes: trace?.metadata?.promptFragmentTypes ?? null,
+          hasLearnedPatterns: trace?.metadata?.promptHasLearnedPatterns ?? false,
+          scoredAt: score.timestamp ?? new Date().toISOString(),
+        },
+      };
+
+      await upsertDatasetItem({ url, headers, datasetName, item, fetchImpl });
+      synced += 1;
+    } catch (err) {
+      if (bestEffort) {
+        errors.push(`${trace?.id}: ${err.message}`);
+        skipped += 1;
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  return { synced, skipped, errors };
+}
+
+/**
+ * CLI entrypoint for `construct eval-datasets`.
+ */
+export async function runEvalDatasetsCli(args = []) {
+  const limitArg = args.find((a) => a.startsWith('--limit='));
+  const limit = limitArg ? parseInt(limitArg.split('=')[1], 10) || MAX_TRACES : MAX_TRACES;
+
+  process.stdout.write(`Syncing eval datasets from telemetry backend (limit: ${limit})…\n`);
+  const result = await syncEvalDatasets({ limit, bestEffort: false });
+  process.stdout.write(`Done. synced=${result.synced} skipped=${result.skipped}${result.errors.length ? ` errors=${result.errors.length}` : ''}\n`);
+  if (result.errors.length) {
+    for (const e of result.errors) process.stderr.write(`  ${e}\n`);
+  }
+}

package/lib/telemetry/{langfuse-ingest.mjs → ingest.mjs}

@@ -1,10 +1,13 @@
 /**
- * lib/telemetry/langfuse-ingest.mjs — Langfuse batch ingestion client.
+ * lib/telemetry/ingest.mjs — Telemetry backend batch ingestion client.
  *
  * POSTs observations to /api/public/ingestion in batches. Silent no-op when
- * LANGFUSE_PUBLIC_KEY/SECRET_KEY are missing. Never throws from the hot path.
+ * credentials are missing. Never throws from the hot path.
+ *
+ * Uses an open ingestion API protocol. Point CONSTRUCT_TELEMETRY_URL
+ * at any compatible backend.
  */
-import { randomUUID } from "node:crypto";
+import { randomUUID } from 'node:crypto';
 
 const DEFAULT_FLUSH_INTERVAL_MS = 500;
 const DEFAULT_MAX_BATCH = 50;
@@ -12,7 +15,7 @@ const MAX_PAYLOAD_CHARS = 16_000;
 
 function truncate(value) {
   if (value == null) return value;
-  if (typeof value === "string") {
+  if (typeof value === 'string') {
     return value.length > MAX_PAYLOAD_CHARS
       ? `${value.slice(0, MAX_PAYLOAD_CHARS)}…[truncated ${value.length - MAX_PAYLOAD_CHARS} chars]`
       : value;
@@ -27,9 +30,11 @@ function truncate(value) {
 }
 
 export function createIngestClient({
-  baseUrl = (process.env.LANGFUSE_BASEURL ?? "https://cloud.langfuse.com").replace(/\/$/, ""),
-  publicKey = process.env.LANGFUSE_PUBLIC_KEY,
-  secretKey = process.env.LANGFUSE_SECRET_KEY,
+  baseUrl = (
+    process.env.CONSTRUCT_TELEMETRY_URL ?? ''
+  ).replace(/\/$/, ''),
+  publicKey = process.env.CONSTRUCT_TELEMETRY_PUBLIC_KEY,
+  secretKey = process.env.CONSTRUCT_TELEMETRY_SECRET_KEY,
   flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS,
   maxBatch = DEFAULT_MAX_BATCH,
   onError = () => {},
@@ -41,8 +46,8 @@ export function createIngestClient({
   let inflight = Promise.resolve();
 
   const authHeader = available
-    ? `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}`
-    : "";
+    ? `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString('base64')}`
+    : '';
 
   function scheduleFlush() {
     if (!available || flushTimer) return;
@@ -50,7 +55,7 @@ export function createIngestClient({
       flushTimer = null;
       void flushBatch();
     }, flushIntervalMs);
-    if (typeof flushTimer.unref === "function") flushTimer.unref();
+    if (typeof flushTimer.unref === 'function') flushTimer.unref();
   }
 
   async function flushBatch() {
@@ -62,14 +67,14 @@ export function createIngestClient({
       try { await prev; } catch { /* ignore prior */ }
       try {
         const res = await fetchImpl(`${baseUrl}/api/public/ingestion`, {
-          method: "POST",
-          headers: { Authorization: authHeader, "Content-Type": "application/json" },
+          method: 'POST',
+          headers: { Authorization: authHeader, 'Content-Type': 'application/json' },
           body: payload,
         });
         if (!res.ok && res.status !== 207) {
-          let detail = "";
+          let detail = '';
           try { detail = (await res.text()).slice(0, 500); } catch { /* ignore */ }
-          onError(new Error(`langfuse ingest ${res.status}: ${detail}`));
+          onError(new Error(`telemetry ingest ${res.status}: ${detail}`));
         }
       } catch (err) {
         onError(err);
@@ -92,12 +97,13 @@ export function createIngestClient({
 
   return {
     available,
-    trace: (body) => push("trace-create", body),
-    generation: (body) => push("generation-create", body),
-    generationUpdate: (body) => push("generation-update", body),
-    span: (body) => push("span-create", body),
-    spanUpdate: (body) => push("span-update", body),
-    event: (body) => push("event-create", body),
+    trace: (body) => push('trace-create', body),
+    traceUpdate: (body) => push('trace-update', body),
+    generation: (body) => push('generation-create', body),
+    generationUpdate: (body) => push('generation-update', body),
+    span: (body) => push('span-create', body),
+    spanUpdate: (body) => push('span-update', body),
+    event: (body) => push('event-create', body),
     async flush() {
       if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
       while (queue.length > 0) await flushBatch();