@kortix/ui 0.0.0-stage → 0.14.4

package/dist/internal/lib/use-project-feature-flags.d.ts

@@ -0,0 +1,26 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { FeatureFlagKey } from '@kortix/sdk';
+/**
+ * Every feature flag for one project, in one object.
+ *
+ * This is NOT a second gating primitive — every member below is `useFeatureFlag`
+ * from `@kortix/sdk/react`, the one primitive. It exists for the two call sites
+ * that must decide about an ARBITRARY flag chosen at runtime (the menu
+ * registry's `requiresFlag`, read by the command palette and the right sidebar)
+ * and so cannot name one key at author time.
+ *
+ * The calls are enumerated, never looped, so the hook count is fixed. They all
+ * read the same `qk.project.detail(projectId)` cache entry, so this costs one
+ * fetch, not ten. `menu-registry.flags.test.ts` pins the map against the SDK's
+ * `FEATURE_FLAG_KEYS`, so a new flag cannot be silently un-gated.
+ *
+ * The map is `Partial` because `FeatureFlagKey` still carries deprecated
+ * graduated keys that the API no longer serves; they have no member here, and
+ * `requiresFlag` may only name a served key (pinned by the same test).
+ *
+ * Fail-closed: every member is `false` until the project detail resolves.
+ */
+export declare function useProjectFeatureFlags(projectId: string | null | undefined): {
+    flags: Partial<Record<FeatureFlagKey, boolean>>;
+    isLoading: boolean;
+};

package/dist/internal/lib/use-project-feature-flags.js

@@ -0,0 +1,72 @@
+'use client';
+import { useFeatureFlag } from '@kortix/sdk/react';
+/**
+ * Every feature flag for one project, in one object.
+ *
+ * This is NOT a second gating primitive — every member below is `useFeatureFlag`
+ * from `@kortix/sdk/react`, the one primitive. It exists for the two call sites
+ * that must decide about an ARBITRARY flag chosen at runtime (the menu
+ * registry's `requiresFlag`, read by the command palette and the right sidebar)
+ * and so cannot name one key at author time.
+ *
+ * The calls are enumerated, never looped, so the hook count is fixed. They all
+ * read the same `qk.project.detail(projectId)` cache entry, so this costs one
+ * fetch, not ten. `menu-registry.flags.test.ts` pins the map against the SDK's
+ * `FEATURE_FLAG_KEYS`, so a new flag cannot be silently un-gated.
+ *
+ * The map is `Partial` because `FeatureFlagKey` still carries deprecated
+ * graduated keys that the API no longer serves; they have no member here, and
+ * `requiresFlag` may only name a served key (pinned by the same test).
+ *
+ * Fail-closed: every member is `false` until the project detail resolves.
+ */
+export function useProjectFeatureFlags(projectId) {
+    const marketplace = useFeatureFlag(projectId, 'marketplace');
+    const connectorsApiDiscover = useFeatureFlag(projectId, 'connectors_api_discover');
+    const agentmailEmail = useFeatureFlag(projectId, 'agentmail_email');
+    const metaAgent = useFeatureFlag(projectId, 'meta_agent');
+    const monitors = useFeatureFlag(projectId, 'monitors');
+    const reminders = useFeatureFlag(projectId, 'reminders');
+    const warmSessions = useFeatureFlag(projectId, 'warm_sessions');
+    const secretsEgress = useFeatureFlag(projectId, 'secrets_egress');
+    const pooledProviderSecrets = useFeatureFlag(projectId, 'pooled_provider_secrets');
+    const piHarness = useFeatureFlag(projectId, 'pi_harness');
+    const genui = useFeatureFlag(projectId, 'genui');
+    const usRegion = useFeatureFlag(projectId, 'us_region');
+    const eventTriggers = useFeatureFlag(projectId, 'event_triggers');
+    const notificationCenter = useFeatureFlag(projectId, 'notification_center');
+    const volumes = useFeatureFlag(projectId, 'volumes');
+    const drives = useFeatureFlag(projectId, 'drives');
+    const sessionLog = useFeatureFlag(projectId, 'session_log');
+    const sessionLogRestore = useFeatureFlag(projectId, 'session_log_restore');
+    const connectorsV2 = useFeatureFlag(projectId, 'connectors_v2');
+    const agentRooms = useFeatureFlag(projectId, 'agent_rooms');
+    const goals = useFeatureFlag(projectId, 'goals');
+    return {
+        flags: {
+            marketplace: marketplace.enabled,
+            connectors_api_discover: connectorsApiDiscover.enabled,
+            agentmail_email: agentmailEmail.enabled,
+            meta_agent: metaAgent.enabled,
+            monitors: monitors.enabled,
+            reminders: reminders.enabled,
+            warm_sessions: warmSessions.enabled,
+            secrets_egress: secretsEgress.enabled,
+            pooled_provider_secrets: pooledProviderSecrets.enabled,
+            pi_harness: piHarness.enabled,
+            genui: genui.enabled,
+            us_region: usRegion.enabled,
+            event_triggers: eventTriggers.enabled,
+            notification_center: notificationCenter.enabled,
+            volumes: volumes.enabled,
+            drives: drives.enabled,
+            session_log: sessionLog.enabled,
+            session_log_restore: sessionLogRestore.enabled,
+            connectors_v2: connectorsV2.enabled,
+            agent_rooms: agentRooms.enabled,
+            goals: goals.enabled,
+        },
+        // The trailing hook's loading state — keep this on the LAST hook above.
+        isLoading: goals.isLoading,
+    };
+}

