@observyze/sdk 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -3,24 +3,43 @@ import {
   Span,
   SpanType,
   Trace,
-  TraceStatus,
-  __esm,
-  __export,
-  __require,
-  __toCommonJS,
-  init_types
-} from "./chunk-YRMQCX2P.mjs";
+  TraceStatus
+} from "./chunk-FQBYUOJB.mjs";
+
+// src/client.ts
+import debug3 from "debug";
 
 // src/instrumentation/openai.ts
+import debug from "debug";
+var log = debug("observyze:sdk");
 function wrapOpenAI(client, nwClient) {
   const anyClient = client;
+  if (nwClient.getConfig().enableProxyRedirect && anyClient.baseURL && anyClient.apiKey) {
+    const isAlreadyRedirected = anyClient.baseURL.includes("/api/v1/proxy/openai");
+    if (!isAlreadyRedirected) {
+      const originalApiKey = anyClient.apiKey;
+      anyClient.baseURL = `${nwClient.getConfig().endpoint}/api/v1/proxy/openai/v1`;
+      anyClient.apiKey = nwClient.getConfig().apiKey;
+      anyClient.defaultHeaders = {
+        ...anyClient.defaultHeaders,
+        "x-provider-key": originalApiKey
+      };
+      if (nwClient.getConfig().debug) {
+        log("[Observyze SDK] Transparently redirected OpenAI client to proxy gateway:", anyClient.baseURL);
+      }
+    }
+  }
   const originalCreate = client.chat.completions.create.bind(client.chat.completions);
   client.chat.completions.create = async function(params, options) {
+    const isProxyRedirected = nwClient.getConfig().enableProxyRedirect && anyClient.baseURL?.includes("/api/v1/proxy/openai");
+    if (isProxyRedirected) {
+      return originalCreate(params, options);
+    }
     const trace = nwClient.startTrace(`openai.chat.completions.create`, {
       provider: "openai",
       model: params.model
     });
-    const span = trace.startSpan("chat.completions.create", "llm" /* LLM */);
+    const span = trace.startSpan("chat.completions.create", SpanType.LLM);
     span.setMetadata("model", params.model);
     span.setMetadata("provider", "openai");
     if (params.temperature !== void 0) span.setMetadata("temperature", params.temperature);
@@ -104,23 +123,38 @@ function wrapOpenAIStream(stream, span, trace, startTime) {
     }
   };
 }
-var init_openai = __esm({
-  "src/instrumentation/openai.ts"() {
-    "use strict";
-    init_types();
-  }
-});
 
 // src/instrumentation/anthropic.ts
+import debug2 from "debug";
+var log2 = debug2("observyze:sdk");
 function wrapAnthropic(client, nwClient) {
   const anyClient = client;
+  if (nwClient.getConfig().enableProxyRedirect && anyClient.baseURL && anyClient.apiKey) {
+    const isAlreadyRedirected = anyClient.baseURL.includes("/api/v1/proxy/anthropic");
+    if (!isAlreadyRedirected) {
+      const originalApiKey = anyClient.apiKey;
+      anyClient.baseURL = `${nwClient.getConfig().endpoint}/api/v1/proxy/anthropic/v1`;
+      anyClient.apiKey = nwClient.getConfig().apiKey;
+      anyClient.defaultHeaders = {
+        ...anyClient.defaultHeaders,
+        "x-provider-key": originalApiKey
+      };
+      if (nwClient.getConfig().debug) {
+        log2("[Observyze SDK] Transparently redirected Anthropic client to proxy gateway:", anyClient.baseURL);
+      }
+    }
+  }
   const originalCreate = client.messages.create.bind(client.messages);
   client.messages.create = async function(params, options) {
+    const isProxyRedirected = nwClient.getConfig().enableProxyRedirect && anyClient.baseURL?.includes("/api/v1/proxy/anthropic");
+    if (isProxyRedirected) {
+      return originalCreate(params, options);
+    }
     const trace = nwClient.startTrace(`anthropic.messages.create`, {
       provider: "anthropic",
       model: params.model
     });
-    const span = trace.startSpan("messages.create", "llm" /* LLM */);
+    const span = trace.startSpan("messages.create", SpanType.LLM);
     span.setMetadata("model", params.model);
     span.setMetadata("provider", "anthropic");
     if (params.temperature !== void 0) span.setMetadata("temperature", params.temperature);
@@ -231,20 +265,8 @@ function wrapAnthropicStream(stream, span, trace, startTime) {
     }
   };
 }
