modelrig 0.0.1 → 0.2.0

package/dist/telemetry/ingest-protocol.js

@@ -0,0 +1,363 @@
+"use strict";
+/**
+ * The telemetry wire contract — Phase 6 WS2.
+ *
+ * ONE definition of what a batch of telemetry looks like, and ONE function
+ * that turns a batch plus a tenant into the exact database writes it becomes.
+ * Both transports use them:
+ *
+ *   direct mode  exporter → stampBatch(batch, ownTenancy)  → PostgREST
+ *   api mode     exporter → POST /v1/ingest → server → stampBatch(batch, keyTenancy) → PostgREST
+ *
+ * telemetry-ingestion-boundary.md §4 requires that "the SDK must treat api
+ * mode and direct mode identically … one exporter interface, two transports —
+ * enforced by a shared conformance test". This module is what makes that
+ * enforceable rather than aspirational: the conformance test does not compare
+ * two hand-written mappers for similarity, it asserts that both paths run the
+ * SAME mapper. A drift bug has nowhere to live.
+ *
+ * ── WHY THE WIRE ROWS DO NOT CARRY A TENANT ──────────────────────────────
+ * T3: tenancy is derived from the principal, never trusted from the caller. A
+ * client that could put `org_id` on a row could put someone else's `org_id` on
+ * a row. So the wire carries the telemetry and nothing else, and the tenant is
+ * stamped by whoever holds the principal — the exporter's config in direct
+ * mode, the resolved key in api mode.
+ *
+ * The single exception is `feedback.org_id`, and it is the reason WS2 exists.
+ * A verdict recorded on OUR hosted server belongs to the org of the person who
+ * recorded it, not to the org the server runs as, and one SQLite store holds
+ * verdicts for many orgs. So a feedback row may name its own org — and the
+ * ingest endpoint VERIFIES that name against the key rather than trusting it
+ * (see `foreignOrgFeedback`). A service-role exporter needs no such check: it
+ * already holds a credential that can write any row in the database.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_INGEST_URL = exports.INGEST_PROTOCOL_VERSION_V1 = exports.INGEST_PROTOCOL_VERSION = exports.INGEST_PATH = void 0;
+exports.stampBatch = stampBatch;
+exports.foreignOrgFeedback = foreignOrgFeedback;
+const fingerprint_1 = require("../registry/fingerprint");
+/** The path the api sink posts to. Spelled once. */
+exports.INGEST_PATH = "/v1/ingest";
+/** The CURRENT protocol version — the maximum the SDK can speak (ruling d).
+ * v2 = v1 + the optional runs/steps/artifacts sections. A server that does not
+ * recognise the version refuses the batch rather than guessing; the SDK sends
+ * v2 ONLY when the artifact namespace is active (spec §1.3), otherwise it keeps
+ * sending v1 batches byte-identical to before v2 existed. */
+exports.INGEST_PROTOCOL_VERSION = 2;
+/** The v1 baseline — batches carrying only the pre-artifact sections announce
+ * this and remain valid forever. The exporter uses it when artifacts are
+ * disabled (byte-identical to today) and for the pre-loop load-error batch. */
+exports.INGEST_PROTOCOL_VERSION_V1 = 1;
+/** Default ingest host — telemetry-ingestion-boundary.md §2.1. */
+exports.DEFAULT_INGEST_URL = "https://api.modelrig.ai";
+/**
+ * Turn a batch plus a tenant into the writes it becomes.
+ *
+ * THE conformance seam. Both transports call this; nothing else builds a
+ * telemetry row. If you are about to add a table to the export, add it here
+ * and both modes gain it at once — which is the point.
+ */
+function stampBatch(batch, tenancy) {
+    const writes = [];
+    const now = new Date().toISOString();
+    if (batch.routes !== undefined && batch.routes.length > 0) {
+        // Derive task identities BEFORE the routes write (spec §4, ruling a): a
+        // route implies a task. This is the derivation, not FK surgery — `routes`
+        // is untouched; the identity is a projection kept current by the same sync.
+        const seenTasks = new Set();
+        const taskRows = [];
+        for (const r of batch.routes) {
+            // Dedup by route NAME: a batch may carry several versions of one route,
+            // but they share a single task identity ((org_id, task) PK).
+            if (seenTasks.has(r.route))
+                continue;
+            seenTasks.add(r.route);
+            // Built field-by-field from the PRINCIPAL's tenancy, never spread from
+            // wire input — a client-supplied org_id must not ride in (ingest.ts:170
+            // doctrine, T3).
+            const taskRow = {
+                org_id: tenancy.org_id,
+                task: r.route,
+                source: "route-sync",
+            };
+            // spread-iff-bundle-present (the 00027 pattern): a metadata-only sync
+            // (no bundle) must NOT null-out an existing schema/fingerprint — a merge
+            // upsert touches only the columns present in the row. The fingerprint is
+            // computed server-side from the inlined schema with the SAME pure
+            // function the loader uses (fingerprintSchema); the parity golden locks
+            // the two call sites to identical output.
+            if (r.bundle !== undefined) {
+                taskRow.declared_schema = r.bundle.outputSchema ?? null;
+                taskRow.fingerprint_cell = (0, fingerprint_1.fingerprintSchema)(r.bundle.outputSchema)?.cellKey ?? null;
+                taskRow.updated_at = now;
+            }
+            taskRows.push(taskRow);
+        }
+        writes.push({
+            // merge=true: a task row is a mutable projection of the latest sync, like
+            // the routes mirror, unlike inferences. onConflict on the PK (S5).
+            table: "tasks",
+            onConflict: "org_id,task",
+            merge: true,
+            rows: taskRows,
+        });
+        writes.push({
+            table: "routes",
+            onConflict: "org_id,route,version",
+            merge: true,
+            rows: batch.routes.map((r) => ({
+                org_id: tenancy.org_id,
+                route: r.route,
+                version: r.version,
+                candidates: r.candidates,
+                capture: r.capture,
+                updated_at: now,
+                // Phase D (spec §13): the resolved bundle + its hash + the sync stamp.
+                // Written only when the batch carries a bundle, so an older SDK's
+                // metadata-only mirror leaves any existing bundle intact (a merge
+                // upsert touches only the columns present in the row). `synced_at` is
+                // the BUNDLE's timestamp — stamped iff a bundle synced — distinct from
+                // `updated_at`, the row's metadata timestamp.
+                ...(r.bundle !== undefined
+                    ? { bundle: r.bundle, bundle_sha: r.bundle_sha ?? null, synced_at: now }
+                    : {}),
+            })),
+        });
+    }
+    if (batch.runs !== undefined && batch.runs.length > 0) {
+        writes.push({
+            // runs are a mutable projection (start → end): merge=true on the PK (S5).
+            table: "runs",
+            onConflict: "org_id,id",
+            merge: true,
+            rows: batch.runs.map((r) => ({
+                // Field-by-field from the principal's tenancy — org_id and source_id are
+                // NEVER carried on the wire (T3). source_id identifies the rig instance,
+                // exactly like inferences.
+                org_id: tenancy.org_id,
+                id: r.id,
+                source_id: tenancy.source_id,
+                pipeline: r.pipeline,
+                pipeline_version: r.pipeline_version,
+                environment: r.environment,
+                episode_key: r.episode_key,
+                started_at: r.started_at,
+                ended_at: r.ended_at,
+                status: r.status,
+                updated_at: now,
+            })),
+        });
+    }
+    if (batch.steps !== undefined && batch.steps.length > 0) {
+        writes.push({
+            // A step is a FACT (one row per attempt): merge=false on the composite PK.
+            // A retry must not rewrite what already landed.
+            table: "steps",
+            onConflict: "org_id,run_id,step_key,attempt_no",
+            merge: false,
+            rows: batch.steps.map((s) => ({
+                org_id: tenancy.org_id,
+                run_id: s.run_id,
+                step_key: s.step_key,
+                attempt_no: s.attempt_no,
+                task: s.task,
+                provenance: s.provenance,
+                // A ground-truth step joins inferences(org_id, source_id, id); the
+                // source_id is the principal's, stamped here (not trusted from the wire).
+                // Attested steps carry no inference reference (span only) — null.
+                inference_source_id: s.provenance === "ground-truth" ? tenancy.source_id : null,
+                inference_id: s.inference_id,
+                span_trace_id: s.span_trace_id,
+                span_id: s.span_id,
+                started_at: s.started_at,
+                ended_at: s.ended_at,
+                failure_class: s.failure_class,
+                // spread-iff-present (the 00027 pattern): the attested envelope is
+                // written ONLY for attested steps (OTLP ingest, E3-Harvest). A
+                // ground-truth step carries no `attested`, so the column stays null and
+                // the 00038 CHECK holds. An SDK batch never sets it → byte-identical.
+                ...(s.attested !== undefined ? { attested: s.attested } : {}),
+            })),
+        });
+    }
+    if (batch.artifacts !== undefined && batch.artifacts.length > 0) {
+        writes.push({
+            table: "artifacts",
+            onConflict: "org_id,id",
+            merge: false, // an artifact metadata row is a fact; a retry must not rewrite it
+            rows: batch.artifacts.map((a) => ({
+                org_id: tenancy.org_id,
+                id: a.id,
+                run_id: a.run_id,
+                step_key: a.step_key,
+                attempt_no: a.attempt_no,
+                task: a.task,
+                name: a.name,
+                type: a.type,
+                version: a.version,
+                supersedes_artifact_id: a.supersedes_artifact_id,
+                declared_schema: a.declared_schema,
+                fingerprint_cell: a.fingerprint_cell,
+                content_ref: a.content_ref,
+                content_hash: a.content_hash,
+                content_bytes: a.content_bytes,
+                data_classification: a.data_classification,
+                expires_at: a.expires_at,
+                // spread-iff-present (00027 pattern): a batch without `scrub` (older SDK,
+                // custody off) leaves the column null rather than overwriting it.
+                ...(a.scrub !== undefined ? { scrub: a.scrub } : {}),
+            })),
+        });
+    }
+    if (batch.artifact_edges !== undefined && batch.artifact_edges.length > 0) {
+        writes.push({
+            table: "artifact_edges",
+            onConflict: "org_id,from_artifact_id,to_artifact_id,kind",
+            merge: false,
+            rows: batch.artifact_edges.map((e) => ({
+                org_id: tenancy.org_id,
+                from_artifact_id: e.from_artifact_id,
+                to_artifact_id: e.to_artifact_id,
+                kind: e.kind,
+            })),
+        });
+    }
+    if (batch.artifact_evaluations !== undefined && batch.artifact_evaluations.length > 0) {
+        writes.push({
+            table: "artifact_evaluations",
+            onConflict: "org_id,id",
+            merge: false,
+            rows: batch.artifact_evaluations.map((v) => ({
+                org_id: tenancy.org_id,
+                id: v.id,
+                artifact_id: v.artifact_id,
+                // Subject-one-of (00051): a run-subject row carries run_id, artifact_id
+                // null; the CHECK rejects a row that sets both or neither.
+                run_id: v.run_id ?? null,
+                evaluator: v.evaluator,
+                evaluator_kind: v.evaluator_kind,
+                score: v.score,
+                passed: v.passed,
+                label: v.label,
+                explanation: v.explanation,
+                created_by: v.created_by,
+            })),
+        });
+    }
+    if (batch.eval_cases !== undefined && batch.eval_cases.length > 0) {
+        writes.push({
+            // An eval case is created once (via promote); a retry must not rewrite it.
+            // Edits/deletes are a server-side owner action, not this stream. merge=false
+            // on the PK — idempotent by doing nothing (S5).
+            table: "eval_cases",
+            onConflict: "org_id,id",
+            merge: false,
+            rows: batch.eval_cases.map((c) => ({
+                org_id: tenancy.org_id,
+                id: c.id,
+                task: c.task,
+                source_artifact_id: c.source_artifact_id,
+                corrected_artifact_id: c.corrected_artifact_id,
+                origin: c.origin,
+                note: c.note,
+                created_by: c.created_by,
+            })),
+        });
+    }
+    if (batch.manifest !== undefined) {
+        writes.push({
+            table: "rig_manifests",
+            onConflict: "org_id,source_id",
+            merge: true,
+            rows: [
+                {
+                    org_id: tenancy.org_id,
+                    source_id: tenancy.source_id,
+                    name: batch.manifest.name,
+                    dimensions: batch.manifest.dimensions,
+                    contribution: batch.manifest.contribution,
+                    serveability: batch.manifest.serveability,
+                    // [] when the load was clean — a merge upsert then clears any stale
+                    // failure a prior broken deploy left on the row (follow-up #2).
+                    load_errors: batch.manifest.load_errors ?? [],
+                    updated_at: now,
+                },
+            ],
+        });
+    }
+    if (batch.inferences !== undefined && batch.inferences.length > 0) {
+        writes.push({
+            table: "inferences",
+            // 00013's tenant-first primary key. Named explicitly so a retry lands on
+            // the row it already wrote rather than on the old single-column pk.
+            onConflict: "org_id,source_id,id",
+            // An inference is a fact that happened. A retry must not be able to
+            // rewrite it — idempotent by doing nothing, not by overwriting.
+            merge: false,
+            rows: batch.inferences.map((row) => ({
+                org_id: tenancy.org_id,
+                project_id: tenancy.project_id,
+                source_id: tenancy.source_id,
+                ...row,
+            })),
+        });
+    }
+    if (batch.watermarkAt !== undefined) {
+        writes.push({
+            table: "export_watermarks",
+            onConflict: "org_id,source_id",
+            merge: true,
+            rows: [
+                {
+                    org_id: tenancy.org_id,
+                    source_id: tenancy.source_id,
+                    last_exported_ts: batch.watermarkAt,
+                },
+            ],
+        });
+    }
+    if (batch.feedback !== undefined && batch.feedback.length > 0) {
+        writes.push({
+            table: "feedback",
+            onConflict: "id",
+            merge: false,
+            rows: batch.feedback.map(({ org_id, ...row }) => ({
+                // The verdict's own org wins when it has one — that is the whole of
+                // QA-P6-010's fix. Note that `source_id` is deliberately absent:
+                // `feedback.source` already means "who judged", and two columns a
+                // letter apart meaning different things is N2's cautionary tale.
+                org_id: org_id ?? tenancy.org_id,
+                project_id: tenancy.project_id,
+                ...row,
+            })),
+        });
+    }
+    if (batch.envelopes !== undefined && batch.envelopes.length > 0) {
+        writes.push({
+            table: "envelopes",
+            onConflict: "org_id,envelope_key",
+            merge: true,
+            rows: batch.envelopes.map((e) => ({
+                org_id: tenancy.org_id,
+                envelope_key: e.envelope_key,
+                budget_usd: e.budget_usd,
+                spent_usd: e.spent_usd,
+                status: e.status,
+                exported_at: now,
+            })),
+        });
+    }
+    return writes;
+}
+/**
+ * Feedback rows naming an org other than the presented key's.
+ *
+ * Exists as its own exported function because the ingest endpoint must drop
+ * these and COUNT them, and a check that lives inline in a request handler is
+ * a check nobody can test in isolation. Returns the offending ids.
+ */
+function foreignOrgFeedback(rows, keyOrgId) {
+    return rows
+        .filter((r) => r.org_id !== undefined && r.org_id !== keyOrgId)
+        .map((r) => r.id);
+}

