@warmdrift/kgauto-compiler 2.0.0-alpha.16 → 2.0.0-alpha.18

package/dist/glassbox-routes/index.mjs

@@ -0,0 +1,269 @@
+import {
+  subscribe
+} from "../chunk-VZGMWKRT.mjs";
+import "../chunk-NUTC7NUC.mjs";
+
+// src/glassbox-routes/auth.ts
+import { Buffer } from "buffer";
+import { timingSafeEqual } from "crypto";
+var JSON_HEADERS = { "Content-Type": "application/json" };
+function jsonError(status, code) {
+  return new Response(JSON.stringify({ error: code }), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+function tokensEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const ab = Buffer.from(a, "utf8");
+  const bb = Buffer.from(b, "utf8");
+  if (ab.length !== bb.length) return false;
+  return timingSafeEqual(ab, bb);
+}
+function checkAuth(req, config) {
+  const authHeader = req.headers.get("Authorization") ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(authHeader);
+  const provided = match?.[1]?.trim() ?? "";
+  if (!provided || !tokensEqual(provided, config.installToken)) {
+    return jsonError(401, "unauthorized");
+  }
+  const origin = req.headers.get("Origin") ?? "";
+  const expected = `chrome-extension://${config.extensionId}`;
+  if (origin !== expected) {
+    return jsonError(403, "forbidden_origin");
+  }
+  return null;
+}
+
+// src/glassbox-routes/proxy.ts
+var JSON_HEADERS2 = {
+  "Content-Type": "application/json",
+  "Cache-Control": "no-store"
+};
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS2 });
+}
+function jsonError2(status, code) {
+  return jsonResponse(status, { error: code });
+}
+function applyScrub(row, scrub) {
+  if (!scrub || row == null || typeof row !== "object") return row;
+  try {
+    return scrub(row);
+  } catch {
+    return row;
+  }
+}
+function parseLimit(raw) {
+  if (!raw) return DEFAULT_LIMIT;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_LIMIT;
+  return Math.min(n, MAX_LIMIT);
+}
+function createProxyHandler(config) {
+  const {
+    installToken,
+    extensionId,
+    brainEndpoint,
+    brainJwt,
+    appId,
+    scrub,
+    fetch: fetchImpl
+  } = config;
+  const doFetch = fetchImpl ?? ((...args) => globalThis.fetch(...args));
+  const base = brainEndpoint.replace(/\/+$/, "");
+  return async function proxy(req) {
+    const authFail = checkAuth(req, { installToken, extensionId });
+    if (authFail) return authFail;
+    const url = new URL(req.url);
+    const traceId = url.searchParams.get("traceId");
+    const limit = parseLimit(url.searchParams.get("limit"));
+    const qs = new URLSearchParams();
+    qs.set("app_id", `eq.${appId}`);
+    if (traceId) {
+      qs.set("trace_id", `eq.${traceId}`);
+    } else {
+      qs.set("order", "created_at.desc");
+      qs.set("limit", String(limit));
+    }
+    const brainUrl = `${base}/rest/v1/compile_outcomes?${qs.toString()}`;
+    let brainRes;
+    try {
+      brainRes = await doFetch(brainUrl, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${brainJwt}`,
+          apikey: brainJwt,
+          Accept: "application/json"
+        }
+      });
+    } catch {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (brainRes.status === 401 || brainRes.status === 403) {
+      return jsonError2(500, "brain_auth_misconfig");
+    }
+    if (brainRes.status >= 500) {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (!brainRes.ok) {
+      return jsonError2(400, "bad_request");
+    }
+    let rows;
+    try {
+      rows = await brainRes.json();
+    } catch {
+      return jsonError2(502, "brain_unavailable");
+    }
+    if (!Array.isArray(rows)) {
+      return jsonError2(502, "brain_unavailable");
+    }
+    const scrubbed = rows.map((row) => applyScrub(row, scrub));
+    return jsonResponse(200, scrubbed);
+  };
+}
+
+// src/glassbox-routes/stream.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache, no-transform",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+};
+var JSON_HEADERS3 = { "Content-Type": "application/json" };
+function jsonError3(status, code) {
+  return new Response(JSON.stringify({ error: code }), {
+    status,
+    headers: JSON_HEADERS3
+  });
+}
+function applyScrub2(event, scrub) {
+  if (!scrub) return event;
+  try {
+    const out = scrub(event);
+    if (out && typeof out === "object" && typeof out.kind === "string" && typeof out.at === "number") {
+      return out;
+    }
+    return event;
+  } catch {
+    return event;
+  }
+}
+function sseFrame(eventName, data) {
+  const safeName = eventName.replace(/[\r\n]/g, "");
+  return `event: ${safeName}
+data: ${JSON.stringify(data)}
+
+`;
+}
+function createStreamHandler(config, subscribe2) {
+  const { installToken, extensionId, scrub } = config;
+  return async function stream(req) {
+    const authFail = checkAuth(req, { installToken, extensionId });
+    if (authFail) return authFail;
+    const url = new URL(req.url);
+    const traceId = url.searchParams.get("traceId");
+    if (!traceId) {
+      return jsonError3(400, "missing_trace_id");
+    }
+    const source = subscribe2(traceId);
+    const encoder = new TextEncoder();
+    let sourceReader;
+    let cancelled = false;
+    const body = new ReadableStream({
+      async start(controller) {
+        controller.enqueue(encoder.encode(sseFrame("ready", {})));
+        sourceReader = source.getReader();
+        const signal = req.signal;
+        if (signal) {
+          if (signal.aborted) {
+            cancelled = true;
+            await sourceReader.cancel();
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          signal.addEventListener(
+            "abort",
+            () => {
+              cancelled = true;
+              sourceReader?.cancel().catch(() => {
+              });
+              try {
+                controller.close();
+              } catch {
+              }
+            },
+            { once: true }
+          );
+        }
+        try {
+          while (!cancelled) {
+            const { value, done } = await sourceReader.read();
+            if (done) break;
+            const scrubbed = applyScrub2(value, scrub);
+            controller.enqueue(
+              encoder.encode(sseFrame(scrubbed.kind, scrubbed))
+            );
+          }
+        } catch {
+        } finally {
+          try {
+            controller.close();
+          } catch {
+          }
+          try {
+            sourceReader?.releaseLock();
+          } catch {
+          }
+        }
+      },
+      cancel() {
+        cancelled = true;
+        sourceReader?.cancel().catch(() => {
+        });
+      }
+    });
+    return new Response(body, { status: 200, headers: SSE_HEADERS });
+  };
+}
+
+// src/glassbox-routes/index.ts
+function requireString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`createGlassboxRoutes: ${name} is required`);
+  }
+  return value;
+}
+function createGlassboxRoutes(config) {
+  const installToken = requireString("installToken", config.installToken);
+  const extensionId = requireString("extensionId", config.extensionId);
+  const brainEndpoint = requireString("brainEndpoint", config.brainEndpoint);
+  const brainJwt = requireString("brainJwt", config.brainJwt);
+  const appId = requireString("appId", config.appId);
+  const proxy = createProxyHandler({
+    installToken,
+    extensionId,
+    brainEndpoint,
+    brainJwt,
+    appId,
+    scrub: config.scrub,
+    fetch: config.fetch
+  });
+  const stream = createStreamHandler(
+    {
+      installToken,
+      extensionId,
+      scrub: config.scrub
+    },
+    config.subscribe ?? subscribe
+  );
+  return { proxy, stream };
+}
+export {
+  createGlassboxRoutes
+};

package/dist/index.d.mts

@@ -1,5 +1,7 @@
-import { M as ModelProfile, C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, R as RecordInput, O as OracleScore, e as CompileResult, B as BestPracticeAdvisory, f as Provider } from './profiles-BoLYdl7F.mjs';
-export { g as ALIASES, h as CacheStrategy, i as CallAttempt, j as CallError, k as CliffRule, l as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, L as LoweringSpec, m as Message, n as MutationApplied, o as NormalizedTokens, p as PromptSection, q as RecoveryRule, S as StructuredOutputCapability, r as SystemPromptMode, T as ToolCall, s as ToolDefinition, t as allProfiles, u as getProfile, v as profilesByProvider, w as tryGetProfile } from './profiles-BoLYdl7F.mjs';
+import { C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, R as RecordInput, O as OracleScore, e as CompileResult, B as BestPracticeAdvisory, f as Provider } from './ir-C3P4gDt0.mjs';
+export { g as CallAttempt, h as CallError, i as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, M as Message, j as MutationApplied, k as NormalizedTokens, l as PromptSection, T as ToolCall, m as ToolDefinition } from './ir-C3P4gDt0.mjs';
+import { ModelProfile } from './profiles.mjs';
+export { ALIASES, CacheStrategy, CliffRule, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, profilesByProvider, tryGetProfile } from './profiles.mjs';
 import { IntentArchetypeName } from './dialect.mjs';
 export { ALL_ARCHETYPES, ContextBucket, DIALECT_VERSION, HistoryDepth, INTENT_ARCHETYPES, OutputMode, ShapeSignature, ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey } from './dialect.mjs';
 

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { M as ModelProfile, C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, R as RecordInput, O as OracleScore, e as CompileResult, B as BestPracticeAdvisory, f as Provider } from './profiles-CVB2_5C8.js';
-export { g as ALIASES, h as CacheStrategy, i as CallAttempt, j as CallError, k as CliffRule, l as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, L as LoweringSpec, m as Message, n as MutationApplied, o as NormalizedTokens, p as PromptSection, q as RecoveryRule, S as StructuredOutputCapability, r as SystemPromptMode, T as ToolCall, s as ToolDefinition, t as allProfiles, u as getProfile, v as profilesByProvider, w as tryGetProfile } from './profiles-CVB2_5C8.js';
+import { C as CompilePolicy, N as NormalizedResponse, A as ApiKeys, P as ProviderOverrides, a as CompiledRequest, b as PromptIR, c as CallOptions, d as CallResult, R as RecordInput, O as OracleScore, e as CompileResult, B as BestPracticeAdvisory, f as Provider } from './ir-CFHU3BUT.js';
+export { g as CallAttempt, h as CallError, i as Constraints, F as FallbackReason, H as HistoryCachePolicy, I as IntentDeclaration, M as Message, j as MutationApplied, k as NormalizedTokens, l as PromptSection, T as ToolCall, m as ToolDefinition } from './ir-CFHU3BUT.js';
+import { ModelProfile } from './profiles.js';
+export { ALIASES, CacheStrategy, CliffRule, LoweringSpec, RecoveryRule, StructuredOutputCapability, SystemPromptMode, allProfiles, getProfile, profilesByProvider, tryGetProfile } from './profiles.js';
 import { IntentArchetypeName } from './dialect.js';
 export { ALL_ARCHETYPES, ContextBucket, DIALECT_VERSION, HistoryDepth, INTENT_ARCHETYPES, OutputMode, ShapeSignature, ToolCountBucket, bucketContext, bucketHistory, bucketToolCount, hashShape, isArchetype, learningKey } from './dialect.js';
 

package/dist/index.js

@@ -2925,9 +2925,321 @@ function ensureCrossProviderTail(opts) {
   return { chain };
 }
 
+// src/glassbox/types.ts
+var GLASSBOX_STREAM_TTL_MS = 6e4;
+
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(traceId, event) {
+    const subs = this.subscribers.get(traceId);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(traceId, sub);
+    }
+  }
+  subscribe(traceId) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(traceId, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(traceId);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(traceId, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(traceId, sub);
+      }
+    });
+  }
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(traceId, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(traceId, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
+  }
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(traceId, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(traceId, sub);
+  }
+  removeSubscriber(traceId, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(traceId);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(traceId);
+  }
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
+  }
+};
+
+// src/glassbox/pubsub-upstash.ts
+var UpstashPubSub = class {
+  url;
+  token;
+  fetchImpl;
+  blockMs;
+  maxLen;
+  constructor(cfg) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.blockMs = cfg.blockMs ?? 100;
+    this.maxLen = cfg.maxLen ?? 100;
+  }
+  async publish(traceId, event) {
+    const key = streamKey(traceId);
+    const payload = JSON.stringify(event);
+    await this.cmd([
+      "XADD",
+      key,
+      "MAXLEN",
+      "~",
+      String(this.maxLen),
+      "*",
+      "event",
+      payload
+    ]);
+    await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
+  }
+  subscribe(traceId) {
+    const key = streamKey(traceId);
+    const self = this;
+    let cursor = "$";
+    let cancelled = false;
+    let ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          while (!cancelled && Date.now() < ttlDeadline) {
+            const resp = await self.cmd([
+              "XREAD",
+              "BLOCK",
+              String(self.blockMs),
+              "STREAMS",
+              key,
+              cursor
+            ]);
+            if (cancelled) break;
+            const parsed = parseXReadResult(resp.result);
+            if (parsed.entries.length === 0) {
+              continue;
+            }
+            for (const entry of parsed.entries) {
+              const evt = decodeEvent(entry.fields);
+              if (evt) {
+                try {
+                  controller.enqueue(evt);
+                } catch {
+                  cancelled = true;
+                  break;
+                }
+              }
+              cursor = entry.id;
+            }
+            ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+          }
+        } catch (err) {
+          if (!cancelled) {
+            try {
+              controller.error(err);
+            } catch {
+            }
+            return;
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        cancelled = true;
+      }
+    });
+  }
+  async cmd(args) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash ${args[0]} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`Upstash ${args[0]} failed: ${json.error}`);
+    }
+    return json;
+  }
+};
+function streamKey(traceId) {
+  return `glassbox:trace:${traceId}`;
+}
+function decodeEvent(fields) {
+  const raw = fields["event"];
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind === "string" && typeof parsed.at === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseXReadResult(raw) {
+  if (!Array.isArray(raw)) return { entries: [] };
+  const entries = [];
+  for (const stream of raw) {
+    if (!Array.isArray(stream) || stream.length < 2) continue;
+    const streamEntries = stream[1];
+    if (!Array.isArray(streamEntries)) continue;
+    for (const entry of streamEntries) {
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const id = String(entry[0]);
+      const flat = entry[1];
+      if (!Array.isArray(flat)) continue;
+      const fields = {};
+      for (let i = 0; i < flat.length; i += 2) {
+        const k = flat[i];
+        const v = flat[i + 1];
+        if (typeof k === "string") fields[k] = String(v ?? "");
+      }
+      entries.push({ id, fields });
+    }
+  }
+  return { entries };
+}
+
+// src/glassbox/emit.ts
+var activePubSub;
+function getPubSub() {
+  if (activePubSub) return activePubSub;
+  const url = readEnv("UPSTASH_REDIS_URL");
+  const token = readEnv("UPSTASH_REDIS_TOKEN");
+  if (url && token) {
+    activePubSub = new UpstashPubSub({ url, token });
+  } else {
+    activePubSub = new MemoryPubSub();
+  }
+  return activePubSub;
+}
+function readEnv(key) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v && v.trim() !== "" ? v : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function emitGlassboxEvent(traceId, kind, data) {
+  if (!traceId) return;
+  const event = { kind, at: Date.now(), data };
+  const ps = getPubSub();
+  try {
+    const p = ps.publish(traceId, event);
+    if (p && typeof p.then === "function") {
+      p.catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+function emitCompileStart(traceId, data) {
+  emitGlassboxEvent(traceId, "compile.start", data);
+}
+function emitCompileDone(traceId, data) {
+  emitGlassboxEvent(traceId, "compile.done", data);
+}
+function emitExecuteAttempt(traceId, data) {
+  emitGlassboxEvent(traceId, "execute.attempt", data);
+}
+function emitExecuteSuccess(traceId, data) {
+  emitGlassboxEvent(traceId, "execute.success", data);
+}
+function emitAdvisoryFired(traceId, data) {
+  emitGlassboxEvent(traceId, "advisory.fired", data);
+}
+function emitFallbackWalked(traceId, data) {
+  emitGlassboxEvent(traceId, "fallback.walked", data);
+}
+
 // src/call.ts
 async function call(ir, opts = {}) {
+  const traceId = generateTraceId();
+  safeEmit(
+    () => emitCompileStart(traceId, {
+      appId: ir.appId,
+      archetype: ir.intent.archetype,
+      models: ir.models
+    })
+  );
   const initial = compileAndRegister(ir, opts);
+  safeEmit(
+    () => emitCompileDone(traceId, {
+      target: initial.target,
+      provider: initial.provider,
+      fallbackChain: initial.fallbackChain,
+      tokensIn: initial.tokensIn,
+      estimatedCostUsd: initial.estimatedCostUsd,
+      mutationsApplied: initial.mutationsApplied,
+      advisories: initial.advisories
+    })
+  );
+  for (const adv of initial.advisories) {
+    safeEmit(
+      () => emitAdvisoryFired(traceId, { code: adv.code, message: adv.message })
+    );
+  }
   const start = Date.now();
   const attempts = [];
   const rawTargets = [initial.target, ...initial.fallbackChain];
@@ -3058,6 +3370,9 @@ async function call(ir, opts = {}) {
         continue;
       }
     }
+    safeEmit(
+      () => emitExecuteAttempt(traceId, { model: targetModel, attemptIndex: i })
+    );
     const exec = await execute(activeCompile.request, {
       apiKeys: opts.apiKeys,
       fetchImpl: opts.fetchImpl,
@@ -3067,6 +3382,14 @@ async function call(ir, opts = {}) {
     if (validated.ok) {
       attempts.push({ model: targetModel, status: "success" });
       const latencyMs2 = Date.now() - start;
+      safeEmit(
+        () => emitExecuteSuccess(traceId, {
+          model: targetModel,
+          tokensIn: validated.response.tokens.input,
+          tokensOut: validated.response.tokens.output,
+          latencyMs: latencyMs2
+        })
+      );
       await record({
         handle: initial.handle,
         tokensIn: validated.response.tokens.input,
@@ -3083,6 +3406,20 @@ async function call(ir, opts = {}) {
         cacheCreationInputTokens: validated.response.tokens.cacheCreated
       });
       const fellOver = targetModel !== initial.target;
+      const fallbackReason = fellOver ? normalizeFallbackReason(attempts) : void 0;
+      if (fellOver) {
+        const firstFailed = attempts.find((a) => a.status !== "success");
+        if (firstFailed) {
+          safeEmit(
+            () => emitFallbackWalked(traceId, {
+              from: initial.target,
+              to: targetModel,
+              reason: fallbackReason ?? "unknown",
+              attempt: firstFailed
+            })
+          );
+        }
+      }
       return {
         handle: initial.handle,
         actualModel: targetModel,
@@ -3094,9 +3431,10 @@ async function call(ir, opts = {}) {
         attempts,
         servedBy: targetModel,
         fellOverFrom: fellOver ? initial.target : void 0,
-        fallbackReason: fellOver ? normalizeFallbackReason(attempts) : void 0,
+        fallbackReason,
         unreachableFiltered,
-        policyBlockedFiltered
+        policyBlockedFiltered,
+        traceId
       };
     }
     attempts.push({
@@ -3193,6 +3531,23 @@ function normalizeFallbackReason(attempts) {
   if (code === "auth" || code === "auth_inferred") return "provider_auth_failed";
   return "provider_error";
 }
+function generateTraceId() {
+  try {
+    const g = globalThis;
+    if (g.crypto && typeof g.crypto.randomUUID === "function") {
+      return g.crypto.randomUUID();
+    }
+  } catch {
+  }
+  const hex = (n) => Math.floor(Math.random() * Math.pow(16, n)).toString(16).padStart(n, "0");
+  return `${hex(8)}-${hex(4)}-${hex(4)}-${hex(4)}-${hex(12)}`;
+}
+function safeEmit(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
 
 // src/oracle.ts
 var DEFAULT_DIMENSIONS = ["correctness", "completeness", "conciseness", "format"];