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

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"];

package/dist/index.mjs

@@ -18,6 +18,14 @@ import {
   profilesByProvider,
   tryGetProfile
 } from "./chunk-7MTHFSNY.mjs";
+import {
+  emitAdvisoryFired,
+  emitCompileDone,
+  emitCompileStart,
+  emitExecuteAttempt,
+  emitExecuteSuccess,
+  emitFallbackWalked
+} from "./chunk-NUTC7NUC.mjs";
 
 // src/tokenizer.ts
 var tokenizerImpl = defaultCharBasedCounter;
@@ -1723,7 +1731,31 @@ function ensureCrossProviderTail(opts) {
 
 // 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];
@@ -1854,6 +1886,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,
@@ -1863,6 +1898,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,
@@ -1879,6 +1922,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,
@@ -1890,9 +1947,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({
@@ -1989,6 +2047,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"];

package/dist/{profiles-BoLYdl7F.d.mts → ir-C3P4gDt0.d.mts}

@@ -538,6 +538,18 @@ interface CallResult {
      * case.
      */
     policyBlockedFiltered?: string[];
+    /**
+     * alpha.17. Unique identifier for this call() invocation, generated at
+     * call() entry via crypto.randomUUID(). Returned on success and emitted
+     * as the routing key for Glass-Box observability events
+     * (compile.start, compile.done, execute.attempt, execute.success,
+     * fallback.walked, advisory.fired). Pass the same id to
+     * `subscribe(traceId)` from `@warmdrift/kgauto-compiler/glassbox` to
+     * tap the in-flight event stream.
+     *
+     * Always present on success. Additive, non-breaking.
+     */
+    traceId: string;
 }
 /**
  * Thrown when call() exhausts the fallback chain without success.
@@ -624,137 +636,4 @@ interface RecordInput {
     ttftMs?: number;
 }
 
-/**
- * Model profiles — executable knowledge about each provider/model.
- *
- * Unlike v1 which carried `known_failures` as prose strings, v2 makes them
- * executable: cliffs trigger guards, lowering describes the wire format,
- * recovery handlers describe what to do after specific failures.
- *
- * Each profile is the answer to "if I want to call THIS model with THIS
- * shape of work, what does it need from me, and what should I do when it
- * fails?"
- */
-
-type StructuredOutputCapability = 'native' | 'grammar' | 'none';
-type SystemPromptMode = 'inline' | 'separate' | 'as_developer' | 'unsupported';
-type CacheStrategy = 'cache_control' | 'cachedContent' | 'unsupported';
-interface CliffRule {
-    /** What metric triggers this cliff. */
-    metric: 'input_tokens' | 'tool_count' | 'history_turns' | 'thinking_with_short_output';
-    /** Threshold — meaning depends on metric. */
-    threshold: number;
-    /** What action to take when triggered. */
-    action: 'downgrade_quality_warning' | 'drop_to_top_relevant' | 'force_thinking_budget_zero' | 'force_terse_output' | 'escalate_target' | 'strip_tools';
-    /**
-     * Optional: only fire this cliff when the IR's intent.archetype matches.
-     * Used for archetype-specific failure modes (e.g. Gemini Flash returns
-     * empty when summarize is offered tools).
-     */
-    whenIntent?: IntentArchetypeName;
-    /** Human-readable reason for digest reporting. */
-    reason: string;
-}
-interface RecoveryRule {
-    /** What signal triggers recovery. */
-    signal: 'empty_response_after_tool' | 'empty_response' | 'malformed_function_call' | 'rate_limit' | 'model_not_found' | 'context_overflow';
-    /** Action: retry with adjusted params, or escalate to next fallback. */
-    action: 'retry_with_params' | 'escalate' | 'log_only';
-    /** When action=retry_with_params, the param adjustments to apply. */
-    retryParams?: Record<string, unknown>;
-    /** Max retries with this rule. */
-    maxRetries?: number;
-    /** Human-readable reason for digest reporting. */
-    reason: string;
-}
-interface LoweringSpec {
-    /** Where the system prompt goes. */
-    system: {
-        mode: SystemPromptMode;
-        field?: string;
-    };
-    /** Cache strategy + parameters. */
-    cache: {
-        strategy: CacheStrategy;
-        /** Min tokens before caching is worth it (provider rules). */
-        minTokens?: number;
-        /** Discount factor on cached input (0.1 = 10% of normal price). */
-        discount?: number;
-        /** TTL hint in seconds. */
-        ttlSeconds?: number;
-    };
-    /** Tool format identifier — see lower.ts for supported formats. */
-    tools?: {
-        format: 'anthropic' | 'google' | 'openai' | 'deepseek';
-    };
-    /** Thinking config — present iff this model has a thinking knob. */
-    thinking?: {
-        /** Field path on the request. */
-        field: string;
-        /** Default value when caller hasn't specified. */
-        default?: number | 'auto' | 'off';
-    };
-}
-interface ModelProfile {
-    id: string;
-    provider: Provider;
-    status: 'current' | 'preview' | 'legacy';
-    maxContextTokens: number;
-    maxOutputTokens: number;
-    maxTools: number;
-    parallelToolCalls: boolean;
-    structuredOutput: StructuredOutputCapability;
-    systemPromptMode: SystemPromptMode;
-    streaming: boolean;
-    cliffs: CliffRule[];
-    costInputPer1m: number;
-    costOutputPer1m: number;
-    lowering: LoweringSpec;
-    recovery: RecoveryRule[];
-    strengths: string[];
-    weaknesses: string[];
-    notes?: string;
-    verifiedAgainstDocs?: string;
-    /**
-     * Hand-curated per-archetype performance score on a 0-10 scale.
-     *
-     *   10 = frontier on this archetype (e.g. Opus 4.7 on critique)
-     *    8 = strong second tier (Sonnet on plan, Pro on extract)
-     *    7 = competent (Haiku on classify, Flash on hunt)
-     *    5 = acceptable for tolerant archetypes (Flash-Lite on classify)
-     *    3 = degraded (Flash on critique, DeepSeek on hunt)
-     *
-     * Missing archetypes default to `5` (no data, neutral). Each non-default
-     * value should carry a one-line rationale in the profile's note or inline
-     * comment citing brain evidence, family prior, or "starter hypothesis —
-     * verify with telemetry."
-     *
-     * Source today: hand-curated from master plan §3.3 + §6.2 starter tables.
-     * Source tomorrow (alpha.10+): brain `archetype_model_evidence` view.
-     *
-     * Anti-hallucination guardrail (master plan §2.5): when the watcher's
-     * `--audit-fields` flag flags a profile stale (>90 days since
-     * verifiedAgainstDocs), the archetypePerf values get re-audited
-     * alongside capability fields. AI-trained intuition is NOT a valid
-     * source — only docs or brain evidence.
-     *
-     * alpha.9.
-     */
-    archetypePerf?: Partial<Record<IntentArchetypeName, number>>;
-}
-declare const ALIASES: Record<string, string>;
-interface ProfileBrainHook {
-    getProfile?: (canonicalId: string) => ModelProfile | undefined;
-    resolveAlias?: (id: string) => string | undefined;
-}
-/** @internal — called by models-brain.ts at module load. */
-declare function _setProfileBrainHook(hook: ProfileBrainHook): void;
-declare function getProfile(id: string): ModelProfile;
-declare function tryGetProfile(id: string): ModelProfile | undefined;
-declare function allProfiles(): readonly ModelProfile[];
-/** @internal — bundled-only access for adapters that need a non-brain
- *  fallback baseline (avoids a brain → profiles → brain re-entry). */
-declare function allProfilesRaw(): readonly ModelProfile[];
-declare function profilesByProvider(provider: Provider): readonly ModelProfile[];
-
-export { type ApiKeys as A, type BestPracticeAdvisory as B, type CompilePolicy as C, type FallbackReason as F, type HistoryCachePolicy as H, type IntentDeclaration as I, type LoweringSpec as L, type ModelProfile as M, type NormalizedResponse as N, type OracleScore as O, type ProviderOverrides as P, type RecordInput as R, type StructuredOutputCapability as S, type ToolCall as T, _setProfileBrainHook as _, type CompiledRequest as a, type PromptIR as b, type CallOptions as c, type CallResult as d, type CompileResult as e, type Provider as f, ALIASES as g, type CacheStrategy as h, type CallAttempt as i, CallError as j, type CliffRule as k, type Constraints as l, type Message as m, type MutationApplied as n, type NormalizedTokens as o, type PromptSection as p, type RecoveryRule as q, type SystemPromptMode as r, type ToolDefinition as s, allProfiles as t, getProfile as u, profilesByProvider as v, tryGetProfile as w, allProfilesRaw as x };
+export { type ApiKeys as A, type BestPracticeAdvisory as B, type CompilePolicy as C, type FallbackReason as F, type HistoryCachePolicy as H, type IntentDeclaration as I, type Message as M, type NormalizedResponse as N, type OracleScore as O, type ProviderOverrides as P, type RecordInput as R, type ToolCall as T, type CompiledRequest as a, type PromptIR as b, type CallOptions as c, type CallResult as d, type CompileResult as e, type Provider as f, type CallAttempt as g, CallError as h, type Constraints as i, type MutationApplied as j, type NormalizedTokens as k, type PromptSection as l, type ToolDefinition as m };