package/dist/telemetry/load-error-report.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Load-error console reporting — follow-up #2.
+ *
+ * When a route bundle fails to load, tell the console WHY. `loadRoutes` throws
+ * before the exporter loop exists, so the run-loop path never gets a chance to
+ * mirror the failure. This sends a one-shot manifest batch carrying
+ * `describeConfigFailure(error)` onto `rig_manifests.load_errors`, which drives
+ * /setup's "Define your first route" step to `failed` with what we looked for
+ * and what we found.
+ *
+ * Fire-and-forget, and best-effort by design: `createRig` is synchronous and
+ * re-throws (the rig genuinely cannot run), and telemetry must never change the
+ * error the caller sees. KNOWN LIMITATION: this only reaches the console once
+ * the app runs with an export configured (MODELRIG_API_KEY / direct creds); a
+ * first-timer who hasn't connected yet still gets the full diagnosis at their
+ * terminal via `renderConfigErrorForTerminal`.
+ *
+ * Lives here rather than in index.ts to keep that file under the LOC cap (P1) —
+ * the same relocation `buildTelemetrySink` made to `sinks.ts`.
+ */
+import type { RigConfig } from "../config";
+import { RouteConfigError } from "../routes/loader";
+export declare function reportLoadError(config: RigConfig, error: RouteConfigError): void;
+//# sourceMappingURL=load-error-report.d.ts.map