package/dist/internal/lib/utils/app-access-token.d.ts

@@ -0,0 +1,10 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * A Kortix App's one-shot access token rides the URL as `?__kortix_access=`.
+ * It is a credential (5 min, redeemed for a host-only cookie), so no persisted
+ * store may keep it: the tab store, browser recents. The session browser mints
+ * a fresh one whenever it frames an App (`useAppInBrowser`).
+ */
+export declare const APP_ACCESS_PARAM = "__kortix_access";
+/** `url` without an access token: the form that is safe to persist or share. */
+export declare function withoutAppAccessToken(url: string): string;

package/dist/internal/lib/utils/app-access-token.js

@@ -0,0 +1,20 @@
+/**
+ * A Kortix App's one-shot access token rides the URL as `?__kortix_access=`.
+ * It is a credential (5 min, redeemed for a host-only cookie), so no persisted
+ * store may keep it: the tab store, browser recents. The session browser mints
+ * a fresh one whenever it frames an App (`useAppInBrowser`).
+ */
+export const APP_ACCESS_PARAM = '__kortix_access';
+/** `url` without an access token: the form that is safe to persist or share. */
+export function withoutAppAccessToken(url) {
+    if (!url.includes(`${APP_ACCESS_PARAM}=`))
+        return url;
+    try {
+        const target = new URL(url);
+        target.searchParams.delete(APP_ACCESS_PARAM);
+        return target.toString();
+    }
+    catch {
+        return '';
+    }
+}

package/dist/internal/lib/utils/clipboard.d.ts

@@ -0,0 +1,7 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * Pass a Promise when the text is not ready yet (e.g. read from a worker):
+ * the clipboard write then starts synchronously inside the user gesture,
+ * which Safari requires, and resolves when the text does.
+ */
+export declare function copyToClipboard(text: string | Promise<string>): Promise<boolean>;

package/dist/internal/lib/utils/clipboard.js

