@devilsdev/rag-core 3.3.0 → 3.5.0

package/dist/types/grounding/provider-citations.d.ts

@@ -0,0 +1,244 @@
+/**
+ * One citation of a claim, normalised.
+ */
+export type ProviderCitation = {
+    /**
+     * - Your document id, the document title or index, a search result's source, a URL or an OpenAI file id
+     */
+    sourceId: string;
+    title: string | null;
+    /**
+     * - Where the passage is; `type` is the provider's citation type
+     */
+    location: any;
+    /**
+     * - The cited text; empty when the response doesn't carry it
+     */
+    passages: string[];
+};
+/**
+ * A claim of the answer and the citations attached to it.
+ */
+export type CitedClaim = {
+    text: string;
+    /**
+     * - Offset in `answer`
+     */
+    start: number;
+    end: number;
+    citations: ProviderCitation[];
+};
+/**
+ * What fromAnthropicCitations() and fromOpenAIFileCitations() return.
+ */
+export type ProviderCitations = {
+    provider: "anthropic" | "openai";
+    /**
+     * - The answer text
+     */
+    answer: string;
+    claims: CitedClaim[];
+    /**
+     * - Citations of other kinds, by type
+     */
+    skipped: {
+        [x: string]: number;
+    };
+    /**
+     * - OpenAI: whether the response had file search results
+     */
+    results?: boolean;
+    /**
+     * - Claude: the message's stop_reason ("refusal" when Claude declined)
+     */
+    stopReason?: string | null;
+};
+/**
+ * A claim's verdict from verifyCitations().
+ */
+export type VerifiedClaim = {
+    text: string;
+    start: number;
+    end: number;
+    verdict: "supported" | "unsupported" | "unverifiable";
+    lexicalReason: "supported" | "low_overlap" | "number_mismatch" | "polarity_mismatch" | "unverifiable";
+    /**
+     * - Why, in words
+     */
+    reason: string;
+    decidedBy: "lexical" | "judge";
+    /**
+     * - Support of the claim by all its cited passages together, 0..1
+     */
+    score: number | null;
+    /**
+     *   - Each citation's own support; null when it had no cited text
+     */
+    citations: Array<{
+        sourceId: string;
+        title: string | null;
+        location: any;
+        score: number | null;
+        supports: boolean | null;
+    }>;
+};
+/**
+ * What verifyCitations() resolves to.
+ */
+export type CitationVerification = {
+    /**
+     * - Not a refusal, at least one claim, every claim supported and every citation checkable; uncited sentences don't count against it (see `uncited`)
+     */
+    verified: boolean;
+    provider: "anthropic" | "openai";
+    claims: VerifiedClaim[];
+    /**
+     * - Sentences with content that no citation covers
+     */
+    uncited: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }>;
+    summary: {
+        claims: number;
+        supported: number;
+        unsupported: number;
+        unverifiable: number;
+        citations: number;
+        unverifiableCitations: number;
+        uncitedSentences: number;
+    };
+    skipped: {
+        [x: string]: number;
+    };
+    /**
+     * - Claude declined to answer (stop_reason "refusal"); never verified
+     */
+    refused: boolean;
+    /**
+     * - Only with the `judge` option
+     */
+    judge?: {
+        calls: number;
+        usage?: any;
+        error?: string;
+    };
+};
+/**
+ * Normalise the citations of a Claude Messages API response.
+ *
+ * Each text block that carries citations is a claim. Pass a stream's
+ * final message (`stream.finalMessage()`).
+ *
+ * @param {object} message - The Message, as the SDK returns it or as JSON
+ * @param {object} [options]
+ * @param {Array<object>} [options.documents] - The request's document blocks
+ *   in order (`document_index` counts them), as your own `{ id }` records,
+ *   so citations name your ids; otherwise a citation is named by the
+ *   document's title, or its index
+ * @returns {ProviderCitations}
+ */
+export function fromAnthropicCitations(message: object, { documents }?: {
+    documents?: Array<object>;
+}): ProviderCitations;
+/**
+ * Normalise the file citations of an OpenAI Responses API response.
+ *
+ * A `file_citation` carries only `file_id`, `filename` and an `index` into
+ * the text, not the passage: the passages come from the file search
+ * results, which the request must ask for with
+ * `include: ["file_search_call.results"]`. Without them every citation is
+ * unverifiable. OpenAI gives a position, not a span, and puts it after the
+ * text it cites, a sentence or a paragraph (several citations can share
+ * it): each sentence from the previous citation's position up to this one
+ * is a claim carrying its citations. The boundary is inferred.
+ * Web and container citations are counted in `skipped`. Pass a stream's
+ * completed response.
+ *
+ * @param {object} response - The Response, as the SDK returns it or as JSON
+ * @returns {ProviderCitations}
+ */
+export function fromOpenAIFileCitations(response: object): ProviderCitations;
+/**
+ * Check every claim against the passages it cites: together, so a claim
+ * that takes one fact from each of two passages is supported. Each
+ * citation's own score is reported too.
+ *
+ * @param {ProviderCitations} input - From fromAnthropicCitations() or fromOpenAIFileCitations()
+ * @param {object} [options]
+ * @param {{generate: Function}} [options.judge] - Opt-in LLM judge for claims
+ *   that failed for lack of word overlap (paraphrases), as in checkAnswer();
+ *   it may only name a passage the claim cites, and never overturns a
+ *   number or negation mismatch. One call at most. Errors from
+ *   `judge.generate` are not caught.
+ * @returns {Promise<CitationVerification>}
+ */
+export function verifyCitations(input: ProviderCitations, { judge }?: {
+    judge?: {
+        generate: Function;
+    };
+}): Promise<CitationVerification>;
+/**
+ * One citation of a claim, normalised.
+ *
+ * @typedef {Object} ProviderCitation
+ * @property {string} sourceId - Your document id, the document title or index, a search result's source, a URL or an OpenAI file id
+ * @property {string|null} title
+ * @property {Object} location - Where the passage is; `type` is the provider's citation type
+ * @property {string[]} passages - The cited text; empty when the response doesn't carry it
+ */
+/**
+ * A claim of the answer and the citations attached to it.
+ *
+ * @typedef {Object} CitedClaim
+ * @property {string} text
+ * @property {number} start - Offset in `answer`
+ * @property {number} end
+ * @property {ProviderCitation[]} citations
+ */
+/**
+ * What fromAnthropicCitations() and fromOpenAIFileCitations() return.
+ *
+ * @typedef {Object} ProviderCitations
+ * @property {'anthropic'|'openai'} provider
+ * @property {string} answer - The answer text
+ * @property {CitedClaim[]} claims
+ * @property {Object<string, number>} skipped - Citations of other kinds, by type
+ * @property {boolean} [results] - OpenAI: whether the response had file search results
+ * @property {string|null} [stopReason] - Claude: the message's stop_reason ("refusal" when Claude declined)
+ */
+/**
+ * A claim's verdict from verifyCitations().
+ *
+ * @typedef {Object} VerifiedClaim
+ * @property {string} text
+ * @property {number} start
+ * @property {number} end
+ * @property {'supported'|'unsupported'|'unverifiable'} verdict
+ * @property {'supported'|'low_overlap'|'number_mismatch'|'polarity_mismatch'|'unverifiable'} lexicalReason
+ * @property {string} reason - Why, in words
+ * @property {'lexical'|'judge'} decidedBy
+ * @property {number|null} score - Support of the claim by all its cited passages together, 0..1
+ * @property {Array<{sourceId: string, title: string|null, location: Object, score: number|null, supports: boolean|null}>} citations
+ *   - Each citation's own support; null when it had no cited text
+ */
+/**
+ * What verifyCitations() resolves to.
+ *
+ * @typedef {Object} CitationVerification
+ * @property {boolean} verified - Not a refusal, at least one claim, every claim supported and every citation checkable; uncited sentences don't count against it (see `uncited`)
+ * @property {'anthropic'|'openai'} provider
+ * @property {VerifiedClaim[]} claims
+ * @property {Array<{text: string, start: number, end: number}>} uncited - Sentences with content that no citation covers
+ * @property {{claims: number, supported: number, unsupported: number, unverifiable: number, citations: number, unverifiableCitations: number, uncitedSentences: number}} summary
+ * @property {Object<string, number>} skipped
+ * @property {boolean} refused - Claude declined to answer (stop_reason "refusal"); never verified
+ * @property {{calls: number, usage?: Object, error?: string}} [judge] - Only with the `judge` option
+ */
+/** Sentences of `text` with their offsets (the splitSentences rule). */
+export function sentencesWithOffsets(text: any): {
+    text: string;
+    start: number;
+    end: number;
+}[];

