@remnic/core 9.69.86 → 9.69.88

package/src/extraction-liveness.ts

@@ -19,6 +19,7 @@
  * the verdict never diverges across code paths.
  */
 import { coerceBool, coerceNumber } from "./connectors/coerce.js";
+import { getExtractionLlmHealth } from "./extraction-llm-health.js";
 import { log } from "./logger.js";
 import type { OperatorDoctorCheck } from "./operator-doctor-types.js";
 import type { PluginConfig } from "./types.js";
@@ -121,6 +122,15 @@ export interface ExtractionLivenessStatus {
   degradedReason: string | null;
   watermarkPending?: boolean;
   watermarkScope: "aggregate";
+  /**
+   * Extraction-LLM availability (issue #3140): outcome of the last extraction
+   * attempt. `lastFailureReason` is non-null exactly while `llmReachable` is
+   * false. Populated by the daemon-wide status readers (`/health`, doctor,
+   * stats), not by the pure evaluators below.
+   */
+  llmReachable?: boolean;
+  lastFailureReason?: string | null;
+  lastFailureAt?: string | null;
 }
 
 interface ExtractionLivenessOrchestratorLike {
@@ -380,7 +390,9 @@ export async function computeExtractionLivenessStatus(
     nowMs,
   });
   throttle?.maybeWarn(status, config.staleWindowMs, nowMs);
-  return status;
+  // Extraction-LLM availability (#3140): a silent no_models / LLM-unreachable
+  // outage must be visible on /health (and doctor/stats) without debug logs.
+  return { ...status, ...getExtractionLlmHealth() };
 }
 
 /**

package/src/extraction-llm-health.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Extraction-LLM health surfacing (issue #3140).
+ *
+ * Covers the three #3140 surfaces:
+ *   1. the singleton tracker that `/health.extraction` reads for LLM
+ *      availability + last failure reason,
+ *   2. the ERROR-level, per-reason-deduplicated failure event emitted by the
+ *      extraction run instead of debug-only lines,
+ *   3. the runExtraction integration recording failures/successes.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  emitExtractionLlmFailureError,
+  getExtractionLlmHealth,
+  recordExtractionLlmFailure,
+  recordExtractionLlmSuccess,
+  resetExtractionLlmHealthForTests,
+} from "./extraction-llm-health.js";
+import { log } from "./logger.js";
+
+test("tracker: starts reachable with no failure recorded", () => {
+  resetExtractionLlmHealthForTests();
+  try {
+    assert.deepEqual(getExtractionLlmHealth(), {
+      llmReachable: true,
+      lastFailureReason: null,
+      lastFailureAt: null,
+    });
+  } finally {
+    resetExtractionLlmHealthForTests();
+  }
+});
+
+test("tracker: a failure marks the extractor unavailable with the last reason (health payload, non-debug)", () => {
+  resetExtractionLlmHealthForTests();
+  try {
+    recordExtractionLlmFailure("no_models", 1_000);
+    const health = getExtractionLlmHealth();
+    assert.equal(health.llmReachable, false);
+    assert.equal(health.lastFailureReason, "no_models");
+    assert.equal(health.lastFailureAt, new Date(1_000).toISOString());
+
+    recordExtractionLlmFailure("local_llm_unavailable", 2_000);
+    assert.equal(getExtractionLlmHealth().lastFailureReason, "local_llm_unavailable");
+  } finally {
+    resetExtractionLlmHealthForTests();
+  }
+});
+
+test("tracker: a later success clears the failure so llmReachable and the reason agree", () => {
+  resetExtractionLlmHealthForTests();
+  try {
+    recordExtractionLlmFailure("no_models");
+    recordExtractionLlmSuccess();
+    assert.deepEqual(getExtractionLlmHealth(), {
+      llmReachable: true,
+      lastFailureReason: null,
+      lastFailureAt: null,
+    });
+  } finally {
+    resetExtractionLlmHealthForTests();
+  }
+});
+
+test("dedup: the first failure of a reason logs at ERROR level, repeats are suppressed", () => {
+  resetExtractionLlmHealthForTests();
+  const errors: string[] = [];
+  const debugs: string[] = [];
+  const originalError = log.error;
+  const originalDebug = log.debug;
+  log.error = (message: unknown) => {
+    errors.push(String(message));
+  };
+  log.debug = (message: unknown) => {
+    debugs.push(String(message));
+  };
+  try {
+    assert.equal(emitExtractionLlmFailureError("no_models", "auth_config", 0), true);
+    assert.equal(errors.length, 1);
+    assert.match(errors[0] ?? "", /no_models/);
+
+    // Same reason inside the window: suppressed to debug, no second ERROR.
+    assert.equal(emitExtractionLlmFailureError("no_models", "auth_config", 60_000), false);
+    assert.equal(errors.length, 1);
+    assert.equal(debugs.length, 1);
+
+    // A different reason emits its own first ERROR.
+    assert.equal(emitExtractionLlmFailureError("local_llm_unavailable", undefined, 60_000), true);
+    assert.equal(errors.length, 2);
+    assert.match(errors[1] ?? "", /local_llm_unavailable/);
+
+    // Outside the window the same reason emits again.
+    assert.equal(emitExtractionLlmFailureError("no_models", undefined, 3_600_000), true);
+    assert.equal(errors.length, 3);
+  } finally {
+    log.error = originalError;
+    log.debug = originalDebug;
+    resetExtractionLlmHealthForTests();
+  }
+});

package/src/extraction-llm-health.ts

@@ -0,0 +1,71 @@
+/**
+ * Extraction-LLM availability tracking surfaced on `/health` (issue #3140).
+ *
+ * A failing extraction LLM (unreachable endpoint, gateway with no models)
+ * used to surface only as debug-level lines while extraction silently skipped
+ * persistence and the buffer grew for days. The extraction run records every
+ * attempt outcome here; the access `/health` payload reads the last outcome so
+ * an unavailable extractor is visible without debug logs, and each distinct
+ * failure reason logs at ERROR level at most once per window instead of once
+ * per failed flush.
+ */
+
+import { log } from "./logger.js";
+
+export interface ExtractionLlmHealth {
+  /** Whether the LAST extraction attempt completed without a failure marker. */
+  llmReachable: boolean;
+  /** `failureReason` of the last failed attempt; null while reachable. */
+  lastFailureReason: string | null;
+  /** ISO timestamp of the last failed attempt; null while reachable. */
+  lastFailureAt: string | null;
+}
+
+/** One ERROR line per distinct reason per window; repeats stay at debug. */
+const DEDUP_WINDOW_MS = 3_600_000;
+
+let lastFailureReason: string | null = null;
+let lastFailureAtMs: number | null = null;
+const lastErrorEmitByReason = new Map<string, number>();
+
+export function recordExtractionLlmSuccess(): void {
+  lastFailureReason = null;
+  lastFailureAtMs = null;
+}
+
+export function recordExtractionLlmFailure(reason: string, atMs: number = Date.now()): void {
+  lastFailureReason = reason;
+  lastFailureAtMs = atMs;
+}
+
+export function getExtractionLlmHealth(): ExtractionLlmHealth {
+  return {
+    llmReachable: lastFailureReason === null,
+    lastFailureReason,
+    lastFailureAt: lastFailureAtMs === null ? null : new Date(lastFailureAtMs).toISOString(),
+  };
+}
+
+/**
+ * ERROR-level, deduplicated failure event (issue #3140): the first failure of
+ * a given reason inside the window logs at error level; repeats inside the
+ * window log at debug so the backoff retry loop cannot flood the transcript
+ * while the outage stays visible. Returns whether the error line was emitted.
+ */
+export function emitExtractionLlmFailureError(reason: string, detail?: string, nowMs: number = Date.now()): boolean {
+  const suffix = detail ? `: ${detail}` : "";
+  const last = lastErrorEmitByReason.get(reason);
+  if (last !== undefined && nowMs - last < DEDUP_WINDOW_MS) {
+    log.debug(`extraction failure repeat suppressed for ${DEDUP_WINDOW_MS / 60_000}m: ${reason}${suffix}`);
+    return false;
+  }
+  lastErrorEmitByReason.set(reason, nowMs);
+  log.error(`extraction failed with no durable outputs (buffer retained for retry): ${reason}${suffix}`);
+  return true;
+}
+
+/** Test seam: restore pristine singleton state. */
+export function resetExtractionLlmHealthForTests(): void {
+  recordExtractionLlmSuccess();
+  lastErrorEmitByReason.clear();
+}

