pygpt-net 2.6.55__py3-none-any.whl → 2.6.56__py3-none-any.whl

pygpt_net/data/js/app/async.js

@@ -0,0 +1,166 @@
+// ==========================================================================
+// Async runner (cooperative yielding for heavy tasks)
+// ==========================================================================
+
+class AsyncRunner {
+
+  // Cooperative scheduler (rAF-based) for CPU-heavy tasks (keeps UI responsive).
+  constructor(cfg, raf) {
+    this.cfg = cfg || {};
+    this.raf = raf || null;
+
+    const A = this.cfg.ASYNC || {};
+    // Base time budget for a slice when the page is visible.
+    this.SLICE_MS = Utils.g('ASYNC_SLICE_MS', A.SLICE_MS ?? 12);
+    // Optional hidden-page tighter budget (yield more aggressively when tab is hidden).
+    this.SLICE_HIDDEN_MS = Utils.g('ASYNC_SLICE_HIDDEN_MS', A.SLICE_HIDDEN_MS ?? Math.min(this.SLICE_MS, 6));
+    // Kept only for config compatibility (no-op in logic).
+    this.MIN_YIELD_MS = Utils.g('ASYNC_MIN_YIELD_MS', A.MIN_YIELD_MS ?? 0);
+
+    // Per-label operation generations (lets us cancel superseded passes cooperatively).
+    this._opGen = new Map(); // label -> number
+  }
+
+  // Returns true if we should yield control (input pending or time budget exceeded).
+  shouldYield(startTs) {
+    // If the browser has pending input, yield immediately.
+    try {
+      const s = navigator && navigator.scheduling;
+      if (s && s.isInputPending && s.isInputPending({ includeContinuous: true })) return true;
+    } catch (_) {}
+
+    const now = Utils.now();
+    const hidden = (typeof document !== 'undefined' && document.visibilityState === 'hidden');
+    const budget = hidden ? this.SLICE_HIDDEN_MS : this.SLICE_MS;
+    return (now - startTs) >= budget;
+  }
+
+  // Yield cooperatively to the next frame (rAF). Falls back to rAF or a minimal timer.
+  async yield() {
+    // Prefer the shared RafManager to avoid extra tasks and to coalesce with the app's rAF pump.
+    if (this.raf && typeof this.raf.nextFrame === 'function') {
+      await this.raf.nextFrame();
+      return;
+    }
+    // Fallback to plain requestAnimationFrame if available.
+    if (typeof requestAnimationFrame === 'function') {
+      await new Promise(res => {
+        try { requestAnimationFrame(() => res()); }
+        catch (_) { setTimeout(res, 16); }
+      });
+      return;
+    }
+    // Final fallback (should not generally happen in QWebEngine).
+    await new Promise(res => setTimeout(res, 16));
+  }
+
+  // Optional: yield to idle. Uses requestIdleCallback if available, falls back to yield().
+  async yieldIdle(timeoutMs = 100) {
+    if (typeof requestIdleCallback === 'function') {
+      await new Promise(res => {
+        try { requestIdleCallback(() => res(), { timeout: timeoutMs }); }
+        catch (_) { res(); }
+      });
+      return;
+    }
+    await this.yield();
+  }
+
+  // Internal: start a new generation for a label; future calls with a higher gen supersede older loops.
+  _beginOp(label) {
+    if (!label) return 0;
+    const g = (this._opGen.get(label) || 0) + 1;
+    this._opGen.set(label, g);
+    return g;
+  }
+
+  // Internal: check if a label/gen pair is still the latest (not superseded).
+  _isLatest(label, gen) {
+    if (!label) return true;
+    return (this._opGen.get(label) === gen);
+  }
+
+  // Cancel all in-flight loops for a given label (cooperative; next yield will abort them).
+  cancel(label) {
+    if (!label) return;
+    const g = (this._opGen.get(label) || 0) + 1;
+    this._opGen.set(label, g);
+  }
+
+  // Process an array in small slices with periodic yields.
+  // Options (4th param OR instead of label):
+  //   { batch=1, release=false, signal, onProgress }:
+  //     - batch: process N items per inner loop before checking shouldYield()
+  //     - release: if true, set arr[i] = undefined after processing (helps GC for very large arrays)
+  //     - signal: AbortSignal to cancel early
+  //     - onProgress: callback({ index, total }) invoked after each processed item (throttled by batch)
+  async forEachChunk(arr, fn, labelOrOpts) {
+    if (!arr || !arr.length) return;
+
+    // Parse args for back-compat: label (string) or options object.
+    let label = (typeof labelOrOpts === 'string') ? labelOrOpts : (labelOrOpts && labelOrOpts.label) || undefined;
+    const opts = (label && typeof labelOrOpts === 'object')
+      ? { ...labelOrOpts, label }
+      : (typeof labelOrOpts === 'object' ? labelOrOpts : {});
+
+    const batch = Math.max(1, opts.batch | 0 || 1);
+    const release = !!opts.release;
+    const signal = opts.signal;
+    const onProgress = (typeof opts.onProgress === 'function') ? opts.onProgress : null;
+
+    const gen = this._beginOp(label);
+    const total = arr.length;
+    let start = Utils.now();
+    let processedInBatch = 0;
+
+    for (let i = 0; i < total; i++) {
+      // Cancellation via AbortSignal or superseded generation (e.g., new render pass started).
+      if ((signal && signal.aborted) || !this._isLatest(label, gen)) break;
+
+      await fn(arr[i], i);
+
+      if (release) {
+        // Clear strong reference to the processed item to help GC on massive arrays.
+        try { arr[i] = undefined; } catch (_) {}
+      }
+
+      processedInBatch++;
+      if (onProgress) {
+        // Call progress hook at most once per item (cheap); caller may throttle if needed.
+        try { onProgress({ index: i + 1, total }); } catch (_) {}
+      }
+
+      if (processedInBatch >= batch || this.shouldYield(start)) {
+        processedInBatch = 0;
+        await this.yield();
+        start = Utils.now();
+      }
+    }
+  }
+
+  // Chunked map with cooperative yielding. Returns a new array of results.
+  // Options same as forEachChunk; accepts AbortSignal/label/batch/release/onProgress.
+  async mapChunked(arr, mapper, labelOrOpts) {
+    if (!arr || !arr.length) return [];
+    const out = new Array(arr.length);
+    let idx = 0;
+    await this.forEachChunk(
+      arr,
+      async (v, i) => { out[i] = await mapper(v, i); idx = i; },
+      labelOrOpts
+    );
+    return out;
+  }
+
+  // Chunked reduce with cooperative yielding.
+  // reducer(acc, value, index) -> acc
+  async reduceChunked(arr, reducer, initial, labelOrOpts) {
+    let acc = initial;
+    await this.forEachChunk(
+      arr,
+      async (v, i) => { acc = await reducer(acc, v, i); },
+      labelOrOpts
+    );
+    return acc;
+  }
+}