package/dist/types/guardrails/detectors.d.ts

@@ -0,0 +1,88 @@
+export namespace DEFAULT_PII_PATTERNS {
+    let email: RegExp;
+    let phone: RegExp;
+    let ssn: RegExp;
+    let creditCard: RegExp;
+}
+/**
+ * The built-in prompt-injection check as a detector.
+ *
+ * @param {object} [options]
+ * @param {RegExp[]} [options.patterns] - Extra patterns, added to the built-in rules
+ * @returns {{name: string, kind: 'injection', detect: (text: string) => {flagged: boolean, labels: string[], matches: Array<{label: string, text: string}>}}}
+ */
+export function patternInjectionDetector({ patterns }?: {
+    patterns?: RegExp[];
+}): {
+    name: string;
+    kind: "injection";
+    detect: (text: string) => {
+        flagged: boolean;
+        labels: string[];
+        matches: Array<{
+            label: string;
+            text: string;
+        }>;
+    };
+};
+/**
+ * The built-in PII check as a detector: emails, phone numbers, US social
+ * security numbers and card numbers, by pattern.
+ *
+ * @param {object} [options]
+ * @param {Object<string, RegExp>} [options.patterns] - Extra patterns by label, merged with the defaults
+ * @returns {{name: string, kind: 'pii', detect: (text: string) => {flagged: boolean, labels: string[], matches: Array<{label: string, text: string, start: number, end: number}>}}}
+ */
+export function patternPIIDetector({ patterns }?: {
+    patterns?: {
+        [x: string]: RegExp;
+    };
+}): {
+    name: string;
+    kind: "pii";
+    detect: (text: string) => {
+        flagged: boolean;
+        labels: string[];
+        matches: Array<{
+            label: string;
+            text: string;
+            start: number;
+            end: number;
+        }>;
+    };
+};
+/**
+ * Check a guard's `detectors` and `builtIn` options.
+ *
+ * @param {string} guard - Guard name, for messages
+ * @param {'injection'|'pii'} kind - The kind of detector this guard runs
+ * @param {object} options - The guard's options
+ * @returns {object[]} The detectors
+ */
+export function resolveDetectors(guard: string, kind: "injection" | "pii", options?: object): object[];
+/**
+ * Run detectors synchronously. A detector that returns a promise throws a
+ * TypeError naming the async method to use, rather than being ignored (an
+ * ignored promise is a check that never fires).
+ *
+ * @returns {object[]} One detection per detector
+ */
+export function runDetectorsSync(detectors: any, text: any, context: any, { guard, asyncMethod }: {
+    guard: any;
+    asyncMethod: any;
+}): object[];
+/**
+ * Run detectors concurrently, sync or async.
+ *
+ * @returns {Promise<object[]>} One detection per detector
+ */
+export function runDetectorsAsync(detectors: any, text: any, context: any): Promise<object[]>;
+/**
+ * The strings PII detectors found in a PostGenerationGuard result, for
+ * `PostGenerationGuard.redact(text, matches)`. The result keeps them in a
+ * non-enumerable `matchedText`, so they don't appear in its JSON.
+ *
+ * @param {object} result - A PostGenerationGuard check() or checkAsync() result
+ * @returns {string[]}
+ */
+export function detectedText(result: object): string[];

