llmz 0.9.0 → 1.0.2

package/dist/truncator-DZqEqnpD.js

@@ -1,253 +0,0 @@
-import { n as __exportAll } from "./rolldown-runtime-EAsCxrDo.js";
-import { o as getTokenizer } from "./utils-UBeAFeEI.js";
-//#region src/truncator.ts
-var truncator_exports = /* @__PURE__ */ __exportAll({
-	stripTruncationTags: () => stripTruncationTags,
-	truncateWrappedContent: () => truncateWrappedContent,
-	wrapContent: () => wrapContent
-});
-const DEFAULT_REMOVE_CHUNK = 250;
-const WRAP_OPEN_TAG_1 = "【TRUNCATE";
-const WRAP_OPEN_TAG_2 = "】";
-const WRAP_CLOSE_TAG = "【/TRUNCATE】";
-const REGEXP = `(${WRAP_OPEN_TAG_1}(?:\\s+[\\w:]+)*\\s*${WRAP_OPEN_TAG_2})([\\s\\S]*?)(${WRAP_CLOSE_TAG})`;
-const DEFAULT_TRUNCATE_OPTIONS = {
-	preserve: "top",
-	flex: 1,
-	minTokens: 0
-};
-/**
-* Wraps content with truncation tags to mark it as truncatable when using `truncateWrappedContent`.
-*
-* This function encases the provided content within special truncation tags that contain metadata
-* about how the content should be truncated. The wrapped content becomes eligible for intelligent
-* truncation while preserving non-wrapped content intact.
-*
-* @param content - The string content to wrap with truncation tags
-* @param options - Optional truncation configuration
-* @param options.preserve - Which part of the content to preserve when truncating:
-*   - 'top': Keep the beginning, remove from the end (default)
-*   - 'bottom': Keep the end, remove from the beginning
-*   - 'both': Keep both ends, remove from the middle
-* @param options.flex - Priority factor for truncation (default: 1). Higher values make this
-*   content more likely to be truncated. A flex of 2 means this content can shrink twice as
-*   much as content with flex of 1.
-* @param options.minTokens - Minimum number of tokens to preserve (default: 0). Content will
-*   never be truncated below this threshold.
-*
-* @returns The content wrapped with truncation tags and embedded metadata
-*
-* @example
-* ```typescript
-* // Basic usage - content will be truncated from the end if needed
-* const wrapped = wrapContent("This is some long content that might need truncation")
-*
-* // Preserve the end of the content
-* const bottomPreserved = wrapContent("Error log: ... important error details", {
-*   preserve: 'bottom'
-* })
-*
-* // High priority for truncation with minimum preservation
-* const flexible = wrapContent("Optional context information", {
-*   flex: 3,
-*   minTokens: 50
-* })
-* ```
-*/
-function wrapContent(content, options) {
-	const preserve = (options === null || options === void 0 ? void 0 : options.preserve) ?? DEFAULT_TRUNCATE_OPTIONS.preserve;
-	const flex = (options === null || options === void 0 ? void 0 : options.flex) ?? DEFAULT_TRUNCATE_OPTIONS.flex;
-	const minTokens = (options === null || options === void 0 ? void 0 : options.minTokens) ?? DEFAULT_TRUNCATE_OPTIONS.minTokens;
-	return `${WRAP_OPEN_TAG_1} preserve:${preserve} flex:${flex} min:${minTokens} ${WRAP_OPEN_TAG_2}${content}${WRAP_CLOSE_TAG}`;
-}
-/**
-* Intelligently truncates message content to fit within a token limit while preserving important parts.
-*
-* This function processes an array of messages and reduces their total token count to fit within the
-* specified limit. It only truncates content that has been wrapped with `wrapContent()`, leaving
-* unwrapped content completely intact. The truncation algorithm prioritizes content based on flex
-* values and respects preservation preferences and minimum token requirements.
-*
-* ## How it works:
-* 1. **Parsing**: Scans each message for wrapped content sections and unwrapped sections
-* 2. **Token counting**: Calculates tokens for each section using the configured tokenizer
-* 3. **Prioritization**: Identifies the largest truncatable sections based on flex values
-* 4. **Intelligent truncation**: Removes content according to preservation preferences
-* 5. **Reconstruction**: Rebuilds messages with truncated content and removes wrapper tags
-*
-* ## Truncation strategy:
-* - **Priority**: Higher flex values = higher truncation priority
-* - **Minimum tokens**: Content is never truncated below its `minTokens` threshold
-* - **Preservation modes**:
-*   - `'top'`: Removes from the end, keeps the beginning
-*   - `'bottom'`: Removes from the beginning, keeps the end
-*   - `'both'`: Removes from the middle, keeps both ends
-*
-* @template T - Type extending MessageLike (must have a content property)
-* @param options - Configuration object
-* @param options.messages - Array of messages to truncate
-* @param options.tokenLimit - Maximum total tokens allowed across all messages
-* @param options.throwOnFailure - Whether to throw an error if truncation fails (default: true).
-*   If false, returns the best effort result even if over the token limit.
-*
-* @returns Array of messages with content truncated to fit the token limit
-*
-* @throws Error if unable to truncate enough content to meet the token limit (when throwOnFailure is true)
-*
-* @example
-* ```typescript
-* const messages = [
-*   {
-*     role: 'system',
-*     content: 'You are a helpful assistant. ' + wrapContent('Here is some background info...', { flex: 2 })
-*   },
-*   {
-*     role: 'user',
-*     content: 'Please help me with: ' + wrapContent('detailed context and examples', { preserve: 'both' })
-*   }
-* ]
-*
-* // Truncate to fit within 1000 tokens
-* const truncated = truncateWrappedContent({
-*   messages,
-*   tokenLimit: 1000,
-*   throwOnFailure: false
-* })
-*
-* // The system message background info will be truncated first (higher flex),
-* // and user context will be truncated from the middle if needed (preserve: 'both')
-* ```
-*/
-function truncateWrappedContent({ messages, tokenLimit, throwOnFailure = true }) {
-	const tokenizer = getTokenizer();
-	/**
-	* Before                      { content: 'content', tokens: 10, truncatable: false }
-	* <WRAPPER>content</WRAPPER>  { content: 'content', tokens: 10, truncatable: true }
-	* After                       { content: 'content', tokens: 10, truncatable: false }
-	*/
-	const parts = [];
-	for (const msg of messages) {
-		const current = [];
-		const content = typeof msg.content === "string" ? msg.content : "";
-		let match;
-		const parser = new _MessageContentParser();
-		while ((match = parser.parse(content)) !== null) {
-			const { attributes, nonTruncatableContent, wrappedContent } = match;
-			if (nonTruncatableContent) current.push({
-				content: nonTruncatableContent,
-				tokens: tokenizer.count(nonTruncatableContent),
-				truncatable: false
-			});
-			current.push({
-				content: wrappedContent,
-				tokens: tokenizer.count(wrappedContent),
-				truncatable: true,
-				attributes: {
-					preserve: attributes.preserve,
-					flex: Number(attributes.flex) || DEFAULT_TRUNCATE_OPTIONS.flex,
-					minTokens: Number(attributes.min) || DEFAULT_TRUNCATE_OPTIONS.minTokens
-				}
-			});
-		}
-		const remainingContent = parser.getRemainingContent(content);
-		if (remainingContent) current.push({
-			content: remainingContent,
-			tokens: tokenizer.count(remainingContent),
-			truncatable: false
-		});
-		parts.push(current);
-	}
-	let currentCount = _countTotalTokens(parts);
-	while (currentCount > tokenLimit) {
-		var _biggest$attributes, _biggest$attributes3;
-		const { biggest, secondBiggest } = _getTwoBiggestTruncables(parts);
-		if (!biggest || !biggest.truncatable || biggest.tokens <= 0) {
-			if (throwOnFailure) throw new Error(`Cannot truncate further, current count: ${currentCount}`);
-			else break;
-		}
-		const delta = Math.max(biggest.tokens - ((secondBiggest === null || secondBiggest === void 0 ? void 0 : secondBiggest.tokens) ?? 0), DEFAULT_REMOVE_CHUNK);
-		const room = Math.min(delta, biggest.tokens);
-		let toRemove = Math.min(room, currentCount - tokenLimit);
-		if (toRemove <= 0) {
-			if (throwOnFailure) throw new Error(`Cannot truncate further, current count: ${currentCount}`);
-			else break;
-		}
-		if (biggest.tokens - toRemove < (((_biggest$attributes = biggest.attributes) === null || _biggest$attributes === void 0 ? void 0 : _biggest$attributes.minTokens) ?? 0)) {
-			var _biggest$attributes2;
-			toRemove = biggest.tokens - (((_biggest$attributes2 = biggest.attributes) === null || _biggest$attributes2 === void 0 ? void 0 : _biggest$attributes2.minTokens) ?? 0);
-		}
-		const preserve = ((_biggest$attributes3 = biggest.attributes) === null || _biggest$attributes3 === void 0 ? void 0 : _biggest$attributes3.preserve) ?? DEFAULT_TRUNCATE_OPTIONS.preserve;
-		const split = tokenizer.splitAndSlice(biggest.content);
-		if (preserve === "bottom") biggest.content = split.slice(toRemove).join("");
-		else if (preserve === "top") biggest.content = split.slice(0, -toRemove).join("");
-		else {
-			const anchor = Math.ceil(split.length / 2);
-			const radius = Math.ceil(toRemove / 2);
-			const left = anchor - radius;
-			const right = anchor + radius;
-			biggest.content = split.slice(0, left).join("") + split.slice(right).join("");
-		}
-		biggest.tokens -= toRemove;
-		currentCount -= toRemove;
-	}
-	return messages.map((msg, i) => {
-		const p = parts[i];
-		return {
-			...msg,
-			content: typeof msg.content === "string" ? _renderRemainingWrappers(p.map((part) => part.content).join("")) : msg.content
-		};
-	});
-}
-var _MessageContentParser = class {
-	_regex;
-	_lastIndex = 0;
-	constructor() {
-		this._regex = _createRegex();
-	}
-	parse(content) {
-		const match = this._regex.exec(content);
-		if (!match) return null;
-		const attributes = match[1].split(/\s+/).slice(1).filter((x) => x !== WRAP_OPEN_TAG_2).map((x) => x.split(":")).reduce((acc, [key, value]) => ({
-			...acc,
-			[key]: value
-		}), {});
-		let nonTruncatableContent = void 0;
-		if (match.index > this._lastIndex) nonTruncatableContent = content.slice(this._lastIndex, match.index);
-		const wrappedContent = match[2];
-		this._lastIndex = this._regex.lastIndex;
-		return {
-			attributes,
-			nonTruncatableContent,
-			wrappedContent
-		};
-	}
-	getRemainingContent(content) {
-		if (this._lastIndex < content.length) return content.slice(this._lastIndex);
-		return null;
-	}
-};
-const _createRegex = () => new RegExp(REGEXP, "g");
-const _renderRemainingWrappers = (content) => content.replace(_createRegex(), "$2");
-/** Removes truncation wrapper tags from content, leaving the wrapped content intact. */
-const stripTruncationTags = (content) => _renderRemainingWrappers(content);
-const _countTotalTokens = (parts) => parts.reduce((acc, x) => acc + x.reduce((acc, y) => acc + y.tokens, 0), 0);
-const _getTwoBiggestTruncables = (parts) => {
-	let biggest = null;
-	let secondBiggest = null;
-	for (const part of parts.flat()) if (part.truncatable) {
-		var _part$attributes, _part$attributes2;
-		if (part.tokens <= (((_part$attributes = part.attributes) === null || _part$attributes === void 0 ? void 0 : _part$attributes.minTokens) ?? 0)) continue;
-		const flex = ((_part$attributes2 = part.attributes) === null || _part$attributes2 === void 0 ? void 0 : _part$attributes2.flex) ?? DEFAULT_TRUNCATE_OPTIONS.flex;
-		const tokens = part.tokens * flex;
-		if (!biggest || tokens > biggest.tokens) {
-			secondBiggest = biggest;
-			biggest = part;
-		} else if (!secondBiggest || tokens > secondBiggest.tokens) secondBiggest = part;
-	}
-	return {
-		biggest,
-		secondBiggest
-	};
-};
-//#endregion
-export { wrapContent as i, truncateWrappedContent as n, truncator_exports as r, stripTruncationTags as t };