pygpt_net/data/js/app/bridge.js

@@ -0,0 +1,88 @@
+// ==========================================================================
+// Bridge manager
+// ==========================================================================
+
+class BridgeManager {
+
+	// Manages the connection to the bridge
+	constructor(cfg, logger) {
+		this.cfg = cfg;
+		this.logger = logger || new Logger(cfg);
+		this.bridge = null;
+		this.connected = false;
+	}
+
+	// Log messages to the bridge
+	log(text) {
+		try {
+			if (this.bridge && this.bridge.log) this.bridge.log(text);
+		} catch (_) {}
+	}
+
+	// Connect to the bridge
+	connect(onChunk, onNode, onNodeReplace, onNodeInput) {
+		if (!this.bridge) return false;
+		if (this.connected) return true;
+		try {
+			if (this.bridge.chunk) this.bridge.chunk.connect((name, chunk, type) => onChunk(name, chunk, type));
+			if (this.bridge.node) this.bridge.node.connect(onNode);
+			if (this.bridge.nodeReplace) this.bridge.nodeReplace.connect(onNodeReplace);
+			if (this.bridge.nodeInput) this.bridge.nodeInput.connect(onNodeInput);
+			this.connected = true;
+			return true;
+		} catch (e) {
+			this.log(e);
+			return false;
+		}
+	}
+
+	// Disconnect from the bridge
+	disconnect() {
+		if (!this.bridge) return false;
+		if (!this.connected) return true;
+		try {
+			if (this.bridge.chunk) this.bridge.chunk.disconnect();
+			if (this.bridge.node) this.bridge.node.disconnect();
+			if (this.bridge.nodeReplace) this.bridge.nodeReplace.disconnect();
+			if (this.bridge.nodeInput) this.bridge.nodeInput.disconnect();
+		} catch (_) {}
+		this.connected = false;
+		return true;
+	}
+
+	// Initialize the QWebChannel
+	initQWebChannel(pid, onReady) {
+		try {
+			new QWebChannel(qt.webChannelTransport, (channel) => {
+				this.bridge = channel.objects.bridge;
+				try {
+					this.logger.bindBridge(this.bridge);
+				} catch (_) {}
+				onReady && onReady(this.bridge);
+				if (this.bridge && this.bridge.js_ready) this.bridge.js_ready(pid);
+			});
+		} catch (e) {
+			/* swallow */
+		}
+	}
+
+	// Copy code to the bridge
+	copyCode(text) {
+		if (this.bridge && this.bridge.copy_text) this.bridge.copy_text(text);
+	}
+
+	// Preview code in the bridge
+	previewCode(text) {
+		if (this.bridge && this.bridge.preview_text) this.bridge.preview_text(text);
+	}
+
+	// Run code in the bridge
+	runCode(text) {
+		if (this.bridge && this.bridge.run_text) this.bridge.run_text(text);
+	}
+
+	// Update the scroll position in the bridge
+	updateScrollPosition(pos) {
+		if (this.bridge && this.bridge.update_scroll_position) this.bridge.update_scroll_position(pos);
+	}
+}

