akm-cli 0.7.4 → 0.8.0-rc1

package/dist/llm/client.js

@@ -8,6 +8,10 @@
  * `llm.ts` re-exports everything from this module for backward compatibility.
  */
 import { fetchWithTimeout } from "../core/common";
+import { escapeJsonStringControls, parseJsonResponse, stripCodeFences, stripThinkBlocks } from "../core/parse";
+// Re-export shared parse utilities so existing importers of `client.ts` continue
+// to resolve `parseJsonResponse` and `parseEmbeddedJsonResponse` from this module.
+export { escapeJsonStringControls, parseEmbeddedJsonResponse, parseJsonResponse, stripCodeFences, stripThinkBlocks, } from "../core/parse";
 /** Maximum length of an LLM error response body included in thrown errors. */
 const ERROR_BODY_MAX_LEN = 200;
 /**
@@ -38,105 +42,78 @@ export function redactErrorBody(input) {
     }
     return out;
 }
+export class LlmCallError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = "LlmCallError";
+    }
+}
 export async function chatCompletion(config, messages, options) {
+    const timeoutMs = options?.timeoutMs ?? config.timeoutMs ?? 120_000;
     const headers = { "Content-Type": "application/json" };
     if (config.apiKey) {
         headers.Authorization = `Bearer ${config.apiKey}`;
     }
-    const response = await fetchWithTimeout(config.endpoint, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-            model: config.model,
-            messages,
-            temperature: options?.temperature ?? config.temperature ?? 0.3,
-            max_tokens: options?.maxTokens ?? config.maxTokens ?? 512,
-            ...config.extraParams,
-        }),
-    }, 30_000, options?.signal);
+    // Only include max_tokens when explicitly set. The model/API knows its own
+    // limits; a hardcoded default creates silent truncation failures when the
+    // guess is wrong. Users who need a cap can set llm.maxTokens in config.
+    const resolvedMaxTokens = options?.maxTokens ?? config.maxTokens;
+    let response;
+    try {
+        response = await fetchWithTimeout(config.endpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: config.model,
+                messages,
+                temperature: options?.temperature ?? config.temperature ?? 0.3,
+                ...(resolvedMaxTokens !== undefined ? { max_tokens: resolvedMaxTokens } : {}),
+                ...config.extraParams,
+            }),
+        }, timeoutMs, options?.signal);
+    }
+    catch (err) {
+        // fetchWithTimeout throws a plain Error with a message containing
+        // "timed out" for AbortController-driven timeouts, or "aborted" for
+        // caller-driven cancellations. Map both to typed LlmCallError.
+        const msg = err instanceof Error ? err.message : String(err);
+        if (err instanceof DOMException && err.name === "AbortError") {
+            throw new LlmCallError(`Request timed out after ${timeoutMs}ms`, "timeout");
+        }
+        if (msg.includes("timed out")) {
+            throw new LlmCallError(`Request timed out after ${timeoutMs}ms`, "timeout");
+        }
+        throw new LlmCallError(`Network error: ${msg}`, "network_error");
+    }
     if (!response.ok) {
         const rawBody = await response.text().catch(() => "");
         const safeBody = redactErrorBody(rawBody);
-        throw new Error(`LLM request failed (${response.status}) ${config.endpoint}: ${safeBody}`);
+        const status = response.status;
+        if (status === 429) {
+            throw new LlmCallError(`LLM request rate limited (429) ${config.endpoint}: ${safeBody}`, "rate_limited", status);
+        }
+        if (status >= 500) {
+            throw new LlmCallError(`LLM provider error (${status}) ${config.endpoint}: ${safeBody}`, "provider_error", status);
+        }
+        throw new LlmCallError(`LLM request failed (${status}) ${config.endpoint}: ${safeBody}`, "provider_error", status);
     }
     const json = (await response.json());
-    return json.choices?.[0]?.message?.content?.trim() ?? "";
-}
-/** Strip leading/trailing markdown code fences from an LLM response. */
-export function stripJsonFences(raw) {
-    return raw
-        .trim()
-        .replace(/<think>[\s\S]*?<\/think>/gi, "")
-        .replace(/^```(?:json)?\s*\n?/i, "")
-        .replace(/\n?```\s*$/i, "")
-        .trim();
-}
-/** Parse a possibly-fenced JSON response. Returns undefined if invalid. */
-export function parseJsonResponse(raw) {
-    try {
-        return JSON.parse(stripJsonFences(raw));
-    }
-    catch {
-        return undefined;
-    }
+    const content = (json.choices?.[0]?.message?.content ?? "").trim();
+    const reasoning = (json.choices?.[0]?.message?.reasoning_content ?? "").trim();
+    return content || reasoning;
 }
 /**
- * Best-effort recovery for providers that wrap JSON in extra prose or fenced
- * blocks. Extracts the first balanced top-level object/array and parses it.
+ * Strip `<think>` blocks, code fences, and escape control characters in JSON
+ * strings. Thin wrapper kept for backward compatibility with call sites that
+ * import `stripJsonFences` from this module. New code should prefer the
+ * granular helpers from `../core/parse`.
  */
