@contractspec/lib.observability 3.7.17 → 3.7.19

package/dist/node/tracing/middleware.js

@@ -1,171 +1 @@
-// src/metrics/index.ts
-import {
-  metrics
-} from "@opentelemetry/api";
-var DEFAULT_METER_NAME = "@contractspec/lib.observability";
-function getMeter(name = DEFAULT_METER_NAME) {
-  return metrics.getMeter(name);
-}
-function createCounter(name, description, meterName) {
-  return getMeter(meterName).createCounter(name, { description });
-}
-function createUpDownCounter(name, description, meterName) {
-  return getMeter(meterName).createUpDownCounter(name, { description });
-}
-function createHistogram(name, description, meterName) {
-  return getMeter(meterName).createHistogram(name, { description });
-}
-var standardMetrics = {
-  httpRequests: createCounter("http_requests_total", "Total HTTP requests"),
-  httpDuration: createHistogram("http_request_duration_seconds", "HTTP request duration"),
-  operationErrors: createCounter("operation_errors_total", "Total operation errors"),
-  workflowDuration: createHistogram("workflow_duration_seconds", "Workflow execution duration")
-};
-
-// src/tracing/core.ts
-import {
-  SpanStatusCode,
-  trace
-} from "@opentelemetry/api";
-var DEFAULT_TRACER_NAME = "@contractspec/lib.observability";
-function getTracer(name = DEFAULT_TRACER_NAME) {
-  return trace.getTracer(name);
-}
-async function traceAsync(name, fn, tracerName) {
-  const tracer = getTracer(tracerName);
-  return tracer.startActiveSpan(name, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-function traceSync(name, fn, tracerName) {
-  const tracer = getTracer(tracerName);
-  return tracer.startActiveSpan(name, (span) => {
-    try {
-      const result = fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-
-// src/tracing/model-selection.span.ts
-async function traceModelSelection(fn, input) {
-  const startMs = performance.now();
-  return traceAsync("model.selection", async (span) => {
-    const result = await fn();
-    const durationMs = performance.now() - startMs;
-    span.setAttribute("model.selected", input.modelId);
-    span.setAttribute("model.provider", input.providerKey);
-    span.setAttribute("model.score", input.score);
-    span.setAttribute("model.alternatives_count", input.alternativesCount);
-    span.setAttribute("model.selection_duration_ms", durationMs);
-    span.setAttribute("model.reason", input.reason);
-    if (input.dimension) {
-      span.setAttribute("model.dimension", input.dimension);
-    }
-    if (input.constraints) {
-      span.setAttribute("model.constraints", JSON.stringify(input.constraints));
-    }
-    return result;
-  });
-}
-// src/tracing/middleware.ts
-function createTracingMiddleware(options = {}) {
-  return async (req, next) => {
-    const method = req.method;
-    const url = new URL(req.url);
-    const path = url.pathname;
-    standardMetrics.httpRequests.add(1, { method, path });
-    const startTime = performance.now();
-    return traceAsync(`HTTP ${method} ${path}`, async (span) => {
-      span.setAttribute("http.method", method);
-      span.setAttribute("http.url", req.url);
-      try {
-        const response = await next();
-        span.setAttribute("http.status_code", response.status);
-        const duration = (performance.now() - startTime) / 1000;
-        standardMetrics.httpDuration.record(duration, {
-          method,
-          path,
-          status: response.status.toString()
-        });
-        emitTelemetrySample({
-          req,
-          res: response,
-          span,
-          success: true,
-          durationMs: duration * 1000,
-          options
-        });
-        return response;
-      } catch (error) {
-        standardMetrics.operationErrors.add(1, { method, path });
-        emitTelemetrySample({
-          req,
-          span,
-          success: false,
-          durationMs: performance.now() - startTime,
-          error,
-          options
-        });
-        throw error;
-      }
-    });
-  };
-}
-function emitTelemetrySample({
-  req,
-  res,
-  span,
-  success,
-  durationMs,
-  error,
-  options
-}) {
-  if (!options.onSample || !options.resolveOperation)
-    return;
-  const operation = options.resolveOperation({ req, res });
-  if (!operation)
-    return;
-  const sample = {
-    operation,
-    durationMs,
-    success,
-    timestamp: new Date,
-    errorCode: !success && error instanceof Error ? error.name : success ? undefined : "unknown",
-    tenantId: options.tenantResolver?.(req),
-    actorId: options.actorResolver?.(req),
-    traceId: span.spanContext().traceId,
-    metadata: {
-      method: req.method,
-      path: new URL(req.url).pathname,
-      status: res?.status
-    }
-  };
-  options.onSample(sample);
-}
-export {
-  createTracingMiddleware
-};
+import{metrics as y}from"@opentelemetry/api";var R="@contractspec/lib.observability";function g(r=R){return y.getMeter(r)}function p(r,t,a){return g(a).createCounter(r,{description:t})}function A(r,t,a){return g(a).createUpDownCounter(r,{description:t})}function T(r,t,a){return g(a).createHistogram(r,{description:t})}var m={httpRequests:p("http_requests_total","Total HTTP requests"),httpDuration:T("http_request_duration_seconds","HTTP request duration"),operationErrors:p("operation_errors_total","Total operation errors"),workflowDuration:T("workflow_duration_seconds","Workflow execution duration")};import{SpanStatusCode as d,trace as S}from"@opentelemetry/api";var h="@contractspec/lib.observability";function l(r=h){return S.getTracer(r)}async function u(r,t,a){return l(a).startActiveSpan(r,async(n)=>{try{let e=await t(n);return n.setStatus({code:d.OK}),e}catch(e){throw n.recordException(e),n.setStatus({code:d.ERROR,message:e instanceof Error?e.message:String(e)}),e}finally{n.end()}})}function E(r,t,a){return l(a).startActiveSpan(r,(n)=>{try{let e=t(n);return n.setStatus({code:d.OK}),e}catch(e){throw n.recordException(e),n.setStatus({code:d.ERROR,message:e instanceof Error?e.message:String(e)}),e}finally{n.end()}})}async function D(r,t){let a=performance.now();return u("model.selection",async(o)=>{let n=await r(),e=performance.now()-a;if(o.setAttribute("model.selected",t.modelId),o.setAttribute("model.provider",t.providerKey),o.setAttribute("model.score",t.score),o.setAttribute("model.alternatives_count",t.alternativesCount),o.setAttribute("model.selection_duration_ms",e),o.setAttribute("model.reason",t.reason),t.dimension)o.setAttribute("model.dimension",t.dimension);if(t.constraints)o.setAttribute("model.constraints",JSON.stringify(t.constraints));return n})}function k(r={}){return async(t,a)=>{let o=t.method,e=new URL(t.url).pathname;m.httpRequests.add(1,{method:o,path:e});let s=performance.now();return u(`HTTP ${o} ${e}`,async(i)=>{i.setAttribute("http.method",o),i.setAttribute("http.url",t.url);try{let c=await a();i.setAttribute("http.status_code",c.status);let f=(performance.now()-s)/1000;return m.httpDuration.record(f,{method:o,path:e,status:c.status.toString()}),w({req:t,res:c,span:i,success:!0,durationMs:f*1000,options:r}),c}catch(c){throw m.operationErrors.add(1,{method:o,path:e}),w({req:t,span:i,success:!1,durationMs:performance.now()-s,error:c,options:r}),c}})}}function w({req:r,res:t,span:a,success:o,durationMs:n,error:e,options:s}){if(!s.onSample||!s.resolveOperation)return;let i=s.resolveOperation({req:r,res:t});if(!i)return;let c={operation:i,durationMs:n,success:o,timestamp:new Date,errorCode:!o&&e instanceof Error?e.name:o?void 0:"unknown",tenantId:s.tenantResolver?.(r),actorId:s.actorResolver?.(r),traceId:a.spanContext().traceId,metadata:{method:r.method,path:new URL(r.url).pathname,status:t?.status}};s.onSample(c)}export{k as createTracingMiddleware};

package/dist/node/tracing/model-selection.span.js

@@ -1,72 +1 @@
-// src/tracing/core.ts
-import {
-  SpanStatusCode,
-  trace
-} from "@opentelemetry/api";
-var DEFAULT_TRACER_NAME = "@contractspec/lib.observability";
-function getTracer(name = DEFAULT_TRACER_NAME) {
-  return trace.getTracer(name);
-}
-async function traceAsync(name, fn, tracerName) {
-  const tracer = getTracer(tracerName);
-  return tracer.startActiveSpan(name, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-function traceSync(name, fn, tracerName) {
-  const tracer = getTracer(tracerName);
-  return tracer.startActiveSpan(name, (span) => {
-    try {
-      const result = fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-
-// src/tracing/model-selection.span.ts
-async function traceModelSelection(fn, input) {
-  const startMs = performance.now();
-  return traceAsync("model.selection", async (span) => {
-    const result = await fn();
-    const durationMs = performance.now() - startMs;
-    span.setAttribute("model.selected", input.modelId);
-    span.setAttribute("model.provider", input.providerKey);
-    span.setAttribute("model.score", input.score);
-    span.setAttribute("model.alternatives_count", input.alternativesCount);
-    span.setAttribute("model.selection_duration_ms", durationMs);
-    span.setAttribute("model.reason", input.reason);
-    if (input.dimension) {
-      span.setAttribute("model.dimension", input.dimension);
-    }
-    if (input.constraints) {
-      span.setAttribute("model.constraints", JSON.stringify(input.constraints));
-    }
-    return result;
-  });
-}
-export {
-  traceModelSelection
-};
+import{SpanStatusCode as g,trace as R}from"@opentelemetry/api";var m="@contractspec/lib.observability";function E(o=m){return R.getTracer(o)}async function T(o,e,S){return E(S).startActiveSpan(o,async(t)=>{try{let r=await e(t);return t.setStatus({code:g.OK}),r}catch(r){throw t.recordException(r),t.setStatus({code:g.ERROR,message:r instanceof Error?r.message:String(r)}),r}finally{t.end()}})}function f(o,e,S){return E(S).startActiveSpan(o,(t)=>{try{let r=e(t);return t.setStatus({code:g.OK}),r}catch(r){throw t.recordException(r),t.setStatus({code:g.ERROR,message:r instanceof Error?r.message:String(r)}),r}finally{t.end()}})}async function v(o,e){let S=performance.now();return T("model.selection",async(c)=>{let t=await o(),r=performance.now()-S;if(c.setAttribute("model.selected",e.modelId),c.setAttribute("model.provider",e.providerKey),c.setAttribute("model.score",e.score),c.setAttribute("model.alternatives_count",e.alternativesCount),c.setAttribute("model.selection_duration_ms",r),c.setAttribute("model.reason",e.reason),e.dimension)c.setAttribute("model.dimension",e.dimension);if(e.constraints)c.setAttribute("model.constraints",JSON.stringify(e.constraints));return t})}export{v as traceModelSelection};

package/dist/pipeline/evolution-pipeline.js

@@ -1,300 +1,2 @@
 // @bun
-// src/intent/aggregator.ts
-var DEFAULT_WINDOW_MS = 15 * 60 * 1000;
-
-class IntentAggregator {
-  windowMs;
-  sequenceSampleSize;
-  samples = [];
-  constructor(options = {}) {
-    this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
-    this.sequenceSampleSize = options.sequenceSampleSize ?? 1000;
-  }
-  add(sample) {
-    this.samples.push(sample);
-  }
-  flush(now = new Date) {
-    const minTimestamp = now.getTime() - this.windowMs;
-    const windowSamples = this.samples.filter((sample) => sample.timestamp.getTime() >= minTimestamp);
-    this.samples.length = 0;
-    const metrics = this.aggregateMetrics(windowSamples);
-    const sequences = this.buildSequences(windowSamples);
-    const timestamps = windowSamples.map((sample) => sample.timestamp.getTime());
-    return {
-      metrics,
-      sequences,
-      sampleCount: windowSamples.length,
-      windowStart: timestamps.length ? new Date(Math.min(...timestamps)) : undefined,
-      windowEnd: timestamps.length ? new Date(Math.max(...timestamps)) : undefined
-    };
-  }
-  aggregateMetrics(samples) {
-    if (!samples.length)
-      return [];
-    const groups = new Map;
-    for (const sample of samples) {
-      const key = `${sample.operation.name}.v${sample.operation.version}`;
-      const arr = groups.get(key) ?? [];
-      arr.push(sample);
-      groups.set(key, arr);
-    }
-    return [...groups.values()].map((group) => {
-      const first = group[0];
-      if (!first)
-        throw new Error("Empty group in aggregation");
-      const durations = group.map((s) => s.durationMs).sort((a, b) => a - b);
-      const errors = group.filter((s) => !s.success);
-      const totalCalls = group.length;
-      const topErrors = errors.reduce((acc, sample) => {
-        if (!sample.errorCode)
-          return acc;
-        acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;
-        return acc;
-      }, {});
-      const timestamps = group.map((s) => s.timestamp.getTime());
-      return {
-        operation: first.operation,
-        totalCalls,
-        successRate: (totalCalls - errors.length) / totalCalls,
-        errorRate: errors.length / totalCalls,
-        averageLatencyMs: durations.reduce((sum, value) => sum + value, 0) / totalCalls,
-        p95LatencyMs: percentile(durations, 0.95),
-        p99LatencyMs: percentile(durations, 0.99),
-        maxLatencyMs: Math.max(...durations),
-        windowStart: new Date(Math.min(...timestamps)),
-        windowEnd: new Date(Math.max(...timestamps)),
-        topErrors
-      };
-    });
-  }
-  buildSequences(samples) {
-    const byTrace = new Map;
-    for (const sample of samples.slice(-this.sequenceSampleSize)) {
-      if (!sample.traceId)
-        continue;
-      const arr = byTrace.get(sample.traceId) ?? [];
-      arr.push(sample);
-      byTrace.set(sample.traceId, arr);
-    }
-    const sequences = {};
-    for (const events of byTrace.values()) {
-      const ordered = events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      const steps = ordered.map((event) => event.operation.name);
-      if (steps.length < 2)
-        continue;
-      const key = `${steps.join(">")}@${ordered[0]?.tenantId ?? "global"}`;
-      const existing = sequences[key];
-      if (existing) {
-        existing.count += 1;
-      } else {
-        sequences[key] = {
-          steps,
-          tenantId: ordered[0]?.tenantId,
-          count: 1
-        };
-      }
-    }
-    return Object.values(sequences).sort((a, b) => b.count - a.count);
-  }
-}
-function percentile(values, ratio) {
-  if (!values.length)
-    return 0;
-  if (values.length === 1)
-    return values[0] ?? 0;
-  const index = Math.min(values.length - 1, Math.floor(ratio * values.length));
-  return values[index] ?? 0;
-}
-
-// src/intent/detector.ts
-import { randomUUID } from "crypto";
-var DEFAULTS = {
-  errorRateThreshold: 0.05,
-  latencyP99ThresholdMs: 750,
-  throughputDropThreshold: 0.3,
-  minSequenceLength: 3
-};
-
-class IntentDetector {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      errorRateThreshold: options.errorRateThreshold ?? DEFAULTS.errorRateThreshold,
-      latencyP99ThresholdMs: options.latencyP99ThresholdMs ?? DEFAULTS.latencyP99ThresholdMs,
-      throughputDropThreshold: options.throughputDropThreshold ?? DEFAULTS.throughputDropThreshold,
-      minSequenceLength: options.minSequenceLength ?? DEFAULTS.minSequenceLength
-    };
-  }
-  detectFromMetrics(current, previous) {
-    const signals = [];
-    const baseline = new Map((previous ?? []).map((metric) => [
-      `${metric.operation.name}.v${metric.operation.version}`,
-      metric
-    ]));
-    for (const metric of current) {
-      if (metric.errorRate >= this.options.errorRateThreshold) {
-        signals.push({
-          id: randomUUID(),
-          type: "error-spike",
-          operation: metric.operation,
-          confidence: Math.min(1, metric.errorRate / this.options.errorRateThreshold),
-          description: `Error rate ${metric.errorRate.toFixed(2)} exceeded threshold`,
-          metadata: {
-            errorRate: metric.errorRate,
-            topErrors: metric.topErrors
-          },
-          evidence: [
-            {
-              type: "metric",
-              description: "error-rate",
-              data: {
-                errorRate: metric.errorRate,
-                threshold: this.options.errorRateThreshold
-              }
-            }
-          ]
-        });
-        continue;
-      }
-      if (metric.p99LatencyMs >= this.options.latencyP99ThresholdMs) {
-        signals.push({
-          id: randomUUID(),
-          type: "latency-regression",
-          operation: metric.operation,
-          confidence: Math.min(1, metric.p99LatencyMs / this.options.latencyP99ThresholdMs),
-          description: `P99 latency ${metric.p99LatencyMs}ms exceeded threshold`,
-          metadata: { p99LatencyMs: metric.p99LatencyMs },
-          evidence: [
-            {
-              type: "metric",
-              description: "p99-latency",
-              data: {
-                p99LatencyMs: metric.p99LatencyMs,
-                threshold: this.options.latencyP99ThresholdMs
-              }
-            }
-          ]
-        });
-        continue;
-      }
-      const base = baseline.get(`${metric.operation.name}.v${metric.operation.version}`);
-      if (base) {
-        const drop = (base.totalCalls - metric.totalCalls) / Math.max(base.totalCalls, 1);
-        if (drop >= this.options.throughputDropThreshold) {
-          signals.push({
-            id: randomUUID(),
-            type: "throughput-drop",
-            operation: metric.operation,
-            confidence: Math.min(1, drop / this.options.throughputDropThreshold),
-            description: `Throughput dropped ${(drop * 100).toFixed(1)}% vs baseline`,
-            metadata: {
-              baselineCalls: base.totalCalls,
-              currentCalls: metric.totalCalls
-            },
-            evidence: [
-              {
-                type: "metric",
-                description: "throughput-drop",
-                data: {
-                  baselineCalls: base.totalCalls,
-                  currentCalls: metric.totalCalls
-                }
-              }
-            ]
-          });
-        }
-      }
-    }
-    return signals;
-  }
-  detectSequentialIntents(sequences) {
-    const signals = [];
-    for (const sequence of sequences) {
-      if (sequence.steps.length < this.options.minSequenceLength)
-        continue;
-      const description = sequence.steps.join(" \u2192 ");
-      signals.push({
-        id: randomUUID(),
-        type: "missing-workflow-step",
-        confidence: 0.6,
-        description: `Repeated workflow detected: ${description}`,
-        metadata: {
-          steps: sequence.steps,
-          tenantId: sequence.tenantId,
-          occurrences: sequence.count
-        },
-        evidence: [
-          {
-            type: "sequence",
-            description: "sequential-calls",
-            data: { steps: sequence.steps, count: sequence.count }
-          }
-        ]
-      });
-    }
-    return signals;
-  }
-}
-
-// src/pipeline/evolution-pipeline.ts
-import { EventEmitter } from "events";
-class EvolutionPipeline {
-  detector;
-  aggregator;
-  emitter;
-  onIntent;
-  onSnapshot;
-  timer;
-  previousMetrics;
-  constructor(options = {}) {
-    this.detector = options.detector ?? new IntentDetector;
-    this.aggregator = options.aggregator ?? new IntentAggregator;
-    this.emitter = options.emitter ?? new EventEmitter;
-    this.onIntent = options.onIntent;
-    this.onSnapshot = options.onSnapshot;
-  }
-  ingest(sample) {
-    this.aggregator.add(sample);
-  }
-  on(listener) {
-    this.emitter.on("event", listener);
-  }
-  start(intervalMs = 5 * 60 * 1000) {
-    this.stop();
-    this.timer = setInterval(() => {
-      this.run();
-    }, intervalMs);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = undefined;
-    }
-  }
-  async run() {
-    const snapshot = this.aggregator.flush();
-    this.emit({
-      type: "telemetry.window",
-      payload: { sampleCount: snapshot.sampleCount }
-    });
-    if (this.onSnapshot)
-      await this.onSnapshot(snapshot);
-    if (!snapshot.sampleCount)
-      return;
-    const metricSignals = this.detector.detectFromMetrics(snapshot.metrics, this.previousMetrics);
-    const sequenceSignals = this.detector.detectSequentialIntents(snapshot.sequences);
-    this.previousMetrics = snapshot.metrics;
-    const signals = [...metricSignals, ...sequenceSignals];
-    for (const signal of signals) {
-      if (this.onIntent)
-        await this.onIntent(signal);
-      this.emit({ type: "intent.detected", payload: signal });
-    }
-  }
-  emit(event) {
-    this.emitter.emit("event", event);
-  }
-}
-export {
-  EvolutionPipeline
-};
+class g{windowMs;sequenceSampleSize;samples=[];constructor(e={}){this.windowMs=e.windowMs??900000,this.sequenceSampleSize=e.sequenceSampleSize??1000}add(e){this.samples.push(e)}flush(e=new Date){let o=e.getTime()-this.windowMs,n=this.samples.filter((i)=>i.timestamp.getTime()>=o);this.samples.length=0;let r=this.aggregateMetrics(n),t=this.buildSequences(n),s=n.map((i)=>i.timestamp.getTime());return{metrics:r,sequences:t,sampleCount:n.length,windowStart:s.length?new Date(Math.min(...s)):void 0,windowEnd:s.length?new Date(Math.max(...s)):void 0}}aggregateMetrics(e){if(!e.length)return[];let o=new Map;for(let n of e){let r=`${n.operation.name}.v${n.operation.version}`,t=o.get(r)??[];t.push(n),o.set(r,t)}return[...o.values()].map((n)=>{let r=n[0];if(!r)throw Error("Empty group in aggregation");let t=n.map((a)=>a.durationMs).sort((a,p)=>a-p),s=n.filter((a)=>!a.success),i=n.length,l=s.reduce((a,p)=>{if(!p.errorCode)return a;return a[p.errorCode]=(a[p.errorCode]??0)+1,a},{}),c=n.map((a)=>a.timestamp.getTime());return{operation:r.operation,totalCalls:i,successRate:(i-s.length)/i,errorRate:s.length/i,averageLatencyMs:t.reduce((a,p)=>a+p,0)/i,p95LatencyMs:u(t,0.95),p99LatencyMs:u(t,0.99),maxLatencyMs:Math.max(...t),windowStart:new Date(Math.min(...c)),windowEnd:new Date(Math.max(...c)),topErrors:l}})}buildSequences(e){let o=new Map;for(let r of e.slice(-this.sequenceSampleSize)){if(!r.traceId)continue;let t=o.get(r.traceId)??[];t.push(r),o.set(r.traceId,t)}let n={};for(let r of o.values()){let t=r.sort((c,a)=>c.timestamp.getTime()-a.timestamp.getTime()),s=t.map((c)=>c.operation.name);if(s.length<2)continue;let i=`${s.join(">")}@${t[0]?.tenantId??"global"}`,l=n[i];if(l)l.count+=1;else n[i]={steps:s,tenantId:t[0]?.tenantId,count:1}}return Object.values(n).sort((r,t)=>t.count-r.count)}}function u(e,o){if(!e.length)return 0;if(e.length===1)return e[0]??0;let n=Math.min(e.length-1,Math.floor(o*e.length));return e[n]??0}import{randomUUID as d}from"crypto";var h={errorRateThreshold:0.05,latencyP99ThresholdMs:750,throughputDropThreshold:0.3,minSequenceLength:3};class m{options;constructor(e={}){this.options={errorRateThreshold:e.errorRateThreshold??h.errorRateThreshold,latencyP99ThresholdMs:e.latencyP99ThresholdMs??h.latencyP99ThresholdMs,throughputDropThreshold:e.throughputDropThreshold??h.throughputDropThreshold,minSequenceLength:e.minSequenceLength??h.minSequenceLength}}detectFromMetrics(e,o){let n=[],r=new Map((o??[]).map((t)=>[`${t.operation.name}.v${t.operation.version}`,t]));for(let t of e){if(t.errorRate>=this.options.errorRateThreshold){n.push({id:d(),type:"error-spike",operation:t.operation,confidence:Math.min(1,t.errorRate/this.options.errorRateThreshold),description:`Error rate ${t.errorRate.toFixed(2)} exceeded threshold`,metadata:{errorRate:t.errorRate,topErrors:t.topErrors},evidence:[{type:"metric",description:"error-rate",data:{errorRate:t.errorRate,threshold:this.options.errorRateThreshold}}]});continue}if(t.p99LatencyMs>=this.options.latencyP99ThresholdMs){n.push({id:d(),type:"latency-regression",operation:t.operation,confidence:Math.min(1,t.p99LatencyMs/this.options.latencyP99ThresholdMs),description:`P99 latency ${t.p99LatencyMs}ms exceeded threshold`,metadata:{p99LatencyMs:t.p99LatencyMs},evidence:[{type:"metric",description:"p99-latency",data:{p99LatencyMs:t.p99LatencyMs,threshold:this.options.latencyP99ThresholdMs}}]});continue}let s=r.get(`${t.operation.name}.v${t.operation.version}`);if(s){let i=(s.totalCalls-t.totalCalls)/Math.max(s.totalCalls,1);if(i>=this.options.throughputDropThreshold)n.push({id:d(),type:"throughput-drop",operation:t.operation,confidence:Math.min(1,i/this.options.throughputDropThreshold),description:`Throughput dropped ${(i*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:s.totalCalls,currentCalls:t.totalCalls},evidence:[{type:"metric",description:"throughput-drop",data:{baselineCalls:s.totalCalls,currentCalls:t.totalCalls}}]})}}return n}detectSequentialIntents(e){let o=[];for(let n of e){if(n.steps.length<this.options.minSequenceLength)continue;let r=n.steps.join(" \u2192 ");o.push({id:d(),type:"missing-workflow-step",confidence:0.6,description:`Repeated workflow detected: ${r}`,metadata:{steps:n.steps,tenantId:n.tenantId,occurrences:n.count},evidence:[{type:"sequence",description:"sequential-calls",data:{steps:n.steps,count:n.count}}]})}return o}}import{EventEmitter as y}from"events";class S{detector;aggregator;emitter;onIntent;onSnapshot;timer;previousMetrics;constructor(e={}){this.detector=e.detector??new m,this.aggregator=e.aggregator??new g,this.emitter=e.emitter??new y,this.onIntent=e.onIntent,this.onSnapshot=e.onSnapshot}ingest(e){this.aggregator.add(e)}on(e){this.emitter.on("event",e)}start(e=300000){this.stop(),this.timer=setInterval(()=>{this.run()},e)}stop(){if(this.timer)clearInterval(this.timer),this.timer=void 0}async run(){let e=this.aggregator.flush();if(this.emit({type:"telemetry.window",payload:{sampleCount:e.sampleCount}}),this.onSnapshot)await this.onSnapshot(e);if(!e.sampleCount)return;let o=this.detector.detectFromMetrics(e.metrics,this.previousMetrics),n=this.detector.detectSequentialIntents(e.sequences);this.previousMetrics=e.metrics;let r=[...o,...n];for(let t of r){if(this.onIntent)await this.onIntent(t);this.emit({type:"intent.detected",payload:t})}}emit(e){this.emitter.emit("event",e)}}export{S as EvolutionPipeline};

package/dist/pipeline/lifecycle-pipeline.js

@@ -1,86 +1,2 @@
 // @bun
-// src/metrics/index.ts
-import {
-  metrics
-} from "@opentelemetry/api";
-var DEFAULT_METER_NAME = "@contractspec/lib.observability";
-function getMeter(name = DEFAULT_METER_NAME) {
-  return metrics.getMeter(name);
-}
-function createCounter(name, description, meterName) {
-  return getMeter(meterName).createCounter(name, { description });
-}
-function createUpDownCounter(name, description, meterName) {
-  return getMeter(meterName).createUpDownCounter(name, { description });
-}
-function createHistogram(name, description, meterName) {
-  return getMeter(meterName).createHistogram(name, { description });
-}
-var standardMetrics = {
-  httpRequests: createCounter("http_requests_total", "Total HTTP requests"),
-  httpDuration: createHistogram("http_request_duration_seconds", "HTTP request duration"),
-  operationErrors: createCounter("operation_errors_total", "Total operation errors"),
-  workflowDuration: createHistogram("workflow_duration_seconds", "Workflow execution duration")
-};
-
-// src/pipeline/lifecycle-pipeline.ts
-import { EventEmitter } from "events";
-import { getStageLabel } from "@contractspec/lib.lifecycle";
-class LifecycleKpiPipeline {
-  assessmentCounter;
-  confidenceHistogram;
-  stageUpDownCounter;
-  emitter;
-  lowConfidenceThreshold;
-  currentStageByTenant = new Map;
-  constructor(options = {}) {
-    const meterName = options.meterName ?? "@contractspec/lib.lifecycle-kpi";
-    this.assessmentCounter = createCounter("lifecycle_assessments_total", "Total lifecycle assessments", meterName);
-    this.confidenceHistogram = createHistogram("lifecycle_assessment_confidence", "Lifecycle assessment confidence distribution", meterName);
-    this.stageUpDownCounter = createUpDownCounter("lifecycle_stage_tenants", "Current tenants per lifecycle stage", meterName);
-    this.emitter = options.emitter ?? new EventEmitter;
-    this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? 0.4;
-  }
-  recordAssessment(assessment, tenantId) {
-    const stageLabel = getStageLabel(assessment.stage);
-    const attributes = { stage: stageLabel, tenantId };
-    this.assessmentCounter.add(1, attributes);
-    this.confidenceHistogram.record(assessment.confidence, attributes);
-    this.ensureStageCounters(assessment.stage, tenantId);
-    this.emitter.emit("event", {
-      type: "assessment.recorded",
-      payload: { tenantId, stage: assessment.stage }
-    });
-    if (assessment.confidence < this.lowConfidenceThreshold) {
-      this.emitter.emit("event", {
-        type: "confidence.low",
-        payload: { tenantId, confidence: assessment.confidence }
-      });
-    }
-  }
-  on(listener) {
-    this.emitter.on("event", listener);
-  }
-  ensureStageCounters(stage, tenantId) {
-    if (!tenantId)
-      return;
-    const previous = this.currentStageByTenant.get(tenantId);
-    if (previous === stage)
-      return;
-    if (previous !== undefined) {
-      this.stageUpDownCounter.add(-1, {
-        stage: getStageLabel(previous),
-        tenantId
-      });
-    }
-    this.stageUpDownCounter.add(1, { stage: getStageLabel(stage), tenantId });
-    this.currentStageByTenant.set(tenantId, stage);
-    this.emitter.emit("event", {
-      type: "stage.changed",
-      payload: { tenantId, previousStage: previous, nextStage: stage }
-    });
-  }
-}
-export {
-  LifecycleKpiPipeline
-};
+import{metrics as l}from"@opentelemetry/api";var p="@contractspec/lib.observability";function o(e=p){return l.getMeter(e)}function n(e,t,r){return o(r).createCounter(e,{description:t})}function a(e,t,r){return o(r).createUpDownCounter(e,{description:t})}function i(e,t,r){return o(r).createHistogram(e,{description:t})}var d={httpRequests:n("http_requests_total","Total HTTP requests"),httpDuration:i("http_request_duration_seconds","HTTP request duration"),operationErrors:n("operation_errors_total","Total operation errors"),workflowDuration:i("workflow_duration_seconds","Workflow execution duration")};import{EventEmitter as f}from"events";import{getStageLabel as s}from"@contractspec/lib.lifecycle";class g{assessmentCounter;confidenceHistogram;stageUpDownCounter;emitter;lowConfidenceThreshold;currentStageByTenant=new Map;constructor(e={}){let t=e.meterName??"@contractspec/lib.lifecycle-kpi";this.assessmentCounter=n("lifecycle_assessments_total","Total lifecycle assessments",t),this.confidenceHistogram=i("lifecycle_assessment_confidence","Lifecycle assessment confidence distribution",t),this.stageUpDownCounter=a("lifecycle_stage_tenants","Current tenants per lifecycle stage",t),this.emitter=e.emitter??new f,this.lowConfidenceThreshold=e.lowConfidenceThreshold??0.4}recordAssessment(e,t){let c={stage:s(e.stage),tenantId:t};if(this.assessmentCounter.add(1,c),this.confidenceHistogram.record(e.confidence,c),this.ensureStageCounters(e.stage,t),this.emitter.emit("event",{type:"assessment.recorded",payload:{tenantId:t,stage:e.stage}}),e.confidence<this.lowConfidenceThreshold)this.emitter.emit("event",{type:"confidence.low",payload:{tenantId:t,confidence:e.confidence}})}on(e){this.emitter.on("event",e)}ensureStageCounters(e,t){if(!t)return;let r=this.currentStageByTenant.get(t);if(r===e)return;if(r!==void 0)this.stageUpDownCounter.add(-1,{stage:s(r),tenantId:t});this.stageUpDownCounter.add(1,{stage:s(e),tenantId:t}),this.currentStageByTenant.set(t,e),this.emitter.emit("event",{type:"stage.changed",payload:{tenantId:t,previousStage:r,nextStage:e}})}}export{g as LifecycleKpiPipeline};

package/dist/telemetry/model-selection-telemetry.js

@@ -1,31 +1,2 @@
 // @bun
-// src/telemetry/model-selection-telemetry.ts
-class ModelSelectionTelemetry {
-  provider;
-  eventName;
-  constructor(provider, options) {
-    this.provider = provider;
-    this.eventName = options?.eventName ?? "$model_selection";
-  }
-  async trackSelection(distinctId, properties) {
-    await this.provider.capture({
-      distinctId,
-      event: this.eventName,
-      timestamp: new Date,
-      properties: {
-        $model_id: properties.modelId,
-        $model_provider: properties.providerKey,
-        $model_score: properties.score,
-        $model_dimension: properties.dimension ?? null,
-        $model_reason: properties.reason,
-        $model_alternatives_count: properties.alternativesCount,
-        $model_cost_estimate_input: properties.costEstimateInput ?? null,
-        $model_cost_estimate_output: properties.costEstimateOutput ?? null,
-        $model_selection_duration_ms: properties.selectionDurationMs ?? null
-      }
-    });
-  }
-}
-export {
-  ModelSelectionTelemetry
-};
+class x{provider;eventName;constructor(q,j){this.provider=q,this.eventName=j?.eventName??"$model_selection"}async trackSelection(q,j){await this.provider.capture({distinctId:q,event:this.eventName,timestamp:new Date,properties:{$model_id:j.modelId,$model_provider:j.providerKey,$model_score:j.score,$model_dimension:j.dimension??null,$model_reason:j.reason,$model_alternatives_count:j.alternativesCount,$model_cost_estimate_input:j.costEstimateInput??null,$model_cost_estimate_output:j.costEstimateOutput??null,$model_selection_duration_ms:j.selectionDurationMs??null}})}}export{x as ModelSelectionTelemetry};