pygpt_net/data/js/app/common.js

@@ -0,0 +1,212 @@
+// ==========================================================================
+// Loading indicator
+// ==========================================================================
+
+class Loading {
+
+	// Loading indicator spinner
+	constructor(dom) {
+		this.dom = dom;
+	}
+
+	// Show loader element (and hide tips if visible).
+	show() {
+		if (typeof window.hideTips === 'function') {
+			window.hideTips();
+		}
+		const el = this.dom.get('_loader_');
+		if (!el) return;
+		if (el.classList.contains('hidden')) el.classList.remove('hidden');
+		el.classList.add('visible');
+	}
+
+	// Hide loader element.
+	hide() {
+		const el = this.dom.get('_loader_');
+		if (!el) return;
+		if (el.classList.contains('visible')) el.classList.remove('visible');
+		el.classList.add('hidden');
+	}
+}
+
+// ==========================================================================
+// Tips manager
+// ==========================================================================
+
+class TipsManager {
+
+	// Lightweight tips rotator that works with your CSS (.tips/.visible)
+	// and is backward-compatible with legacy `let tips = [...]` injection.
+	constructor(dom) {
+		this.dom = dom;
+		this.hidden = false;
+		this._timers = [];
+		this._running = false;
+		this._idx = 0;
+	}
+
+	// Resolve tips list from multiple legacy/new sources.
+	_getList() {
+		// New preferred: window.TIPS (array)
+		const upper = (typeof window !== 'undefined') ? window.TIPS : undefined;
+		if (Array.isArray(upper) && upper.length) return upper;
+
+		// Legacy inline: window.tips (array or JSON string)
+		const lower = (typeof window !== 'undefined') ? window.tips : undefined;
+		if (Array.isArray(lower) && lower.length) return lower;
+		if (typeof lower === 'string' && lower.trim().length) {
+			try {
+				const arr = JSON.parse(lower);
+				if (Array.isArray(arr)) return arr;
+			} catch (_) {}
+		}
+
+		// Optional: data-tips='["...","..."]' on #tips
+		const host = this._host();
+		if (host && host.dataset && typeof host.dataset.tips === 'string') {
+			try {
+				const arr = JSON.parse(host.dataset.tips);
+				if (Array.isArray(arr)) return arr;
+			} catch (_) {}
+		}
+
+		return [];
+	}
+
+	// Get the tips container element.
+	_host() {
+		return this.dom.get('tips') || document.getElementById('tips');
+	}
+
+	// Clear all timers.
+	_clearTimers() {
+		for (const t of this._timers) {
+			try {
+				clearTimeout(t);
+			} catch (_) {}
+		}
+		this._timers.length = 0;
+	}
+
+	// Stop any running rotation timers.
+	stopTimers() {
+		this._clearTimers();
+		this._running = false;
+	}
+
+	// Apply base styles to the tips container.
+	_applyBaseStyle(el) {
+		if (!el) return;
+		// Keep your flex layout and sizing; do not overwrite width/height.
+		// Ensure it renders above other layers.
+		const z = (typeof window !== 'undefined' && typeof window.TIPS_ZINDEX !== 'undefined') ?
+			String(window.TIPS_ZINDEX) : '2147483000';
+		el.style.zIndex = z;
+	}
+
+	// Hide tips layer and stop rotation.
+	hide() {
+		if (this.hidden) return;
+		this.stopTimers();
+		const el = this._host();
+		if (el) {
+			// Remove visibility class and hide hard (used when stream starts etc.)
+			el.classList.remove('visible');
+			el.classList.remove('hidden'); // in case it was set elsewhere
+			el.style.display = 'none';
+		}
+		this.hidden = true;
+	}
+
+	// Show tips layer (does not start rotation).
+	show() {
+		const list = this._getList();
+		if (!list.length) return;
+		const el = this._host();
+		if (!el) return;
+
+		this.hidden = false;
+		this._applyBaseStyle(el);
+		el.classList.remove('hidden');
+		el.style.display = 'block'; // CSS handles opacity via .tips/.visible
+		// Do not add 'visible' yet – cycle() takes care of fade-in steps.
+	}
+
+	// Show one tip (by index) and fade it in next frame.
+	_showOne(idx) {
+		const list = this._getList();
+		if (!list.length) return;
+		const el = this._host();
+		if (!el || this.hidden) return;
+
+		this._applyBaseStyle(el);
+		el.innerHTML = list[idx % list.length];
+
+		// Centralize "next-frame" visibility toggle through RafManager to guarantee CSS transition.
+		try {
+			if (typeof runtime !== 'undefined' && runtime.raf && typeof runtime.raf.schedule === 'function') {
+				const key = {
+					t: 'Tips:show',
+					el,
+					i: Math.random()
+				};
+				runtime.raf.schedule(key, () => {
+					if (this.hidden || !el.isConnected) return;
+					el.classList.add('visible');
+				}, 'Tips', 2);
+			} else {
+				// Fallback: no frame delay – still functional, transition may not play.
+				el.classList.add('visible');
+			}
+		} catch (_) {
+			el.classList.add('visible');
+		}
+	}
+
+	// Internal loop: show, wait, hide, wait fade, next.
+	_cycleLoop() {
+		if (this.hidden) return;
+		const el = this._host();
+		if (!el) return;
+
+		const VISIBLE_MS = (typeof window !== 'undefined' && window.TIPS_VISIBLE_MS) ? window.TIPS_VISIBLE_MS : 15000;
+		const FADE_MS = (typeof window !== 'undefined' && window.TIPS_FADE_MS) ? window.TIPS_FADE_MS : 1000;
+
+		this._showOne(this._idx);
+
+		// Sequence: visible -> wait -> remove 'visible' -> wait fade -> next
+		this._timers.push(setTimeout(() => {
+			if (this.hidden) return;
+			el.classList.remove('visible');
+			this._timers.push(setTimeout(() => {
+				if (this.hidden) return;
+				const list = this._getList();
+				if (!list.length) return;
+				this._idx = (this._idx + 1) % list.length;
+				this._cycleLoop();
+			}, FADE_MS));
+		}, VISIBLE_MS));
+	}
+
+	// Start rotation with initial delay.
+	cycle() {
+		const list = this._getList();
+		if (!list.length || this._running) return;
+		this._running = true;
+		this._idx = 0;
+		this.show(); // make sure the host is visible and centered
+
+		const INIT_DELAY = (typeof window !== 'undefined' && window.TIPS_INIT_DELAY_MS) ? window.TIPS_INIT_DELAY_MS : 10000;
+		this._timers.push(setTimeout(() => {
+			if (this.hidden) return;
+			this._cycleLoop();
+		}, Math.max(0, INIT_DELAY)));
+	}
+
+	// Stop and reset.
+	cleanup() {
+		this.stopTimers();
+		const el = this._host();
+		if (el) el.classList.remove('visible');
+	}
+}

