@joshuaswarren/openclaw-engram 9.0.77 → 9.0.78

package/dist/index.js

@@ -2177,6 +2177,14 @@ var FallbackLlmClient = class {
    * Returns parsed JSON or null on failure.
    */
   async parseWithSchema(messages, schema, options = {}) {
+    const detailed = await this.parseWithSchemaDetailed(messages, schema, options);
+    return detailed?.result ?? null;
+  }
+  /**
+   * Like parseWithSchema but also returns the model that was used,
+   * so callers can emit accurate trace events.
+   */
+  async parseWithSchemaDetailed(messages, schema, options = {}) {
     const response = await this.chatCompletion(messages, options);
     if (!response?.content) return null;
     try {
@@ -2184,7 +2192,7 @@ var FallbackLlmClient = class {
       for (const c of candidates) {
         try {
           const parsed = JSON.parse(c);
-          return schema.parse(parsed);
+          return { result: schema.parse(parsed), modelUsed: response.modelUsed };
         } catch {
         }
       }
@@ -3234,18 +3242,18 @@ var ExtractionEngine = class {
     };
   }
   async parseWithGatewayFallback(traceId, operation, startedAtMs, schema, messages, options = {}) {
-    const result = await this.fallbackLlm.parseWithSchema(messages, schema, options);
-    if (result) {
+    const detailed = await this.fallbackLlm.parseWithSchemaDetailed(messages, schema, options);
+    if (detailed?.result) {
       const durationMs = Date.now() - startedAtMs;
       this.emit({
         kind: "llm_end",
         traceId,
-        model: "fallback",
+        model: detailed.modelUsed,
         operation,
         durationMs,
-        output: JSON.stringify(result).slice(0, 2e3)
+        output: JSON.stringify(detailed.result).slice(0, 2e3)
       });
-      return result;
+      return detailed.result;
     }
     return null;
   }
@@ -3267,7 +3275,11 @@ var ExtractionEngine = class {
     const lastTurnTs = boundedTurns.length > 0 ? new Date(boundedTurns[boundedTurns.length - 1].timestamp) : void 0;
     const messageTimestamp = lastTurnTs && !isNaN(lastTurnTs.getTime()) ? lastTurnTs : void 0;
     const traceId = crypto.randomUUID();
-    this.emit({ kind: "llm_start", traceId, model: this.config.model, operation: "extraction", input: conversation });
+    const emittedDirectStart = !!(this.client || this.config.localLlmEnabled);
+    if (emittedDirectStart) {
+      this.emit({ kind: "llm_start", traceId, model: this.config.model, operation: "extraction", input: conversation });
+    }
+    let closedDirectTrace = false;
     const startTime = Date.now();
     if (this.config.localLlmEnabled) {
       try {
@@ -3302,34 +3314,75 @@ var ExtractionEngine = class {
           const sanitized = this.sanitizeExtractionResult(directResult, messageTimestamp);
           return await this.applyProactiveQuestionPass(conversation, sanitized);
         }
+        try {
+          this.emit({
+            kind: "llm_error",
+            traceId,
+            model: this.config.model,
+            operation: "extraction",
+            durationMs: Date.now() - startTime,
+            error: "direct client returned no result"
+          });
+        } catch {
+        }
+        closedDirectTrace = true;
         log.info("extraction: direct client returned no result, falling back to gateway AI");
       } catch (err) {
+        try {
+          this.emit({
+            kind: "llm_error",
+            traceId,
+            model: this.config.model,
+            operation: "extraction",
+            durationMs: Date.now() - startTime,
+            error: String(err)
+          });
+        } catch {
+        }
+        closedDirectTrace = true;
         log.info("extraction: direct client failed, falling back to gateway AI:", err);
       }
     }
+    if (emittedDirectStart && !closedDirectTrace) {
+      try {
+        this.emit({
+          kind: "llm_error",
+          traceId,
+          model: this.config.model,
+          operation: "extraction",
+          durationMs: Date.now() - startTime,
+          error: "local LLM failed, handing off to gateway fallback"
+        });
+      } catch {
+      }
+    }
+    const fallbackTraceId = crypto.randomUUID();
+    const fallbackStartTime = Date.now();
     log.info("extraction: falling back to gateway default AI");
     try {
       const messages = [
         { role: "system", content: this.buildExtractionInstructions(existingEntities) },
         { role: "user", content: conversation }
       ];
-      const result = await this.fallbackLlm.parseWithSchema(
+      this.emit({ kind: "llm_start", traceId: fallbackTraceId, model: "fallback", operation: "extraction", input: conversation });
+      const detailed = await this.fallbackLlm.parseWithSchemaDetailed(
         messages,
         ExtractionResultSchema,
         { temperature: 0.3, maxTokens: 4096 }
       );
-      const durationMs = Date.now() - startTime;
-      if (result && Array.isArray(result.facts)) {
+      const fallbackDurationMs = Date.now() - fallbackStartTime;
+      if (detailed?.result && Array.isArray(detailed.result.facts)) {
+        const result = detailed.result;
         this.emit({
           kind: "llm_end",
-          traceId,
-          model: "fallback",
+          traceId: fallbackTraceId,
+          model: detailed.modelUsed,
           operation: "extraction",
-          durationMs,
+          durationMs: fallbackDurationMs,
           output: JSON.stringify(result).slice(0, 2e3)
         });
         log.debug(
-          `extracted ${result.facts.length} facts, ${result.entities.length} entities, ${(result.questions ?? []).length} questions via fallback`
+          `extracted ${result.facts.length} facts, ${result.entities.length} entities, ${(result.questions ?? []).length} questions via fallback (${detailed.modelUsed})`
         );
         const sanitized = this.sanitizeExtractionResult({
           ...result,
@@ -3338,15 +3391,23 @@ var ExtractionEngine = class {
         }, messageTimestamp);
         return await this.applyProactiveQuestionPass(conversation, sanitized);
       }
+      this.emit({
+        kind: "llm_error",
+        traceId: fallbackTraceId,
+        model: "fallback",
+        operation: "extraction",
+        durationMs: fallbackDurationMs,
+        error: "fallback returned no parsed output"
+      });
       log.warn("extraction fallback returned no parsed output");
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
     } catch (err) {
       this.emit({
         kind: "llm_error",
-        traceId,
+        traceId: fallbackTraceId,
         model: "fallback",
         operation: "extraction",
-        durationMs: Date.now() - startTime,
+        durationMs: Date.now() - fallbackStartTime,
         error: String(err)
       });
       log.error("extraction fallback failed", err);
@@ -40009,11 +40070,34 @@ async function postSpanBatch(cfg, spans, log2) {
     log2.debug?.(`[opik-exporter] span batch error: ${err}`);
   }
 }
+async function postTraceBatch(cfg, traces, log2) {
+  const url = `${cfg.apiUrl.replace(/\/$/, "")}/v1/private/traces/batch`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: buildHeaders(cfg),
+      body: JSON.stringify({ traces })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      log2.debug?.(`[opik-exporter] trace batch failed ${res.status}: ${text}`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    log2.debug?.(`[opik-exporter] trace batch error: ${err}`);
+    return false;
+  }
+}
 var OpikExporter = class _OpikExporter {
   cfg;
   log;
   _handler;
   inFlight = /* @__PURE__ */ new Map();
+  /** Track which trace_ids we have already created parent trace objects for. */
+  createdTraces = /* @__PURE__ */ new Set();
+  /** In-flight ensureTrace promises keyed by traceId — concurrent callers await the same promise. */
+  pendingTraces = /* @__PURE__ */ new Map();
   /** TTL for in-flight LLM entries (ms). Entries older than this are discarded. */
   static IN_FLIGHT_TTL_MS = 5 * 60 * 1e3;
   // 5 minutes
@@ -40116,9 +40200,11 @@ var OpikExporter = class _OpikExporter {
       metadata.identityInjectedChars = evt.identityInjectedChars;
     }
     if (evt.timings) metadata.timings = evt.timings;
+    const traceId = evt.sessionKey ? this.sessionToTraceId(evt.sessionKey) : uuidV7();
+    await this.ensureTrace(traceId, evt.sessionKey ?? "engram:recall", startTime, endTime);
     const span = {
       id: uuidV7(),
-      trace_id: evt.sessionKey ? this.sessionToTraceId(evt.sessionKey) : uuidV7(),
+      trace_id: traceId,
       project_name: this.cfg.projectName,
       name: "engram:recall",
       type: "general",
@@ -40162,9 +40248,11 @@ var OpikExporter = class _OpikExporter {
     if (evt.tokenUsage?.input != null) usage.prompt_tokens = evt.tokenUsage.input;
     if (evt.tokenUsage?.output != null) usage.completion_tokens = evt.tokenUsage.output;
     if (evt.tokenUsage?.total != null) usage.total_tokens = evt.tokenUsage.total;
+    const traceId = state?.traceId ?? uuidV7();
+    await this.ensureTrace(traceId, `engram:${evt.operation}`, startTime, endTime);
     const span = {
       id: state?.spanId ?? uuidV7(),
-      trace_id: state?.traceId ?? uuidV7(),
+      trace_id: traceId,
       project_name: this.cfg.projectName,
       name: `engram:${evt.operation}`,
       type: "llm",
@@ -40186,6 +40274,47 @@ var OpikExporter = class _OpikExporter {
   // -------------------------------------------------------------------------
   // Helpers
   // -------------------------------------------------------------------------
+  /**
+   * Create a parent trace object in Opik if we haven't already.
+   * Opik does NOT auto-create traces from spans, so without this
+   * the spans are orphaned and don't show up in the trace list UI.
+   */
+  async ensureTrace(traceId, name, startTime, endTime) {
+    if (this.createdTraces.has(traceId)) return;
+    const existing = this.pendingTraces.get(traceId);
+    if (existing) {
+      await existing;
+      if (this.createdTraces.has(traceId)) return;
+      const retrying = this.pendingTraces.get(traceId);
+      if (retrying) {
+        await retrying;
+        if (this.createdTraces.has(traceId)) return;
+      }
+    }
+    const work = (async () => {
+      const trace = {
+        id: traceId,
+        project_name: this.cfg.projectName,
+        name,
+        start_time: startTime,
+        end_time: endTime,
+        tags: ["engram"]
+      };
+      const ok = await postTraceBatch(this.cfg, [trace], this.log);
+      if (!ok) {
+        this.pendingTraces.delete(traceId);
+        return;
+      }
+      this.createdTraces.add(traceId);
+      this.pendingTraces.delete(traceId);
+      if (this.createdTraces.size > 1e4) {
+        const first = this.createdTraces.values().next().value;
+        if (first) this.createdTraces.delete(first);
+      }
+    })();
+    this.pendingTraces.set(traceId, work);
+    await work;
+  }
   /**
    * Convert a sessionKey to a stable, deterministic UUID v7-shaped ID so that
    * spans for the same session share a trace_id and are threaded in Opik.