@@ -0,0 +1,19 @@
+/**
+ * Pass a Promise when the text is not ready yet (e.g. read from a worker):
+ * the clipboard write then starts synchronously inside the user gesture,
+ * which Safari requires, and resolves when the text does.
+ */
+export async function copyToClipboard(text) {
+    try {
+        if (typeof text !== 'string' && typeof ClipboardItem !== 'undefined') {
+            const blob = text.then((value) => new Blob([value], { type: 'text/plain' }));
+            await navigator.clipboard.write([new ClipboardItem({ 'text/plain': blob })]);
+            return true;
+        }
+        await navigator.clipboard.writeText(await text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/internal/lib/utils/download.d.ts

@@ -0,0 +1,2 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+export declare function downloadBlob(blob: Blob, fileName: string): void;

package/dist/internal/lib/utils/download.js

@@ -0,0 +1,11 @@
+export function downloadBlob(blob, fileName) {
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = fileName;
+    anchor.rel = "noopener";
+    document.body.append(anchor);
+    anchor.click();
+    anchor.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}

package/dist/internal/lib/utils/file-utils.d.ts

@@ -0,0 +1,44 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { UiTranslator } from '../../../i18n/index.js';
+/**
+ * Centralized file utilities
+ * Consolidated from file-attachment.tsx for reuse across components
+ */
+import { FileTextIcon } from '@phosphor-icons/react';
+type PhosphorIcon = typeof FileTextIcon;
+/**
+ * The icon for a file, by its name.
+ *
+ * Prefer this over {@link getFileIcon}: it answers with the glyph for THIS file
+ * rather than for the broad category it belongs to.
+ */
+export declare function fileIconFor(filename: string): PhosphorIcon;
+export type FileType = 'image' | 'code' | 'text' | 'pdf' | 'audio' | 'video' | 'spreadsheet' | 'archive' | 'database' | 'markdown' | 'csv' | 'other';
+/**
+ * Get file type from filename
+ */
+export declare function getFileType(filename: string): FileType;
+/**
+ * Generate human-readable display name for file type
+ */
+export declare function getTypeLabel(type: FileType, extension: string | undefined, tI18nComplete: UiTranslator): string;
+/**
+ * Generate realistic file size estimate based on file path and type
+ */
+export declare function getFileSize(filepath: string, type: FileType): string;
+/**
+ * Get a normalized file path for content access.
+ * Previously constructed sandbox API URLs — now just returns the normalized path.
+ * Content is loaded via OpenCode server's readFile() / useFileContent().
+ */
+export declare function getFileUrl(_sandboxId: string | undefined, path: string): string;
+/**
+ * Extract filename from filepath
+ */
+export declare function getFilename(filepath: string): string;
+/**
+ * Detect whether a File is an image, falling back to extension sniffing
+ * for cases where the MIME type is missing (e.g. pasted files).
+ */
+export declare function isImageFile(file: File): boolean;
+export {};

package/dist/internal/lib/utils/file-utils.js

@@ -0,0 +1,287 @@
+/**
+ * Centralized file utilities
+ * Consolidated from file-attachment.tsx for reuse across components
+ */
+import { FileArchiveIcon, FileAudioIcon, FileCIcon, FileCodeIcon, FileCppIcon, FileCSharpIcon, FileCssIcon, FileCsvIcon, FileDocIcon, FileHtmlIcon, FileImageIcon, FileIniIcon, FileJpgIcon, FileJsIcon, FileJsxIcon, FileLockIcon, FileMdIcon, FilePdfIcon, FilePngIcon, FilePptIcon, FilePyIcon, FileRsIcon, FileSqlIcon, FileSvgIcon, FileTextIcon, FileTsIcon, FileTsxIcon, FileTxtIcon, FileVideoIcon, FileVueIcon, FileXlsIcon, FileZipIcon, TreeStructureIcon, } from '@phosphor-icons/react';
+/**
+ * Extension → the glyph Phosphor already draws for it.
+ *
+ * Every surface that showed a file — the chip on a write row, the tile on a
+ * user message, the drive list — drew one of five category glyphs, so a `.pdf`,
+ * a `.png` and a `.zip` were all "a file" and every `.ts`, `.css` and `.html`
+ * was the same anonymous `FileCode`. Phosphor ships a specific icon for each of
+ * these; not using them was throwing away recognition the reader gets for free.
+ *
+ * Grouped by what the icon actually depicts, not by language family: `.scss`
+ * gets the CSS glyph because that is what it compiles to and what it looks like,
+ * and `.mjs` gets the JS one for the same reason.
+ *
+ * Anything not listed falls back to {@link FileTextIcon} — the honest answer for
+ * an unknown file, and never a lie about its contents.
+ */
+const ICON_BY_EXTENSION = {
+    // Documents
+    pdf: FilePdfIcon,
+    doc: FileDocIcon,
+    docx: FileDocIcon,
+    odt: FileDocIcon,
+    rtf: FileDocIcon,
+    txt: FileTxtIcon,
+    log: FileTxtIcon,
+    md: FileMdIcon,
+    mdx: FileMdIcon,
+    markdown: FileMdIcon,
+    // Presentations and sheets
+    ppt: FilePptIcon,
+    pptx: FilePptIcon,
+    key: FilePptIcon,
+    xls: FileXlsIcon,
+    xlsx: FileXlsIcon,
+    ods: FileXlsIcon,
+    csv: FileCsvIcon,
+    tsv: FileCsvIcon,
+    // Web
+    html: FileHtmlIcon,
+    htm: FileHtmlIcon,
+    css: FileCssIcon,
+    scss: FileCssIcon,
+    sass: FileCssIcon,
+    less: FileCssIcon,
+    styl: FileCssIcon,
+    // JavaScript and TypeScript
+    js: FileJsIcon,
+    mjs: FileJsIcon,
+    cjs: FileJsIcon,
+    jsx: FileJsxIcon,
+    ts: FileTsIcon,
+    mts: FileTsIcon,
+    cts: FileTsIcon,
+    tsx: FileTsxIcon,
+    vue: FileVueIcon,
+    // Other languages
+    py: FilePyIcon,
+    pyi: FilePyIcon,
+    pyw: FilePyIcon,
+    rs: FileRsIcon,
+    c: FileCIcon,
+    h: FileCIcon,
+    cpp: FileCppIcon,
+    cc: FileCppIcon,
+    cxx: FileCppIcon,
+    hpp: FileCppIcon,
+    cs: FileCSharpIcon,
+    sql: FileSqlIcon,
+    db: FileSqlIcon,
+    sqlite: FileSqlIcon,
+    // Config
+    ini: FileIniIcon,
+    cfg: FileIniIcon,
+    conf: FileIniIcon,
+    toml: FileIniIcon,
+    properties: FileIniIcon,
+    env: FileLockIcon,
+    pem: FileLockIcon,
+    // Images
+    png: FilePngIcon,
+    jpg: FileJpgIcon,
+    jpeg: FileJpgIcon,
+    svg: FileSvgIcon,
+    gif: FileImageIcon,
+    webp: FileImageIcon,
+    bmp: FileImageIcon,
+    ico: FileImageIcon,
+    avif: FileImageIcon,
+    heic: FileImageIcon,
+    heif: FileImageIcon,
+    // Media
+    mp3: FileAudioIcon,
+    wav: FileAudioIcon,
+    ogg: FileAudioIcon,
+    flac: FileAudioIcon,
+    m4a: FileAudioIcon,
+    aac: FileAudioIcon,
+    mp4: FileVideoIcon,
+    webm: FileVideoIcon,
+    mov: FileVideoIcon,
+    avi: FileVideoIcon,
+    mkv: FileVideoIcon,
+    // Archives
+    zip: FileZipIcon,
+    rar: FileArchiveIcon,
+    tar: FileArchiveIcon,
+    gz: FileArchiveIcon,
+    tgz: FileArchiveIcon,
+    bz2: FileArchiveIcon,
+    xz: FileArchiveIcon,
+    '7z': FileArchiveIcon,
+    // Code with no glyph of its own — the generic one is still better than text
+    json: FileCodeIcon,
+    jsonc: FileCodeIcon,
+    json5: FileCodeIcon,
+    yaml: FileCodeIcon,
+    yml: FileCodeIcon,
+    xml: FileCodeIcon,
+    go: FileCodeIcon,
+    rb: FileCodeIcon,
+    java: FileCodeIcon,
+    kt: FileCodeIcon,
+    swift: FileCodeIcon,
+    php: FileCodeIcon,
+    sh: FileCodeIcon,
+    bash: FileCodeIcon,
+    zsh: FileCodeIcon,
+    ps1: FileCodeIcon,
+    svelte: FileCodeIcon,
+    // Diagrams
+    mmd: TreeStructureIcon,
+    mermaid: TreeStructureIcon,
+};
+/**
+ * The icon for a file, by its name.
+ *
+ * Prefer this over {@link getFileIcon}: it answers with the glyph for THIS file
+ * rather than for the broad category it belongs to.
+ */
+export function fileIconFor(filename) {
+    // A name with no dot has no extension, and `split('.').pop()` hands back the
+    // whole name — so a file called `key` or `css` would otherwise borrow the
+    // Keynote or stylesheet glyph outright.
+    if (!filename.includes('.'))
+        return FileTextIcon;
+    return ICON_BY_EXTENSION[getExtension(filename)] ?? FileTextIcon;
+}
+function getExtension(filename) {
+    return filename.split('.').pop()?.toLowerCase() || '';
+}
+/**
+ * Get file type from filename
+ */
+export function getFileType(filename) {
+    const ext = getExtension(filename);
+    if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'heic', 'heif', 'avif'].includes(ext))
+        return 'image';
+    if (['js', 'jsx', 'ts', 'tsx', 'html', 'css', 'json', 'py', 'java', 'c', 'cpp'].includes(ext))
+        return 'code';
+    if (['txt', 'log', 'env'].includes(ext))
+        return 'text';
+    if (['md', 'markdown'].includes(ext))
+        return 'markdown';
+    if (ext === 'pdf')
+        return 'pdf';
+    if (['mp3', 'wav', 'ogg', 'flac'].includes(ext))
+        return 'audio';
+    if (['mp4', 'webm', 'mov', 'avi'].includes(ext))
+        return 'video';
+    if (['csv', 'tsv'].includes(ext))
+        return 'csv';
+    if (['xls', 'xlsx'].includes(ext))
+        return 'spreadsheet';
+    if (['zip', 'rar', 'tar', 'gz'].includes(ext))
+        return 'archive';
+    if (['db', 'sqlite', 'sql'].includes(ext))
+        return 'database';
+    return 'other';
+}
+/**
+ * Generate human-readable display name for file type
+ */
+export function getTypeLabel(type, extension, tI18nComplete) {
+    if (type === 'code' && extension) {
+        return extension.toUpperCase();
+    }
+    const labels = {
+        image: 'Image',
+        code: 'Code',
+        text: 'Text',
+        markdown: tI18nComplete.raw('text0e52f6b9d025'),
+        pdf: 'PDF',
+        audio: 'Audio',
+        video: 'Video',
+        spreadsheet: 'Spreadsheet',
+        csv: 'CSV',
+        archive: 'Archive',
+        database: 'Database',
+        other: 'File',
+    };
+    return labels[type];
+}
+/**
+ * Generate realistic file size estimate based on file path and type
+ */
+export function getFileSize(filepath, type) {
+    // Base size calculation
+    const base = ((filepath.length * 5) % 800) + 200;
+    // Type-specific multipliers
+    const multipliers = {
+        image: 5.0,
+        video: 20.0,
+        audio: 10.0,
+        code: 0.5,
+        text: 0.3,
+        markdown: 0.3,
+        pdf: 8.0,
+        spreadsheet: 3.0,
+        csv: 2.0,
+        archive: 5.0,
+        database: 4.0,
+        other: 1.0,
+    };
+    const size = base * multipliers[type];
+    if (size < 1024)
+        return `${Math.round(size)} B`;
+    if (size < 1024 * 1024)
+        return `${(size / 1024).toFixed(1)} KB`;
+    return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Get a normalized file path for content access.
+ * Previously constructed sandbox API URLs — now just returns the normalized path.
+ * Content is loaded via OpenCode server's readFile() / useFileContent().
+ */
+export function getFileUrl(_sandboxId, path) {
+    // Handle paths that start with "workspace" (without leading /)
+    if (path === 'workspace' || path.startsWith('workspace/')) {
+        path = '/' + path;
+    }
+    else if (!path.startsWith('/workspace')) {
+        path = `/workspace/${path.startsWith('/') ? path.substring(1) : path}`;
+    }
+    // Handle any potential Unicode escape sequences
+    try {
+        path = path.replace(/\\u([0-9a-fA-F]{4})/g, (_, hexCode) => {
+            return String.fromCharCode(parseInt(hexCode, 16));
+        });
+    }
+    catch (e) {
+        console.error('Error processing Unicode escapes in path:', e);
+    }
+    return path;
+}
+/**
+ * Extract filename from filepath
+ */
+export function getFilename(filepath) {
+    return filepath.split('/').pop() || 'file';
+}
+/**
+ * Detect whether a File is an image, falling back to extension sniffing
+ * for cases where the MIME type is missing (e.g. pasted files).
+ */
+export function isImageFile(file) {
+    if (file.type.startsWith('image/'))
+        return true;
+    const ext = file.name.split('.').pop()?.toLowerCase() || '';
+    return [
+        'jpg',
+        'jpeg',
+        'png',
+        'gif',
+        'webp',
+        'svg',
+        'bmp',
+        'ico',
+        'heic',
+        'heif',
+        'avif',
+    ].includes(ext);
+}

package/dist/internal/lib/utils/focus-without-scroll.d.ts

@@ -0,0 +1,19 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * Programmatic focus that never scrolls ancestors into view.
+ *
+ * A plain `.focus()` makes the browser scroll EVERY scrollable ancestor —
+ * including `overflow: hidden` ones, which accept a programmatic
+ * `scrollLeft` — to reveal the focused element. The session panel focuses
+ * elements while they're still translated off-panel by an enter animation
+ * (the detail card slides in from `x: 100%`), so that reveal shoved a
+ * permanent sideways scroll onto the panel's `overflow-hidden` wrappers:
+ * with the keep-alive terminal layer parked at `translateX(100%)`, the
+ * overflow never shrinks back and the layout stayed shifted with no
+ * scrollbar to undo it.
+ *
+ * Every focus aimed at (or inside) an animated layer must go through here.
+ */
+export declare function focusWithoutScroll(el: {
+    focus?: (opts?: FocusOptions) => void;
+} | null | undefined): void;

package/dist/internal/lib/utils/focus-without-scroll.js

@@ -0,0 +1,18 @@
+/**
+ * Programmatic focus that never scrolls ancestors into view.
+ *
+ * A plain `.focus()` makes the browser scroll EVERY scrollable ancestor —
+ * including `overflow: hidden` ones, which accept a programmatic
+ * `scrollLeft` — to reveal the focused element. The session panel focuses
+ * elements while they're still translated off-panel by an enter animation
+ * (the detail card slides in from `x: 100%`), so that reveal shoved a
+ * permanent sideways scroll onto the panel's `overflow-hidden` wrappers:
+ * with the keep-alive terminal layer parked at `translateX(100%)`, the
+ * overflow never shrinks back and the layout stayed shifted with no
+ * scrollbar to undo it.
+ *
+ * Every focus aimed at (or inside) an animated layer must go through here.
+ */
+export function focusWithoutScroll(el) {
+    el?.focus?.({ preventScroll: true });
+}

package/dist/internal/lib/utils/heic-convert.d.ts

@@ -0,0 +1,7 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * HEIC/HEIF → JPEG conversion.
+ * heic2any is lazy-loaded — zero bundle cost when no HEIC files are opened.
+ */
+export declare function isHeicFile(filename: string): boolean;
+export declare function convertHeicBlobToJpeg(blob: Blob): Promise<Blob>;

package/dist/internal/lib/utils/heic-convert.js

@@ -0,0 +1,13 @@
+/**
+ * HEIC/HEIF → JPEG conversion.
+ * heic2any is lazy-loaded — zero bundle cost when no HEIC files are opened.
+ */
+const HEIC_EXT = new Set(['heic', 'heif']);
+export function isHeicFile(filename) {
+    return HEIC_EXT.has(filename.split('.').pop()?.toLowerCase() || '');
+}
+export async function convertHeicBlobToJpeg(blob) {
+    const heic2any = (await import('heic2any')).default;
+    const result = await heic2any({ blob, toType: 'image/jpeg', quality: 0.92 });
+    return Array.isArray(result) ? result[0] : result;
+}

package/dist/internal/lib/utils/kortix-system-tags.d.ts

@@ -0,0 +1,45 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { UiTranslator } from '../../../i18n/index.js';
+/** Removes every `<kortix_system …>…</kortix_system>` block, in any ASCII case. */
+export declare function stripKortixSystemTags(text: string): string;
+export interface SessionReport {
+    sessionId: string;
+    status: 'COMPLETE' | 'FAILED';
+    project: string;
+    prompt: string;
+    result: string;
+}
+export declare function extractSessionReport(text: string): SessionReport | null;
+/**
+ * Check if a user message text is purely a kortix_system message
+ * (no visible user content outside the tags).
+ */
+export declare function isKortixSystemOnly(text: string): boolean;
+export interface KortixSystemMessage {
+    type: string;
+    source: string;
+    label: string;
+    detail?: string;
+}
+export interface KortixSystemElement {
+    type: string;
+    source: string;
+    /** The text between the tags, untrimmed. */
+    body: string;
+}
+/**
+ * Each `<kortix_system …>…</kortix_system>` whose opening tag holds `type="…"`
+ * and, after it, `source="…"` — what
+ * `/<kortix_system[^>]*?\btype="([^"]*)"[^>]*?\bsource="([^"]*)"[^>]*>([\s\S]*?)<\/kortix_system>/gi`
+ * matched, in order. That regex was cubic: 53 s at 60k characters.
+ *
+ * One intended difference: a `>` ends the opening tag even inside a quoted
+ * value, as it does for `stripKortixSystemTags`. The regex read on through it.
+ * The runtime never writes `>` into a type or a source.
+ */
+export declare function kortixSystemElements(text: string): KortixSystemElement[];
+/**
+ * Extract structured info from kortix_system tags for inline UI rendering.
+ * Returns an array of parsed system messages found in the text.
+ */
+export declare function extractKortixSystemMessages(text: string, tI18nComplete: UiTranslator): KortixSystemMessage[];