-var init_anthropic = __esm({
-  "src/instrumentation/anthropic.ts"() {
-    "use strict";
-    init_types();
-  }
-});
 
 // src/instrumentation/index.ts
-var instrumentation_exports = {};
-__export(instrumentation_exports, {
-  wrap: () => wrap,
-  wrapAnthropic: () => wrapAnthropic,
-  wrapOpenAI: () => wrapOpenAI
-});
 function wrap(client, nwClient) {
   if ("chat" in client && client.chat && "completions" in client.chat) {
     return wrapOpenAI(client, nwClient);
@@ -256,26 +278,26 @@ function wrap(client, nwClient) {
     "Observyze SDK: Unsupported client type. Supported clients: OpenAI, Anthropic"
   );
 }
-var init_instrumentation = __esm({
-  "src/instrumentation/index.ts"() {
-    "use strict";
-    init_openai();
-    init_anthropic();
-    init_openai();
-    init_anthropic();
-  }
-});
 
 // src/client.ts
-init_types();
+import fs from "fs";
+import path from "path";
+var log3 = debug3("observyze:sdk");
 var DEFAULT_CONFIG = {
-  endpoint: "https://api.observyze.com",
+  endpoint: "http://localhost:3001",
   batchSize: 100,
   flushInterval: 5e3,
   enableAutoInstrumentation: true,
   debug: false,
   dryRun: false,
-  enablePiiRedaction: true
+  enablePiiRedaction: true,
+  hallucinationThreshold: 0.8,
+  safetyThreshold: 0.9,
+  confidenceThreshold: 0.4,
+  evalEndpoint: process.env.EVAL_ENDPOINT || (process.env.NODE_ENV === "production" ? "https://api.observyze.com" : "http://localhost:3001"),
+  enableCircuitBreaker: true,
+  failClosed: true,
+  enableProxyRedirect: true
 };
 var ObservyzeClient = class _ObservyzeClient {
   config;
@@ -284,7 +306,37 @@ var ObservyzeClient = class _ObservyzeClient {
   isShuttingDown = false;
   MAX_QUEUE_SIZE = 1e3;
   RETRY_DELAYS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
-  // ms: 1s → 2s → 4s → 8s → 16s → 30s
+  /**
+   * Parse a JSON API error response and extract trace_id, error code, and message.
+   * The api-gateway error handler includes these fields in every error response.
+   */
+  static parseApiError(_response, body) {
+    try {
+      const parsed = JSON.parse(body);
+      const error = parsed.error || parsed;
+      return {
+        traceId: error.trace_id || "unknown",
+        code: error.code || "UNKNOWN_ERROR",
+        message: error.message || body.slice(0, 200)
+      };
+    } catch {
+      return {
+        traceId: "unknown",
+        code: "UNKNOWN_ERROR",
+        message: body.slice(0, 200)
+      };
+    }
+  }
+  /**
+   * Format an API error into a user-friendly message with trace_id for correlation.
+   * Example output:
+   *   "Observyze API error (401 [ref: err_a1b2c3d4]): MISSING_PROVIDER_KEY — No API key configured..."
+   */
+  static formatApiError(response, body) {
+    const { traceId, code, message } = _ObservyzeClient.parseApiError(response, body);
+    const prefix = traceId !== "unknown" ? ` [ref: ${traceId}]` : "";
+    return `Observyze API error (${response.status}${prefix}): ${code} \u2014 ${message}`;
+  }
   constructor(config) {
     if (!config.apiKey) {
       throw new Error("Observyze SDK: apiKey is required");
@@ -297,7 +349,7 @@ var ObservyzeClient = class _ObservyzeClient {
     };
     this.startFlushTimer();
     if (this.config.debug) {
-      console.log("[Observyze SDK] Initialized with config:", {
+      log3("[Observyze SDK] Initialized with config:", {
         endpoint: this.config.endpoint,
         batchSize: this.config.batchSize,
         flushInterval: this.config.flushInterval,
@@ -318,7 +370,7 @@ var ObservyzeClient = class _ObservyzeClient {
       trace.setMetadataAll(metadata);
     }
     const originalEnd = trace.end.bind(trace);
-    trace.end = (status = "success" /* SUCCESS */) => {
+    trace.end = (status = TraceStatus.SUCCESS) => {
       originalEnd(status);
       this.bufferTrace(trace);
     };
@@ -330,23 +382,23 @@ var ObservyzeClient = class _ObservyzeClient {
   bufferTrace(trace) {
     if (!trace.isEnded) {
       if (this.config.debug) {
-        console.warn("[Observyze SDK] Attempted to buffer a trace that has not ended");
+        log3.extend("warn")("[Observyze SDK] Attempted to buffer a trace that has not ended");
       }
       return;
     }
     if (this.traceBuffer.length >= this.MAX_QUEUE_SIZE) {
       if (this.config.debug) {
-        console.warn(`[Observyze SDK] Queue at max capacity (${this.MAX_QUEUE_SIZE}), dropping oldest trace`);
+        log3.extend("warn")(`[Observyze SDK] Queue at max capacity (${this.MAX_QUEUE_SIZE}), dropping oldest trace`);
       }
       this.traceBuffer.shift();
     }
     this.traceBuffer.push(trace);
     if (this.config.debug) {
-      console.log(`[Observyze SDK] Buffered trace ${trace.id} (${this.traceBuffer.length}/${this.config.batchSize})`);
+      log3(`[Observyze SDK] Buffered trace ${trace.id} (${this.traceBuffer.length}/${this.config.batchSize})`);
     }
     if (this.traceBuffer.length >= this.config.batchSize) {
       this.flush().catch((err) => {
-        console.error("[Observyze SDK] Error flushing buffer:", err);
+        log3.extend("error")("[Observyze SDK] Error flushing buffer:", err);
       });
     }
   }
@@ -360,7 +412,7 @@ var ObservyzeClient = class _ObservyzeClient {
     this.flushTimer = setInterval(() => {
       if (this.traceBuffer.length > 0) {
         this.flush().catch((err) => {
-          console.error("[Observyze SDK] Error in auto-flush:", err);
+          log3.extend("error")("[Observyze SDK] Error in auto-flush:", err);
         });
       }
     }, this.config.flushInterval);
@@ -377,11 +429,11 @@ var ObservyzeClient = class _ObservyzeClient {
     }
     const tracesToSend = this.traceBuffer.splice(0, this.config.batchSize);
     if (this.config.debug) {
-      console.log(`[Observyze SDK] Flushing ${tracesToSend.length} traces`);
+      log3(`[Observyze SDK] Flushing ${tracesToSend.length} traces`);
     }
     if (this.config.dryRun) {
       if (this.config.debug) {
-        console.log("[Observyze SDK] Dry-run mode: traces not sent");
+        log3("[Observyze SDK] Dry-run mode: traces not sent");
       }
       return;
     }
@@ -392,15 +444,15 @@ var ObservyzeClient = class _ObservyzeClient {
       if (remainingSpace > 0) {
         this.traceBuffer.unshift(...tracesToSend.slice(0, remainingSpace));
         if (this.config.debug) {
-          console.log(`[Observyze SDK] Re-queued ${Math.min(tracesToSend.length, remainingSpace)} traces after failure`);
+          log3(`[Observyze SDK] Re-queued ${Math.min(tracesToSend.length, remainingSpace)} traces after failure`);
         }
       } else {
         if (this.config.debug) {
-          console.warn(`[Observyze SDK] Queue full, dropped ${tracesToSend.length} traces`);
+          log3.extend("warn")(`[Observyze SDK] Queue full, dropped ${tracesToSend.length} traces`);
         }
       }
       if (this.config.debug) {
-        console.error("[Observyze SDK] Failed to send traces after retries:", error);
+        log3.extend("error")("[Observyze SDK] Failed to send traces after retries:", error);
       }
       throw error;
     }
@@ -430,10 +482,11 @@ var ObservyzeClient = class _ObservyzeClient {
         });
         if (!response.ok) {
           const errorBody = await response.text();
-          throw new Error(`Ingestion failed: ${response.status} ${errorBody}`);
+          const formatted = _ObservyzeClient.formatApiError(response, errorBody);
+          throw new Error(`[Observyze SDK] Trace ingestion failed. ${formatted}`);
         }
         if (this.config.debug) {
-          console.log(`[Observyze SDK] Successfully sent ${traces.length} traces${attempt > 0 ? ` (after ${attempt} retries)` : ""}`);
+          log3(`[Observyze SDK] Successfully sent ${traces.length} traces${attempt > 0 ? ` (after ${attempt} retries)` : ""}`);
         }
         return;
       } catch (error) {
@@ -443,7 +496,7 @@ var ObservyzeClient = class _ObservyzeClient {
         }
         const delay = this.RETRY_DELAYS[attempt];
         if (this.config.debug) {
-          console.warn(`[Observyze SDK] Attempt ${attempt + 1} failed, retrying in ${delay}ms...`, error);
+          log3.extend("warn")(`[Observyze SDK] Attempt ${attempt + 1} failed, retrying in ${delay}ms...`, error);
         }
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
@@ -459,7 +512,7 @@ var ObservyzeClient = class _ObservyzeClient {
     }
     this.isShuttingDown = true;
     if (this.config.debug) {
-      console.log("[Observyze SDK] Shutting down...");
+      log3("[Observyze SDK] Shutting down...");
     }
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
@@ -468,10 +521,10 @@ var ObservyzeClient = class _ObservyzeClient {
     try {
       await this.flush();
     } catch (error) {
-      console.error("[Observyze SDK] Error during shutdown flush:", error);
+      log3.extend("error")("[Observyze SDK] Error during shutdown flush:", error);
     }
     if (this.config.debug) {
-      console.log("[Observyze SDK] Shutdown complete");
+      log3("[Observyze SDK] Shutdown complete");
     }
   }
   /**
@@ -508,8 +561,7 @@ var ObservyzeClient = class _ObservyzeClient {
    * ```
    */
   wrap(client) {
-    const { wrap: wrapClient } = (init_instrumentation(), __toCommonJS(instrumentation_exports));
-    return wrapClient(client, this);
+    return wrap(client, this);
   }
   /**
    * Sync local agent .history file to Observyze cloud
@@ -520,8 +572,6 @@ var ObservyzeClient = class _ObservyzeClient {
       if (typeof process === "undefined" || !process.versions?.node) {
         throw new Error("syncLocalHistory is only available in Node.js environments");
       }
-      const fs = __require("fs");
-      const path = __require("path");
       const fullPath = path.resolve(process.cwd(), filePath);
       if (!fs.existsSync(fullPath)) {
         throw new Error(`History file not found: ${fullPath}`);
@@ -537,7 +587,7 @@ var ObservyzeClient = class _ObservyzeClient {
         items = [items];
       }
       if (this.config.debug) {
-        console.log(`[Observyze SDK] Syncing ${items.length} traces from ${filePath}`);
+        log3(`[Observyze SDK] Syncing ${items.length} traces from ${filePath}`);
       }
       for (let i = 0; i < items.length; i += this.config.batchSize) {
         const batch = items.slice(i, i + this.config.batchSize);
@@ -551,14 +601,15 @@ var ObservyzeClient = class _ObservyzeClient {
         });
         if (!response.ok) {
           const errorBody = await response.text();
-          throw new Error(`Batch sync failed: ${response.status} ${errorBody}`);
+          const formatted = _ObservyzeClient.formatApiError(response, errorBody);
+          throw new Error(`[Observyze SDK] Local history sync failed. ${formatted}`);
         }
         if (this.config.debug) {
-          console.log(`[Observyze SDK] Synced batch of ${batch.length} traces from local history`);
+          log3(`[Observyze SDK] Synced batch of ${batch.length} traces from local history`);
         }
       }
     } catch (err) {
-      console.error("[Observyze SDK] Failed to sync local history:", err);
+      log3.extend("error")("[Observyze SDK] Failed to sync local history:", err);
       throw err;
     }
   }
@@ -655,11 +706,223 @@ var ObservyzeClient = class _ObservyzeClient {
     }
     return data;
   }
+  /**
+   * Phase 4: Autonomous Circuit Breakers (Requirement 4.1)
+   * Evaluate a trace or text for hallucination in real-time.
+   * If hallucination score > hallucinationThreshold, the SDK blocks execution.
+   * 
+   * Returns GuardrailResult with score: null when evaluation couldn't be performed.
+   * In failClosed mode, null scores result in blocked execution.
+   * In failOpen mode, null scores allow execution through.
+   */
+  async checkGuardrails(content) {
+    if (!this.config.enableCircuitBreaker) {
+      return { pass: true, score: 0, safetyScore: 0, evaluationSource: "disabled" };
+    }
+    try {
+      if (this.config.debug) {
+        log3(`[Observyze Guardrail] Analyzing payload for hallucination anomalies...`);
+      }
+      const evalEndpoint = this.config.evalEndpoint;
+      const payload = typeof content === "string" ? { text: content, organization_id: this.config.organizationId } : { trace: content, organization_id: this.config.organizationId };
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5e3);
+      let evalResult = null;
+      try {
+        const response = await fetch(`${evalEndpoint}/api/v1/evaluate/hallucination`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.apiKey}`
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+          evalResult = await response.json();
+        } else {
+          const errorBody = await response.text();
+          const { traceId, code, message } = _ObservyzeClient.parseApiError(response, errorBody);
+          if (this.config.debug) {
+            log3.extend("warn")(`[Observyze Guardrail] Eval returned ${response.status} [${code}] (ref: ${traceId}): ${message}`);
+          }
+        }
+      } catch (fetchError) {
+        clearTimeout(timeout);
+        if (fetchError.name === "AbortError") {
+          if (this.config.debug) {
+            log3.extend("warn")("[Observyze Guardrail] Evaluation timed out after 5s");
+          }
+        } else if (this.config.debug) {
+          log3.extend("warn")("[Observyze Guardrail] Evaluation request failed:", fetchError.message);
+        }
+      }
+      let hallucinationScore = 0;
+      let safetyScore = 0;
+      let evaluationSource = "live";
+      let confidence = null;
+      if (evalResult) {
+        hallucinationScore = evalResult.score ?? evalResult.hallucination_score ?? null;
+        safetyScore = evalResult.safety_score ?? 0;
+        evaluationSource = evalResult.evaluation_source ?? "live";
+        confidence = evalResult.confidence ?? null;
+        if (hallucinationScore === null) {
+          if (this.config.failClosed) {
+            if (this.config.debug) {
+              log3.extend("warn")("[Observyze Guardrail] Eval returned null score \u2014 failing closed (blocking)");
+            }
+            return {
+              pass: false,
+              score: null,
+              confidence: null,
+              safetyScore: null,
+              evaluationSource: "error",
+              fallbackReason: evalResult.message || "Evaluation failed to produce a score",
+              reason: "Evaluation service failed to produce a score. Fail-closed: execution blocked."
+            };
+          }
+          if (this.config.debug) {
+            log3("[Observyze Guardrail] Eval returned null score \u2014 allowing (fail-open)");
+          }
+          return {
+            pass: true,
+            score: null,
+            confidence: null,
+            safetyScore: null,
+            evaluationSource: "error",
+            fallbackReason: evalResult.message || "Evaluation failed to produce a score"
+          };
+        }
+      } else if (this.config.failClosed) {
+        if (this.config.debug) {
+          log3.extend("warn")("[Observyze Guardrail] Eval unavailable \u2014 failing closed (blocking)");
+        }
+        return {
+          pass: false,
+          score: null,
+          confidence: null,
+          safetyScore: null,
+          evaluationSource: "error",
+          fallbackReason: "Evaluation service unreachable",
+          reason: "Evaluation service unreachable. Fail-closed: execution blocked."
+        };
+      } else {
+        if (this.config.debug) {
+          log3("[Observyze Guardrail] Eval unavailable \u2014 allowing (fail-open)");
+        }
+        return {
+          pass: true,
+          score: null,
+          confidence: null,
+          safetyScore: null,
+          evaluationSource: "error",
+          fallbackReason: "Evaluation service unreachable"
+        };
+      }
+      const hallThreshold = this.config.hallucinationThreshold;
+      const safeThreshold = this.config.safetyThreshold;
+      const confThreshold = this.config.confidenceThreshold;
+      if (confidence !== null && confidence < confThreshold) {
+        if (hallucinationScore >= hallThreshold) {
+          if (this.config.debug) {
+            log3.extend("warn")(`[Observyze Guardrail] High score (${hallucinationScore.toFixed(2)}) but low confidence (${confidence.toFixed(2)}). Alerting only.`);
+          }
+          return {
+            pass: true,
+            score: hallucinationScore,
+            confidence,
+            safetyScore,
+            evaluationSource,
+            reason: `Score ${hallucinationScore.toFixed(2)} but confidence ${confidence.toFixed(2)} is low. Execution allowed with alert.`
+          };
+        }
+      }
+      if (hallucinationScore >= hallThreshold) {
+        if (this.config.debug) {
+          log3.extend("warn")(`[Observyze Guardrail] Hallucination circuit breached! Score: ${hallucinationScore.toFixed(2)} >= ${hallThreshold}`);
+        }
+        return {
+          pass: false,
+          score: hallucinationScore,
+          confidence,
+          safetyScore,
+          evaluationSource,
+          reason: `Hallucination score ${hallucinationScore.toFixed(2)} exceeds threshold ${hallThreshold}. Execution blocked for human review.`
+        };
+      }
+      if (safetyScore !== null && safetyScore >= safeThreshold) {
+        if (this.config.debug) {
+          log3.extend("warn")(`[Observyze Guardrail] Safety circuit breached! Score: ${safetyScore.toFixed(2)} >= ${safeThreshold}`);
+        }
+        return {
+          pass: false,
+          score: hallucinationScore,
+          confidence,
+          safetyScore,
+          evaluationSource,
+          reason: `Safety score ${safetyScore.toFixed(2)} exceeds threshold ${safeThreshold}. Execution blocked for safety review.`
+        };
+      }
+      return { pass: true, score: hallucinationScore, confidence, safetyScore, evaluationSource };
+    } catch (err) {
+      log3.extend("error")("[Observyze Guardrail] Failed to evaluate:", err);
+      if (this.config.failClosed) {
+        return { pass: false, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: "Guardrail exception", reason: "Guardrail error \u2014 fail-closed: execution blocked." };
+      }
+      return { pass: true, score: null, confidence: null, safetyScore: null, evaluationSource: "error", fallbackReason: "Guardrail exception" };
+    }
+  }
+  /**
+   * Phase 4: Autonomous Circuit Breakers
+   * Execute an agent action wrapped with the Circuit Breaker.
+   * Pauses execution if hallucination score >= hallucinationThreshold and requests human review.
+   * @throws Error when execution is blocked by circuit breaker
+   */
+  async executeWithCircuitBreaker(agentExecution, traceContext) {
+    if (!this.config.enableCircuitBreaker) {
+      return await agentExecution();
+    }
+    const guardResult = await this.checkGuardrails(traceContext || "execution context");
+    if (!guardResult.pass) {
+      const error = new Error(`[Observyze] Execution Blocked by Autonomous Circuit Breaker. Hallucination: ${guardResult.score?.toFixed(2) ?? "N/A"}, Safety: ${(guardResult.safetyScore ?? 0)?.toFixed(2) ?? "N/A"}. Reason: ${guardResult.reason}. Human approval required before agent can continue.`);
+      if (this.config.debug) {
+        log3.extend("error")("[Observyze CircuitBreaker] Execution blocked:", error.message);
+      }
+      throw error;
+    }
+    if (this.config.debug) {
+      log3(`[Observyze CircuitBreaker] Execution allowed. Hallucination: ${guardResult.score?.toFixed(2) ?? "N/A"}, Safety: ${(guardResult.safetyScore ?? 0)?.toFixed(2) ?? "N/A"}`);
+    }
+    return await agentExecution();
+  }
+  /**
+   * Phase 4: Bug Bounty Protocol (Automated) (Requirement 4.2)
+   * Automatically shard persistent failure cases to external security researcher endpoints (e.g. HackerOne wrapper)
+   */
+  async reportBugBounty(traceId, securityEndpoint, failureContext) {
+    try {
+      if (this.config.debug) {
+        log3(`[Observyze SDK] Sharding persistent failure case ${traceId} to Bug Bounty Protocol endpoint...`);
+      }
+      await fetch(securityEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          alert: "persistent_failure_sharded",
+          trace_id: traceId,
+          context: failureContext,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      });
+      if (this.config.debug) {
+        log3(`[Observyze SDK] Bug Bounty payload successfully transmitted.`);
+      }
+    } catch (err) {
+      log3.extend("error")("[Observyze Bug Bounty] Failed to shard failure case:", err);
+    }
+  }
 };
-
-// src/index.ts
-init_types();
-init_instrumentation();
 export {
   ObservyzeClient,
   ObservyzeSpanExporter,

package/dist/opentelemetry/index.d.mts

@@ -1 +1,2 @@
-export { a as ObservyzeExporterConfig, b as ObservyzeSpanExporter } from '../index-DEorAmFu.mjs';
+export { a as ObservyzeExporterConfig, b as ObservyzeSpanExporter } from '../index--b41_E-1.mjs';
+import '@observyze/types';

package/dist/opentelemetry/index.d.ts

@@ -1 +1,2 @@
-export { a as ObservyzeExporterConfig, b as ObservyzeSpanExporter } from '../index-DEorAmFu.js';
+export { a as ObservyzeExporterConfig, b as ObservyzeSpanExporter } from '../index--b41_E-1.js';
+import '@observyze/types';

package/dist/opentelemetry/index.js

@@ -24,6 +24,9 @@ __export(opentelemetry_exports, {
 });
 module.exports = __toCommonJS(opentelemetry_exports);
 
+// src/types.ts
+var import_types = require("@observyze/types");
+
 // src/trace.ts
 var import_crypto = require("crypto");
 function generateId() {
@@ -127,7 +130,7 @@ var Trace = class {
       organization_id: organizationId,
       project_id: projectId,
       name,
-      status: "running" /* RUNNING */,
+      status: import_types.TraceStatus.RUNNING,
       start_time: new Date(this.startTime),
       end_time: new Date(this.startTime),
       // Will be updated on end()
@@ -195,7 +198,7 @@ var Trace = class {
   /**
    * End the trace with a final status
    */
-  end(status = "success" /* SUCCESS */) {
+  end(status = import_types.TraceStatus.SUCCESS) {
     if (this.ended) {
       return;
     }
@@ -296,9 +299,9 @@ var ObservyzeSpanExporter = class {
         const statusCode = status?.code;
         if (statusCode === 2) {
           oSpan.setError(new Error(status?.message || "OTel span error"));
-          trace.end("error" /* ERROR */);
+          trace.end(import_types.TraceStatus.ERROR);
         } else {
-          trace.end("success" /* SUCCESS */);
+          trace.end(import_types.TraceStatus.SUCCESS);
         }
       }
       resultCallback({ code: 0 });

package/dist/opentelemetry/index.mjs

@@ -1,6 +1,6 @@
 import {
   ObservyzeSpanExporter
-} from "../chunk-YRMQCX2P.mjs";
+} from "../chunk-FQBYUOJB.mjs";
 export {
   ObservyzeSpanExporter
 };