risicare 0.2.1 → 0.3.0

package/dist/providers/openai/index.js

@@ -1,3 +1,1386 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/globals.ts
+import { AsyncLocalStorage } from "async_hooks";
+function getTracer() {
+  return G[PREFIX + "tracer"];
+}
+function getContextStorage() {
+  if (!G[PREFIX + "ctx"]) {
+    G[PREFIX + "ctx"] = new AsyncLocalStorage();
+  }
+  return G[PREFIX + "ctx"];
+}
+function getDebug() {
+  return G[PREFIX + "debug"] ?? false;
+}
+var G, PREFIX;
+var init_globals = __esm({
+  "src/globals.ts"() {
+    "use strict";
+    G = globalThis;
+    PREFIX = "__risicare_";
+  }
+});
+
+// src/utils/log.ts
+function debug(msg) {
+  if (getDebug()) {
+    process.stderr.write(`[risicare] ${msg}
+`);
+  }
+}
+function warn(msg) {
+  process.stderr.write(`[risicare] WARNING: ${msg}
+`);
+}
+var init_log = __esm({
+  "src/utils/log.ts"() {
+    "use strict";
+    init_globals();
+  }
+});
+
+// src/runtime/config.ts
+function resolveFixRuntimeConfig(config) {
+  return {
+    apiEndpoint: config.apiEndpoint,
+    apiKey: config.apiKey,
+    enabled: config.enabled ?? true,
+    cacheEnabled: config.cacheEnabled ?? true,
+    cacheTtlMs: config.cacheTtlMs ?? 3e5,
+    cacheMaxEntries: config.cacheMaxEntries ?? 1e3,
+    autoRefresh: config.autoRefresh ?? true,
+    refreshIntervalMs: config.refreshIntervalMs ?? 6e4,
+    dryRun: config.dryRun ?? false,
+    abTestingEnabled: config.abTestingEnabled ?? true,
+    timeoutMs: config.timeoutMs ?? 1e3,
+    debug: config.debug ?? false
+  };
+}
+function matchesError(fix, errorCode) {
+  if (fix.errorCode === errorCode) {
+    return true;
+  }
+  if (fix.errorCode.endsWith("*")) {
+    const prefix = fix.errorCode.slice(0, -1);
+    return errorCode.startsWith(prefix);
+  }
+  return false;
+}
+function shouldApply(fix, sessionHash) {
+  if (fix.trafficPercentage >= 100) return true;
+  if (fix.trafficPercentage <= 0) return false;
+  const bucket = sessionHash % 100;
+  return bucket < fix.trafficPercentage;
+}
+function activeFixFromApiResponse(item) {
+  return {
+    fixId: item.id ?? item.fix_id ?? item.fixId ?? "",
+    deploymentId: item.deployment_id ?? item.deploymentId ?? "",
+    errorCode: item.error_code ?? item.errorCode ?? "",
+    fixType: item.fix_type ?? item.fixType ?? "prompt",
+    config: item.config ?? {},
+    trafficPercentage: item.traffic_percentage ?? item.trafficPercentage ?? 100,
+    version: item.version ?? 1
+  };
+}
+var init_config = __esm({
+  "src/runtime/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/cache.ts
+var FixCache;
+var init_cache = __esm({
+  "src/runtime/cache.ts"() {
+    "use strict";
+    init_config();
+    init_log();
+    FixCache = class {
+      _ttlMs;
+      _maxEntries;
+      _enabled;
+      _cache;
+      _stats;
+      constructor(config) {
+        this._enabled = config?.cacheEnabled ?? true;
+        this._ttlMs = config?.cacheTtlMs ?? 3e5;
+        this._maxEntries = config?.cacheMaxEntries ?? 1e3;
+        this._cache = /* @__PURE__ */ new Map();
+        this._stats = {
+          hits: 0,
+          misses: 0,
+          evictions: 0,
+          size: 0,
+          lastRefresh: null
+        };
+      }
+      /** Whether caching is enabled. */
+      get enabled() {
+        return this._enabled;
+      }
+      /**
+       * Get a fix by error code.
+       *
+       * Checks exact match first, then scans for wildcard matches.
+       * Expired entries are evicted on access.
+       */
+      get(errorCode) {
+        try {
+          if (!this._enabled) return null;
+          const now = Date.now();
+          const exactEntry = this._cache.get(errorCode);
+          if (exactEntry) {
+            if (exactEntry.expiresAt > now) {
+              this._stats.hits++;
+              return exactEntry.fix;
+            }
+            this._cache.delete(errorCode);
+            this._stats.evictions++;
+          }
+          for (const [key, entry] of this._cache) {
+            if (entry.expiresAt <= now) {
+              this._cache.delete(key);
+              this._stats.evictions++;
+              continue;
+            }
+            if (matchesError(entry.fix, errorCode)) {
+              this._stats.hits++;
+              return entry.fix;
+            }
+          }
+          this._stats.misses++;
+          return null;
+        } catch (e) {
+          debug(`FixCache.get error: ${e}`);
+          return null;
+        }
+      }
+      /**
+       * Add a single fix to the cache.
+       *
+       * Evicts the oldest entry if at capacity.
+       */
+      set(fix) {
+        try {
+          if (!this._enabled) return;
+          if (this._cache.size >= this._maxEntries) {
+            this._evictOldest();
+          }
+          const now = Date.now();
+          this._cache.set(fix.errorCode, {
+            fix,
+            createdAt: now,
+            expiresAt: now + this._ttlMs
+          });
+          this._stats.size = this._cache.size;
+        } catch (e) {
+          debug(`FixCache.set error: ${e}`);
+        }
+      }
+      /**
+       * Replace all cached fixes (bulk refresh).
+       *
+       * Clears the cache and populates with the given fixes.
+       */
+      setAll(fixes) {
+        try {
+          if (!this._enabled) return;
+          this._cache.clear();
+          const now = Date.now();
+          for (const fix of fixes) {
+            if (this._cache.size >= this._maxEntries) break;
+            this._cache.set(fix.errorCode, {
+              fix,
+              createdAt: now,
+              expiresAt: now + this._ttlMs
+            });
+          }
+          this._stats.size = this._cache.size;
+          this._stats.lastRefresh = now;
+        } catch (e) {
+          debug(`FixCache.setAll error: ${e}`);
+        }
+      }
+      /**
+       * Get all non-expired fixes.
+       */
+      getAll() {
+        try {
+          const now = Date.now();
+          const valid = [];
+          const expired = [];
+          for (const [key, entry] of this._cache) {
+            if (entry.expiresAt > now) {
+              valid.push(entry.fix);
+            } else {
+              expired.push(key);
+            }
+          }
+          for (const key of expired) {
+            this._cache.delete(key);
+            this._stats.evictions++;
+          }
+          this._stats.size = this._cache.size;
+          return valid;
+        } catch (e) {
+          debug(`FixCache.getAll error: ${e}`);
+          return [];
+        }
+      }
+      /** Clear all cache entries. Returns the number of entries cleared. */
+      clear() {
+        const count = this._cache.size;
+        this._cache.clear();
+        this._stats.size = 0;
+        return count;
+      }
+      /** Get cache statistics. */
+      get stats() {
+        this._stats.size = this._cache.size;
+        return { ...this._stats };
+      }
+      /** Evict the oldest cache entry. */
+      _evictOldest() {
+        if (this._cache.size === 0) return;
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this._cache) {
+          if (entry.createdAt < oldestTime) {
+            oldestTime = entry.createdAt;
+            oldestKey = key;
+          }
+        }
+        if (oldestKey !== null) {
+          this._cache.delete(oldestKey);
+          this._stats.evictions++;
+        }
+      }
+    };
+  }
+});
+
+// src/runtime/applier.ts
+import { createHash } from "crypto";
+function emptyResult(fix, fixType) {
+  return {
+    applied: false,
+    fixId: fix.fixId,
+    deploymentId: fix.deploymentId,
+    fixType,
+    modifications: {}
+  };
+}
+var MAX_FIX_CONTENT_LENGTH, FixApplier;
+var init_applier = __esm({
+  "src/runtime/applier.ts"() {
+    "use strict";
+    init_config();
+    init_log();
+    MAX_FIX_CONTENT_LENGTH = 1e4;
+    FixApplier = class {
+      _config;
+      _cache;
+      _applicationLog = [];
+      constructor(config, cache) {
+        this._config = resolveFixRuntimeConfig(config);
+        this._cache = cache;
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // Fix Lookup
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Get applicable fix for an error code.
+       *
+       * Considers A/B testing bucket if sessionId is provided. Uses
+       * crypto.createHash('md5') for deterministic bucketing across restarts.
+       */
+      getFixForError(errorCode, sessionId) {
+        try {
+          const fix = this._cache.get(errorCode);
+          if (!fix) return null;
+          if (sessionId && this._config.abTestingEnabled) {
+            const hashHex = createHash("md5").update(sessionId).digest("hex").substring(0, 8);
+            const sessionHash = parseInt(hashHex, 16);
+            if (!shouldApply(fix, sessionHash)) {
+              debug(`Fix ${fix.fixId} not applied (A/B control group)`);
+              return null;
+            }
+          }
+          return fix;
+        } catch (e) {
+          debug(`getFixForError error: ${e}`);
+          return null;
+        }
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // 1. Prompt Fix
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Apply a prompt fix to messages.
+       *
+       * Supports 4 modification types:
+       * - prepend: Add content before first system message
+       * - append:  Add content after first system message
+       * - replace: Regex replace across all messages
+       * - few_shot: Insert user/assistant example pairs after system message
+       */
+      applyPromptFix(fix, messages) {
+        try {
+          const cfg = fix.config;
+          const modificationType = cfg.modification_type ?? cfg.modificationType ?? "append";
+          const target = cfg.target ?? "system";
+          let content = cfg.content ?? "";
+          if (content.length > MAX_FIX_CONTENT_LENGTH) {
+            warn(
+              `Fix ${fix.fixId} content truncated from ${content.length} to ${MAX_FIX_CONTENT_LENGTH} chars`
+            );
+            content = content.slice(0, MAX_FIX_CONTENT_LENGTH);
+          }
+          const result = emptyResult(fix, "prompt");
+          if (this._config.dryRun) {
+            result.modifications = {
+              type: modificationType,
+              target,
+              contentPreview: content.slice(0, 100)
+            };
+            return { messages, result };
+          }
+          let modified = messages.map((m) => ({ ...m }));
+          if (modificationType === "prepend") {
+            modified = this._prependToTarget(modified, target, content);
+            result.applied = true;
+            result.modifications = { type: "prepend", target };
+          } else if (modificationType === "append") {
+            modified = this._appendToTarget(modified, target, content);
+            result.applied = true;
+            result.modifications = { type: "append", target };
+          } else if (modificationType === "replace") {
+            const pattern = cfg.pattern ?? "";
+            if (pattern) {
+              modified = this._replaceInMessages(modified, pattern, content);
+              result.applied = true;
+              result.modifications = { type: "replace", pattern };
+            }
+          } else if (modificationType === "few_shot") {
+            const examples = cfg.examples ?? [];
+            if (examples.length > 0) {
+              modified = this._addFewShotExamples(modified, examples);
+              result.applied = true;
+              result.modifications = { type: "few_shot", count: examples.length };
+            }
+          }
+          return { messages: modified, result };
+        } catch (e) {
+          debug(`applyPromptFix error: ${e}`);
+          return {
+            messages,
+            result: {
+              applied: false,
+              fixId: fix.fixId,
+              fixType: "prompt",
+              modifications: {},
+              error: String(e)
+            }
+          };
+        }
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // 2. Parameter Fix
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Apply a parameter fix — merge config.parameters into params.
+       */
+      applyParameterFix(fix, params) {
+        try {
+          const newParams = fix.config.parameters ?? {};
+          const result = emptyResult(fix, "parameter");
+          if (this._config.dryRun) {
+            result.modifications = { parameters: newParams };
+            return { params, result };
+          }
+          const modified = { ...params, ...newParams };
+          result.applied = true;
+          result.modifications = { parameters: newParams };
+          return { params: modified, result };
+        } catch (e) {
+          debug(`applyParameterFix error: ${e}`);
+          return {
+            params,
+            result: {
+              applied: false,
+              fixId: fix.fixId,
+              fixType: "parameter",
+              modifications: {},
+              error: String(e)
+            }
+          };
+        }
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // 3. Retry Fix (async — uses setTimeout for sleeping)
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Apply a retry fix to an async operation.
+       *
+       * Retries with exponential backoff + jitter using
+       * `await new Promise(r => setTimeout(r, delay))`.
+       */
+      async applyRetryFix(fix, operation) {
+        const cfg = fix.config;
+        const maxRetries = cfg.max_retries ?? cfg.maxRetries ?? 3;
+        const initialDelayMs = cfg.initial_delay_ms ?? cfg.initialDelayMs ?? 1e3;
+        const maxDelayMs = cfg.max_delay_ms ?? cfg.maxDelayMs ?? 3e4;
+        const exponentialBase = cfg.exponential_base ?? cfg.exponentialBase ?? 2;
+        const jitter = cfg.jitter ?? true;
+        const retryOn = cfg.retry_on ?? cfg.retryOn ?? [];
+        const result = emptyResult(fix, "retry");
+        if (this._config.dryRun) {
+          result.modifications = { maxRetries, initialDelayMs };
+          const value = await operation();
+          return { value, result };
+        }
+        let lastError = null;
+        let attempts = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          attempts++;
+          try {
+            const value = await operation();
+            result.applied = true;
+            result.modifications = { attempts };
+            return { value, result };
+          } catch (e) {
+            lastError = e instanceof Error ? e : new Error(String(e));
+            const errorType = lastError.constructor.name;
+            if (retryOn.length > 0 && !retryOn.includes(errorType)) {
+              throw lastError;
+            }
+            if (attempt < maxRetries) {
+              let delayMs = Math.min(
+                initialDelayMs * Math.pow(exponentialBase, attempt),
+                maxDelayMs
+              );
+              if (jitter) {
+                delayMs *= 0.5 + Math.random();
+              }
+              debug(
+                `Retry ${attempt + 1}/${maxRetries} after ${Math.round(delayMs)}ms`
+              );
+              await new Promise((r) => setTimeout(r, delayMs));
+            }
+          }
+        }
+        result.applied = true;
+        result.error = lastError?.message;
+        result.modifications = { attempts, exhausted: true };
+        throw lastError;
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // 4. Fallback Fix
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Apply a fallback fix.
+       *
+       * - 'model': Replace params.model with the fallback model
+       * - 'default': Set params._fallbackResponse for the caller to use
+       */
+      applyFallbackFix(fix, params) {
+        try {
+          const cfg = fix.config;
+          const fallbackType = cfg.fallback_type ?? cfg.fallbackType ?? "model";
+          const fallbackConfig = cfg.fallback_config ?? cfg.fallbackConfig ?? {};
+          const result = emptyResult(fix, "fallback");
+          if (this._config.dryRun) {
+            result.modifications = { fallbackType, fallbackConfig };
+            return { params, result };
+          }
+          const modified = { ...params };
+          if (fallbackType === "model") {
+            const fallbackModel = fallbackConfig.model;
+            if (fallbackModel) {
+              modified.model = fallbackModel;
+              result.applied = true;
+              result.modifications = { model: fallbackModel };
+            }
+          } else if (fallbackType === "default") {
+            const defaultResponse = fallbackConfig.response;
+            if (defaultResponse !== void 0) {
+              modified._fallbackResponse = defaultResponse;
+              result.applied = true;
+              result.modifications = { defaultResponse: true };
+            }
+          }
+          return { params: modified, result };
+        } catch (e) {
+          debug(`applyFallbackFix error: ${e}`);
+          return {
+            params,
+            result: {
+              applied: false,
+              fixId: fix.fixId,
+              fixType: "fallback",
+              modifications: {},
+              error: String(e)
+            }
+          };
+        }
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // 5. Guard Fix
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Apply a guard fix (validation).
+       *
+       * Guard types:
+       * - content_filter: Regex-based blocked patterns
+       * - format_check:   JSON.parse() validity
+       * - input_validation / output_validation: min/max length
+       */
+      applyGuardFix(fix, content, isInput = true) {
+        try {
+          const cfg = fix.config;
+          const guardType = cfg.guard_type ?? cfg.guardType ?? "output_validation";
+          const guardConfig = cfg.guard_config ?? cfg.guardConfig ?? {};
+          const result = emptyResult(fix, "guard");
+          if (isInput && guardType !== "input_validation" && guardType !== "content_filter") {
+            return { content, passed: true, result };
+          }
+          if (!isInput && guardType !== "output_validation" && guardType !== "format_check") {
+            return { content, passed: true, result };
+          }
+          if (this._config.dryRun) {
+            result.modifications = { guardType };
+            return { content, passed: true, result };
+          }
+          let passed = true;
+          if (guardType === "content_filter") {
+            const blockedPatterns = guardConfig.blocked_patterns ?? guardConfig.blockedPatterns ?? [];
+            for (const pattern of blockedPatterns) {
+              const regex = this._safeCompileRegex(pattern);
+              if (regex && regex.test(content)) {
+                passed = false;
+                break;
+              }
+            }
+          } else if (guardType === "format_check") {
+            const requiredFormat = guardConfig.format;
+            if (requiredFormat === "json") {
+              try {
+                JSON.parse(content);
+              } catch {
+                passed = false;
+              }
+            }
+          } else if (guardType === "input_validation" || guardType === "output_validation") {
+            const minLength = guardConfig.min_length ?? guardConfig.minLength ?? 0;
+            const maxLength = guardConfig.max_length ?? guardConfig.maxLength ?? Infinity;
+            if (content.length < minLength || content.length > maxLength) {
+              passed = false;
+            }
+          }
+          result.applied = true;
+          result.modifications = { passed, guardType };
+          return { content, passed, result };
+        } catch (e) {
+          debug(`applyGuardFix error: ${e}`);
+          return {
+            content,
+            passed: true,
+            result: {
+              applied: false,
+              fixId: fix.fixId,
+              fixType: "guard",
+              modifications: {},
+              error: String(e)
+            }
+          };
+        }
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // Application Log
+      // ═══════════════════════════════════════════════════════════════════════════
+      /** Log a fix application result. */
+      logApplication(result) {
+        this._applicationLog.push(result);
+        if (this._applicationLog.length > 1e3) {
+          this._applicationLog = this._applicationLog.slice(-500);
+        }
+      }
+      /** Get the application log. */
+      getApplicationLog() {
+        return [...this._applicationLog];
+      }
+      // ═══════════════════════════════════════════════════════════════════════════
+      // Private Helpers
+      // ═══════════════════════════════════════════════════════════════════════════
+      /**
+       * Safely compile a regex pattern from untrusted input.
+       * Returns null if invalid or too long.
+       */
+      _safeCompileRegex(pattern, maxLength = 500) {
+        if (!pattern || pattern.length > maxLength) return null;
+        try {
+          return new RegExp(pattern, "i");
+        } catch {
+          debug(`Invalid regex pattern (length=${pattern.length})`);
+          return null;
+        }
+      }
+      /** Prepend content to the first message matching the target role. */
+      _prependToTarget(messages, target, content) {
+        return messages.map((msg) => {
+          if (msg.role === target) {
+            return {
+              ...msg,
+              content: content + "\n\n" + (msg.content ?? "")
+            };
+          }
+          return msg;
+        });
+      }
+      /** Append content to the first message matching the target role. */
+      _appendToTarget(messages, target, content) {
+        return messages.map((msg) => {
+          if (msg.role === target) {
+            return {
+              ...msg,
+              content: (msg.content ?? "") + "\n\n" + content
+            };
+          }
+          return msg;
+        });
+      }
+      /** Regex replace across all messages. */
+      _replaceInMessages(messages, pattern, replacement) {
+        const regex = this._safeCompileRegex(pattern);
+        if (!regex) {
+          debug("Skipping invalid regex pattern in prompt fix");
+          return messages;
+        }
+        return messages.map((msg) => {
+          const msgContent = msg.content;
+          if (typeof msgContent === "string") {
+            return { ...msg, content: msgContent.replace(regex, replacement) };
+          }
+          return msg;
+        });
+      }
+      /** Add few-shot examples after the first system message. */
+      _addFewShotExamples(messages, examples) {
+        const result = [];
+        let systemFound = false;
+        for (const msg of messages) {
+          result.push(msg);
+          if (msg.role === "system" && !systemFound) {
+            systemFound = true;
+            for (const example of examples) {
+              if (example.user) {
+                result.push({ role: "user", content: example.user });
+              }
+              if (example.assistant) {
+                result.push({ role: "assistant", content: example.assistant });
+              }
+            }
+          }
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/runtime/loader.ts
+var SDK_VERSION, FixLoader;
+var init_loader = __esm({
+  "src/runtime/loader.ts"() {
+    "use strict";
+    init_config();
+    init_config();
+    init_log();
+    SDK_VERSION = "0.1.3";
+    FixLoader = class _FixLoader {
+      _config;
+      _cache;
+      _refreshTimer = null;
+      _lastLoadTime = null;
+      _consecutiveFailures = 0;
+      _circuitOpenUntil = 0;
+      _onLoadCallbacks = [];
+      // Circuit breaker settings
+      static CIRCUIT_BREAKER_THRESHOLD = 3;
+      static CIRCUIT_BREAKER_COOLDOWN_MS = 3e4;
+      constructor(config, cache) {
+        this._config = resolveFixRuntimeConfig(config);
+        this._cache = cache;
+      }
+      /** Timestamp of last successful load. */
+      get lastLoadTime() {
+        return this._lastLoadTime;
+      }
+      /**
+       * Start the loader: perform initial load and start background refresh.
+       *
+       * Never throws — failures are logged and the runtime degrades gracefully.
+       */
+      start() {
+        try {
+          if (!this._config.enabled) {
+            debug("Fix runtime disabled, skipping loader start");
+            return;
+          }
+          if (!this._config.apiKey) {
+            warn("No API key configured, fixes will not be loaded");
+            return;
+          }
+          this.loadSync().catch((e) => {
+            debug(`Initial fix load failed: ${e}`);
+          });
+          if (this._config.autoRefresh) {
+            this._startRefreshInterval();
+          }
+        } catch (e) {
+          debug(`FixLoader.start error: ${e}`);
+        }
+      }
+      /** Stop the loader: clear the refresh interval. */
+      stop() {
+        try {
+          if (this._refreshTimer !== null) {
+            clearInterval(this._refreshTimer);
+            this._refreshTimer = null;
+          }
+        } catch (e) {
+          debug(`FixLoader.stop error: ${e}`);
+        }
+      }
+      /**
+       * Register a callback invoked after each successful load.
+       */
+      onLoad(callback) {
+        this._onLoadCallbacks.push(callback);
+      }
+      /**
+       * Load fixes from the API.
+       *
+       * Name kept as "loadSync" for parity with the Python SDK, but this
+       * returns a Promise in JS (there's no synchronous fetch in Node.js).
+       */
+      async loadSync() {
+        if (!this._config.apiKey) {
+          return [];
+        }
+        const now = Date.now();
+        if (this._consecutiveFailures >= _FixLoader.CIRCUIT_BREAKER_THRESHOLD && now < this._circuitOpenUntil) {
+          debug("Fix loader circuit breaker open \u2014 skipping load");
+          return this._cache.getAll();
+        }
+        try {
+          const endpoint = this._config.apiEndpoint.replace(/\/+$/, "");
+          const url = `${endpoint}/api/v1/fixes/active`;
+          const controller = new AbortController();
+          const timeoutId = setTimeout(
+            () => controller.abort(),
+            this._config.timeoutMs
+          );
+          const response = await fetch(url, {
+            method: "GET",
+            headers: {
+              "Authorization": `Bearer ${this._config.apiKey}`,
+              "Content-Type": "application/json",
+              "X-Risicare-SDK-Version": SDK_VERSION
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
+          const data = await response.json();
+          const fixes = this._parseResponse(data);
+          this._onLoadSuccess(fixes);
+          return fixes;
+        } catch (e) {
+          this._onLoadFailure(e);
+          throw e;
+        }
+      }
+      /** Get currently cached fixes without hitting the API. */
+      getCached() {
+        return this._cache.getAll();
+      }
+      // ─── Private ────────────────────────────────────────────────────────────
+      _parseResponse(data) {
+        const fixes = [];
+        const items = data.fixes ?? data.data ?? [];
+        if (!Array.isArray(items)) return fixes;
+        for (const item of items) {
+          try {
+            if (item && typeof item === "object") {
+              fixes.push(activeFixFromApiResponse(item));
+            }
+          } catch (e) {
+            debug(`Failed to parse fix item: ${e}`);
+          }
+        }
+        return fixes;
+      }
+      _onLoadSuccess(fixes) {
+        this._lastLoadTime = Date.now();
+        this._consecutiveFailures = 0;
+        this._cache.setAll(fixes);
+        for (const callback of this._onLoadCallbacks) {
+          try {
+            callback(fixes);
+          } catch (e) {
+            debug(`Load callback error: ${e}`);
+          }
+        }
+        debug(`Loaded ${fixes.length} active fixes`);
+      }
+      _onLoadFailure(error) {
+        this._consecutiveFailures++;
+        if (this._consecutiveFailures >= _FixLoader.CIRCUIT_BREAKER_THRESHOLD) {
+          this._circuitOpenUntil = Date.now() + _FixLoader.CIRCUIT_BREAKER_COOLDOWN_MS;
+          warn(
+            `Fix loader circuit breaker opened after ${this._consecutiveFailures} failures. Cooldown: ${_FixLoader.CIRCUIT_BREAKER_COOLDOWN_MS / 1e3}s`
+          );
+        } else {
+          debug(
+            `Fix load failed (attempt ${this._consecutiveFailures}): ${error.message}`
+          );
+        }
+      }
+      _startRefreshInterval() {
+        const tick = () => {
+          this.loadSync().catch((e) => {
+            debug(`Background fix refresh failed: ${e}`);
+          });
+        };
+        this._refreshTimer = setInterval(
+          () => {
+            if (this._consecutiveFailures >= _FixLoader.CIRCUIT_BREAKER_THRESHOLD && Date.now() < this._circuitOpenUntil) {
+              return;
+            }
+            tick();
+          },
+          this._config.refreshIntervalMs
+        );
+        this._refreshTimer.unref();
+        debug("Started fix refresh interval");
+      }
+    };
+  }
+});
+
+// src/runtime/interceptors.ts
+function createInterceptContext(operationType, operationName, options) {
+  return {
+    operationType,
+    operationName,
+    sessionId: options?.sessionId,
+    traceId: options?.traceId,
+    errorCode: options?.errorCode,
+    attempt: 1,
+    appliedFixes: []
+  };
+}
+function classifyError(error) {
+  const errorType = error.constructor.name.toLowerCase();
+  const errorMsg = error.message.toLowerCase();
+  if (errorType.includes("timeout") || errorMsg.includes("timeout") || errorMsg.includes("aborted")) {
+    return "TOOL.EXECUTION.TIMEOUT";
+  }
+  if (errorMsg.includes("rate") && errorMsg.includes("limit")) {
+    return "TOOL.EXECUTION.RATE_LIMIT";
+  }
+  if (errorMsg.includes("429") || errorMsg.includes("too many requests")) {
+    return "TOOL.EXECUTION.RATE_LIMIT";
+  }
+  if (errorType.includes("connection") || errorMsg.includes("connection") || errorMsg.includes("econnrefused") || errorMsg.includes("econnreset") || errorMsg.includes("fetch failed")) {
+    return "TOOL.EXECUTION.CONNECTION_ERROR";
+  }
+  if (errorMsg.includes("auth") || errorMsg.includes("401") || errorMsg.includes("403") || errorMsg.includes("unauthorized") || errorMsg.includes("forbidden")) {
+    return "TOOL.EXECUTION.AUTH_ERROR";
+  }
+  if (errorType.includes("syntaxerror") || errorType.includes("json") || errorMsg.includes("json") || errorMsg.includes("unexpected token")) {
+    return "OUTPUT.FORMAT.JSON_INVALID";
+  }
+  return "TOOL.EXECUTION.FAILURE";
+}
+var DefaultFixInterceptor;
+var init_interceptors = __esm({
+  "src/runtime/interceptors.ts"() {
+    "use strict";
+    init_config();
+    init_log();
+    DefaultFixInterceptor = class {
+      _config;
+      _cache;
+      _applier;
+      constructor(config, cache, applier) {
+        this._config = resolveFixRuntimeConfig(config);
+        this._cache = cache;
+        this._applier = applier;
+      }
+      /**
+       * Apply pre-call fixes.
+       *
+       * - If retrying after error: look up fix by error_code, apply
+       *   prompt/parameter/fallback fixes
+       * - Runs input guard fixes on all message content
+       */
+      preCall(ctx, messages, params) {
+        try {
+          if (!this._config.enabled) {
+            return { messages, params };
+          }
+          let modifiedMessages = messages;
+          let modifiedParams = { ...params };
+          if (ctx.errorCode) {
+            const fix = this._applier.getFixForError(ctx.errorCode, ctx.sessionId);
+            if (fix) {
+              debug(`Applying fix ${fix.fixId} for ${ctx.errorCode}`);
+              if (fix.fixType === "prompt" && messages) {
+                const msgRecords = messages;
+                const { messages: newMessages, result } = this._applier.applyPromptFix(fix, msgRecords);
+                modifiedMessages = newMessages;
+                ctx.appliedFixes.push(result);
+                this._applier.logApplication(result);
+              } else if (fix.fixType === "parameter") {
+                const { params: newParams, result } = this._applier.applyParameterFix(fix, modifiedParams);
+                modifiedParams = newParams;
+                ctx.appliedFixes.push(result);
+                this._applier.logApplication(result);
+              } else if (fix.fixType === "fallback") {
+                const { params: newParams, result } = this._applier.applyFallbackFix(fix, modifiedParams);
+                modifiedParams = newParams;
+                ctx.appliedFixes.push(result);
+                this._applier.logApplication(result);
+              }
+            }
+          }
+          if (modifiedMessages && this._config.enabled) {
+            for (const msg of modifiedMessages) {
+              const content = msg.content;
+              if (typeof content === "string") {
+                for (const fix of this._cache.getAll()) {
+                  if (fix.fixType === "guard") {
+                    const { result } = this._applier.applyGuardFix(
+                      fix,
+                      content,
+                      true
+                    );
+                    if (result.applied) {
+                      ctx.appliedFixes.push(result);
+                      this._applier.logApplication(result);
+                    }
+                  }
+                }
+              }
+            }
+          }
+          return { messages: modifiedMessages, params: modifiedParams };
+        } catch (e) {
+          debug(`DefaultFixInterceptor.preCall error: ${e}`);
+          return { messages, params };
+        }
+      }
+      /**
+       * Apply post-call fixes (output validation).
+       *
+       * Runs output guard fixes on response content.
+       */
+      postCall(ctx, response) {
+        try {
+          if (!this._config.enabled) {
+            return { response, shouldContinue: true };
+          }
+          for (const fix of this._cache.getAll()) {
+            if (fix.fixType !== "guard") continue;
+            const content = this._extractResponseContent(response);
+            if (!content) continue;
+            const { passed, result } = this._applier.applyGuardFix(
+              fix,
+              content,
+              false
+            );
+            if (result.applied) {
+              ctx.appliedFixes.push(result);
+              this._applier.logApplication(result);
+            }
+            if (!passed) {
+              warn(`Output guard failed for fix ${fix.fixId}`);
+            }
+          }
+          return { response, shouldContinue: true };
+        } catch (e) {
+          debug(`DefaultFixInterceptor.postCall error: ${e}`);
+          return { response, shouldContinue: true };
+        }
+      }
+      /**
+       * Handle errors and decide whether to retry.
+       *
+       * Classifies the error, looks up retry/fallback fixes, and returns
+       * whether the caller should retry.
+       */
+      onError(ctx, error) {
+        try {
+          if (!this._config.enabled) {
+            return { shouldRetry: false, modifiedParams: null };
+          }
+          const errorCode = classifyError(error);
+          ctx.errorCode = errorCode;
+          ctx.errorMessage = error.message;
+          const fix = this._applier.getFixForError(errorCode, ctx.sessionId);
+          if (!fix) {
+            return { shouldRetry: false, modifiedParams: null };
+          }
+          if (fix.fixType === "retry") {
+            const maxRetries = fix.config.max_retries ?? fix.config.maxRetries ?? 3;
+            if (ctx.attempt <= maxRetries) {
+              debug(
+                `Retry fix ${fix.fixId}: attempt ${ctx.attempt}/${maxRetries}`
+              );
+              const result = {
+                applied: true,
+                fixId: fix.fixId,
+                deploymentId: fix.deploymentId,
+                fixType: "retry",
+                modifications: { attempt: ctx.attempt }
+              };
+              ctx.appliedFixes.push(result);
+              this._applier.logApplication(result);
+              return { shouldRetry: true, modifiedParams: null };
+            }
+          }
+          if (fix.fixType === "fallback") {
+            const { params: modifiedParams, result } = this._applier.applyFallbackFix(fix, {});
+            if (result.applied) {
+              ctx.appliedFixes.push(result);
+              this._applier.logApplication(result);
+              return { shouldRetry: true, modifiedParams };
+            }
+          }
+          return { shouldRetry: false, modifiedParams: null };
+        } catch (e) {
+          debug(`DefaultFixInterceptor.onError error: ${e}`);
+          return { shouldRetry: false, modifiedParams: null };
+        }
+      }
+      // ─── Private ────────────────────────────────────────────────────────────
+      /** Extract text content from a response object. */
+      _extractResponseContent(response) {
+        if (typeof response === "string") return response;
+        if (response && typeof response === "object") {
+          const resp = response;
+          const choices = resp.choices;
+          if (Array.isArray(choices) && choices.length > 0) {
+            const first = choices[0];
+            const message = first?.message;
+            if (typeof message?.content === "string") {
+              return message.content;
+            }
+          }
+          const content = resp.content;
+          if (typeof content === "string") return content;
+          if (Array.isArray(content) && content.length > 0) {
+            const first = content[0];
+            if (typeof first?.text === "string") return first.text;
+          }
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/runtime/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  FixRuntime: () => FixRuntime,
+  getFixRuntime: () => getFixRuntime,
+  initFixRuntime: () => initFixRuntime,
+  setFixRuntime: () => setFixRuntime,
+  shutdownFixRuntime: () => shutdownFixRuntime
+});
+function getFixRuntime() {
+  return G2[RUNTIME_KEY];
+}
+function setFixRuntime(runtime) {
+  G2[RUNTIME_KEY] = runtime;
+}
+function initFixRuntime(config) {
+  try {
+    const existing = G2[RUNTIME_KEY];
+    if (existing) {
+      debug("Fix runtime already initialized");
+      return existing;
+    }
+    const runtime = new FixRuntime(config);
+    runtime.start();
+    G2[RUNTIME_KEY] = runtime;
+    return runtime;
+  } catch (e) {
+    warn(`initFixRuntime failed: ${e}`);
+    const fallback = new FixRuntime({ ...config, enabled: false });
+    G2[RUNTIME_KEY] = fallback;
+    return fallback;
+  }
+}
+function shutdownFixRuntime() {
+  try {
+    const runtime = G2[RUNTIME_KEY];
+    if (runtime) {
+      runtime.stop();
+    }
+    G2[RUNTIME_KEY] = void 0;
+  } catch (e) {
+    debug(`shutdownFixRuntime error: ${e}`);
+    G2[RUNTIME_KEY] = void 0;
+  }
+}
+var G2, RUNTIME_KEY, FixRuntime;
+var init_runtime = __esm({
+  "src/runtime/runtime.ts"() {
+    "use strict";
+    init_cache();
+    init_config();
+    init_applier();
+    init_loader();
+    init_interceptors();
+    init_log();
+    G2 = globalThis;
+    RUNTIME_KEY = "__risicare_fix_runtime";
+    FixRuntime = class {
+      _config;
+      _cache;
+      _loader;
+      _applier;
+      _interceptor;
+      _started = false;
+      // Effectiveness tracking
+      _fixApplications = /* @__PURE__ */ new Map();
+      _fixSuccesses = /* @__PURE__ */ new Map();
+      constructor(config) {
+        this._config = resolveFixRuntimeConfig(config);
+        this._cache = new FixCache(this._config);
+        this._loader = new FixLoader(config, this._cache);
+        this._applier = new FixApplier(config, this._cache);
+        this._interceptor = new DefaultFixInterceptor(
+          config,
+          this._cache,
+          this._applier
+        );
+      }
+      // ─── Accessors ──────────────────────────────────────────────────────────
+      /** Runtime configuration (with defaults resolved). */
+      get config() {
+        return this._config;
+      }
+      /** Whether the runtime is enabled and started. */
+      get isEnabled() {
+        return this._config.enabled && this._started;
+      }
+      /** The fix cache. */
+      get cache() {
+        return this._cache;
+      }
+      /** The fix loader. */
+      get loader() {
+        return this._loader;
+      }
+      /** The fix applier. */
+      get applier() {
+        return this._applier;
+      }
+      /** The interceptor. */
+      get interceptor() {
+        return this._interceptor;
+      }
+      // ─── Lifecycle ──────────────────────────────────────────────────────────
+      /**
+       * Start the runtime.
+       *
+       * Triggers initial fix load and starts background refresh.
+       * Never throws — failures degrade gracefully.
+       */
+      start() {
+        try {
+          if (this._started) return;
+          if (!this._config.enabled) {
+            debug("Fix runtime disabled");
+            return;
+          }
+          debug("Starting fix runtime...");
+          this._loader.start();
+          this._started = true;
+          debug("Fix runtime started");
+        } catch (e) {
+          warn(`Fix runtime start failed: ${e}`);
+        }
+      }
+      /**
+       * Stop the runtime.
+       *
+       * Stops background refresh and clears the cache.
+       * Never throws.
+       */
+      stop() {
+        try {
+          if (!this._started) return;
+          debug("Stopping fix runtime...");
+          this._loader.stop();
+          this._cache.clear();
+          this._started = false;
+          debug("Fix runtime stopped");
+        } catch (e) {
+          debug(`Fix runtime stop error: ${e}`);
+        }
+      }
+      // ─── Intercept API ──────────────────────────────────────────────────────
+      /**
+       * Intercept a call: create context and run preCall fixes.
+       *
+       * Returns modified messages/params and the InterceptContext for
+       * use in subsequent interceptResponse / interceptError calls.
+       */
+      interceptCall(operationType, operationName, messages, params, options) {
+        const ctx = createInterceptContext(operationType, operationName, options);
+        try {
+          if (!this.isEnabled) {
+            return { messages, params, ctx };
+          }
+          const result = this._interceptor.preCall(ctx, messages, params);
+          return { messages: result.messages, params: result.params, ctx };
+        } catch (e) {
+          debug(`interceptCall error: ${e}`);
+          return { messages, params, ctx };
+        }
+      }
+      /**
+       * Intercept a response: run postCall fixes (output validation).
+       */
+      interceptResponse(ctx, response) {
+        try {
+          if (!this.isEnabled) {
+            return { response, shouldContinue: true };
+          }
+          const result = this._interceptor.postCall(ctx, response);
+          this._trackSuccess(ctx);
+          return result;
+        } catch (e) {
+          debug(`interceptResponse error: ${e}`);
+          return { response, shouldContinue: true };
+        }
+      }
+      /**
+       * Intercept an error: decide on retry/fallback.
+       */
+      interceptError(ctx, error) {
+        try {
+          if (!this.isEnabled) {
+            return { shouldRetry: false, modifiedParams: null };
+          }
+          ctx.attempt++;
+          const result = this._interceptor.onError(ctx, error);
+          if (!result.shouldRetry) {
+            this._trackFailure(ctx);
+          }
+          return result;
+        } catch (e) {
+          debug(`interceptError error: ${e}`);
+          return { shouldRetry: false, modifiedParams: null };
+        }
+      }
+      // ─── Direct Fix Access ──────────────────────────────────────────────────
+      /**
+       * Get applicable fix for an error code.
+       */
+      getFix(errorCode, sessionId) {
+        try {
+          if (!this.isEnabled) return null;
+          return this._applier.getFixForError(errorCode, sessionId);
+        } catch (e) {
+          debug(`getFix error: ${e}`);
+          return null;
+        }
+      }
+      /**
+       * Manually refresh fixes from the API.
+       */
+      async refreshFixes() {
+        try {
+          return await this._loader.loadSync();
+        } catch (e) {
+          debug(`refreshFixes error: ${e}`);
+          return [];
+        }
+      }
+      // ─── Effectiveness ──────────────────────────────────────────────────────
+      /** Get effectiveness statistics for all fixes. */
+      getEffectivenessStats() {
+        const stats = {};
+        for (const [fixId, applications] of this._fixApplications) {
+          const successes = this._fixSuccesses.get(fixId) ?? 0;
+          stats[fixId] = {
+            applications,
+            successes,
+            successRate: applications > 0 ? successes / applications : 0
+          };
+        }
+        return stats;
+      }
+      // ─── Private ────────────────────────────────────────────────────────────
+      _trackSuccess(ctx) {
+        for (const result of ctx.appliedFixes) {
+          if (result.applied && result.fixId) {
+            this._fixApplications.set(
+              result.fixId,
+              (this._fixApplications.get(result.fixId) ?? 0) + 1
+            );
+            this._fixSuccesses.set(
+              result.fixId,
+              (this._fixSuccesses.get(result.fixId) ?? 0) + 1
+            );
+          }
+        }
+      }
+      _trackFailure(ctx) {
+        for (const result of ctx.appliedFixes) {
+          if (result.applied && result.fixId) {
+            this._fixApplications.set(
+              result.fixId,
+              (this._fixApplications.get(result.fixId) ?? 0) + 1
+            );
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/ids.ts
 import { randomBytes } from "crypto";
 
@@ -71,24 +1454,8 @@ var NOOP_SPAN = Object.freeze({
   }
 });
 
-// src/globals.ts
-import { AsyncLocalStorage } from "async_hooks";
-var G = globalThis;
-var PREFIX = "__risicare_";
-function getTracer() {
-  return G[PREFIX + "tracer"];
-}
-function getContextStorage() {
-  if (!G[PREFIX + "ctx"]) {
-    G[PREFIX + "ctx"] = new AsyncLocalStorage();
-  }
-  return G[PREFIX + "ctx"];
-}
-function getDebug() {
-  return G[PREFIX + "debug"] ?? false;
-}
-
 // src/context/storage.ts
+init_globals();
 function storage() {
   return getContextStorage();
 }
@@ -96,15 +1463,15 @@ function getContext() {
   return storage().getStore() ?? {};
 }
 
-// src/utils/log.ts
-function debug(msg) {
-  if (getDebug()) {
-    process.stderr.write(`[risicare] ${msg}
-`);
-  }
-}
+// src/exporters/batch.ts
+init_log();
+
+// src/exporters/http.ts
+init_log();
 
 // src/client.ts
+init_log();
+init_globals();
 function requireTracer() {
   const tracer = getTracer();
   if (!tracer) {
@@ -114,6 +1481,7 @@ function requireTracer() {
   }
   return tracer;
 }
+var _ERROR_DEDUP_TTL_MS = 5 * 60 * 1e3;
 
 // src/utils/pricing.ts
 var PRICING = {
@@ -161,6 +1529,9 @@ function calculateCost(model, promptTokens, completionTokens) {
   return inputCost + outputCost;
 }
 
+// src/providers/openai/patch.ts
+init_log();
+
 // src/context/dedup.ts
 function isProviderInstrumentationSuppressed() {
   return getContext()._suppressProviderInstrumentation === true;
@@ -187,11 +1558,41 @@ function detectProvider(client) {
     return "openai";
   }
 }
+function enrichSpanFromRequest(span, params, provider) {
+  const model = params.model;
+  if (model) {
+    span.setAttribute("gen_ai.system", provider);
+    span.setAttribute("gen_ai.request.model", model);
+  }
+  if (params.temperature !== void 0) span.setAttribute("gen_ai.request.temperature", params.temperature);
+  if (params.max_tokens !== void 0) span.setAttribute("gen_ai.request.max_tokens", params.max_tokens);
+  if (params.top_p !== void 0) span.setAttribute("gen_ai.request.top_p", params.top_p);
+  if (params.frequency_penalty !== void 0) span.setAttribute("gen_ai.request.frequency_penalty", params.frequency_penalty);
+  if (params.presence_penalty !== void 0) span.setAttribute("gen_ai.request.presence_penalty", params.presence_penalty);
+  if (params.stream !== void 0) span.setAttribute("llm.stream", !!params.stream);
+  const tools = params.tools;
+  if (Array.isArray(tools) && tools.length > 0) {
+    span.setAttribute("gen_ai.request.has_tools", true);
+    span.setAttribute("gen_ai.request.tool_count", tools.length);
+  }
+}
 function enrichSpanFromResponse(span, response, provider) {
   const model = response.model;
   const usage = response.usage;
   if (model) {
     span.setLlmFields({ provider, model });
+    span.setAttribute("gen_ai.response.model", model);
+  }
+  if (response.id) span.setAttribute("gen_ai.response.id", response.id);
+  const choices = response.choices;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const reasons = choices.map((c) => c.finish_reason).filter(Boolean);
+    if (reasons.length > 0) span.setAttribute("gen_ai.response.finish_reasons", reasons);
+    const firstChoice = choices[0];
+    const msg = firstChoice?.message;
+    if (msg?.tool_calls && Array.isArray(msg.tool_calls)) {
+      span.setAttribute("gen_ai.response.tool_call_count", msg.tool_calls.length);
+    }
   }
   if (usage) {
     const promptTokens = usage.prompt_tokens ?? 0;
@@ -204,6 +1605,10 @@ function enrichSpanFromResponse(span, response, provider) {
       totalTokens,
       costUsd: cost
     });
+    span.setAttribute("gen_ai.usage.prompt_tokens", promptTokens);
+    span.setAttribute("gen_ai.usage.completion_tokens", completionTokens);
+    span.setAttribute("gen_ai.usage.total_tokens", totalTokens);
+    if (cost !== void 0) span.setAttribute("llm.cost.total_usd", cost);
   }
 }
 function createChatCompletionProxy(originalCreate, provider) {
@@ -218,13 +1623,26 @@ function createChatCompletionProxy(originalCreate, provider) {
       debug("Tracer not initialized \u2014 call init() before using patchOpenAI()");
       return originalCreate.apply(this, args);
     }
-    const params = args[0] ?? {};
-    const model = params.model ?? "unknown";
+    let params = args[0] ?? {};
+    let model = params.model ?? "unknown";
     const isStream = !!params.stream;
+    try {
+      const { getFixRuntime: getFixRuntime2 } = (init_runtime(), __toCommonJS(runtime_exports));
+      const rt = getFixRuntime2();
+      if (rt?.isEnabled) {
+        const result = rt.interceptCall("llm_call", model, params.messages ?? null, params);
+        if (result.messages) params = { ...params, messages: result.messages };
+        if (result.params) params = { ...params, ...result.params };
+        model = params.model ?? model;
+        args[0] = params;
+      }
+    } catch {
+    }
     return tracer.startSpan(
-      { name: `openai.chat.completions.create`, kind: "llm_call" /* LLM_CALL */, attributes: { "llm.request.model": model, "llm.stream": isStream } },
+      { name: `openai.chat.completions.create`, kind: "llm_call" /* LLM_CALL */ },
       (span) => {
         span.setLlmFields({ provider, model });
+        enrichSpanFromRequest(span, params, provider);
         const result = originalCreate.apply(this, args);
         if (result && typeof result === "object" && typeof result.then === "function") {
           return result.then((response) => {
@@ -254,9 +1672,10 @@ function createEmbeddingsProxy(originalCreate, provider) {
     const params = args[0] ?? {};
     const model = params.model ?? "unknown";
     return tracer.startSpan(
-      { name: `openai.embeddings.create`, kind: "llm_call" /* LLM_CALL */, attributes: { "llm.request.model": model } },
+      { name: `openai.embeddings.create`, kind: "llm_call" /* LLM_CALL */ },
       (span) => {
         span.setLlmFields({ provider, model });
+        enrichSpanFromRequest(span, params, provider);
         const result = originalCreate.apply(this, args);
         if (result && typeof result === "object" && typeof result.then === "function") {
           return result.then((response) => {