-export function parseEmbeddedJsonResponse(raw) {
-    const direct = parseJsonResponse(raw);
-    if (direct !== undefined)
-        return direct;
-    const text = stripJsonFences(raw);
-    let arrayFallback;
-    for (let start = 0; start < text.length; start++) {
-        const opener = text[start];
-        if (opener !== "{" && opener !== "[")
-            continue;
-        const closer = opener === "{" ? "}" : "]";
-        let depth = 0;
-        let inString = false;
-        let escaped = false;
-        for (let i = start; i < text.length; i++) {
-            const ch = text[i];
-            if (inString) {
-                if (escaped) {
-                    escaped = false;
-                }
-                else if (ch === "\\") {
-                    escaped = true;
-                }
-                else if (ch === '"') {
-                    inString = false;
-                }
-                continue;
-            }
-            if (ch === '"') {
-                inString = true;
-                continue;
-            }
-            if (ch === opener)
-                depth += 1;
-            if (ch === closer) {
-                depth -= 1;
-                if (depth === 0) {
-                    try {
-                        const parsed = JSON.parse(text.slice(start, i + 1));
-                        if (!Array.isArray(parsed)) {
-                            return parsed;
-                        }
-                        arrayFallback ??= parsed;
-                        break;
-                    }
-                    catch {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return arrayFallback;
+export function stripJsonFences(raw) {
+    return escapeJsonStringControls(stripCodeFences(stripThinkBlocks(raw)));
 }
 // ── Availability check ──────────────────────────────────────────────────────
 /**

package/dist/llm/feature-gate.js

@@ -8,16 +8,15 @@
  * The seam is intentionally tiny:
  *
  *   - `isLlmFeatureEnabled(config, feature)` — pure predicate, no side
- *     effects, no I/O. Returns `true` only when the feature flag is the
- *     literal boolean `true` in config. Defaults are `false` per v1
- *     spec §14 — adding a flag to the schema is a non-event until the user
- *     opts in.
+ *     effects, no I/O. Returns `true` when the feature flag is explicitly
+ *     `true`, or when the feature has a non-false default (currently
+ *     `graph_extraction`).
  *   - `tryLlmFeature(feature, config, fn, fallback, opts?)` — single-call
  *     wrapper that runs `fn()` only when the gate is open, enforces a hard
- *     timeout (default 30s — overridable per call), and returns `fallback`
- *     on disablement, throw, or timeout. The wrapper is referentially
- *     transparent for any given (gate-state, fn-result) pair: no module
- *     state is mutated.
+ *     timeout (default 600s — overridable per call via `opts.timeoutMs`),
+ *     and returns `fallback` on disablement, throw, or timeout. The wrapper
+ *     is referentially transparent for any given (gate-state, fn-result)
+ *     pair: no module state is mutated.
  *
  * Statelessness invariant (v1 spec §14.4): nothing in this module holds
  * state across calls. There are no caches, no module-level singletons, no
@@ -29,18 +28,30 @@
 /**
  * Pure predicate: is the named feature gate explicitly enabled in `config`?
  *
- * Returns `false` when:
- *   - the LLM block is missing,
- *   - the `features` block is missing,
- *   - the key is absent (defaults are `false`),
- *   - the key is set to `false`.
+ * Returns `false` only when the key is explicitly set to `false`, or when
+ * the key is absent and its default is `false`.
  */
+const FEATURE_DEFAULTS = {
+    memory_inference: true,
+    graph_extraction: true,
+};
 export function isLlmFeatureEnabled(config, feature) {
-    if (!config?.llm?.features)
+    const configured = config?.llm?.features?.[feature];
+    if (configured === true)
+        return true;
+    if (configured === false)
         return false;
-    return config.llm.features[feature] === true;
+    return FEATURE_DEFAULTS[feature] === true;
 }
-const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Default hard timeout for every bounded in-tree LLM call. Set to 10 minutes
+ * (600 000 ms) — generous enough for a slow local model on a single-threaded
+ * server. Override per-call via `TryLlmFeatureOptions.timeoutMs`.
+ *
+ * Do NOT reduce this default without a documented user-facing reason — local
+ * model users need the headroom.
+ */
+const DEFAULT_TIMEOUT_MS = 600_000;
 /**
  * Run `fn()` only if `isLlmFeatureEnabled(config, feature)` is `true`. On
  * disablement, throw, or timeout, return `fallback` (or — if it is a

package/dist/llm/graph-extract.js

@@ -5,8 +5,8 @@
  * asks the configured LLM to surface the entities mentioned in it and the
  * relations between them. The pass itself
  * (`src/indexer/graph-extraction.ts`) is responsible for deciding which
- * files to extract, persisting the resulting nodes/edges to a stash-local
- * `graph.json` artifact, and feeding the artifact into the FTS5+boosts
+ * files to extract, persisting the resulting nodes/edges to the index DB,
+ * and feeding the graph data into the FTS5+boosts
  * search pipeline as a single boost component.
  *
  * This module is intentionally tiny and stateless so tests can stub it via
@@ -20,88 +20,321 @@
 import { toErrorMessage } from "../core/common";
 import { warn } from "../core/warn";
 import { chatCompletion, parseEmbeddedJsonResponse } from "./client";
+import { tryLlmFeature } from "./feature-gate";
+import userPromptTemplate from "./prompts/graph-extract-user-prompt.md" with { type: "text" };
+/**
+ * Separator token used between assets in a batch prompt.
+ * Chosen to be visually clear and unlikely to appear verbatim in asset bodies.
+ */
+const BATCH_ASSET_SEPARATOR = "=== ASSET";
 /** Hard cap on body chars sent to the model. */
 const MAX_BODY_CHARS = 4000;
 /** Hard cap on entities returned per asset — guards against runaway LLM output. */
 const MAX_ENTITIES_PER_ASSET = 32;
 /** Hard cap on relations returned per asset. */
 const MAX_RELATIONS_PER_ASSET = 32;
-/** Hard timeout for the LLM call; an `akm index` run must not hang on a misbehaving endpoint. */
-const LLM_TIMEOUT_MS = 30_000;
-const SYSTEM_PROMPT = "You extract a knowledge graph from developer notes. Return only valid JSON. " + "No prose, no markdown fences.";
-const USER_PROMPT_PREFIX = `Extract entities and relations from the asset body below.
-
-Rules:
-- Output ONLY a JSON object: {"entities": ["Entity One", ...], "relations": [{"from": "A", "to": "B", "type": "uses"}, ...]}.
-- Entities are short, canonical noun phrases (project names, services, tools, people, file/dir names, technical concepts).
-- Relations connect two entities that both appear in the entities array.
-- "type" is a short verb phrase (e.g. "uses", "depends on", "owns", "documents"). Optional; omit when unsure.
-- Drop pleasantries, meta-commentary, and timestamps.
-- Limit to at most ${MAX_ENTITIES_PER_ASSET} entities and ${MAX_RELATIONS_PER_ASSET} relations per asset.
-- Return {"entities": [], "relations": []} if the body has no extractable graph content.
-
-Asset body:
-`;
+const SYSTEM_PROMPT = "You extract a knowledge graph from developer notes. Return ONLY valid JSON — no prose, no markdown fences, no preamble.";
+const USER_PROMPT_PREFIX = userPromptTemplate
+    .replace("{{MAX_ENTITIES}}", String(MAX_ENTITIES_PER_ASSET))
+    .replace("{{MAX_RELATIONS}}", String(MAX_RELATIONS_PER_ASSET));
+function parseConfidence(raw) {
+    if (typeof raw !== "number" || !Number.isFinite(raw))
+        return undefined;
+    return Math.max(0, Math.min(1, raw));
+}
+function normalizeEntityName(raw) {
+    return raw
+        .trim()
+        .replace(/^[`"']+|[`"']+$/g, "")
+        .replace(/\s+/g, " ")
+        .replace(/[;,!?]+$/g, "")
+        .trim();
+}
+function normalizeRelationType(raw) {
+    const normalized = raw
+        .trim()
+        .toLowerCase()
+        .replace(/^[`"']+|[`"']+$/g, "")
+        .replace(/\s+/g, " ")
+        .replace(/[.;,!?]+$/g, "")
+        .trim();
+    if (!normalized)
+        return undefined;
+    if (normalized === "use" || normalized === "utilizes")
+        return "uses";
+    if (normalized === "depend on" || normalized === "depends")
+        return "depends on";
+    if (normalized === "integrates" || normalized === "integration with")
+        return "integrates with";
+    return normalized;
+}
+function parseGraphExtraction(raw) {
+    const empty = { entities: [], relations: [] };
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return empty;
+    const item = raw;
+    const entityCanonical = new Map();
+    if (Array.isArray(item.entities)) {
+        for (const value of item.entities) {
+            if (typeof value !== "string")
+                continue;
+            const normalized = normalizeEntityName(value);
+            if (!normalized)
+                continue;
+            const key = normalized.toLowerCase();
+            if (!entityCanonical.has(key))
+                entityCanonical.set(key, normalized);
+            if (entityCanonical.size >= MAX_ENTITIES_PER_ASSET)
+                break;
+        }
+    }
+    const entities = Array.from(entityCanonical.values());
+    const relations = [];
+    if (Array.isArray(item.relations)) {
+        for (const relation of item.relations) {
+            if (typeof relation !== "object" || relation === null || Array.isArray(relation))
+                continue;
+            const rel = relation;
+            const fromRaw = typeof rel.from === "string" ? normalizeEntityName(rel.from) : "";
+            const toRaw = typeof rel.to === "string" ? normalizeEntityName(rel.to) : "";
+            if (!fromRaw || !toRaw)
+                continue;
+            const from = entityCanonical.get(fromRaw.toLowerCase());
+            const to = entityCanonical.get(toRaw.toLowerCase());
+            if (!from || !to)
+                continue;
+            const type = typeof rel.type === "string" ? normalizeRelationType(rel.type) : undefined;
+            const confidence = parseConfidence(rel.confidence);
+            relations.push({
+                from,
+                to,
+                ...(type ? { type } : {}),
+                ...(confidence !== undefined ? { confidence } : {}),
+            });
+            if (relations.length >= MAX_RELATIONS_PER_ASSET)
+                break;
+        }
+    }
+    const confidence = parseConfidence(item.confidence);
+    return {
+        entities,
+        relations,
+        ...(confidence !== undefined ? { confidence } : {}),
+    };
+}
+/**
+ * Build the system prompt for a batched graph-extraction call.
+ *
+ * The prompt instructs the model to return a JSON array of exactly `count`
+ * objects, one per asset, in input order. Index alignment is the critical
+ * invariant — if the model drops an asset it still must emit an empty
+ * placeholder `{"entities":[],"relations":[]}` at that position.
+ *
+ * Worked example (3 assets, abbreviated):
+ *
+ *   Input user message:
+ *     Extract entities and relations from the N=3 assets below.
+ *     ...rules...
+ *     === ASSET 1 ===
+ *     ServiceA integrates with ServiceB.
+ *     === ASSET 2 ===
+ *     Terraform provisions the Prod cluster.
+ *     === ASSET 3 ===
+ *     No extractable graph content here.
+ *
+ *   Expected model output (valid JSON array, no prose):
+ *     [
+ *       {"entities":["ServiceA","ServiceB"],"relations":[{"from":"ServiceA","to":"ServiceB","type":"integrates with"}]},
+ *       {"entities":["Terraform","Prod cluster"],"relations":[{"from":"Terraform","to":"Prod cluster","type":"provisions"}]},
+ *       {"entities":[],"relations":[]}
+ *     ]
+ *
+ * If the model returns fewer than 3 items (partial failure), the caller
+ * (`extractGraphFromBodies`) falls back to individual calls for missing indices.
+ */
+function buildBatchSystemPrompt() {
+    return ("You extract knowledge graphs from developer notes. " +
+        "Return ONLY a valid JSON array — no prose, no markdown fences, no preamble. " +
+        "Each element of the array corresponds to one input asset, in order. " +
+        "The array length MUST equal the number of assets provided. " +
+        'Use {"entities":[],"relations":[]} for assets with no extractable graph content.');
+}
+function buildBatchUserPrompt(bodies) {
+    const count = bodies.length;
+    const assetBlocks = bodies
+        .map((body, i) => `${BATCH_ASSET_SEPARATOR} ${i + 1} ===\n${body.trim().slice(0, MAX_BODY_CHARS)}`)
+        .join("\n\n");
+    return (`Extract entities and relations from the N=${count} assets below.\n\n` +
+        `Rules:\n` +
+        `- Output ONLY a JSON array of exactly ${count} objects, one per asset, preserving input order.\n` +
+        `- Each object: {"entities": ["Entity One", ...], "relations": [{"from": "A", "to": "B", "type": "uses"}, ...]}\n` +
+        `- Entities are short, canonical noun phrases (project names, services, tools, people, file/dir names, technical concepts).\n` +
+        `- Relations connect two entities that both appear in that asset's entities array.\n` +
+        `- "type" is a short verb phrase (e.g. "uses", "depends on", "owns"). Optional; omit when unsure.\n` +
+        `- Drop pleasantries, meta-commentary, and timestamps.\n` +
+        `- Limit to at most ${MAX_ENTITIES_PER_ASSET} entities and ${MAX_RELATIONS_PER_ASSET} relations per asset.\n` +
+        `- Use {"entities":[],"relations":[]} for assets with no extractable graph content.\n` +
+        `- The array MUST have exactly ${count} elements — one placeholder per asset even if empty.\n\n` +
+        assetBlocks);
+}
+/**
+ * Parse and validate a single item from the batch response array.
+ * Mirrors the validation logic in `extractGraphFromBody`.
+ */
+function parseBatchItem(raw) {
+    return parseGraphExtraction(raw);
+}
+/**
+ * Extract entities and relations from multiple asset bodies in a single LLM
+ * call (batched graph extraction).
+ *
+ * Sends all `bodies` as a single prompt with `=== ASSET N ===` separators
+ * and expects a JSON array where element `i` corresponds to `bodies[i]`.
+ *
+ * **Partial-failure handling**: if the model returns fewer elements than
+ * `bodies.length`, missing indices are filled by falling back to individual
+ * `extractGraphFromBody` calls — ensuring every input always has a result.
+ *
+ * Returns an array of the same length as `bodies` (never shorter).
+ * Individual elements default to `{entities:[], relations:[]}` on failure.
+ *
+ * Routes through `tryLlmFeature("graph_extraction", ...)` so the feature gate
+ * and onFallback hook are honoured uniformly.
+ *
+ * @param llmConfig - LLM connection configuration.
+ * @param bodies    - Asset body strings to process in one batch.
+ * @param signal    - Optional AbortSignal for cancellation.
+ * @param akmConfig - Full AKM config (for feature-gate checks).
+ * @param onFallback - Optional fallback event sink.
+ */
+export async function extractGraphFromBodies(llmConfig, bodies, signal, akmConfig, onFallback) {
+    const empty = () => ({ entities: [], relations: [] });
+    // Degenerate case: no bodies → empty array (not an error).
+    if (bodies.length === 0)
+        return [];
+    // Single body: delegate to the single-asset path for identical behaviour.
+    if (bodies.length === 1) {
+        const result = await extractGraphFromBody(llmConfig, bodies[0] ?? "", signal, akmConfig, onFallback);
+        return [result];
+    }
+    // Filter out bodies that are empty so we don't waste tokens, but keep
+    // index correspondence by tracking which indices were non-empty.
+    const results = bodies.map(empty);
+    const nonEmptyIndices = [];
+    const nonEmptyBodies = [];
+    for (let i = 0; i < bodies.length; i++) {
+        const trimmed = (bodies[i] ?? "").trim();
+        if (trimmed) {
+            nonEmptyIndices.push(i);
+            nonEmptyBodies.push(trimmed);
+        }
+    }
+    if (nonEmptyBodies.length === 0)
+        return results;
+    const systemPrompt = buildBatchSystemPrompt();
+    const userPrompt = buildBatchUserPrompt(nonEmptyBodies);
+    const batchResult = await tryLlmFeature("graph_extraction", akmConfig, async () => {
+        try {
+            const raw = await chatCompletion(llmConfig, [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ], {
+                temperature: 0.1,
+                timeoutMs: llmConfig.timeoutMs,
+                signal,
+            });
+            if (!raw)
+                return null;
+            const parsed = parseEmbeddedJsonResponse(raw);
+            if (!Array.isArray(parsed)) {
+                warn("graph extraction (batch): LLM response was not a JSON array; will fall back per-asset.");
+                return null;
+            }
+            return parsed;
+        }
+        catch (err) {
+            warn(`graph extraction (batch) failed: ${toErrorMessage(err)}`);
+            return null;
+        }
+    }, null, {
+        timeoutMs: llmConfig.timeoutMs,
+        onFallback,
+    });
+    // Map successful batch results back to their original indices.
+    if (batchResult !== null) {
+        for (let j = 0; j < nonEmptyBodies.length; j++) {
+            const originalIndex = nonEmptyIndices[j];
+            if (originalIndex === undefined)
+                continue;
+            if (j < batchResult.length) {
+                results[originalIndex] = parseBatchItem(batchResult[j]);
+            }
+            // j >= batchResult.length → partial failure; handled below.
+        }
+    }
+    // Partial-failure fallback: any non-empty body whose result is still the
+    // empty placeholder (either because batchResult was null or the array was
+    // shorter than expected) gets an individual retry.
+    const fallbackIndices = nonEmptyIndices.filter((_origIdx, j) => {
+        // Result is still empty → needs a fallback call.
+        if (batchResult === null)
+            return true;
+        // batchResult was shorter than the number of non-empty bodies.
+        return j >= batchResult.length;
+    });
+    if (fallbackIndices.length > 0) {
+        if (batchResult !== null) {
+            // Only warn on partial failure (not when the whole batch failed, which
+            // already emitted a warn above).
+            warn(`graph extraction (batch): response had ${batchResult.length} items for ${nonEmptyBodies.length} assets; ` +
+                `falling back to individual calls for ${fallbackIndices.length} missing asset(s).`);
+        }
+        await Promise.all(fallbackIndices.map(async (origIdx) => {
+            const body = bodies[origIdx] ?? "";
+            results[origIdx] = await extractGraphFromBody(llmConfig, body, signal, akmConfig, onFallback);
+        }));
+    }
+    return results;
+}
 /**
  * Extract entities and relations from a single asset body via the configured LLM.
  *
  * Returns `{entities: [], relations: []}` on any failure (timeout, invalid
  * JSON, empty response). Errors are logged via `warn()` but never thrown — a
  * failed extraction for one asset must not abort the rest of the index pass.
+ *
+ * Routes through `tryLlmFeature("graph_extraction", ...)` so the feature gate
+ * and onFallback hook are honoured uniformly (Fix C5).
  */
-export async function extractGraphFromBody(llmConfig, body, signal) {
+export async function extractGraphFromBody(llmConfig, body, signal, akmConfig, onFallback) {
     const empty = { entities: [], relations: [] };
     const trimmedBody = body.trim();
     if (!trimmedBody)
         return empty;
     const userPrompt = `${USER_PROMPT_PREFIX}${trimmedBody.slice(0, MAX_BODY_CHARS)}`;
-    let timeoutHandle;
-    try {
-        const raw = await Promise.race([
-            chatCompletion(llmConfig, [
+    return tryLlmFeature("graph_extraction", akmConfig, async () => {
+        try {
+            const raw = await chatCompletion(llmConfig, [
                 { role: "system", content: SYSTEM_PROMPT },
                 { role: "user", content: userPrompt },
-            ], { maxTokens: 1024, temperature: 0.1, signal }),
-            new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => reject(new Error("graph extraction timed out")), LLM_TIMEOUT_MS);
-            }),
-        ]);
-        if (!raw)
-            return empty;
-        const parsed = parseEmbeddedJsonResponse(raw);
-        if (!parsed) {
-            warn("graph extraction: invalid JSON response from LLM; skipping asset.");
+            ], { temperature: 0.1, timeoutMs: llmConfig.timeoutMs, signal });
+            if (!raw)
+                return empty;
+            const parsed = parseEmbeddedJsonResponse(raw);
+            if (!parsed) {
+                warn("graph extraction: invalid JSON response from LLM; skipping asset.");
+                return empty;
+            }
+            return parseGraphExtraction(parsed);
+        }
+        catch (err) {
+            warn(`graph extraction failed: ${toErrorMessage(err)}`);
             return empty;
         }
-        const entities = Array.isArray(parsed.entities)
-            ? parsed.entities
-                .filter((e) => typeof e === "string")
-                .map((e) => e.trim())
-                .filter((e) => e.length > 0)
-                .slice(0, MAX_ENTITIES_PER_ASSET)
-            : [];
-        const entitySet = new Set(entities);
-        const relations = Array.isArray(parsed.relations)
-            ? parsed.relations
-                .filter((r) => typeof r === "object" && r !== null && !Array.isArray(r))
-                .map((r) => ({
-                from: typeof r.from === "string" ? r.from.trim() : "",
-                to: typeof r.to === "string" ? r.to.trim() : "",
-                type: typeof r.type === "string" && r.type.trim() ? r.type.trim() : undefined,
-            }))
-                // Both endpoints must be non-empty AND mentioned in entities[];
-                // dangling relations are noise and inflate the boost component.
-                .filter((r) => r.from && r.to && entitySet.has(r.from) && entitySet.has(r.to))
-                .slice(0, MAX_RELATIONS_PER_ASSET)
-            : [];
-        return { entities, relations };
-    }
-    catch (err) {
-        warn(`graph extraction failed: ${toErrorMessage(err)}`);
-        return empty;
-    }
-    finally {
-        if (timeoutHandle !== undefined)
-            clearTimeout(timeoutHandle);
-    }
+    }, empty, {
+        timeoutMs: llmConfig.timeoutMs,
+        onFallback,
+    });
 }
+// deduplicateGraph moved to src/indexer/graph-dedup.ts (pure utility, no LLM calls).
+export { deduplicateGraph } from "../indexer/graph-dedup";