pygpt_net/data/js/app/config.js

@@ -0,0 +1,223 @@
+// ==========================================================================
+// Config
+// ==========================================================================
+
+class Config {
+	
+	constructor() {
+		// Process identifier (passed from host).
+		this.PID = Utils.g('PID', 0);
+
+		// UI: scroll behavior and busy/zoom signalling thresholds (milliseconds / pixels).
+		this.UI = {
+			AUTO_FOLLOW_REENABLE_PX: Utils.g('AUTO_FOLLOW_REENABLE_PX', 8),
+			SCROLL_NEAR_MARGIN_PX: Utils.g('SCROLL_NEAR_MARGIN_PX', 450),
+			INTERACTION_BUSY_MS: Utils.g('UI_INTERACTION_BUSY_MS', 140),
+			ZOOM_BUSY_MS: Utils.g('UI_ZOOM_BUSY_MS', 300)
+		};
+
+		// FAB (floating action button) visibility and debounce.
+		this.FAB = {
+			SHOW_DOWN_THRESHOLD_PX: Utils.g('SHOW_DOWN_THRESHOLD_PX', 0),
+			TOGGLE_DEBOUNCE_MS: Utils.g('FAB_TOGGLE_DEBOUNCE_MS', 100)
+		};
+
+		// Highlighting controls and per-frame budget.
+		this.HL = {
+			PER_FRAME: Utils.g('HL_PER_FRAME', 2),
+			DISABLE_ALL: Utils.g('DISABLE_SYNTAX_HIGHLIGHT', false)
+		};
+
+		// Intersection-like margins (we do our own scan, but these guide budgets).
+		this.OBSERVER = {
+			CODE_ROOT_MARGIN: Utils.g('CODE_ROOT_MARGIN', '1000px 0px 1000px 0px'),
+			BOX_ROOT_MARGIN: Utils.g('BOX_ROOT_MARGIN', '1500px 0px 1500px 0px'),
+			CODE_THRESHOLD: [0, 0.001],
+			BOX_THRESHOLD: 0
+		};
+
+		// Viewport scan preload distance (in pixels).
+		this.SCAN = {
+			PRELOAD_PX: Utils.g('SCAN_PRELOAD_PX', 1000)
+		};
+
+		// Code scroll behavior (auto-follow re-enable margin and near-bottom margin).
+		this.CODE_SCROLL = {
+			AUTO_FOLLOW_REENABLE_PX: Utils.g('CODE_AUTO_FOLLOW_REENABLE_PX', 8),
+			NEAR_MARGIN_PX: Utils.g('CODE_SCROLL_NEAR_MARGIN_PX', 48)
+		};
+
+		// Stream (snapshot) budgets and queue limits.
+		this.STREAM = {
+			MAX_PER_FRAME: Utils.g('STREAM_MAX_PER_FRAME', 8),
+			EMERGENCY_COALESCE_LEN: Utils.g('STREAM_EMERGENCY_COALESCE_LEN', 300),
+			COALESCE_MODE: Utils.g('STREAM_COALESCE_MODE', 'fixed'),
+			SNAPSHOT_MAX_STEP: Utils.g('STREAM_SNAPSHOT_MAX_STEP', 8000),
+			QUEUE_MAX_ITEMS: Utils.g('STREAM_QUEUE_MAX_ITEMS', 1200),
+			PRESERVE_CODES_MAX: Utils.g('STREAM_PRESERVE_CODES_MAX', 120),
+
+			// switch to plain text after this many lines without markdown tokens
+			PLAIN_ACTIVATE_AFTER_LINES: Utils.g('STREAM_PLAIN_ACTIVATE_AFTER_LINES', 80),
+		};
+
+		// Math (KaTeX) idle batching and per-batch hint.
+		this.MATH = {
+			IDLE_TIMEOUT_MS: Utils.g('MATH_IDLE_TIMEOUT_MS', 800),
+			BATCH_HINT: Utils.g('MATH_BATCH_HINT', 24)
+		};
+
+		// Icon URLs (provided by host app).
+		this.ICONS = {
+			EXPAND: Utils.g('ICON_EXPAND', ''),
+			COLLAPSE: Utils.g('ICON_COLLAPSE', ''),
+			CODE_MENU: Utils.g('ICON_CODE_MENU', ''),
+			CODE_COPY: Utils.g('ICON_CODE_COPY', ''),
+			CODE_RUN: Utils.g('ICON_CODE_RUN', ''),
+			CODE_PREVIEW: Utils.g('ICON_CODE_PREVIEW', '')
+		};
+
+		// Localized UI strings.
+		this.LOCALE = {
+			PREVIEW: Utils.g('LOCALE_PREVIEW', 'Preview'),
+			RUN: Utils.g('LOCALE_RUN', 'Run'),
+			COLLAPSE: Utils.g('LOCALE_COLLAPSE', 'Collapse'),
+			EXPAND: Utils.g('LOCALE_EXPAND', 'Expand'),
+			COPY: Utils.g('LOCALE_COPY', 'Copy'),
+			COPIED: Utils.g('LOCALE_COPIED', 'Copied')
+		};
+
+		// Code block styling theme (hljs theme key or custom).
+		this.CODE_STYLE = Utils.g('CODE_SYNTAX_STYLE', 'default');
+
+		// Adaptive snapshot profile for plain text.
+		this.PROFILE_TEXT = {
+			base: Utils.g('PROFILE_TEXT_BASE', 4),
+			growth: Utils.g('PROFILE_TEXT_GROWTH', 1.28),
+			minInterval: Utils.g('PROFILE_TEXT_MIN_INTERVAL', 4),
+			softLatency: Utils.g('PROFILE_TEXT_SOFT_LATENCY', 60),
+			adaptiveStep: Utils.g('PROFILE_TEXT_ADAPTIVE_STEP', false)
+		};
+
+		// Adaptive snapshot profile for code (line-aware).
+		this.PROFILE_CODE = {
+			base: 2048,
+			growth: 2.6,
+			minInterval: 500,
+			softLatency: 1200,
+			minLinesForHL: Utils.g('PROFILE_CODE_HL_N_LINE', 25),
+			minCharsForHL: Utils.g('PROFILE_CODE_HL_N_CHARS', 5000),
+			promoteMinInterval: 300,
+			promoteMaxLatency: 800,
+			promoteMinLines: Utils.g('PROFILE_CODE_HL_N_LINE', 25),
+			adaptiveStep: Utils.g('PROFILE_CODE_ADAPTIVE_STEP', false),
+			stopAfterLines: Utils.g('PROFILE_CODE_STOP_HL_AFTER_LINES', 300),
+			streamPlainAfterLines: 0,
+			streamPlainAfterChars: 0,
+			maxFrozenChars: 32000, // max chars to freeze DOM nodes in .hl-freeze
+			finalHighlightMaxLines: Utils.g('PROFILE_CODE_FINAL_HL_MAX_LINES', 1500),
+			finalHighlightMaxChars: Utils.g('PROFILE_CODE_FINAL_HL_MAX_CHARS', 350000)
+		};
+
+		// Debounce for heavy resets (ms).
+		this.RESET = {
+			HEAVY_DEBOUNCE_MS: Utils.g('RESET_HEAVY_DEBOUNCE_MS', 24)
+		};
+
+		// Logging caps (used by Logger).
+		this.LOG = {
+			MAX_QUEUE: Utils.g('LOG_MAX_QUEUE', 400),
+			MAX_BYTES: Utils.g('LOG_MAX_BYTES', 256 * 1024),
+			BATCH_MAX: Utils.g('LOG_BATCH_MAX', 64),
+			RATE_LIMIT_PER_SEC: Utils.g('LOG_RATE_LIMIT_PER_SEC', 0)
+		};
+
+		// Async tuning for background work.
+		this.ASYNC = {
+			SLICE_MS: Utils.g('ASYNC_SLICE_MS', 12),
+			MIN_YIELD_MS: Utils.g('ASYNC_MIN_YIELD_MS', 0),
+			MD_NODES_PER_SLICE: Utils.g('ASYNC_MD_NODES_PER_SLICE', 12)
+		};
+
+		// RAF pump tuning (budget per frame).
+		this.RAF = {
+			FLUSH_BUDGET_MS: Utils.g('RAF_FLUSH_BUDGET_MS', 7),
+			MAX_TASKS_PER_FLUSH: Utils.g('RAF_MAX_TASKS_PER_FLUSH', 120)
+		};
+
+		// Markdown tuning – allow/disallow indented code blocks.
+		this.MD = {
+			ALLOW_INDENTED_CODE: Utils.g('MD_ALLOW_INDENTED_CODE', false)
+		};
+
+		// Custom markup rules for simple tags in text.
+		// NOTE: added nl2br + allowBr for think rules; rest unchanged.
+		this.CUSTOM_MARKUP_RULES = Utils.g('CUSTOM_MARKUP_RULES', [{
+				name: 'cmd',
+				open: '[!cmd]',
+				close: '[/!cmd]',
+				tag: 'div',
+				className: 'cmd',
+				innerMode: 'text'
+			},
+
+			// Think (Markdown-style) – convert newlines to <br>, allow real <br> tokens; safe-escape everything else.
+			{
+				name: 'think_md',
+				open: '[!think]',
+				close: '[/!think]',
+				tag: 'think',
+				className: '',
+				innerMode: 'text',
+				nl2br: true,
+				allowBr: true
+			},
+
+			// Think (HTML-style, streaming-friendly)
+			{
+				name: 'think_html',
+				open: '<think>',
+				close: '</think>',
+				tag: 'think',
+				className: '',
+				innerMode: 'text',
+				stream: true,
+				nl2br: true,
+				allowBr: true
+			},
+
+			{
+				name: 'tool',
+				open: '<tool>',
+				close: '</tool>',
+				tag: 'div',
+				className: 'cmd',
+				innerMode: 'text',
+				stream: true
+			},
+
+			// Streams+final: convert [!exec]... into fenced python code BEFORE markdown-it
+			{
+				name: 'exec_md',
+				open: '[!exec]',
+				close: '[/!exec]',
+				innerMode: 'text',
+				stream: true,
+				openReplace: '```python\n',
+				closeReplace: '\n```',
+				phase: 'source'
+			},
+
+			// Streams+final: convert <execute>...</execute> into fenced python code BEFORE markdown-it
+			{
+				name: 'exec_html',
+				open: '<execute>',
+				close: '</execute>',
+				innerMode: 'text',
+				stream: true,
+				openReplace: '```python\n',
+				closeReplace: '\n```',
+				phase: 'source'
+			}
+		]);
+	}
+}