package/dist/types/guardrails/evaluate-detectors.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Run detectors over labelled cases and score them.
+ *
+ * @param {Array<object>} cases - Labelled cases (see the module comment)
+ * @param {Array<{name: string, kind: 'injection'|'pii', detect: Function}>} detectors
+ * @param {object} [options]
+ * @param {number} [options.concurrency=4] - Cases in flight per detector
+ * @param {string[]|Object<string, string[]>} [options.coveredLabels] - Span labels each PII detector is meant to find, for the headline span recall; an array applies to every PII detector
+ * @param {AbortSignal} [options.signal] - Stops the run
+ * @returns {Promise<object>} The report: `{ createdAt, cases, detectors: { [name]: metrics } }`
+ */
+export function evaluateDetectors(cases: Array<object>, detectors: Array<{
+    name: string;
+    kind: "injection" | "pii";
+    detect: Function;
+}>, options?: {
+    concurrency?: number;
+    coveredLabels?: string[] | {
+        [x: string]: string[];
+    };
+    signal?: AbortSignal;
+}): Promise<object>;
+/**
+ * Check labelled cases and fill in their ids.
+ *
+ * @param {Array<object>} cases
+ * @returns {Array<object>} The cases, each with an `id`
+ */
+export function validateDetectorCases(cases: Array<object>): Array<object>;
+/**
+ * Check minimums such as `{ 'pattern-injection.recall': 0.5 }` against a
+ * report. A key is `<detector>.<metric>`, where metric is precision,
+ * recall, f1 or accuracy, or spans.precision / spans.recall.
+ *
+ * @param {object} report - An evaluateDetectors() report
+ * @param {Object<string, number>} [min]
+ * @returns {{passed: boolean, reasons: string[]}}
+ */
+export function detectorVerdict(report: object, min?: {
+    [x: string]: number;
+}): {
+    passed: boolean;
+    reasons: string[];
+};
+/**
+ * Render an evaluateDetectors() report as Markdown or a standalone HTML page.
+ *
+ * @param {object} report
+ * @param {object} [options]
+ * @param {'markdown'|'html'} [options.format='markdown']
+ * @param {string} [options.title='Guardrail detectors']
+ * @param {Object<string, number>} [options.min] - Minimums, as for detectorVerdict()
+ * @returns {string}
+ */
+export function renderDetectorReport(report: object, options?: {
+    format?: "markdown" | "html";
+    title?: string;
+    min?: {
+        [x: string]: number;
+    };
+}): string;

