@retinue/agentkit 0.1.0 → 0.3.0

package/dist/knowledge/graph-retrieval.js

@@ -0,0 +1,303 @@
+/**
+ * `graph-local` — entity-centric retrieval. REQ-064 (#270), task #273.
+ *
+ * The mode that answers *"which teams depend on the retry budget?"* — a question whose answer exists in no
+ * single chunk. Semantic search finds chunks that look like the question; this finds the chunks that are
+ * *connected to what the question is about*.
+ *
+ * Four steps, and the interesting decisions are in the first and the last:
+ *
+ * 1. **Resolve** the entities the question names.
+ * 2. **Traverse** their neighbourhood, bounded.
+ * 3. **Gather** the chunks those entities and edges came from.
+ * 4. **Filter and rank**, returning ordinary `RetrievalHit`s.
+ *
+ * ## Why the query is swept for n-grams rather than read by a model
+ *
+ * The obvious way to find the entities in a question is to ask a model. It costs a call per query, it is not
+ * reproducible across model versions, and #275 has to measure this against a fixed baseline.
+ *
+ * So instead every 1-to-4 word window of the question is normalised and looked up, and **the graph itself is
+ * the filter** — a window that is not an entity simply matches nothing. That is deterministic, free, and uses
+ * exactly the normalisation the index used, which is what makes AC-3 hold by construction rather than by two
+ * functions agreeing.
+ *
+ * It will miss an entity the question refers to obliquely ("the budget thing"). That is a real limit, it is
+ * measurable, and #275 is where it gets measured.
+ *
+ * ## Why there is no fallback to semantic search
+ *
+ * When nothing resolves, this returns an honest empty result. Falling back would mean a caller attributing
+ * semantic results to `graph-local` — which is precisely why `not-configured` exists as its own reason rather
+ * than as `no-match`, and the same reasoning applies one level down.
+ */
+import { normaliseName } from "./graph.js";
+/**
+ * How far a traversal goes by default.
+ *
+ * One hop is often too few — "which teams depend on the retry budget" is one hop, but "what does the retry
+ * budget affect downstream" is two. Three is a large fraction of a connected graph, and the cost is not the
+ * traversal but the chunks it drags in. Two is the useful middle, and it is a parameter because the right
+ * answer is corpus-shaped.
+ */
+export const DEFAULT_GRAPH_DEPTH = 2;
+/** Edges considered per hop. A hub entity can have hundreds; taking all of them buries the specific ones. */
+export const DEFAULT_NEIGHBOUR_LIMIT = 50;
+/** The longest phrase treated as a possible entity name. Four words covers "the retry budget policy". */
+export const MAX_ENTITY_NGRAM = 4;
+/**
+ * Words never worth looking up on their own.
+ *
+ * Not a linguistic stopword list — a *lookup* filter. Its only job is to stop the sweep asking the store about
+ * "the" and "which" fifty times per query. A word here can still appear *inside* a longer n-gram, so "the
+ * retry budget" resolves even though "the" does not.
+ */
+const SKIP_ALONE = new Set([
+    "the", "a", "an", "of", "in", "on", "at", "to", "for", "by", "with", "and", "or", "is", "are", "was", "were",
+    "be", "been", "do", "does", "did", "which", "what", "who", "whom", "whose", "when", "where", "why", "how",
+    "that", "this", "these", "those", "it", "its", "we", "our", "you", "your", "they", "their", "from", "as",
+]);
+/**
+ * Every phrase in the query that could name an entity, normalised and deduplicated.
+ *
+ * Longest first, which matters for ranking rather than correctness: "retry budget policy" is a more specific
+ * match than "retry budget", and a caller that stops early should see the specific one.
+ *
+ * Exported for its own test — this is the function that decides whether a real question finds anything, and
+ * its failure mode is silent (an empty result that looks like an empty corpus).
+ */
+export const entityCandidates = (query) => {
+    const words = normaliseName(query).split(" ").filter((word) => word !== "");
+    const seen = new Set();
+    const out = [];
+    for (let size = Math.min(MAX_ENTITY_NGRAM, words.length); size >= 1; size -= 1) {
+        for (let start = 0; start + size <= words.length; start += 1) {
+            const phrase = words.slice(start, start + size).join(" ");
+            if (size === 1 && SKIP_ALONE.has(phrase))
+                continue;
+            if (seen.has(phrase))
+                continue;
+            seen.add(phrase);
+            out.push(phrase);
+        }
+    }
+    return out;
+};
+/** Gathered wide, then ranked. Below this a re-rank has too little to choose between. */
+export const DEFAULT_POOL_FACTOR = 8;
+export const MIN_POOL = 40;
+/**
+ * How much an entity's breadth discounts it — the hub problem, in one line.
+ *
+ * `docs/01-architecture.md` and `concepts/architecture.md` appeared in miss after miss. Generic entities
+ * ("run", "tool", "platform") are extracted from nearly every chunk, link to nearly everything, and drag the
+ * architecture overview into every traversal. An entity that touches half the corpus tells you almost nothing
+ * about *which* chunk you want, and counting it equally with a specific one is the mechanism by which the
+ * overview outranks the page that answers the question.
+ *
+ * A logarithmic discount rather than an IDF proper, because IDF needs the corpus size and this needs only what
+ * is already in hand. An entity in 2 chunks keeps most of its weight; one in 200 keeps about a seventh of it.
+ */
+export const hubDiscount = (provenanceSize) => 1 / Math.log2(2 + Math.max(0, provenanceSize));
+/** Cosine similarity. Vectors from one provider share a dimension, and a mismatch is a bug worth surfacing. */
+export const cosine = (a, b) => {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let index = 0; index < a.length; index += 1) {
+        const x = a[index];
+        const y = b[index];
+        dot += x * y;
+        normA += x * x;
+        normB += y * y;
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dot / magnitude;
+};
+export const createGraphLocalSearch = (deps) => {
+    const maxDepth = Math.max(1, deps.depth ?? DEFAULT_GRAPH_DEPTH);
+    const neighbourLimit = Math.max(1, deps.neighbourLimit ?? DEFAULT_NEIGHBOUR_LIMIT);
+    return {
+        async search(context, input) {
+            const rankedBy = deps.embeddings === undefined ? "connectivity" : "relevance";
+            const empty = {
+                hits: [],
+                matchedEntities: [],
+                relationships: [],
+                truncated: false,
+                rankedBy,
+            };
+            if (input.authSubjects.length === 0)
+                return empty;
+            const candidates = entityCandidates(input.query);
+            if (candidates.length === 0)
+                return empty;
+            const matched = await deps.graph.resolveEntities({
+                tenantId: context.tenantId,
+                normalisedNames: candidates,
+            });
+            // No fallback. See the header: semantic results wearing this mode's label is the failure to avoid.
+            if (matched.length === 0)
+                return empty;
+            /**
+             * Breadth-first, bounded on both axes.
+             *
+             * `truncated` is set when a hop returned exactly its limit, which is the honest signal: the store
+             * returned as much as it was allowed to, so there may be more. Inferring truncation from a short page
+             * would be wrong in the other direction.
+             */
+            const seedIds = matched.map((entity) => entity.id);
+            const reached = new Set(seedIds);
+            const edges = new Map();
+            let frontier = seedIds;
+            let truncated = false;
+            for (let hop = 0; hop < maxDepth && frontier.length > 0; hop += 1) {
+                const found = await deps.graph.neighbours({
+                    tenantId: context.tenantId,
+                    entityIds: frontier,
+                    limit: neighbourLimit,
+                });
+                if (found.length >= neighbourLimit)
+                    truncated = true;
+                const next = [];
+                for (const edge of found) {
+                    edges.set(edge.id, edge);
+                    for (const id of [edge.fromId, edge.toId]) {
+                        if (reached.has(id))
+                            continue;
+                        reached.add(id);
+                        next.push(id);
+                    }
+                }
+                // Sorted so a traversal is reproducible: `neighbours` is ordered, but the set of *new* ids depends on
+                // what was already reached, and an unsorted frontier makes the next hop's `limit` cut differently.
+                frontier = next.sort();
+            }
+            /**
+             * Chunks, and **which entities led to each** — the scoring signal.
+             *
+             * A chunk named by three of the question's entities is more relevant than one named by a single
+             * neighbour two hops out, and that is knowable without embeddings. Seeds count for more than entities
+             * discovered by traversal, because the question actually mentioned them.
+             */
+            const SEED_WEIGHT = 3;
+            const chunkScores = new Map();
+            const credit = (chunkId, entityName, weight) => {
+                const existing = chunkScores.get(chunkId);
+                if (existing === undefined)
+                    chunkScores.set(chunkId, { score: weight, via: new Set([entityName]) });
+                else {
+                    existing.score += weight;
+                    existing.via.add(entityName);
+                }
+            };
+            const seedIdSet = new Set(seedIds);
+            const reachedEntities = await deps.graph.getEntities({ tenantId: context.tenantId, ids: [...reached].sort() });
+            for (const entity of reachedEntities) {
+                /**
+                 * Discounted by how many chunks the entity appears in — #277, AC-2.
+                 *
+                 * Without it, an entity extracted from nearly every chunk contributes to nearly every chunk's score,
+                 * and the documents that mention everything — the architecture overviews — win by breadth. The
+                 * discount is applied to seeds too: a question that names "run" has named a hub, and the hub is no
+                 * more discriminating for having been asked about.
+                 */
+                const weight = (seedIdSet.has(entity.id) ? SEED_WEIGHT : 1) * hubDiscount(entity.provenance.length);
+                for (const chunkId of entity.provenance)
+                    credit(chunkId, entity.name, weight);
+            }
+            for (const edge of edges.values()) {
+                // An edge's own provenance is where the *relationship* was stated, which is usually the chunk that
+                // answers a "how are these connected" question — so it is credited too.
+                for (const chunkId of edge.provenance)
+                    credit(chunkId, `${edge.fromId} → ${edge.toId}`, 1);
+            }
+            const poolSize = Math.max(input.limit, MIN_POOL, input.limit * Math.max(1, deps.poolFactor ?? DEFAULT_POOL_FACTOR));
+            const wantedTypes = input.sourceTypes === undefined ? null : new Set(input.sourceTypes);
+            const allowed = new Set(input.authSubjects);
+            const gathered = [];
+            // Sorted before fetching, so the chunks fetched under a cap are the same ones every run.
+            const ranked = [...chunkScores.entries()].sort((a, b) => b[1].score - a[1].score || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+            for (const [chunkId, scored] of ranked) {
+                const chunk = await deps.knowledge.get({ tenantId: context.tenantId, id: chunkId });
+                if (chunk === null)
+                    continue;
+                /**
+                 * **AC-8, and the whole reason this loop does not trust the graph.**
+                 *
+                 * `KnowledgeStore.get` returns a chunk by id with no permission filter — it is a primary-key read, and
+                 * the vector index is where filtering normally lives. A graph traversal can arrive at a chunk from an
+                 * entity mentioned by a document the principal *can* read, so without this check an edge becomes a way
+                 * to reach text they cannot. That is the most plausible way a graph leaks, and it is one line.
+                 */
+                if (!allowed.has(chunk.authSubject))
+                    continue;
+                if (wantedTypes !== null && !wantedTypes.has(chunk.sourceType))
+                    continue;
+                gathered.push({ chunk, score: scored.score, via: [...scored.via].sort() });
+                /**
+                 * A **pool**, not the answer — #277.
+                 *
+                 * This used to stop at `input.limit`, which meant the top-k by connectivity were the only chunks that
+                 * could ever be returned and no re-ranking could reach past them. Gathering wider costs a few more
+                 * primary-key reads and is what makes ranking able to change anything.
+                 */
+                if (gathered.length >= poolSize) {
+                    if (ranked.length > gathered.length)
+                        truncated = true;
+                    break;
+                }
+            }
+            if (gathered.length === 0)
+                return { ...empty, matchedEntities: matched.map((entity) => entity.name) };
+            /**
+             * **The graph selected; embeddings rank** — #277, AC-1.
+             *
+             * The candidate set is exactly what the traversal found: this changes the order, never the membership.
+             * That is the whole claim of the mode — these chunks are connected to what you asked about — and
+             * replacing the candidates with a semantic search would be a different mode wearing this one's label.
+             *
+             * **The vector-privacy constraint is respected rather than worked around.** `KnowledgeStore` read paths
+             * deliberately never return vectors, so the stored embeddings are not available here and the port is not
+             * widened to leak them. The chunk *text* is already in hand — it was fetched to be returned — so the
+             * candidates are embedded from their text, in one batched call alongside the query.
+             *
+             * The cost is one extra embedding call per query, and it is real: see `docs/29`. A mode whose selling
+             * point was two milliseconds does not get to spend that silently.
+             */
+            let ordered = gathered;
+            if (deps.embeddings !== undefined) {
+                const vectors = await deps.embeddings.embed([input.query, ...gathered.map((entry) => entry.chunk.content)]);
+                const queryVector = vectors[0];
+                if (queryVector !== undefined && vectors.length === gathered.length + 1) {
+                    ordered = gathered
+                        .map((entry, index) => ({ ...entry, score: cosine(queryVector, vectors[index + 1]) }))
+                        // Ties broken by chunk id, so the order is reproducible across runs like every other mode's.
+                        .sort((a, b) => b.score - a.score || (a.chunk.id < b.chunk.id ? -1 : a.chunk.id > b.chunk.id ? 1 : 0));
+                }
+                // A provider that returned the wrong count is a bug, and the connectivity order is a worse answer
+                // rather than a wrong one — so the traversal still returns something rather than throwing.
+            }
+            const hits = ordered.slice(0, input.limit);
+            if (ordered.length > hits.length)
+                truncated = true;
+            // Normalised against the best, so the score means the same thing it does in every other mode.
+            const best = hits[0]?.score ?? 1;
+            return {
+                hits: hits.map((entry) => ({
+                    chunk: entry.chunk,
+                    score: best === 0 ? 0 : entry.score / best,
+                    viaEntities: entry.via,
+                })),
+                matchedEntities: matched.map((entity) => entity.name),
+                // Only the edges whose endpoints were both reached, sorted so the output is stable.
+                relationships: [...edges.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)),
+                truncated,
+                rankedBy,
+            };
+        },
+    };
+};
+//# sourceMappingURL=graph-retrieval.js.map