package/dist/telemetry/load-error-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-error-report.d.ts","sourceRoot":"","sources":["../../src/telemetry/load-error-report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAOpD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAoBhF"}

package/dist/telemetry/load-error-report.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Load-error console reporting — follow-up #2.
+ *
+ * When a route bundle fails to load, tell the console WHY. `loadRoutes` throws
+ * before the exporter loop exists, so the run-loop path never gets a chance to
+ * mirror the failure. This sends a one-shot manifest batch carrying
+ * `describeConfigFailure(error)` onto `rig_manifests.load_errors`, which drives
+ * /setup's "Define your first route" step to `failed` with what we looked for
+ * and what we found.
+ *
+ * Fire-and-forget, and best-effort by design: `createRig` is synchronous and
+ * re-throws (the rig genuinely cannot run), and telemetry must never change the
+ * error the caller sees. KNOWN LIMITATION: this only reaches the console once
+ * the app runs with an export configured (MODELRIG_API_KEY / direct creds); a
+ * first-timer who hasn't connected yet still gets the full diagnosis at their
+ * terminal via `renderConfigErrorForTerminal`.
+ *
+ * Lives here rather than in index.ts to keep that file under the LOC cap (P1) —
+ * the same relocation `buildTelemetrySink` made to `sinks.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportLoadError = reportLoadError;
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const manifest_1 = require("../routes/manifest");
+const config_teaching_1 = require("../types/config-teaching");
+const exporter_1 = require("./exporter");
+const sinks_1 = require("./sinks");
+function reportLoadError(config, error) {
+    if (config.export === undefined)
+        return;
+    const sourceId = config.export.sourceId ?? (0, node_os_1.hostname)();
+    // rig.yaml can load fine even when a route bundle can't — carry its
+    // name/dimensions/contribution so the reporting upsert doesn't blank them.
+    let manifestMeta = null;
+    try {
+        manifestMeta = (0, manifest_1.loadManifest)((0, node_path_1.dirname)(config.routesDir));
+    }
+    catch {
+        // rig.yaml is itself broken/absent; fall back to source-id naming so the
+        // row still lands and the console still learns of the failure.
+    }
+    const sink = (0, sinks_1.buildTelemetrySink)(config.export, sourceId);
+    const batch = (0, exporter_1.buildLoadErrorBatch)(sourceId, manifestMeta, [(0, config_teaching_1.describeConfigFailure)(error)]);
+    void sink.send(batch).catch((err) => {
+        console.warn(`[modelrig] could not report the route load error to the console: ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    });
+}