package/dist/types/guardrails/guardrails-pipeline.d.ts

@@ -1,12 +1,4 @@
-/**
- * Pipeline wrapper that applies all three guardrail layers (pre-retrieval,
- * retrieval, and post-generation) around an existing RAG pipeline. In strict
- * mode, any guard failure aborts the pipeline; otherwise issues are collected
- * as warnings and execution continues.
- *
- * @extends EventEmitter
- */
-export class GuardrailsPipeline extends EventEmitter<[never]> {
+export class GuardrailsPipeline extends EventEmitter {
     /**
      * @param {object} pipeline - The underlying RAG pipeline (must have a .run() method)
      * @param {object} [options] - Override default configuration
@@ -47,6 +39,7 @@ export class GuardrailsPipeline extends EventEmitter<[never]> {
      * scrub every string in them with the same PII patterns as the answer.
      *
      * @param {*} value - Object, array or string to redact in place
+     * @param {string[]} [matches=[]] - Strings found by PII detectors, redacted too
      * @returns {*} The redacted value
      * @private
      */

package/dist/types/guardrails/post-generation-guard.d.ts

@@ -5,7 +5,7 @@
  *
  * @extends EventEmitter
  */
-export class PostGenerationGuard extends EventEmitter<[never]> {
+export class PostGenerationGuard extends EventEmitter {
     /**
      * @param {object} [options] - Override default configuration
      * @param {boolean} [options.enablePIIDetection=true] - Whether to detect PII in output
@@ -14,6 +14,9 @@ export class PostGenerationGuard extends EventEmitter<[never]> {
      * @param {number} [options.maxResponseLength=50000] - Maximum allowed response length
      * @param {number} [options.minResponseLength=0] - Minimum response length
      * @param {object} [options.piiPatterns] - Custom PII regex patterns (merged with defaults)
+     * @param {Array<object>} [options.detectors=[]] - PII detectors to run on the output too (see ./detectors); their matches are redacted. Async ones need checkAsync()
+     * @param {boolean} [options.builtIn=true] - false: use only `detectors`, not the built-in PII patterns
+     * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws makes the output unsafe ('block'; what it would have found can't be redacted) or is ignored ('skip')
      */
     constructor(options?: {
         enablePIIDetection?: boolean;
@@ -22,7 +25,12 @@ export class PostGenerationGuard extends EventEmitter<[never]> {
         maxResponseLength?: number;
         minResponseLength?: number;
         piiPatterns?: object;
+        detectors?: Array<object>;
+        builtIn?: boolean;
+        onDetectorError?: "block" | "skip";
     });
+    /** @private */
+    private _detectors;
     config: any;
     /**
      * Check generated output for safety issues, PII, and groundedness.
@@ -43,15 +51,37 @@ export class PostGenerationGuard extends EventEmitter<[never]> {
         sanitizedOutput: string;
         groundednessScore?: number;
     };
+    /**
+     * check() for async detectors, such as a model or a PII service.
+     * Detectors run concurrently.
+     *
+     * @param {string} output
+     * @param {Array<object>} [retrievedDocs=[]]
+     * @param {object} [options]
+     * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+     * @returns {Promise<ReturnType<PostGenerationGuard['check']>>}
+     */
+    checkAsync(output: string, retrievedDocs?: Array<object>, { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<ReturnType<PostGenerationGuard["check"]>>;
+    /** @private */
+    private _runDetectors;
+    /** @private 1. The output must be a string. */
+    private _invalid;
+    /** @private */
+    private _check;
     /**
      * Replace PII matches in arbitrary text with [REDACTED], using the same
      * patterns as check(). Used to scrub text derived from the answer, such as
-     * citation sentences.
+     * citation sentences. Detectors don't run here (they may be async):
+     * pass the strings a check found, `detectedText(result)`, as `matches`
+     * so they are removed too.
      *
      * @param {string} text
+     * @param {string[]} [matches=[]] - Exact strings to redact as well
      * @returns {string}
      */
-    redact(text: string): string;
+    redact(text: string, matches?: string[]): string;
 }
 /**
  * Default configuration for the PostGenerationGuard.

package/dist/types/guardrails/pre-retrieval-guard.d.ts

@@ -5,7 +5,7 @@
  *
  * @extends EventEmitter
  */
-export class PreRetrievalGuard extends EventEmitter<[never]> {
+export class PreRetrievalGuard extends EventEmitter {
     /**
      * @param {object} [options] - Override default configuration
      * @param {number} [options.maxQueryLength=10000] - Maximum allowed query length
@@ -14,6 +14,9 @@ export class PreRetrievalGuard extends EventEmitter<[never]> {
      * @param {string[]} [options.blockedTopics=[]] - Topics to reject
      * @param {string[]} [options.allowedTopics=[]] - If non-empty, only these topics are permitted
      * @param {RegExp[]} [options.injectionPatterns] - Additional injection patterns (merged with defaults)
+     * @param {Array<object>} [options.detectors=[]] - Injection detectors to run on the query as well (see ./detectors); async ones need checkAsync()
+     * @param {boolean} [options.builtIn=true] - false: use only `detectors`, not the built-in patterns
+     * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws makes the query unsafe ('block') or is ignored ('skip')
      */
     constructor(options?: {
         maxQueryLength?: number;
@@ -22,7 +25,12 @@ export class PreRetrievalGuard extends EventEmitter<[never]> {
         blockedTopics?: string[];
         allowedTopics?: string[];
         injectionPatterns?: RegExp[];
+        detectors?: Array<object>;
+        builtIn?: boolean;
+        onDetectorError?: "block" | "skip";
     });
+    /** @private */
+    private _detectors;
     config: any;
     /** @private Extra patterns supplied by the caller */
     private _customPatterns;
@@ -55,6 +63,26 @@ export class PreRetrievalGuard extends EventEmitter<[never]> {
             }>;
         };
     };
+    /**
+     * check() for async detectors, such as a classifier model or a service.
+     * Detectors run concurrently.
+     *
+     * @param {string} query
+     * @param {object} [options]
+     * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+     * @returns {Promise<ReturnType<PreRetrievalGuard['check']>>}
+     */
+    checkAsync(query: string, { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<ReturnType<PreRetrievalGuard["check"]>>;
+    /** @private */
+    private _runDetectors;
+    /** @private */
+    private _emit;
+    /** @private Validation and the built-in checks, before any detector runs. */
+    private _prepare;
+    /** @private Merge the detectors' findings and emit the result. */
+    private _finish;
 }
 /**
  * Default configuration for the PreRetrievalGuard.

package/dist/types/guardrails/retrieval-guard.d.ts

@@ -5,7 +5,7 @@
  *
  * @extends EventEmitter
  */
-export class RetrievalGuard extends EventEmitter<[never]> {
+export class RetrievalGuard extends EventEmitter {
     /**
      * @param {object} [options] - Override default configuration
      * @param {number} [options.minRelevanceScore=0] - Minimum relevance score threshold
@@ -14,6 +14,9 @@ export class RetrievalGuard extends EventEmitter<[never]> {
      * @param {boolean} [options.detectInjection=false] - Scan document text for prompt injection
      * @param {'remove'|'flag'} [options.injectionAction='remove'] - Remove flagged documents or keep and mark them
      * @param {RegExp[]} [options.injectionPatterns=[]] - Extra injection patterns for the scan
+     * @param {Array<object>} [options.detectors=[]] - Injection detectors to run on each document's text too, when detectInjection is on (see ./detectors); async ones need filterAsync(), which calls them once per document, concurrently
+     * @param {boolean} [options.builtIn=true] - false: use only `detectors` for the injection scan
+     * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws counts as a finding ('block': the document is removed or flagged) or is ignored ('skip')
      */
     constructor(options?: {
         minRelevanceScore?: number;
@@ -22,8 +25,13 @@ export class RetrievalGuard extends EventEmitter<[never]> {
         detectInjection?: boolean;
         injectionAction?: "remove" | "flag";
         injectionPatterns?: RegExp[];
+        detectors?: Array<object>;
+        builtIn?: boolean;
+        onDetectorError?: "block" | "skip";
     });
     config: any;
+    /** @private */
+    private _detectors;
     /**
      * Filter retrieval results based on configured guards.
      *
@@ -48,6 +56,27 @@ export class RetrievalGuard extends EventEmitter<[never]> {
             };
         };
     };
+    /**
+     * filter() for async detectors, such as a classifier model or a service. Each
+     * document that reaches the injection scan is checked by every detector,
+     * all concurrently.
+     *
+     * @param {Array<object>} results
+     * @param {object} [context={}]
+     * @param {object} [options]
+     * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+     * @returns {Promise<ReturnType<RetrievalGuard['filter']>>}
+     */
+    filterAsync(results: Array<object>, context?: object, { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<ReturnType<RetrievalGuard["filter"]>>;
+    /**
+     * @private Relevance, freshness and ACL, then which documents go on to
+     * the injection scan.
+     */
+    private _screen;
+    /** @private 4. Indirect prompt injection in document text (opt-in). */
+    private _finish;
 }
 /**
  * Default configuration for the RetrievalGuard.

package/dist/types/mcp/mcp-server.d.ts

@@ -9,7 +9,7 @@
  * const tools = server.getToolDefinitions();
  * const result = await server.handleToolUse('my_tool', { query: 'What is X?' });
  */
-export class MCPServer extends EventEmitter<[never]> {
+export class MCPServer extends EventEmitter {
     /**
      * Convenience factory: create an MCPServer with a single pipeline registered.
      *

package/dist/types/observability/otel.d.ts

@@ -1,16 +1,22 @@
 /**
  * Normalise the `telemetry` option of createRagPipeline. `api` is the
- * @opentelemetry/api module, for builds that cannot require() it (/edge).
- * @param {boolean|{tracer?: object, api?: object, recordContent?: boolean}} option
- * @returns {null|{api: object, tracer: object, recordContent: boolean}}
+ * @opentelemetry/api module, for builds that cannot require() it (/edge);
+ * `logs` is @opentelemetry/api-logs, for evaluation events with an SDK that
+ * registers its LoggerProvider there, and `logger` a Logger to emit them with.
+ * @param {boolean|{tracer?: object, api?: object, logs?: object, logger?: object, recordContent?: boolean}} option
+ * @returns {null|{api: object, tracer: object, logger: object|null, runKey: symbol, recordContent: boolean}}
  */
 export function createTelemetry(option: boolean | {
     tracer?: object;
     api?: object;
+    logs?: object;
+    logger?: object;
     recordContent?: boolean;
 }): null | {
     api: object;
     tracer: object;
+    logger: object | null;
+    runKey: symbol;
     recordContent: boolean;
 };
 /** Wrap a component so its stage methods run in spans. */