package/src/index.ts

@@ -876,12 +876,12 @@ export {
   type OfflineSyncFileRecord,
   type OfflineSyncFileContentChunk,
   type OfflineSyncRecordDeletionRevision,
-  type OfflineSyncFileState,
-  type OfflineSyncFileTarget,
-  type OfflineSyncFileWriteTarget,
+  type OfflineSyncFileState, type OfflineSyncFileTarget, type OfflineSyncFileWriteTarget,
   type OfflineSyncSnapshot,
   type OfflineSyncState,
 } from "./offline-sync.js";
+export { embeddingGenerationMembership, divergedEmbeddingGenerationDeferrals } from "./offline-sync-embedding-generation.js";
+export { EmbeddingIndexCapacityError, EmbeddingIndexFileStore, EmbeddingIndexStorageError, parseEmbeddingIndexDocument, serializeEmbeddingShard, shardEntriesForIndex, shardIndexOf, validateShardMembership } from "./embedding-index-storage.js";
 
 // ---------------------------------------------------------------------------
 // Memory Extension Host (#382)

package/src/json-extract.ts

@@ -21,6 +21,12 @@ export function extractJsonCandidates(text: string): string[] {
   const cleaned = stripCodeFences(trimmed);
   const candidates: string[] = [];
 
+  // Verbatim balanced blocks FIRST: stripCodeFences rewrites every ``` pair, so
+  // a stripped candidate can parse while carrying altered content (e.g. a
+  // patch value that embeds an inner code block). A string-aware balanced scan
+  // of the unstripped text yields the payload unmodified; stripped candidates
+  // remain as later fallbacks for shapes the raw scan cannot cut.
+  candidates.push(...scanBalancedJsonBlocks(trimmed));
   if (cleaned.length > 0) candidates.push(cleaned);
   candidates.push(...scanBalancedJsonBlocks(cleaned));
 

package/src/local-llm-thinking.test.ts

@@ -356,3 +356,15 @@ test("request-level thinking override leaves short extraction thinking enabled (
   }
   assert.equal("reasoning_effort" in (bodies[0] ?? {}), false);
 });
+
+test("disableThinking injects chat_template_kwargs for correction classify (#3134)", async () => {
+  const client = new LocalLlmClient(createConfig());
+  primeClient(client, { thinking: true, detected: "lmstudio" });
+  const { restore, bodies } = captureFetchBodies();
+  try {
+    await runOneChatCompletion(client, "correction-classify");
+  } finally {
+    restore();
+  }
+  assert.deepEqual(bodies[0]?.chat_template_kwargs, { enable_thinking: false });
+});

package/src/local-llm.ts

@@ -141,6 +141,7 @@ const THINKING_SUPPRESSED_OPERATIONS: ReadonlySet<string> = new Set([
   "day_summary",
   "hourly_summary",
   "hourly_summary_extended",
+  "correction-classify",
 ]);
 
 export interface LocalModelInfo {