package/dist/knowledge/graph.d.ts

@@ -0,0 +1,223 @@
+/**
+ * The knowledge graph — REQ-064 (#270), task #271.
+ *
+ * Retrieval finds the chunks that *look like* the question. That cannot answer "which teams depend on the retry
+ * budget?", because no chunk says so: the fact is spread across a dozen documents, each naming one team and one
+ * dependency. This module builds the structure that does — entities, the relationships between them, and where
+ * each came from.
+ *
+ * Nothing here retrieves anything. #273 and #274 do that; this produces the graph and, just as importantly,
+ * proves it costs nothing when nobody asked for it.
+ *
+ * ## Three properties everything else rests on
+ *
+ * **Off costs nothing.** The extractor is optional in the dependencies and gated twice more at run time. A
+ * deployment that never enables GraphRAG supplies no extractor, makes no model calls, and writes no graph rows
+ * — measured by a test that counts calls rather than by reading this paragraph.
+ *
+ * **Determinism.** The same corpus produces byte-identical graphs twice. This is not tidiness: #275 measures
+ * GraphRAG against a fixed baseline, and a graph that shifts between runs cannot be measured, cannot be
+ * debugged, and cannot have its incremental rebuild (#272) verified. Every ordering here is explicit, and
+ * entity resolution is rule-based rather than similarity-based for exactly this reason — embedding similarity
+ * is not stable across model versions.
+ *
+ * **Provenance.** Every entity and edge records its chunks. The retriever will present graph-derived material
+ * as citable, so an untraceable claim is one the model states as though a document said it.
+ *
+ * ## What extraction is allowed to do to us
+ *
+ * Extraction is a model call, so it can return prose, malformed JSON, entities with no names, or an edge
+ * between two things it never mentioned. **None of that may corrupt the graph or fail the index.** A chunk
+ * whose extraction is unusable simply contributes nothing — it stays embedded and findable by every existing
+ * mode, and the graph is the only thing missing. `sanitiseExtraction` is where that judgement lives, and it is
+ * deliberately strict: an edge naming an entity that was not extracted is dropped rather than repaired,
+ * because repairing it would invent a provenance nobody asserted.
+ */
+import type { TenantId } from "../core/ids.js";
+import type { GraphContribution, GraphStore, KnowledgeSourceType } from "../persistence/index.js";
+/**
+ * What an extractor returns for one chunk, before validation.
+ *
+ * Loose on purpose — it is the output of a language model, and typing it strictly here would only mean casting
+ * somewhere less visible. `sanitiseExtraction` is the boundary where it becomes trustworthy.
+ */
+export type RawExtraction = {
+    readonly entities?: readonly {
+        readonly name?: unknown;
+        readonly type?: unknown;
+        readonly description?: unknown;
+    }[];
+    readonly relationships?: readonly {
+        readonly from?: unknown;
+        readonly to?: unknown;
+        readonly type?: unknown;
+        readonly description?: unknown;
+    }[];
+};
+export type ExtractionChunk = {
+    readonly id: string;
+    readonly content: string;
+};
+/**
+ * Turns a chunk into entities and relationships.
+ *
+ * A port separate from `EmbeddingProvider`, not a widening of it. Embedding is cheap, deterministic and
+ * batchable; extraction is none of those. Keeping them apart is what lets a deployment with GraphRAG off supply
+ * an embedder and nothing else — if this were one port, every deployment would have to configure a language
+ * model to index a document.
+ *
+ * `usage` is optional and reported when the provider gives it, because AC-9 needs the bill to be visible before
+ * it arrives rather than reconstructed from an invoice.
+ */
+export interface EntityExtractor {
+    readonly id: string;
+    extract(chunk: ExtractionChunk): Promise<{
+        readonly extraction: RawExtraction;
+        readonly usage?: {
+            readonly inputTokens?: number;
+            readonly outputTokens?: number;
+        };
+    }>;
+}
+/**
+ * A name reduced to what makes two spellings the same thing.
+ *
+ * Case, whitespace, separators and a leading article. That gets "the retry budget", "Retry Budget" and
+ * "retry-budget" to one entity, which is the merge AC-4 names.
+ *
+ * **What it deliberately does not do** is anything cleverer. Stemming would merge "billing" with "bill";
+ * embedding similarity would merge whatever the model of the week thinks is close and would stop being
+ * reproducible the moment that model changed. Both would make the graph unmeasurable, and the second would
+ * make it undebuggable too.
+ *
+ * Parenthetical qualifiers survive as words, so "Ana (engineering)" and "Ana (sales)" stay distinct — which
+ * AC-4 asks for, and which a punctuation-stripping rule gets right only by accident. It is worth being explicit
+ * that this is *why* punctuation becomes a space rather than nothing.
+ */
+export declare const normaliseName: (raw: string) => string;
+/** An entity type, normalised the same way but without the article rule — a type is one word in practice. */
+export declare const normaliseType: (raw: string) => string;
+/**
+ * The identity of an entity: its type and its normalised name.
+ *
+ * Readable rather than hashed, deliberately. `concept:retry budget` in a log, an error message or a database
+ * row tells whoever is reading it what went wrong; `sha256:9f2a…` tells them to go and write a script. The id
+ * is not a secret and its length is not a problem at this scale.
+ *
+ * Type participates because a person and a project can share a name and are not the same thing.
+ */
+export declare const entityId: (type: string, name: string) => string;
+/** The identity of an edge. Direction is part of it: "A depends on B" is not "B depends on A". */
+export declare const relationshipId: (fromId: string, type: string, toId: string) => string;
+/**
+ * How long a description may be before it is a chunk rather than a description.
+ *
+ * A model asked for a short description sometimes returns the paragraph. Truncating rather than refusing keeps
+ * the entity — the name and the edges are the valuable part — and stops one verbose extraction from dominating
+ * the storage of a whole corpus.
+ */
+export declare const MAX_DESCRIPTION_CHARS = 480;
+/**
+ * One chunk's raw extraction, turned into rows that can be trusted — or into nothing.
+ *
+ * Total: any input produces a valid contribution, possibly empty. That is what makes AC-7 hold everywhere at
+ * once rather than at each call site.
+ *
+ * The strict part is edges. An extractor routinely names an endpoint it did not extract — a pronoun it
+ * resolved, a thing it inferred — and the tempting fix is to create the missing entity. That invents an entity
+ * with a provenance nobody asserted, which is the exact failure provenance exists to prevent. So the edge is
+ * dropped, and the chunk keeps whatever else it gave us.
+ */
+export declare const sanitiseExtraction: (chunkId: string, raw: RawExtraction) => GraphContribution;
+/**
+ * Many chunks' contributions, merged into one source's contribution.
+ *
+ * Where surface forms accumulate and edge weights are counted. The canonical `name` is the one that sorts
+ * first among everything merged — an arbitrary rule, chosen because it is *stable*: "first seen" would depend
+ * on chunk order, and chunk order is a thing that can change without the document changing.
+ */
+export declare const mergeContributions: (parts: readonly GraphContribution[]) => GraphContribution;
+/** What indexing a source into the graph cost and produced — AC-9. */
+export type GraphIndexResult = {
+    /** `false` when GraphRAG is off for the tenant or the source is not flagged. Nothing was called. */
+    readonly ran: boolean;
+    readonly entities: number;
+    readonly relationships: number;
+    readonly pruned: number;
+    /** Model calls made. The number an operator needs before enabling this on a large corpus. */
+    readonly extractionCalls: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    /** Chunks whose extraction was unusable. Nonzero is a signal about the extractor, not a failure. */
+    readonly unusableChunks: number;
+    readonly elapsedMs: number;
+};
+export type GraphIndexerDeps = {
+    readonly store: GraphStore;
+    readonly extractor: EntityExtractor;
+    readonly now?: () => number;
+    readonly log?: (message: string, detail?: Readonly<Record<string, unknown>>) => void;
+};
+/**
+ * Extraction runs one chunk at a time by default.
+ *
+ * Sequential rather than parallel because the cost is the point: a corpus of 603 chunks is 603 model calls, and
+ * firing them concurrently is how a re-index becomes a rate-limit incident. A deployment that wants throughput
+ * raises this deliberately, having read the number.
+ */
+export declare const DEFAULT_EXTRACTION_CONCURRENCY = 1;
+export declare const createGraphIndexer: (deps: GraphIndexerDeps) => {
+    extractorId: string;
+    /**
+     * Whether this source would be graph-indexed — both switches, in the cheap order.
+     *
+     * The tenant switch first, so a deployment with GraphRAG off does one settings read and stops, rather than
+     * one read per source. AC-2's "flag is inert while the tenant switch is off" is this ordering: the source
+     * flag is never even consulted, and it stays stored for the day the tenant switch flips.
+     */
+    shouldIndex(context: {
+        readonly tenantId: TenantId;
+    }, source: {
+        readonly sourceType: KnowledgeSourceType;
+        readonly sourceId: string;
+    }): Promise<boolean>;
+    /**
+     * Extract one source's chunks into the graph, replacing whatever that source contributed before.
+     *
+     * The caller has already decided this should run — `indexSource` calls `shouldIndex` first — so this does
+     * not re-check. Keeping the decision in one place is what makes "off costs nothing" a property of one
+     * function rather than a convention two functions share.
+     */
+    indexSource(context: {
+        readonly tenantId: TenantId;
+    }, input: {
+        readonly sourceType: KnowledgeSourceType;
+        readonly sourceId: string;
+        readonly chunks: readonly ExtractionChunk[];
+        readonly concurrency?: number;
+    }): Promise<GraphIndexResult>;
+};
+export type GraphIndexer = ReturnType<typeof createGraphIndexer>;
+/** What `indexSource` reports when the graph was not touched. Every counter zero, and `ran` says why. */
+export declare const GRAPH_NOT_RUN: GraphIndexResult;
+/**
+ * The default `EntityExtractor`: one model call per chunk — AC-2.
+ *
+ * Thin on purpose. The provider call lives in `models/extraction.ts` behind boundary rule R3, so this is the
+ * adapter between that function and the port — which means a deployment can replace the extractor entirely
+ * (a smaller model, a local one, a rules-based one for a known corpus) without touching the pipeline.
+ *
+ * `model` is a factory rather than a value because a `LanguageModel` is resolved from a policy per tenant, and
+ * a single resolved model captured at construction would be the same one for every tenant in the deployment.
+ */
+export declare const createModelEntityExtractor: (deps: {
+    readonly id?: string;
+    readonly extract: (text: string) => Promise<{
+        readonly extraction: RawExtraction;
+        readonly usage: {
+            readonly inputTokens: number;
+            readonly outputTokens: number;
+        };
+    }>;
+}) => EntityExtractor;
+//# sourceMappingURL=graph.d.ts.map