package/dist/telemetry/otel-map.d.ts

@@ -0,0 +1,121 @@
+/**
+ * OTLP mapping — E1 (spec §3, §4). PURE: no I/O, no env, no imports from the
+ * exporter/sinks/store. One `inferences` row → one OTLP/HTTP JSON span.
+ *
+ * ── THE ONE PLACE gen_ai.* NAMES LIVE ────────────────────────────────────
+ * Every OpenTelemetry semantic-convention attribute name this product emits is
+ * declared in THIS module and nowhere else (architect-review-2026-08 §2(f)).
+ * The pin is `SEMCONV_VERSION` below — bump it here and the wire changes in one
+ * edit, not scattered across the codebase. If you find a `"gen_ai.*"` string
+ * literal outside this file, it is a bug.
+ *
+ * ── WHY HAND-BUILT JSON, NOT @opentelemetry/* ────────────────────────────
+ * We are mapping completed rows, not instrumenting live code, so the SDK's
+ * tracer runtime would be dead weight (spec §2.2). The shape below is the
+ * OTLP/HTTP `ExportTraceServiceRequest` JSON encoding. Two encoding rules bite
+ * here and are easy to get wrong (plan §"risks"):
+ *   • trace_id / span_id are LOWERCASE HEX strings — the documented OTLP/JSON
+ *     exception to Protobuf's base64-for-bytes. NOT base64.
+ *   • int64 attribute + timestamp values are DECIMAL STRINGS; doubles are
+ *     numbers. `intValue`/`startTimeUnixNano` are strings on the wire.
+ */
+import type { TelemetryRow } from "../types/telemetry";
+import type { CacheContext } from "../watch/evaluate";
+/** Semantic-conventions pin (architect ruling §2(f)). The scope version on the
+ * wire and the single source of truth for which gen_ai vintage we speak. */
+export declare const SEMCONV_VERSION = "1.41.0";
+/** STATUS_CODE_UNSET / STATUS_CODE_ERROR (OK is never set — gen_ai convention
+ * leaves a successful span UNSET). */
+declare const STATUS_UNSET = 0;
+declare const STATUS_ERROR = 2;
+export type OtlpAnyValue = {
+    readonly stringValue: string;
+} | {
+    readonly intValue: string;
+} | {
+    readonly doubleValue: number;
+} | {
+    readonly boolValue: boolean;
+};
+export interface OtlpAttribute {
+    readonly key: string;
+    readonly value: OtlpAnyValue;
+}
+export interface OtlpStatus {
+    readonly code: typeof STATUS_UNSET | typeof STATUS_ERROR;
+    readonly message?: string;
+}
+export interface OtlpSpanJson {
+    /** 32 lowercase hex chars (16 bytes). */
+    readonly traceId: string;
+    /** 16 lowercase hex chars (8 bytes). */
+    readonly spanId: string;
+    /** 16 lowercase hex chars — present only when a caller traceparent nests us. */
+    readonly parentSpanId?: string;
+    readonly name: string;
+    readonly kind: number;
+    readonly startTimeUnixNano: string;
+    readonly endTimeUnixNano: string;
+    readonly attributes: readonly OtlpAttribute[];
+    readonly status: OtlpStatus;
+}
+export interface OtlpResource {
+    readonly serviceName: string;
+    /** Optional extra resource attributes (e.g. deployment.environment). */
+    readonly attributes?: readonly OtlpAttribute[];
+}
+export interface ExportTraceServiceRequestJson {
+    readonly resourceSpans: ReadonlyArray<{
+        readonly resource: {
+            readonly attributes: readonly OtlpAttribute[];
+        };
+        readonly scopeSpans: ReadonlyArray<{
+            readonly scope: {
+                readonly name: string;
+                readonly version: string;
+            };
+            readonly spans: readonly OtlpSpanJson[];
+        }>;
+    }>;
+}
+/** The tag key the gateway stashes an inbound traceparent under (spec §2.5). */
+export declare const TRACEPARENT_TAG = "otel.traceparent";
+export interface Traceparent {
+    /** Caller's trace id — the emitted span joins this trace. */
+    readonly traceId: string;
+    /** Caller's span id — the emitted span's parent. */
+    readonly parentSpanId: string;
+}
+/**
+ * Parse a W3C `traceparent` value, or null when absent/malformed. The gateway
+ * (packages/modelrig-server) reuses this so the SDK and the server cannot
+ * disagree about what "well-formed" means. All-zero trace/parent ids are
+ * rejected per the W3C spec (they mean "no parent").
+ */
+export declare function parseTraceparent(value: string | undefined | null): Traceparent | null;
+/**
+ * Map one telemetry row to one OTLP span (spec §3, normative). Pure and total:
+ * every field comes from the row; nulls are omitted (never emitted as empty).
+ */
+export declare function inferenceToSpan(row: TelemetryRow): OtlpSpanJson;
+/**
+ * Decision-span attributes for a cache-aware routing decision (cache-aware-routing
+ * spec §5.5 — "routing must never be opaque"). Returns the `modelrig.cache.*`
+ * attribute set a caller attaches to the swap/proposal decision span so the
+ * verdict + its economics travel to any OTLP backend alongside the inference
+ * spans. Declared HERE because this module is the one place OTLP attribute names
+ * live (the pin at the top of this file).
+ *
+ * `breakeven_conformant_calls` can be `Infinity` ("never breaks even"), which is
+ * not a valid JSON number — so it is emitted as a double ONLY when finite, and a
+ * boolean `modelrig.cache.breakeven_reachable` records the never-case explicitly
+ * rather than dropping the fact.
+ */
+export declare function cacheDecisionSpanAttributes(ctx: CacheContext): OtlpAttribute[];
+/**
+ * Wrap spans in the OTLP `ExportTraceServiceRequest` envelope (spec §4, pure).
+ * One resource, one scope (`modelrig` @ SEMCONV_VERSION), N spans.
+ */
+export declare function buildExportTraceRequest(spans: readonly OtlpSpanJson[], resource: OtlpResource): ExportTraceServiceRequestJson;
+export {};
+//# sourceMappingURL=otel-map.d.ts.map

package/dist/telemetry/otel-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-map.d.ts","sourceRoot":"","sources":["../../src/telemetry/otel-map.ts"],"names":[],"mappings":"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"}