comisai 1.0.19 → 1.0.23

package/node_modules/@comis/agent/dist/safety/schema-normalizer.js

@@ -1,137 +0,0 @@
-/**
- * Provider-specific JSON Schema normalization: strips unsupported keywords
- * from tool definitions based on the target LLM provider.
- *
- * Different providers reject different JSON Schema keywords in tool
- * input_schema definitions. This normalizer deep-walks the schema tree
- * and strips keywords that the target provider does not support.
- *
- * Designed for use as a StreamFnWrapper in stream-wrappers.ts. Wiring
- * is NOT done here -- this is a pure function module.
- *
- * @module
- */
-// ---------------------------------------------------------------------------
-// Provider keyword maps
-// ---------------------------------------------------------------------------
-/**
- * Map of provider -> set of unsupported JSON Schema keywords to strip.
- * OpenAI is not listed because it supports the standard keywords.
- * OpenRouter passes through to the underlying provider.
- */
-export const PROVIDER_UNSUPPORTED_KEYWORDS = {
-    anthropic: new Set([
-        "format",
-        "pattern",
-        "minLength",
-        "maxLength",
-        "minimum",
-        "maximum",
-        "exclusiveMinimum",
-        "exclusiveMaximum",
-        "multipleOf",
-        "minItems",
-        "maxItems",
-        "uniqueItems",
-        "minProperties",
-        "maxProperties",
-        "patternProperties",
-        "additionalItems",
-    ]),
-    google: new Set([
-        "additionalProperties",
-        "format",
-        "pattern",
-        "minLength",
-        "maxLength",
-        "minimum",
-        "maximum",
-        "exclusiveMinimum",
-        "exclusiveMaximum",
-        "multipleOf",
-        "minItems",
-        "maxItems",
-        "uniqueItems",
-    ]),
-};
-// ---------------------------------------------------------------------------
-// Schema walking
-// ---------------------------------------------------------------------------
-/** Keys that contain nested schema objects to recurse into. */
-const NESTED_SCHEMA_KEYS = new Set([
-    "properties",
-    "items",
-    "allOf",
-    "anyOf",
-    "oneOf",
-    "not",
-    "if",
-    "then",
-    "else",
-    "additionalProperties",
-]);
-/**
- * Deep-walk a schema node and strip unsupported keywords.
- * Mutates the clone in-place and collects stripped keyword names.
- */
-function walkAndStrip(node, unsupported, stripped) {
-    // Strip unsupported keywords at this level
-    for (const key of Object.keys(node)) {
-        if (unsupported.has(key)) {
-            stripped.add(key);
-            delete node[key];
-        }
-    }
-    // Recurse into nested schema structures
-    for (const key of NESTED_SCHEMA_KEYS) {
-        const value = node[key];
-        if (value === undefined || value === null)
-            continue;
-        // Skip $ref -- don't walk into references
-        if (key === "$ref")
-            continue;
-        if (key === "properties" && typeof value === "object" && !Array.isArray(value)) {
-            // properties: { propName: schemaObject, ... }
-            for (const propSchema of Object.values(value)) {
-                if (propSchema && typeof propSchema === "object" && !Array.isArray(propSchema)) {
-                    walkAndStrip(propSchema, unsupported, stripped);
-                }
-            }
-        }
-        else if (Array.isArray(value)) {
-            // allOf, anyOf, oneOf: array of schema objects
-            for (const item of value) {
-                if (item && typeof item === "object" && !Array.isArray(item)) {
-                    walkAndStrip(item, unsupported, stripped);
-                }
-            }
-        }
-        else if (typeof value === "object") {
-            // items, not, if, then, else, additionalProperties: single schema object
-            walkAndStrip(value, unsupported, stripped);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Deep-clone a JSON Schema and strip unsupported keywords for the given provider.
- *
- * If the provider has no entry in PROVIDER_UNSUPPORTED_KEYWORDS, returns the
- * schema unchanged (still cloned to prevent mutation).
- *
- * @param schema - The JSON Schema to normalize
- * @param provider - Target LLM provider name
- * @returns Normalized schema with list of stripped keywords
- */
-export function normalizeToolSchema(schema, provider) {
-    const cloned = structuredClone(schema);
-    const unsupported = PROVIDER_UNSUPPORTED_KEYWORDS[provider];
-    if (!unsupported || unsupported.size === 0) {
-        return { schema: cloned, strippedKeywords: [] };
-    }
-    const stripped = new Set();
-    walkAndStrip(cloned, unsupported, stripped);
-    return { schema: cloned, strippedKeywords: [...stripped].sort() };
-}

package/node_modules/@comis/agent/dist/safety/schema-pruning.d.ts

@@ -1,50 +0,0 @@
-/**
- * Schema description pruning: strips optional parameter descriptions from
- * tool JSON schemas to save tokens for small models.
- *
- * Small models (context window <= 32K) waste tokens on optional parameter
- * descriptions they rarely use. This module strips those descriptions while
- * preserving required parameter descriptions and excluding designated tools
- * (e.g., browser) from pruning.
- *
- * Designed as a pure function module -- wiring is done in pi-executor.ts.
- *
- * @module
- */
-import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
-/** Result of pruning descriptions from a single schema. */
-export interface PruneResult {
-    schema: Record<string, unknown>;
-    removedCount: number;
-}
-/** Result of pruning descriptions from an array of tool definitions. */
-export interface PruneToolsResult {
-    tools: ToolDefinition[];
-    totalRemoved: number;
-    estimatedTokensSaved: number;
-}
-/**
- * Deep-clone a JSON Schema and strip descriptions from optional parameters.
- *
- * Required parameters (listed in the schema's `required` array) retain
- * their descriptions unconditionally. Parameters not in `required` have
- * their `description` field removed.
- *
- * CRITICAL: Uses structuredClone to avoid mutating shared TypeBox TSchema
- * objects that may be referenced across sessions.
- *
- * @param schema - The JSON Schema to prune
- * @returns Pruned schema with removal count
- */
-export declare function pruneSchemaDescriptions(schema: Record<string, unknown>): PruneResult;
-/**
- * Prune optional parameter descriptions from an array of tool definitions.
- *
- * Tools whose name is in `excludeNames` are passed through unmodified
- * (default: browser tool excluded since it needs full descriptions).
- *
- * @param tools - Array of tool definitions to prune
- * @param excludeNames - Tool names to skip (default: `new Set(["browser"])`)
- * @returns Pruned tools with total removal count and estimated token savings
- */
-export declare function pruneToolSchemas(tools: ToolDefinition[], excludeNames?: Set<string>): PruneToolsResult;

package/node_modules/@comis/agent/dist/safety/schema-pruning.js

@@ -1,112 +0,0 @@
-/**
- * Schema description pruning: strips optional parameter descriptions from
- * tool JSON schemas to save tokens for small models.
- *
- * Small models (context window <= 32K) waste tokens on optional parameter
- * descriptions they rarely use. This module strips those descriptions while
- * preserving required parameter descriptions and excluding designated tools
- * (e.g., browser) from pruning.
- *
- * Designed as a pure function module -- wiring is done in pi-executor.ts.
- *
- * @module
- */
-import { CHARS_PER_TOKEN_RATIO } from "../context-engine/constants.js";
-// ---------------------------------------------------------------------------
-// Schema walking
-// ---------------------------------------------------------------------------
-/**
- * Walk a schema node and strip descriptions from optional parameters.
- * Mutates the clone in-place. Returns the count of removed descriptions
- * and the total character length of removed description strings.
- */
-function walkAndPrune(node, requiredSet) {
-    let removed = 0;
-    let charsRemoved = 0;
-    const properties = node.properties;
-    if (!properties || typeof properties !== "object") {
-        return { removed, charsRemoved };
-    }
-    for (const [propName, propSchema] of Object.entries(properties)) {
-        if (!propSchema || typeof propSchema !== "object")
-            continue;
-        if (!requiredSet.has(propName) && "description" in propSchema) {
-            const desc = propSchema.description;
-            if (typeof desc === "string") {
-                charsRemoved += desc.length;
-            }
-            delete propSchema.description;
-            removed++;
-        }
-        // Recurse into nested object properties
-        if (propSchema.type === "object" &&
-            propSchema.properties &&
-            typeof propSchema.properties === "object") {
-            const innerRequired = Array.isArray(propSchema.required)
-                ? new Set(propSchema.required)
-                : new Set();
-            const inner = walkAndPrune(propSchema, innerRequired);
-            removed += inner.removed;
-            charsRemoved += inner.charsRemoved;
-        }
-    }
-    return { removed, charsRemoved };
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Deep-clone a JSON Schema and strip descriptions from optional parameters.
- *
- * Required parameters (listed in the schema's `required` array) retain
- * their descriptions unconditionally. Parameters not in `required` have
- * their `description` field removed.
- *
- * CRITICAL: Uses structuredClone to avoid mutating shared TypeBox TSchema
- * objects that may be referenced across sessions.
- *
- * @param schema - The JSON Schema to prune
- * @returns Pruned schema with removal count
- */
-export function pruneSchemaDescriptions(schema) {
-    const cloned = structuredClone(schema);
-    const requiredSet = Array.isArray(cloned.required)
-        ? new Set(cloned.required)
-        : new Set();
-    const { removed } = walkAndPrune(cloned, requiredSet);
-    return { schema: cloned, removedCount: removed };
-}
-/**
- * Prune optional parameter descriptions from an array of tool definitions.
- *
- * Tools whose name is in `excludeNames` are passed through unmodified
- * (default: browser tool excluded since it needs full descriptions).
- *
- * @param tools - Array of tool definitions to prune
- * @param excludeNames - Tool names to skip (default: `new Set(["browser"])`)
- * @returns Pruned tools with total removal count and estimated token savings
- */
-export function pruneToolSchemas(tools, excludeNames = new Set(["browser"])) {
-    let totalRemoved = 0;
-    let totalCharsRemoved = 0;
-    const prunedTools = tools.map((tool) => {
-        if (excludeNames.has(tool.name)) {
-            return tool;
-        }
-        const schema = tool.parameters;
-        const cloned = structuredClone(schema);
-        const requiredSet = Array.isArray(cloned.required)
-            ? new Set(cloned.required)
-            : new Set();
-        const { removed, charsRemoved } = walkAndPrune(cloned, requiredSet);
-        totalRemoved += removed;
-        totalCharsRemoved += charsRemoved;
-        return { ...tool, parameters: cloned };
-    });
-    const estimatedTokensSaved = Math.ceil(totalCharsRemoved / CHARS_PER_TOKEN_RATIO);
-    return {
-        tools: prunedTools,
-        totalRemoved,
-        estimatedTokensSaved,
-    };
-}

package/node_modules/@comis/agent/dist/safety/tool-image-sanitizer.d.ts

@@ -1,43 +0,0 @@
-/**
- * Tool image sanitizer -- validates, resizes, and re-encodes images
- * from tool results before they enter LLM context.
- *
- * Prevents memory spikes from oversized images and rejects corrupt
- * or unsupported image data. Uses sharp for processing with
- * decompression bomb protection via limitInputPixels.
- */
-import type { Result } from "@comis/shared";
-/** Configuration options for image sanitization. */
-export interface ImageSanitizeOptions {
-    /** Max width in pixels (default: 1024) */
-    maxWidth?: number;
-    /** Max height in pixels (default: 1024) */
-    maxHeight?: number;
-    /** Max input size in bytes (default: 10_485_760 = 10MB) */
-    maxInputBytes?: number;
-    /** Output format (default: "png") */
-    outputFormat?: "png" | "jpeg" | "webp";
-    /** JPEG/WebP quality 1-100 (default: 85) */
-    quality?: number;
-}
-/** Result of a successful image sanitization. */
-export interface SanitizeResult {
-    buffer: Buffer;
-    format: string;
-    width: number;
-    height: number;
-    originalBytes: number;
-    sanitizedBytes: number;
-}
-/** Tool image sanitizer interface. */
-export interface ToolImageSanitizer {
-    /** Sanitize a base64-encoded image. Returns Result with sanitized buffer or error. */
-    sanitize(base64Data: string, mimeType?: string): Promise<Result<SanitizeResult, string>>;
-}
-/**
- * Create a tool image sanitizer instance.
- *
- * @param opts - Optional configuration overriding defaults.
- * @returns A ToolImageSanitizer instance.
- */
-export declare function createToolImageSanitizer(opts?: ImageSanitizeOptions): ToolImageSanitizer;

package/node_modules/@comis/agent/dist/safety/tool-image-sanitizer.js

@@ -1,96 +0,0 @@
-/**
- * Tool image sanitizer -- validates, resizes, and re-encodes images
- * from tool results before they enter LLM context.
- *
- * Prevents memory spikes from oversized images and rejects corrupt
- * or unsupported image data. Uses sharp for processing with
- * decompression bomb protection via limitInputPixels.
- */
-import sharp from "sharp";
-import { ok, err } from "@comis/shared";
-// Disable sharp cache to prevent memory accumulation across calls
-sharp.cache(false);
-/** Default limit for decompression bomb protection (268 million pixels). */
-const DEFAULT_LIMIT_INPUT_PIXELS = 268_402_689;
-/**
- * Create a tool image sanitizer instance.
- *
- * @param opts - Optional configuration overriding defaults.
- * @returns A ToolImageSanitizer instance.
- */
-export function createToolImageSanitizer(opts) {
-    const maxWidth = opts?.maxWidth ?? 1024;
-    const maxHeight = opts?.maxHeight ?? 1024;
-    const maxInputBytes = opts?.maxInputBytes ?? 10_485_760;
-    const outputFormat = opts?.outputFormat ?? "png";
-    const quality = opts?.quality ?? 85;
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        async sanitize(base64Data, _mimeType) {
-            // Reject empty input
-            if (!base64Data || base64Data.length === 0) {
-                return err("Empty image data provided");
-            }
-            // Decode base64 to buffer
-            let inputBuffer;
-            try {
-                inputBuffer = Buffer.from(base64Data, "base64");
-            }
-            catch {
-                return err("Failed to decode base64 image data");
-            }
-            // Reject if decoded buffer is empty (empty base64 decodes to empty buffer)
-            if (inputBuffer.length === 0) {
-                return err("Empty image data after base64 decode");
-            }
-            // Check size against maxInputBytes
-            if (inputBuffer.length > maxInputBytes) {
-                return err(`Image size ${inputBuffer.length} bytes exceeds maximum allowed ${maxInputBytes} bytes`);
-            }
-            try {
-                // Create sharp instance with decompression bomb protection
-                const image = sharp(inputBuffer, {
-                    limitInputPixels: DEFAULT_LIMIT_INPUT_PIXELS,
-                });
-                // Read metadata to determine if resize is needed
-                const metadata = await image.metadata();
-                if (!metadata.width || !metadata.height) {
-                    return err("Unable to read image dimensions -- possibly corrupt or unsupported format");
-                }
-                // Resize if exceeds limits (fit: inside preserves aspect ratio)
-                const needsResize = metadata.width > maxWidth || metadata.height > maxHeight;
-                if (needsResize) {
-                    image.resize(maxWidth, maxHeight, { fit: "inside" });
-                }
-                // Convert to output format
-                let outputBuffer;
-                switch (outputFormat) {
-                    case "jpeg":
-                        outputBuffer = await image.jpeg({ quality }).toBuffer();
-                        break;
-                    case "webp":
-                        outputBuffer = await image.webp({ quality }).toBuffer();
-                        break;
-                    case "png":
-                    default:
-                        outputBuffer = await image.png().toBuffer();
-                        break;
-                }
-                // Read final metadata from the output
-                const outputMeta = await sharp(outputBuffer).metadata();
-                return ok({
-                    buffer: outputBuffer,
-                    format: outputFormat,
-                    width: outputMeta.width ?? (needsResize ? maxWidth : metadata.width),
-                    height: outputMeta.height ?? (needsResize ? maxHeight : metadata.height),
-                    originalBytes: inputBuffer.length,
-                    sanitizedBytes: outputBuffer.length,
-                });
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return err(`Image processing failed: ${message}`);
-            }
-        },
-    };
-}

package/node_modules/@comis/agent/dist/safety/tool-sanitizer.d.ts

@@ -1,44 +0,0 @@
-/**
- * Tool output sanitizer -- strips indirect prompt injection patterns.
- *
- * Detects instruction-like text in tool outputs that could be used
- * to hijack the agent's behavior via indirect prompt injection.
- * Replaces detected patterns with "[REDACTED]" and truncates
- * oversized output at newline boundaries.
- */
-/**
- * Normalize text for secure pattern matching.
- * 1. Apply Unicode NFKC normalization (compatibility decomposition + canonical composition)
- * 2. Strip zero-width and invisible formatting characters (including tag block bypass)
- *
- * IMPORTANT: Always normalize FIRST, then do pattern matching on the normalized string.
- * NFKC can change string length (e.g., fullwidth A -> A, ligatures decompose).
- */
-export declare function normalizeForMatching(text: string): string;
-/**
- * Regex patterns that indicate potential prompt injection attempts.
- *
- * Imported from @comis/core injection-patterns.ts (single source of truth).
- * Each pattern uses the `gi` flag for case-insensitive global matching.
- *
- * Note: The `system\s*:\s+` pattern requires whitespace after colon
- * to avoid matching URLs like `https://system.example.com:8080`
- * or code like `process.env.system`.
- */
-export declare const INSTRUCTION_PATTERNS: readonly RegExp[];
-/**
- * Sanitize tool output against indirect prompt injection.
- *
- * 1. Checks for Unicode tag block bypass characters (for caller-side INFO logging)
- * 2. Replaces instruction-like injection patterns with "[REDACTED]"
- * 3. Truncates output exceeding `maxChars` at the last newline before
- *    the 95% mark, appending a truncation notice
- *
- * @param text - Raw tool output text
- * @param maxChars - Maximum allowed characters (default: 50,000)
- * @param options - Optional callbacks for tag block detection logging
- * @returns Sanitized text with injections redacted and size enforced
- */
-export declare function sanitizeToolOutput(text: string, maxChars?: number, options?: {
-    onTagBlockDetected?: () => void;
-}): string;

package/node_modules/@comis/agent/dist/safety/tool-sanitizer.js

@@ -1,94 +0,0 @@
-/**
- * Tool output sanitizer -- strips indirect prompt injection patterns.
- *
- * Detects instruction-like text in tool outputs that could be used
- * to hijack the agent's behavior via indirect prompt injection.
- * Replaces detected patterns with "[REDACTED]" and truncates
- * oversized output at newline boundaries.
- */
-import { stripInvisible, containsTagBlockChars, IGNORE_PREV_INSTRUCTIONS, YOU_ARE_NOW, FORGET_EVERYTHING, NEW_INSTRUCTIONS, SYSTEM_COLON, SYSTEM_BRACKET, INST_BRACKET, SYSTEM_TAG, IMPORTANT_OVERRIDE, DISREGARD_INSTRUCTIONS, ACT_AS_ROLE, ASSISTANT_ROLE_MARKER, SPECIAL_TOKEN_DELIMITERS, CONTEXT_RESET, RULE_REPLACEMENT, OVERRIDE_SAFETY, } from "@comis/core";
-/**
- * Normalize text for secure pattern matching.
- * 1. Apply Unicode NFKC normalization (compatibility decomposition + canonical composition)
- * 2. Strip zero-width and invisible formatting characters (including tag block bypass)
- *
- * IMPORTANT: Always normalize FIRST, then do pattern matching on the normalized string.
- * NFKC can change string length (e.g., fullwidth A -> A, ligatures decompose).
- */
-export function normalizeForMatching(text) {
-    return stripInvisible(text.normalize("NFKC")).text;
-}
-/** Default maximum characters for tool output */
-const DEFAULT_MAX_CHARS = 50_000;
-/** Truncation message appended when output is cut */
-const TRUNCATION_MSG = "\n[Content truncated -- exceeded size limit]";
-/**
- * Regex patterns that indicate potential prompt injection attempts.
- *
- * Imported from @comis/core injection-patterns.ts (single source of truth).
- * Each pattern uses the `gi` flag for case-insensitive global matching.
- *
- * Note: The `system\s*:\s+` pattern requires whitespace after colon
- * to avoid matching URLs like `https://system.example.com:8080`
- * or code like `process.env.system`.
- */
-export const INSTRUCTION_PATTERNS = [
-    IGNORE_PREV_INSTRUCTIONS, // /ignore\s+(all\s+)?previous\s+instructions/gi
-    YOU_ARE_NOW, // /you\s+are\s+now\s+/gi
-    FORGET_EVERYTHING, // /forget\s+(everything|all|your)\s/gi
-    NEW_INSTRUCTIONS, // /new\s+instructions?\s*:/gi
-    SYSTEM_COLON, // /system\s*:\s+/gi
-    SYSTEM_BRACKET, // /\[SYSTEM\]/gi
-    INST_BRACKET, // /\[INST\]/gi
-    SYSTEM_TAG, // /<\/?system>/gi
-    IMPORTANT_OVERRIDE, // /IMPORTANT\s*:\s*override/gi
-    DISREGARD_INSTRUCTIONS, // /disregard ... instructions/
-    ACT_AS_ROLE, // /act as root|admin|.../
-    ASSISTANT_ROLE_MARKER, // /assistant:|user:/
-    SPECIAL_TOKEN_DELIMITERS, // /<|...|>/
-    CONTEXT_RESET, // /context reset|cleared|.../
-    RULE_REPLACEMENT, // /new rules:|updated guidelines:/
-    OVERRIDE_SAFETY, // /override safety|bypass security/
-];
-/**
- * Sanitize tool output against indirect prompt injection.
- *
- * 1. Checks for Unicode tag block bypass characters (for caller-side INFO logging)
- * 2. Replaces instruction-like injection patterns with "[REDACTED]"
- * 3. Truncates output exceeding `maxChars` at the last newline before
- *    the 95% mark, appending a truncation notice
- *
- * @param text - Raw tool output text
- * @param maxChars - Maximum allowed characters (default: 50,000)
- * @param options - Optional callbacks for tag block detection logging
- * @returns Sanitized text with injections redacted and size enforced
- */
-export function sanitizeToolOutput(text, maxChars = DEFAULT_MAX_CHARS, options) {
-    if (text.length === 0)
-        return text;
-    // Check for tag block bypass BEFORE normalization strips them
-    if (containsTagBlockChars(text)) {
-        options?.onTagBlockDetected?.();
-    }
-    // Phase 1: Normalize for pattern matching (NFKC + strip zero-width + tag block)
-    let sanitized = normalizeForMatching(text);
-    // Phase 2: Redact injection patterns (on normalized text)
-    for (const pattern of INSTRUCTION_PATTERNS) {
-        // Reset lastIndex for sticky/global regexes across multiple calls
-        pattern.lastIndex = 0;
-        sanitized = sanitized.replace(pattern, "[REDACTED]");
-    }
-    // Phase 3: Truncate oversized output
-    if (sanitized.length > maxChars) {
-        const cutPoint = Math.floor(maxChars * 0.95);
-        const lastNewline = sanitized.lastIndexOf("\n", cutPoint);
-        if (lastNewline > 0) {
-            sanitized = sanitized.slice(0, lastNewline + 1) + TRUNCATION_MSG;
-        }
-        else {
-            // No newline found -- hard cut at 95%
-            sanitized = sanitized.slice(0, cutPoint) + TRUNCATION_MSG;
-        }
-    }
-    return sanitized;
-}

package/node_modules/@comis/channels/dist/shared/thinking-tag-filter.d.ts

@@ -1,28 +0,0 @@
-/**
- * Thinking tag filter -- strips <think>, <thinking>, and <final> blocks
- * from streaming deltas using a character-level state machine.
- *
- * Handles tags split across chunk boundaries by buffering partial
- * tag sequences and resolving them when more data arrives.
- *
- * @module
- */
-/** Streaming thinking tag filter interface. */
-export interface ThinkingTagFilter {
-    /** Process a streaming delta, returning only visible text. */
-    feed(delta: string): string;
-    /** Flush any buffered partial tag text (call at stream end). */
-    flush(): string;
-    /** Reset state for a new message. */
-    reset(): void;
-}
-/**
- * Create a thinking tag filter that strips thinking blocks from streaming deltas.
- *
- * The filter processes characters one at a time through a state machine:
- * - `passthrough`: Normal text flows through. On `<`, transition to `buffering`.
- * - `buffering`: Accumulating chars after `<` to identify an opening or closing tag.
- * - `inside_block`: All text is suppressed. On `<`, transition to `close_buffering`.
- * - `close_buffering`: Inside a block, checking for the matching closing tag.
- */
-export declare function createThinkingTagFilter(): ThinkingTagFilter;