@pipedog/core 0.0.0 → 0.2.0

package/dist/utils/context/audio_context_manager.d.ts

@@ -0,0 +1,131 @@
+/** Audio contexts a TTS service plays one after another. */
+import { Queue } from "@pipedog/asyncio";
+import { Frame, TTSAudioRawFrame } from "../../frames/frames.ts";
+import { FrameQueue } from "../frame_queue.ts";
+export interface AudioContextFrameOptions {
+    /** The audio context to play. */
+    contextId: string;
+}
+/**
+ * Marks where an audio context plays among the queued frames.
+ *
+ * - `contextId`: the audio context to play.
+ */
+export declare class AudioContextFrame extends Frame {
+    contextId: string;
+    constructor(options: AudioContextFrameOptions);
+}
+/** The bytes of a sample split across audio chunks, with their format. */
+interface AudioRemainder {
+    audio: Uint8Array;
+    sampleRate: number;
+    numChannels: number;
+}
+/** An item queued on an audio context: audio, other frames, word timestamps... `null` ends it. */
+export type AudioContextItem = unknown;
+/**
+ * Audio contexts and frames, played in the order they are queued.
+ *
+ * Each audio context has its own queue of items (audio, other frames, word
+ * timestamps), so a context's audio can arrive while an earlier one is still
+ * playing. `nextForPlayback` returns the next context or frame to play, and
+ * `get` returns a context's items until the context ends.
+ *
+ * `playingContextId` is the context `nextForPlayback` returned last. The
+ * caller sets it back to `null` when that context stops playing.
+ */
+export declare class AudioContextManager {
+    #private;
+    protected _contexts: Map<string, Queue<unknown>>;
+    protected _remainders: Map<string, AudioRemainder>;
+    protected _queue: FrameQueue<Frame | null>;
+    playingContextId: string | null;
+    /** The audio contexts that haven't finished playing. */
+    get contextIds(): string[];
+    /**
+     * Whether an audio context exists and hasn't finished playing.
+     *
+     * @param contextId The audio context to check.
+     */
+    available(contextId: string): boolean;
+    /**
+     * Create an audio context and queue it to play after what's already queued.
+     *
+     * @param contextId The audio context to create.
+     * @param options.interruptible Whether `reset` drops the context while it
+     *   waits to play. Defaults to true.
+     */
+    create(contextId: string, options?: {
+        interruptible?: boolean;
+    }): Promise<void>;
+    /**
+     * Append an item to an audio context. `null` ends the context.
+     *
+     * Audio is trimmed to whole samples, and a split sample is carried to the
+     * context's next audio frame. Providers may cut their PCM stream at any
+     * byte, but consumers read audio frame by frame.
+     *
+     * @param contextId The audio context to append to. It must exist.
+     * @param item The item to append, or `null` to end the context.
+     */
+    append(contextId: string, item: AudioContextItem): Promise<void>;
+    /**
+     * Restart the wait of `get` for an audio context, if it exists.
+     *
+     * @param contextId The audio context still in use.
+     */
+    keepalive(contextId: string): void;
+    /**
+     * Queue a frame to play after what's already queued.
+     *
+     * @param frame The frame to queue.
+     */
+    putFrame(frame: Frame): Promise<void>;
+    /** End playback once everything already queued has played. */
+    endPlayback(): Promise<void>;
+    /**
+     * Wait for the next audio context or frame to play.
+     *
+     * Contexts removed before they play are skipped.
+     *
+     * @returns An `AudioContextFrame`, whose context becomes the playing one,
+     *   another queued frame, or `null` when playback ends.
+     */
+    nextForPlayback(): Promise<Frame | null>;
+    /**
+     * Return an audio context's next item, waiting up to `timeout` for it.
+     *
+     * A keepalive restarts the wait and is not returned.
+     *
+     * @param contextId The audio context to read.
+     * @param timeout Seconds to wait for an item.
+     * @returns The next item, or `null` when the context ends.
+     * @throws TimeoutError If no item arrives in time.
+     */
+    get(contextId: string, timeout: number): Promise<AudioContextItem>;
+    /**
+     * Remove an audio context and its queued items.
+     *
+     * @param contextId The audio context to remove.
+     */
+    remove(contextId: string): void;
+    /**
+     * Drop the frames and contexts waiting to play, except uninterruptible ones.
+     *
+     * The dropped contexts stay available until they are removed.
+     */
+    reset(): void;
+    /** Take the next item in play order. */
+    protected _nextQueued(): Promise<Frame | null>;
+    /**
+     * Trim an audio frame to whole samples, carrying a split sample forward.
+     *
+     * @returns False if the frame holds less than one whole sample and should
+     *   be dropped, true otherwise.
+     */
+    protected _alignAudioFrame(contextId: string, frame: TTSAudioRawFrame): boolean;
+    /** Queue a context's held-back partial sample, zero-padded to a whole one. */
+    protected _flushAudioRemainder(contextId: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=audio_context_manager.d.ts.map

package/dist/utils/context/audio_context_manager.js

@@ -0,0 +1,233 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/context/audio_context_manager.py
+/** Audio contexts a TTS service plays one after another. */
+import { Queue, waitFor } from "@pipedog/asyncio";
+import { Frame, TTSAudioRawFrame, TTSStoppedFrame } from "../../frames/frames.js";
+import { FrameQueue } from "../frame_queue.js";
+/**
+ * Marks where an audio context plays among the queued frames.
+ *
+ * - `contextId`: the audio context to play.
+ */
+export class AudioContextFrame extends Frame {
+    contextId;
+    constructor(options) {
+        super(options);
+        this.contextId = options.contextId;
+    }
+}
+const KEEPALIVE = Symbol("AudioContextManager.KEEPALIVE");
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+/**
+ * Audio contexts and frames, played in the order they are queued.
+ *
+ * Each audio context has its own queue of items (audio, other frames, word
+ * timestamps), so a context's audio can arrive while an earlier one is still
+ * playing. `nextForPlayback` returns the next context or frame to play, and
+ * `get` returns a context's items until the context ends.
+ *
+ * `playingContextId` is the context `nextForPlayback` returned last. The
+ * caller sets it back to `null` when that context stops playing.
+ */
+export class AudioContextManager {
+    _contexts = new Map();
+    // Trailing bytes of a sample split across audio chunks, per context.
+    _remainders = new Map();
+    // Contexts and frames in play order. null ends playback.
+    _queue = new FrameQueue((item) => (item instanceof Frame ? item : null));
+    playingContextId = null;
+    /** The audio contexts that haven't finished playing. */
+    get contextIds() {
+        return [...this._contexts.keys()];
+    }
+    /**
+     * Whether an audio context exists and hasn't finished playing.
+     *
+     * @param contextId The audio context to check.
+     */
+    available(contextId) {
+        return this._contexts.has(contextId);
+    }
+    /**
+     * Create an audio context and queue it to play after what's already queued.
+     *
+     * @param contextId The audio context to create.
+     * @param options.interruptible Whether `reset` drops the context while it
+     *   waits to play. Defaults to true.
+     */
+    async create(contextId, options = {}) {
+        this._contexts.set(contextId, new Queue());
+        const frame = new AudioContextFrame({ contextId });
+        frame.interruptible = options.interruptible ?? true;
+        await this._queue.put(frame);
+    }
+    /**
+     * Append an item to an audio context. `null` ends the context.
+     *
+     * Audio is trimmed to whole samples, and a split sample is carried to the
+     * context's next audio frame. Providers may cut their PCM stream at any
+     * byte, but consumers read audio frame by frame.
+     *
+     * @param contextId The audio context to append to. It must exist.
+     * @param item The item to append, or `null` to end the context.
+     */
+    async append(contextId, item) {
+        if (item instanceof TTSAudioRawFrame && !this._alignAudioFrame(contextId, item)) {
+            return;
+        }
+        // The context's audio ends here, so a held-back partial sample is
+        // queued before the stop frame (or the end marker) that follows it.
+        if (item === null || item instanceof TTSStoppedFrame) {
+            await this._flushAudioRemainder(contextId);
+        }
+        await this.#context(contextId).put(item);
+    }
+    /**
+     * Restart the wait of `get` for an audio context, if it exists.
+     *
+     * @param contextId The audio context still in use.
+     */
+    keepalive(contextId) {
+        if (this.available(contextId)) {
+            this.#context(contextId).putNowait(KEEPALIVE);
+        }
+    }
+    /**
+     * Queue a frame to play after what's already queued.
+     *
+     * @param frame The frame to queue.
+     */
+    async putFrame(frame) {
+        await this._queue.put(frame);
+    }
+    /** End playback once everything already queued has played. */
+    async endPlayback() {
+        await this._queue.put(null);
+    }
+    /**
+     * Wait for the next audio context or frame to play.
+     *
+     * Contexts removed before they play are skipped.
+     *
+     * @returns An `AudioContextFrame`, whose context becomes the playing one,
+     *   another queued frame, or `null` when playback ends.
+     */
+    async nextForPlayback() {
+        let item = await this._nextQueued();
+        while (item instanceof AudioContextFrame && !this.available(item.contextId)) {
+            item = await this._nextQueued();
+        }
+        if (item instanceof AudioContextFrame) {
+            this.playingContextId = item.contextId;
+        }
+        return item;
+    }
+    /**
+     * Return an audio context's next item, waiting up to `timeout` for it.
+     *
+     * A keepalive restarts the wait and is not returned.
+     *
+     * @param contextId The audio context to read.
+     * @param timeout Seconds to wait for an item.
+     * @returns The next item, or `null` when the context ends.
+     * @throws TimeoutError If no item arrives in time.
+     */
+    async get(contextId, timeout) {
+        const queue = this.#context(contextId);
+        let item = KEEPALIVE;
+        while (item === KEEPALIVE) {
+            item = await waitFor(() => queue.get(), timeout);
+        }
+        return item;
+    }
+    /**
+     * Remove an audio context and its queued items.
+     *
+     * @param contextId The audio context to remove.
+     */
+    remove(contextId) {
+        this._contexts.delete(contextId);
+        this._remainders.delete(contextId);
+    }
+    /**
+     * Drop the frames and contexts waiting to play, except uninterruptible ones.
+     *
+     * The dropped contexts stay available until they are removed.
+     */
+    reset() {
+        this._queue.reset();
+    }
+    /** Take the next item in play order. */
+    async _nextQueued() {
+        const item = await this._queue.get();
+        this._queue.taskDone();
+        return item;
+    }
+    /**
+     * Trim an audio frame to whole samples, carrying a split sample forward.
+     *
+     * @returns False if the frame holds less than one whole sample and should
+     *   be dropped, true otherwise.
+     */
+    _alignAudioFrame(contextId, frame) {
+        const blockSize = 2 * Math.max(frame.numChannels, 1);
+        const remainder = this._remainders.get(contextId);
+        this._remainders.delete(contextId);
+        if (!remainder && frame.audio.length % blockSize === 0) {
+            return true;
+        }
+        const audio = remainder ? concatBytes(remainder.audio, frame.audio) : frame.audio;
+        const alignedLength = audio.length - (audio.length % blockSize);
+        if (alignedLength < audio.length) {
+            this._remainders.set(contextId, {
+                audio: audio.slice(alignedLength),
+                sampleRate: frame.sampleRate,
+                numChannels: frame.numChannels,
+            });
+        }
+        if (alignedLength) {
+            frame.audio = audio.slice(0, alignedLength);
+            frame.numFrames = Math.trunc(alignedLength / blockSize);
+        }
+        return alignedLength > 0;
+    }
+    /** Queue a context's held-back partial sample, zero-padded to a whole one. */
+    async _flushAudioRemainder(contextId) {
+        const remainder = this._remainders.get(contextId);
+        this._remainders.delete(contextId);
+        if (!remainder) {
+            return;
+        }
+        const blockSize = 2 * Math.max(remainder.numChannels, 1);
+        let audio = remainder.audio;
+        if (audio.length < blockSize) {
+            const padded = new Uint8Array(blockSize);
+            padded.set(audio, 0);
+            audio = padded;
+        }
+        const frame = new TTSAudioRawFrame({
+            audio,
+            sampleRate: remainder.sampleRate,
+            numChannels: remainder.numChannels,
+            contextId,
+        });
+        await this.#context(contextId).put(frame);
+    }
+    #context(contextId) {
+        const queue = this._contexts.get(contextId);
+        if (!queue) {
+            // Upstream raises KeyError.
+            throw new Error(`KeyError: '${contextId}'`);
+        }
+        return queue;
+    }
+}
+//# sourceMappingURL=audio_context_manager.js.map

package/dist/utils/context/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/context/index.js

@@ -0,0 +1,7 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/utils/context/__init__.py
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/context/llm_context_summarization.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Utility for context summarization in LLM services.
+ *
+ * This module provides reusable functionality for automatically compressing
+ * conversation context when token limits are reached, enabling efficient
+ * long-running conversations.
+ *
+ * The deprecated `LLMContextSummarizationConfig` is not ported; use
+ * `LLMAutoContextSummarizationConfig` with a nested `LLMContextSummaryConfig`.
+ */
+import { type LLMContext, type LLMContextMessage } from "../../processors/aggregators/llm_context.ts";
+import type { LLMService } from "../../services/llm_service.ts";
+/** Fallback timeout (seconds) used when summarizationTimeout is null. */
+export declare const DEFAULT_SUMMARIZATION_TIMEOUT = 120;
+/** Industry-standard heuristic: 1 token ≈ 4 characters. */
+export declare const CHARS_PER_TOKEN = 4;
+/** Estimated structural overhead per message. */
+export declare const TOKEN_OVERHEAD_PER_MESSAGE = 10;
+/** Rough estimate for image content. */
+export declare const IMAGE_TOKEN_ESTIMATE = 500;
+/** Keep summary at 80% of available space for safety. */
+export declare const SUMMARY_TOKEN_BUFFER = 0.8;
+/** Minimum tokens to allocate for summary. */
+export declare const MIN_SUMMARY_TOKENS = 100;
+export declare const DEFAULT_SUMMARIZATION_PROMPT = "You are summarizing a conversation between a user and an AI assistant.\n\nYour task:\n1. Create a concise summary that preserves:\n   - Key facts, decisions, and agreements\n   - Important context needed to continue the conversation\n   - User preferences and requirements mentioned\n   - Any unresolved questions or action items\n\n2. Format:\n   - Use clear, factual statements\n   - Group related information\n   - Prioritize information likely to be referenced later\n   - Keep the summary concise to fit within the specified token budget\n\n3. Omit:\n   - Greetings and small talk\n   - Redundant information\n   - Tangential discussions that were resolved\n\nThe conversation transcript follows. Generate only the summary, no other text.";
+export interface LLMContextSummaryConfigOptions {
+    /**
+     * Maximum token size for the generated summary. This value is passed
+     * directly to the LLM as the max_tokens parameter when generating the
+     * summary. Should be sized appropriately to allow the summary plus recent
+     * preserved messages to fit within reasonable context limits.
+     */
+    targetContextTokens?: number;
+    /**
+     * Number of recent messages to preserve uncompressed after each
+     * summarization. These messages maintain immediate conversational context.
+     */
+    minMessagesAfterSummary?: number;
+    /**
+     * Custom prompt for the LLM to use when generating summaries. If null,
+     * uses DEFAULT_SUMMARIZATION_PROMPT.
+     */
+    summarizationPrompt?: string | null;
+    /**
+     * Template for formatting the summary when injected into context. Must
+     * contain `{summary}` as a placeholder for the generated summary text.
+     * Allows applications to wrap the summary in custom delimiters (e.g., XML
+     * tags) so that system prompts can distinguish summaries from live
+     * conversation.
+     */
+    summaryMessageTemplate?: string;
+    /**
+     * Optional separate LLM service for generating summaries. When set,
+     * summarization requests are sent to this service instead of the
+     * pipeline's primary LLM. Useful for routing summarization to a
+     * cheaper/faster model (e.g., Gemini Flash) while keeping an expensive
+     * model for conversation. If null, uses the pipeline LLM.
+     */
+    llm?: LLMService | null;
+    /**
+     * Maximum time in seconds to wait for the LLM to generate a summary. If
+     * the call exceeds this timeout, summarization is aborted with an error
+     * and future summarizations are unblocked.
+     */
+    summarizationTimeout?: number;
+}
+/**
+ * Configuration for summary generation parameters.
+ *
+ * Contains settings that control how a summary is generated. Used by both
+ * automatic and manual summarization modes. See
+ * `LLMContextSummaryConfigOptions` for the fields.
+ */
+export declare class LLMContextSummaryConfig {
+    targetContextTokens: number;
+    minMessagesAfterSummary: number;
+    summarizationPrompt: string | null;
+    summaryMessageTemplate: string;
+    llm: LLMService | null;
+    summarizationTimeout: number;
+    /**
+     * @throws Error If a parameter is out of range (upstream: ValueError).
+     */
+    constructor(options?: LLMContextSummaryConfigOptions);
+    /**
+     * The summarization prompt to use: the custom prompt if set, otherwise the
+     * default summarization prompt.
+     */
+    get summaryPrompt(): string;
+}
+export interface LLMAutoContextSummarizationConfigOptions {
+    /**
+     * Maximum allowed context size in tokens. When this limit is reached,
+     * summarization is triggered to compress the context. The tokens are
+     * calculated using the industry-standard approximation of 1 token ≈ 4
+     * characters. This measures the context messages only: the LLM service's
+     * `systemInstruction` is sent on every inference but is not part of the
+     * context, and summarization cannot compress it. Size this limit against
+     * the model's window minus the instruction. Set to null to disable
+     * token-based triggering. Defaults to 8000.
+     */
+    maxContextTokens?: number | null;
+    /**
+     * Maximum number of new messages that can accumulate since the last
+     * summary before triggering a new summarization. This ensures regular
+     * compression even if token limits are not reached. Set to null to disable
+     * message-count triggering. Defaults to 20.
+     */
+    maxUnsummarizedMessages?: number | null;
+    /**
+     * Configuration for summary generation parameters (prompt, token budget,
+     * messages to keep). If not provided, uses default `LLMContextSummaryConfig`
+     * values.
+     */
+    summaryConfig?: LLMContextSummaryConfig;
+}
+/**
+ * Configuration for automatic context summarization.
+ *
+ * Controls when conversation context is automatically compressed and how
+ * that summary is generated. Summarization is triggered when either the
+ * token limit or the unsummarized message count threshold is exceeded.
+ *
+ * At least one of `maxContextTokens` and `maxUnsummarizedMessages` must be
+ * set. Set the other to null to disable that threshold.
+ */
+export declare class LLMAutoContextSummarizationConfig {
+    maxContextTokens: number | null;
+    maxUnsummarizedMessages: number | null;
+    summaryConfig: LLMContextSummaryConfig;
+    /**
+     * @throws Error If a parameter is out of range (upstream: ValueError).
+     */
+    constructor(options?: LLMAutoContextSummarizationConfigOptions);
+}
+export interface LLMMessagesToSummarizeOptions {
+    /** Messages to include in the summary. */
+    messages: LLMContextMessage[];
+    /** Index of the last message being summarized. */
+    lastSummarizedIndex: number;
+}
+/**
+ * Result of the getMessagesToSummarize operation.
+ *
+ * - `messages`: Messages to include in the summary.
+ * - `lastSummarizedIndex`: Index of the last message being summarized.
+ */
+export declare class LLMMessagesToSummarize {
+    messages: LLMContextMessage[];
+    lastSummarizedIndex: number;
+    constructor(options: LLMMessagesToSummarizeOptions);
+}
+/**
+ * Utility providing context summarization capabilities for LLM processing.
+ *
+ * This utility enables automatic conversation context compression when token
+ * limits are reached. It provides functionality for both aggregators
+ * (which decide when to summarize) and LLM services (which generate summaries).
+ *
+ * Key features:
+ * - Token estimation using character-count heuristics (chars / 4)
+ * - Smart message selection (preserves system messages and recent context)
+ * - Function call awareness (avoids summarizing incomplete tool interactions)
+ * - Flexible transcript formatting for summarization
+ * - Maximum summary token calculation with safety buffers
+ *
+ * @example
+ * // Use the static methods directly on the class:
+ * const tokens = LLMContextSummarizationUtil.estimateContextTokens(context);
+ * const result = LLMContextSummarizationUtil.getMessagesToSummarize(context, 4);
+ * const transcript = LLMContextSummarizationUtil.formatMessagesForSummary(messages);
+ *
+ * Note: token estimation uses the industry-standard heuristic of 1 token ≈ 4 characters.
+ */
+export declare class LLMContextSummarizationUtil {
+    /**
+     * Estimate token count for text using character count heuristic.
+     *
+     * Uses the industry-standard approximation of 1 token ≈ 4 characters.
+     * This works well across different content types (prose, code, etc.)
+     * and languages.
+     *
+     * Note: for more accurate token counts, use the model's official tokenizer.
+     * This is a rough estimate suitable for threshold checks and budgeting.
+     *
+     * @param text Text to estimate tokens for.
+     * @returns Estimated token count (characters / 4, rounded down).
+     */
+    static estimateTokens(text: string | null | undefined): number;
+    /**
+     * Estimate total token count for a context.
+     *
+     * Calculates an approximate token count by analyzing all messages,
+     * including text content, tool calls, and structural overhead.
+     *
+     * @param context LLM context to estimate.
+     * @returns The estimated total token count, covering message content (text
+     *   and images), tool calls and their arguments, tool results, and
+     *   `TOKEN_OVERHEAD_PER_MESSAGE` of structural overhead per message.
+     */
+    static estimateContextTokens(context: LLMContext): number;
+    /**
+     * Return true if a tool message content represents an unresolved call.
+     *
+     * A tool message is considered pending (unresolved) when its content is
+     * the synchronous `"IN_PROGRESS"` sentinel or the async
+     * `{"type": "async_tool", "status": "started"}` marker — both indicate
+     * that the actual result has not yet been written back to the context.
+     *
+     * @param content The `content` field of a tool-role context message.
+     * @returns True if the tool call should be treated as still in progress.
+     */
+    protected static _isToolMessagePending(content: string): boolean;
+    /**
+     * Find the earliest message index with incomplete function calls.
+     *
+     * Scans messages from `startIdx` up to (but not including) `summaryEnd`
+     * to identify tool calls whose responses either don't exist yet, fall in
+     * the kept portion of the context (>= summaryEnd), or are still marked as
+     * `IN_PROGRESS` (async calls whose results have not yet arrived).
+     *
+     * This prevents summarizing tool call requests when their responses would
+     * remain in the kept context as orphans, which the OpenAI API rejects,
+     * and avoids summarizing async function calls before their results arrive.
+     *
+     * @param messages List of messages to check.
+     * @param startIdx Index to start checking from.
+     * @param summaryEnd Exclusive upper bound for the scan (the first kept
+     *   message index). Only tool responses within this range count as
+     *   completing a call; responses beyond it are treated as absent, leaving
+     *   the call "in progress".
+     * @returns Index of first message with function call in progress, or -1 if
+     *   all function calls are complete within the scanned range.
+     */
+    protected static _getEarliestFunctionCallNotResolvedInRange(messages: readonly LLMContextMessage[], startIdx: number, summaryEnd: number): number;
+    /**
+     * Determine which messages should be included in summarization.
+     *
+     * Intelligently selects messages for summarization while preserving:
+     * - The first system message (defines assistant behavior)
+     * - The last N messages (maintains immediate conversation context)
+     * - Incomplete function call sequences (preserves tool interaction integrity)
+     *
+     * @param context The LLM context containing all messages.
+     * @param minMessagesToKeep Number of recent messages to exclude from summarization.
+     * @returns LLMMessagesToSummarize containing the messages to summarize and
+     *   the index of the last message included.
+     */
+    static getMessagesToSummarize(context: LLMContext, minMessagesToKeep: number): LLMMessagesToSummarize;
+    /**
+     * Format messages as a transcript for summarization.
+     *
+     * @param messages Messages to format.
+     * @returns Formatted transcript string.
+     */
+    static formatMessagesForSummary(messages: readonly LLMContextMessage[]): string;
+}
+//# sourceMappingURL=llm_context_summarization.d.ts.map