package/dist/truncator.d.ts

@@ -1,118 +0,0 @@
-import { LLMzPrompts } from './prompts/prompt.js';
-type MessageLike = LLMzPrompts.Message;
-type Options<T> = {
-    messages: T[];
-    tokenLimit: number;
-    throwOnFailure?: boolean;
-};
-type TruncateOptions = {
-    preserve: 'top' | 'bottom' | 'both';
-    /**
-     * A number of 2 means that the content can shrink twice as much as the other parts
-     * @default: 1
-     * */
-    flex: number;
-    /** If provided, the message will never truncate below that number */
-    minTokens: number;
-};
-/**
- * Wraps content with truncation tags to mark it as truncatable when using `truncateWrappedContent`.
- *
- * This function encases the provided content within special truncation tags that contain metadata
- * about how the content should be truncated. The wrapped content becomes eligible for intelligent
- * truncation while preserving non-wrapped content intact.
- *
- * @param content - The string content to wrap with truncation tags
- * @param options - Optional truncation configuration
- * @param options.preserve - Which part of the content to preserve when truncating:
- *   - 'top': Keep the beginning, remove from the end (default)
- *   - 'bottom': Keep the end, remove from the beginning
- *   - 'both': Keep both ends, remove from the middle
- * @param options.flex - Priority factor for truncation (default: 1). Higher values make this
- *   content more likely to be truncated. A flex of 2 means this content can shrink twice as
- *   much as content with flex of 1.
- * @param options.minTokens - Minimum number of tokens to preserve (default: 0). Content will
- *   never be truncated below this threshold.
- *
- * @returns The content wrapped with truncation tags and embedded metadata
- *
- * @example
- * ```typescript
- * // Basic usage - content will be truncated from the end if needed
- * const wrapped = wrapContent("This is some long content that might need truncation")
- *
- * // Preserve the end of the content
- * const bottomPreserved = wrapContent("Error log: ... important error details", {
- *   preserve: 'bottom'
- * })
- *
- * // High priority for truncation with minimum preservation
- * const flexible = wrapContent("Optional context information", {
- *   flex: 3,
- *   minTokens: 50
- * })
- * ```
- */
-export declare function wrapContent(content: string, options?: Partial<TruncateOptions>): string;
-/**
- * Intelligently truncates message content to fit within a token limit while preserving important parts.
- *
- * This function processes an array of messages and reduces their total token count to fit within the
- * specified limit. It only truncates content that has been wrapped with `wrapContent()`, leaving
- * unwrapped content completely intact. The truncation algorithm prioritizes content based on flex
- * values and respects preservation preferences and minimum token requirements.
- *
- * ## How it works:
- * 1. **Parsing**: Scans each message for wrapped content sections and unwrapped sections
- * 2. **Token counting**: Calculates tokens for each section using the configured tokenizer
- * 3. **Prioritization**: Identifies the largest truncatable sections based on flex values
- * 4. **Intelligent truncation**: Removes content according to preservation preferences
- * 5. **Reconstruction**: Rebuilds messages with truncated content and removes wrapper tags
- *
- * ## Truncation strategy:
- * - **Priority**: Higher flex values = higher truncation priority
- * - **Minimum tokens**: Content is never truncated below its `minTokens` threshold
- * - **Preservation modes**:
- *   - `'top'`: Removes from the end, keeps the beginning
- *   - `'bottom'`: Removes from the beginning, keeps the end
- *   - `'both'`: Removes from the middle, keeps both ends
- *
- * @template T - Type extending MessageLike (must have a content property)
- * @param options - Configuration object
- * @param options.messages - Array of messages to truncate
- * @param options.tokenLimit - Maximum total tokens allowed across all messages
- * @param options.throwOnFailure - Whether to throw an error if truncation fails (default: true).
- *   If false, returns the best effort result even if over the token limit.
- *
- * @returns Array of messages with content truncated to fit the token limit
- *
- * @throws Error if unable to truncate enough content to meet the token limit (when throwOnFailure is true)
- *
- * @example
- * ```typescript
- * const messages = [
- *   {
- *     role: 'system',
- *     content: 'You are a helpful assistant. ' + wrapContent('Here is some background info...', { flex: 2 })
- *   },
- *   {
- *     role: 'user',
- *     content: 'Please help me with: ' + wrapContent('detailed context and examples', { preserve: 'both' })
- *   }
- * ]
- *
- * // Truncate to fit within 1000 tokens
- * const truncated = truncateWrappedContent({
- *   messages,
- *   tokenLimit: 1000,
- *   throwOnFailure: false
- * })
- *
- * // The system message background info will be truncated first (higher flex),
- * // and user context will be truncated from the middle if needed (preserve: 'both')
- * ```
- */
-export declare function truncateWrappedContent<T extends MessageLike>({ messages, tokenLimit, throwOnFailure, }: Options<T>): T[];
-/** Removes truncation wrapper tags from content, leaving the wrapped content intact. */
-export declare const stripTruncationTags: (content: string) => string;
-export {};