@openviking/react 0.1.3 → 0.1.4

package/dist/a~0.js

@@ -1,21 +1,1300 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-function Console({ className, style, labels }) {
+import { useEffect, useId, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createPortal } from "react-dom";
+import { resolveLocale, mergeLabels } from "./nx~0.js";
+import { useOvSignal, useOvClient, createOvClient, isOvClientError } from "./ae~0.js";
+import { new_sessionreact, historyreact } from "./lg~0.js";
+import { useOverlayPosition } from "./o~0.js";
+import { Tooltip } from "./r~0.js";
+import { VikingBotSessionActions, VikingBot } from "./c~0.js";
+import { Tui } from "./3c~0.js";
+const command_specs_uri = {
+    name: 'uri',
+    kind: 'uri'
+};
+const limit = {
+    name: 'limit',
+    kind: 'integer',
+    min: 1
+};
+const recursive = {
+    name: 'recursive',
+    kind: 'boolean'
+};
+const wait = {
+    name: 'wait',
+    kind: 'boolean'
+};
+const taskId = {
+    name: 'id'
+};
+const COMMAND_SPECS = [
+    {
+        name: 'help'
+    },
+    {
+        name: 'clear'
+    },
+    {
+        name: 'health',
+        skeleton: 'status',
+        request: ()=>({
+                method: 'GET',
+                path: '/health'
+            })
+    },
+    {
+        name: 'status',
+        skeleton: 'status',
+        request: ()=>({
+                method: 'GET',
+                path: '/api/v1/system/status'
+            })
+    },
+    ...[
+        'ls',
+        'tree'
+    ].map((name)=>({
+            name,
+            positional: [
+                {
+                    ...command_specs_uri,
+                    optional: true
+                }
+            ],
+            flags: [
+                limit,
+                {
+                    name: 'offset',
+                    kind: 'integer'
+                },
+                ...'tree' === name ? [
+                    {
+                        name: 'level_limit',
+                        kind: 'integer',
+                        min: 1
+                    }
+                ] : [
+                    recursive
+                ]
+            ],
+            skeleton: 'tree',
+            request: (values)=>({
+                    method: 'GET',
+                    path: `/api/v1/fs/${name}`,
+                    query: {
+                        uri: 'viking://',
+                        limit: 100,
+                        ...values,
+                        output: 'original'
+                    }
+                })
+        })),
+    {
+        name: 'stat',
+        positional: [
+            command_specs_uri
+        ],
+        skeleton: 'status',
+        request: (query)=>({
+                method: 'GET',
+                path: '/api/v1/fs/stat',
+                query
+            })
+    },
+    ...[
+        'read',
+        'abstract',
+        'overview'
+    ].map((name)=>({
+            name,
+            positional: [
+                command_specs_uri
+            ],
+            flags: 'read' === name ? [
+                {
+                    name: 'offset',
+                    kind: 'integer'
+                },
+                {
+                    ...limit,
+                    min: -1
+                }
+            ] : [],
+            skeleton: 'resource',
+            request: (query)=>({
+                    method: 'GET',
+                    path: `/api/v1/content/${name}`,
+                    query
+                })
+        })),
+    ...[
+        'find',
+        'search'
+    ].map((name)=>({
+            name,
+            positional: [
+                {
+                    name: 'query'
+                }
+            ],
+            flags: [
+                {
+                    name: 'target_uri',
+                    kind: 'uri'
+                },
+                limit
+            ],
+            skeleton: 'search',
+            request: (body)=>({
+                    method: 'POST',
+                    path: `/api/v1/search/${name}`,
+                    body
+                })
+        })),
+    ...[
+        'grep',
+        'glob'
+    ].map((name)=>({
+            name,
+            positional: [
+                {
+                    name: 'pattern'
+                }
+            ],
+            flags: [
+                command_specs_uri,
+                {
+                    name: 'node_limit',
+                    kind: 'integer',
+                    min: 1
+                },
+                ...'grep' === name ? [
+                    {
+                        name: 'case_insensitive',
+                        kind: 'boolean'
+                    }
+                ] : []
+            ],
+            skeleton: 'search',
+            request: (values)=>({
+                    method: 'POST',
+                    path: `/api/v1/search/${name}`,
+                    body: {
+                        uri: 'viking://',
+                        ...values
+                    }
+                })
+        })),
+    {
+        name: 'mkdir',
+        positional: [
+            command_specs_uri
+        ],
+        flags: [
+            {
+                name: "description"
+            }
+        ],
+        skeleton: 'write',
+        request: (body)=>({
+                method: 'POST',
+                path: '/api/v1/fs/mkdir',
+                body
+            })
+    },
+    ...[
+        'cp',
+        'mv'
+    ].map((name)=>({
+            name,
+            positional: [
+                {
+                    name: 'from_uri',
+                    kind: 'uri'
+                },
+                {
+                    name: 'to_uri',
+                    kind: 'uri'
+                }
+            ],
+            flags: 'cp' === name ? [
+                recursive
+            ] : [],
+            skeleton: 'write',
+            request: (body)=>({
+                    method: 'POST',
+                    path: `/api/v1/fs/${name}`,
+                    body
+                })
+        })),
+    {
+        name: 'rm',
+        positional: [
+            command_specs_uri
+        ],
+        flags: [
+            recursive,
+            wait
+        ],
+        skeleton: 'write',
+        request: (query)=>({
+                method: 'DELETE',
+                path: '/api/v1/fs',
+                query
+            })
+    },
+    {
+        name: 'write',
+        positional: [
+            command_specs_uri,
+            {
+                name: 'content'
+            }
+        ],
+        flags: [
+            {
+                name: 'mode',
+                choices: [
+                    'create',
+                    'replace',
+                    'append'
+                ]
+            },
+            wait
+        ],
+        skeleton: 'write',
+        request: (body)=>({
+                method: 'POST',
+                path: '/api/v1/content/write',
+                body
+            })
+    },
+    {
+        name: 'task list',
+        flags: [
+            limit,
+            {
+                name: 'status'
+            },
+            {
+                name: 'task_type'
+            }
+        ],
+        skeleton: 'status',
+        request: (query)=>({
+                method: 'GET',
+                path: '/api/v1/tasks',
+                query
+            })
+    },
+    {
+        name: 'task status',
+        positional: [
+            taskId
+        ],
+        skeleton: 'status',
+        request: ({ id })=>({
+                method: 'GET',
+                path: `/api/v1/tasks/${encodeURIComponent(String(id))}`
+            })
+    },
+    {
+        name: 'task cancel',
+        positional: [
+            taskId
+        ],
+        skeleton: 'write',
+        request: ({ id })=>({
+                method: 'POST',
+                path: `/api/v1/tasks/${encodeURIComponent(String(id))}/cancel`
+            })
+    }
+];
+const messages = {
+    labels: {
+        conversation: 'VikingBot',
+        command: 'Terminal',
+        mode: 'Panel mode',
+        description: 'Connect your resources, memories and context to turn your data into usable knowledge.',
+        clear: 'New session',
+        history: 'Command history',
+        emptyHistory: 'No command history yet'
+    },
+    commands: {
+        grep: 'Match text in resources',
+        glob: 'Match resource paths',
+        help: 'Show available commands',
+        clear: 'Clear local records',
+        health: 'Check server health',
+        status: 'Show system status',
+        ls: 'List directory entries',
+        tree: 'List a resource tree',
+        stat: 'Inspect a resource',
+        read: 'Read file content',
+        abstract: 'Read an L0 abstract',
+        overview: 'Read an L1 overview',
+        find: 'Find matching context',
+        search: 'Search with query planning',
+        mkdir: 'Create a directory',
+        cp: 'Copy a resource',
+        mv: 'Move a resource',
+        rm: 'Remove a resource',
+        write: 'Write text content',
+        'task list': 'List background tasks',
+        'task status': 'Inspect a background task',
+        'task cancel': 'Request task cancellation'
+    },
+    availableCommands: 'Available commands',
+    messages: {
+        cancelled: ()=>'Request cancelled; the server may still process an accepted operation.',
+        unknownCommand: ()=>'Unknown command. Enter ov help for available commands.',
+        shellSyntax: ()=>'Shell syntax is not supported.',
+        unclosedQuote: ()=>'Unclosed quote or escape.',
+        unexpectedArgument: (value)=>`Unexpected argument: ${value}`,
+        duplicateArgument: (value)=>`Duplicate argument: ${value}`,
+        missingValue: (value)=>`Missing value: ${value}`,
+        expectedUri: (value)=>`Expected a Viking URI: ${value}`,
+        invalidArgument: (value)=>`Invalid ${value}`,
+        missingArgument: (value)=>`Missing ${value}`
+    }
+};
+const en_US = messages;
+const zh_CN_messages = {
+    labels: {
+        conversation: 'VikingBot',
+        command: '终端',
+        mode: '面板模式',
+        description: '连接你的资料、记忆与上下文，让每一份数据都成为可用的知识',
+        clear: '新建会话',
+        history: '命令历史',
+        emptyHistory: '暂无命令历史'
+    },
+    commands: {
+        grep: '匹配资源文本',
+        glob: '匹配资源路径',
+        help: '查看可用命令',
+        clear: '清空本地记录',
+        health: '检查服务健康状态',
+        status: '查看系统状态',
+        ls: '列出目录内容',
+        tree: '查看资源树',
+        stat: '查看资源属性',
+        read: '读取文件内容',
+        abstract: '读取 L0 摘要',
+        overview: '读取 L1 概览',
+        find: '检索匹配上下文',
+        search: '通过查询规划检索',
+        mkdir: '创建目录',
+        cp: '复制资源',
+        mv: '移动资源',
+        rm: '删除资源',
+        write: '写入文本内容',
+        'task list': '列出后台任务',
+        'task status': '查看后台任务',
+        'task cancel': '请求取消后台任务'
+    },
+    availableCommands: '可用命令',
+    messages: {
+        cancelled: ()=>'请求已取消；服务端可能仍在处理已接收的操作。',
+        unknownCommand: ()=>'未知命令。输入 ov help 查看可用命令。',
+        shellSyntax: ()=>'不支持 Shell 语法。',
+        unclosedQuote: ()=>'引号或转义未闭合。',
+        unexpectedArgument: (value)=>`未知参数：${value}`,
+        duplicateArgument: (value)=>`重复参数：${value}`,
+        missingValue: (value)=>`参数缺少值：${value}`,
+        expectedUri: (value)=>`需要 Viking URI：${value}`,
+        invalidArgument: (value)=>`无效参数 ${value}`,
+        missingArgument: (value)=>`缺少参数 ${value}`
+    }
+};
+const zh_CN = zh_CN_messages;
+function resolveConsoleLocale(locale) {
+    return resolveLocale({
+        'en-US': en_US,
+        'zh-CN': zh_CN
+    }, locale);
+}
+function consoleLabels(locale, overrides) {
+    const defaults = resolveConsoleLocale(locale).labels;
+    const merged = mergeLabels(defaults, overrides);
+    const legacy = {
+        emptyTitle: overrides?.commandTitle,
+        emptyDescription: overrides?.commandDescription,
+        quickStart: overrides?.quickStart
+    };
+    return {
+        ...merged,
+        tui: mergeLabels(Object.fromEntries(Object.entries(legacy).filter(([, value])=>null != value)), overrides?.tui),
+        vikingBot: mergeLabels({
+            welcomeDescription: overrides?.description ?? defaults.description
+        }, overrides?.vikingBot)
+    };
+}
+function formatConsoleMessage(message, locale) {
+    const format = resolveConsoleLocale(locale).messages[message.code];
+    const text = format(message.value ?? '');
+    return message.usage ? `${text}\n${message.usage}` : text;
+}
+class ConsoleCommandError extends Error {
+    code;
+    value;
+    usage;
+    constructor(code, value, usage, locale = 'en-US'){
+        super(formatConsoleMessage({
+            code,
+            value,
+            usage
+        }, locale)), this.code = code, this.value = value, this.usage = usage;
+    }
+}
+function tokenize(input) {
+    const tokens = [];
+    let value = '', quote = '', escaped = false, started = false, literal = false;
+    for (const character of input.trim())if (escaped) {
+        value += character;
+        escaped = false;
+        started = true;
+    } else if ('\\' === character && "'" !== quote) {
+        escaped = true;
+        literal = true;
+    } else if (quote) if (character === quote) quote = '';
+    else value += character;
+    else if ('"' === character || "'" === character) {
+        quote = character;
+        started = true;
+        literal = true;
+    } else if (/\s/.test(character)) {
+        if (started) tokens.push({
+            value,
+            literal
+        });
+        value = '';
+        started = false;
+        literal = false;
+    } else {
+        if ('|;&<>`$'.includes(character)) throw new ConsoleCommandError('shellSyntax');
+        value += character;
+        started = true;
+    }
+    if (quote || escaped) throw new ConsoleCommandError('unclosedQuote');
+    if (started) tokens.push({
+        value,
+        literal
+    });
+    if (tokens[0]?.value === 'ov') tokens.shift();
+    if (tokens[0]?.value.startsWith('/')) tokens[0].value = tokens[0].value.slice(1);
+    return tokens;
+}
+function parseArguments(tokens, positional, flags = []) {
+    const result = {};
+    let index = 0;
+    let options = true;
+    for(let cursor = 0; cursor < tokens.length; cursor++){
+        const current = tokens[cursor];
+        const token = current.value;
+        if (options && !current.literal && '--' === token) {
+            options = false;
+            continue;
+        }
+        const flag = options && !current.literal && token.startsWith('--');
+        const argument = flag ? flags.find((item)=>token === `--${item.name}`) : positional[index++];
+        if (!argument) throw new ConsoleCommandError('unexpectedArgument', token);
+        if (Object.hasOwn(result, argument.name)) throw new ConsoleCommandError('duplicateArgument', token);
+        const next = flag && 'boolean' !== argument.kind ? tokens[++cursor] : current;
+        if (!next || flag && 'boolean' !== argument.kind && !next.literal && next.value.startsWith('--')) throw new ConsoleCommandError('missingValue', token);
+        const value = flag && 'boolean' === argument.kind ? 'true' : next.value;
+        if ('uri' === argument.kind && !/^viking:\/\//.test(value)) throw new ConsoleCommandError('expectedUri', value);
+        if (argument.choices && !argument.choices.includes(value)) throw new ConsoleCommandError('invalidArgument', `${argument.name}: ${value}`);
+        if ('integer' === argument.kind) {
+            const number = Number(value);
+            if (!/^-?\d+$/.test(value) || !Number.isSafeInteger(number) || number < (argument.min ?? 0)) throw new ConsoleCommandError('invalidArgument', `${argument.name}: ${value}`);
+            result[argument.name] = number;
+        } else result[argument.name] = 'boolean' === argument.kind ? true : value;
+    }
+    for (const argument of positional)if (!argument.optional && void 0 === result[argument.name]) throw new ConsoleCommandError('missingArgument', argument.name);
+    return result;
+}
+function object(value) {
+    return null === value || 'object' != typeof value || Array.isArray(value) ? {} : value;
+}
+function results_text(value) {
+    return 'string' == typeof value ? value : JSON.stringify(value, null, 2) ?? '';
+}
+function formatResult(name, data, values) {
+    if ([
+        'read',
+        'abstract',
+        'overview'
+    ].includes(name)) return {
+        variant: 'resource-preview',
+        title: String(values.uri).split('/').pop() || String(values.uri),
+        uri: String(values.uri),
+        content: results_text(data)
+    };
+    if ([
+        'ls',
+        'tree'
+    ].includes(name) && Array.isArray(data)) return {
+        variant: 'resource-tree',
+        items: data.map((entry, index)=>{
+            const item = object(entry);
+            const uri = 'string' == typeof item.uri ? item.uri : void 0;
+            return {
+                id: `${index}`,
+                title: 'string' == typeof entry ? entry : results_text(item.name ?? item.rel_path ?? uri ?? index),
+                uri,
+                metaLabel: 'string' == typeof item.abstract ? item.abstract : void 0
+            };
+        })
+    };
+    const result = object(data);
+    if ([
+        'find',
+        'search'
+    ].includes(name)) {
+        const items = [];
+        for (const key of [
+            'memories',
+            'resources',
+            'skills'
+        ]){
+            const entries = result[key];
+            if (Array.isArray(entries)) for (const entry of entries){
+                const item = object(entry);
+                const uri = 'string' == typeof item.uri ? item.uri : void 0;
+                items.push({
+                    id: `${key}-${items.length}`,
+                    title: uri?.split('/').pop() || uri || key,
+                    uri,
+                    metaLabel: uri,
+                    typeLabel: 'string' == typeof item.context_type ? item.context_type : key,
+                    levelLabel: 'number' == typeof item.level ? `L${item.level}` : void 0,
+                    scoreLabel: 'number' == typeof item.score ? item.score.toFixed(3) : void 0,
+                    preview: 'string' == typeof item.abstract ? item.abstract : void 0
+                });
+            }
+        }
+        return {
+            variant: 'search-list',
+            items
+        };
+    }
+    if ([
+        'stat',
+        'status',
+        'health',
+        'task status',
+        'task cancel'
+    ].includes(name) && Object.keys(result).length) return {
+        variant: 'status',
+        rows: Object.entries(result).map(([label, value])=>({
+                label,
+                value: results_text(value),
+                variant: 'object' == typeof value ? 'pre' : 'inline'
+            }))
+    };
+    return {
+        variant: 'text',
+        text: results_text(data)
+    };
+}
+function consoleCommands(locale) {
+    const text = resolveConsoleLocale(locale);
+    return COMMAND_SPECS.map((spec)=>({
+            name: spec.name,
+            inputText: `ov ${spec.name}`,
+            description: text.commands[spec.name],
+            usage: [
+                'ov',
+                spec.name,
+                ...(spec.positional ?? []).map((arg)=>arg.optional ? `[${arg.name}]` : `<${arg.name}>`),
+                ...(spec.flags ?? []).map((flag)=>`[--${flag.name}${'boolean' === flag.kind ? '' : ` <${flag.name}>`}]`)
+            ].join(' '),
+            params: spec.positional?.map((arg)=>({
+                    label: arg.name,
+                    description: 'uri' === arg.kind ? 'viking://…' : arg.name,
+                    required: !arg.optional
+                })),
+            options: spec.flags?.map((flag)=>({
+                    token: `--${flag.name}`,
+                    description: flag.choices?.join(' | ') ?? flag.name
+                })),
+            skeleton: spec.skeleton
+        }));
+}
+function createCommandHelp(locale) {
+    return {
+        variant: 'command-help',
+        sections: [
+            {
+                key: 'commands',
+                label: resolveConsoleLocale(locale).availableCommands,
+                items: consoleCommands(locale).map((item)=>({
+                        key: item.name,
+                        name: item.usage,
+                        description: item.description
+                    }))
+            }
+        ]
+    };
+}
+async function executeCommand(input, client, options, locale) {
+    const tokens = tokenize(input);
+    const spec = [
+        ...COMMAND_SPECS
+    ].sort((a, b)=>b.name.length - a.name.length).find((item)=>item.name.split(' ').every((part, index)=>tokens[index]?.value === part));
+    if (!spec) throw new ConsoleCommandError('unknownCommand');
+    let values;
+    try {
+        values = parseArguments(tokens.slice(spec.name.split(' ').length), spec.positional ?? [], spec.flags);
+    } catch (error) {
+        const usage = consoleCommands(locale).find((item)=>item.name === spec.name).usage;
+        if (error instanceof ConsoleCommandError) throw new ConsoleCommandError(error.code, error.value, usage);
+        throw error;
+    }
+    if (!spec.request) return createCommandHelp(locale);
+    const data = await client.request({
+        ...spec.request(values),
+        options
+    });
+    return formatResult(spec.name, data, values);
+}
+function localizeConsoleRecords(records, locale) {
+    return records.map(({ localMessage, ...record })=>{
+        if (localMessage) return {
+            ...record,
+            content: {
+                variant: 'text',
+                text: formatConsoleMessage(localMessage, locale)
+            }
+        };
+        if (record.content?.variant === 'command-help') return {
+            ...record,
+            content: createCommandHelp(locale)
+        };
+        return record;
+    });
+}
+function createConsoleController(client, options = {}) {
+    let state = {
+        records: [],
+        command: '',
+        conversationDraft: '',
+        isExecuting: false
+    };
+    const listeners = new Set();
+    let running;
+    let active = false;
+    let sequence = 0;
+    let cancelRunning;
+    const update = (patch)=>{
+        state = {
+            ...state,
+            ...patch
+        };
+        listeners.forEach((listener)=>listener());
+    };
+    const cancel = ()=>cancelRunning?.();
+    const clear = ()=>{
+        cancel();
+        update({
+            records: [],
+            command: '',
+            error: void 0,
+            failedCommand: void 0
+        });
+    };
+    async function execute(input = state.command, locale = 'en-US') {
+        const command = input.trim();
+        if (!active || running || !command) return;
+        try {
+            const tokens = tokenize(command);
+            if (tokens[0]?.value === 'clear') {
+                parseArguments(tokens.slice(1), []);
+                clear();
+                update({
+                    command: ''
+                });
+                return;
+            }
+        } catch  {}
+        const controller = new AbortController();
+        const signal = options.signal ? AbortSignal.any([
+            options.signal,
+            controller.signal
+        ]) : controller.signal;
+        running = controller;
+        const id = `command-${++sequence}`;
+        const current = ()=>active && running === controller;
+        const finish = (message)=>{
+            if (!current()) return;
+            running = void 0;
+            cancelRunning = void 0;
+            update({
+                isExecuting: false,
+                records: state.records.map((record)=>record.id === id ? {
+                        ...record,
+                        status: 'error',
+                        localMessage: message,
+                        content: {
+                            variant: 'text',
+                            text: formatConsoleMessage(message, 'en-US')
+                        }
+                    } : record)
+            });
+        };
+        const onAbort = ()=>finish({
+                code: 'cancelled'
+            });
+        cancelRunning = ()=>{
+            controller.abort();
+            signal.removeEventListener('abort', onAbort);
+        };
+        update({
+            command: '',
+            isExecuting: true,
+            error: void 0,
+            failedCommand: void 0,
+            records: [
+                ...state.records,
+                {
+                    id,
+                    command,
+                    status: 'pending',
+                    createdAtMs: Date.now()
+                }
+            ]
+        });
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        try {
+            if (signal.aborted) return void onAbort();
+            const content = await executeCommand(command, client, {
+                ...options,
+                signal
+            }, locale);
+            if (!current() || signal.aborted) return;
+            update({
+                records: state.records.map((record)=>record.id === id ? {
+                        ...record,
+                        status: 'success',
+                        content
+                    } : record)
+            });
+        } catch (error) {
+            if (!current() || signal.aborted) return;
+            const localMessage = error instanceof ConsoleCommandError ? {
+                code: error.code,
+                value: error.value,
+                usage: error.usage
+            } : void 0;
+            const message = isOvClientError(error) ? `${error.code}: ${error.message}` : error instanceof Error ? error.message : String(error);
+            update({
+                error,
+                failedCommand: command,
+                records: state.records.map((record)=>record.id === id ? {
+                        ...record,
+                        status: 'error',
+                        localMessage,
+                        content: {
+                            variant: 'text',
+                            text: message
+                        }
+                    } : record)
+            });
+        } finally{
+            signal.removeEventListener('abort', onAbort);
+            if (current()) {
+                running = void 0;
+                cancelRunning = void 0;
+                update({
+                    isExecuting: false
+                });
+            }
+        }
+    }
+    return {
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>{
+                listeners.delete(listener);
+            };
+        },
+        getSnapshot: ()=>state,
+        start () {
+            active = true;
+            return ()=>{
+                cancel();
+                active = false;
+            };
+        },
+        execute,
+        cancel,
+        clear,
+        setCommand: (command)=>update({
+                command
+            }),
+        setConversationDraft: (conversationDraft)=>update({
+                conversationDraft
+            }),
+        retry: (locale)=>state.failedCommand ? execute(state.failedCommand, locale) : Promise.resolve()
+    };
+}
+function useConsole({ mode: controlledMode, defaultMode = 'conversation', locale = 'en-US', scopeKey, onModeChange, requestOptions = {} } = {}) {
+    const inherited = useOvClient();
+    const inheritedSignal = useOvSignal();
+    const [fallback] = useState(()=>createOvClient());
+    const client = inherited ?? fallback;
+    const { baseURL, apiKey, accountId, userId, resourceId, signal = inheritedSignal } = requestOptions;
+    const controller = useMemo(()=>createConsoleController(client, {
+            baseURL,
+            apiKey,
+            accountId,
+            userId,
+            resourceId,
+            signal
+        }), [
+        client,
+        baseURL,
+        apiKey,
+        accountId,
+        userId,
+        resourceId,
+        signal,
+        scopeKey
+    ]);
+    useEffect(()=>controller.start(), [
+        controller
+    ]);
+    const state = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+    const [internalMode, setInternalMode] = useState(defaultMode);
+    const mode = controlledMode ?? internalMode;
+    const records = useMemo(()=>localizeConsoleRecords(state.records, locale), [
+        state.records,
+        locale
+    ]);
+    const error = useMemo(()=>state.error instanceof ConsoleCommandError ? new ConsoleCommandError(state.error.code, state.error.value, state.error.usage, locale) : state.error, [
+        state.error,
+        locale
+    ]);
+    return {
+        ...state,
+        records,
+        error,
+        mode,
+        commands: consoleCommands(locale),
+        setMode (next) {
+            if (next === mode) return;
+            if (void 0 === controlledMode) setInternalMode(next);
+            onModeChange?.(next);
+        },
+        setCommand: controller.setCommand,
+        setConversationDraft: controller.setConversationDraft,
+        execute: (command)=>controller.execute(command, locale),
+        retry: ()=>controller.retry(locale),
+        cancel: controller.cancel,
+        clear: controller.clear
+    };
+}
+const SvgConversation = (props)=>/*#__PURE__*/ jsx("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        fill: "none",
+        preserveAspectRatio: "none",
+        viewBox: "0 0 12.928 12.867",
+        ...props,
+        children: /*#__PURE__*/ jsx("path", {
+            stroke: "currentColor",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 1.2,
+            d: "M2.988 5.983a5 5 0 0 1-.055-.716C2.933 2.689 5.036.6 7.631.6c2.594 0 4.697 2.09 4.697 4.667a4.6 4.6 0 0 1-.303 1.653c-.041.107-.061.16-.07.202a.5.5 0 0 0-.014.113c-.001.042.004.09.016.183l.235 1.908c.025.206.038.31.004.385a.3.3 0 0 1-.15.146c-.076.033-.18.018-.385-.012l-1.858-.273a1.4 1.4 0 0 0-.19-.02.5.5 0 0 0-.116.012c-.044.009-.099.03-.21.07a4.7 4.7 0 0 1-2.374.245m-3.028 2.388c1.73 0 3.132-1.437 3.132-3.209S5.615 5.85 3.885 5.85.754 7.286.754 9.058c0 .357.056.7.16 1.02.045.135.067.202.074.248a.5.5 0 0 1 .006.125c-.002.046-.014.1-.037.205L.6 12.266l1.747-.238c.095-.013.143-.02.185-.02.043.001.067.004.11.012.04.008.101.03.223.072.32.113.663.175 1.02.175"
+        })
+    });
+const conversationreact = SvgConversation;
+const SvgTerminal = (props)=>/*#__PURE__*/ jsx("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        fill: "none",
+        preserveAspectRatio: "none",
+        viewBox: "0 0 11.7 11.7",
+        ...props,
+        children: /*#__PURE__*/ jsx("path", {
+            stroke: "currentColor",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 1.2,
+            d: "m2.933 7.6 1.75-1.75-1.75-1.75m3.5 3.5h2.334M3.4 11.1h4.9c.98 0 1.47 0 1.845-.19a1.75 1.75 0 0 0 .764-.765c.191-.375.191-.865.191-1.845V3.4c0-.98 0-1.47-.19-1.844a1.75 1.75 0 0 0-.765-.765C9.77.6 9.28.6 8.3.6H3.4c-.98 0-1.47 0-1.844.19a1.75 1.75 0 0 0-.765.766C.6 1.93.6 2.42.6 3.4v4.9c0 .98 0 1.47.19 1.845.169.329.436.597.766.764.374.191.864.191 1.844.191"
+        })
+    });
+const terminalreact = SvgTerminal;
+const SvgHistoryEmpty = (props)=>/*#__PURE__*/ jsxs("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 259,
+        height: 140,
+        fill: "none",
+        viewBox: "0 0 259 140",
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx("path", {
+                stroke: "var(--ov-ui-color-border-2, var(--ov-ui-border-2-default))",
+                strokeDasharray: "2 2",
+                d: "M0 28h259M0 56h259M0 84h259M0 112h259M37 0v140M75 0v140M117 0v140M159 0v140M199 0v140M235 0v140",
+                opacity: 0.36,
+                style: {
+                    maskImage: "radial-gradient(ellipse at center,currentColor,transparent 72%)"
+                }
+            }),
+            /*#__PURE__*/ jsx("path", {
+                fill: "var(--ov-ui-color-bg-1, var(--ov-ui-bg-1-default))",
+                d: "m95 81 8-22q1-3 4-3h45q3 0 4 3l8 22v17q0 6-6 6h-57q-6 0-6-6Z"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                fill: "currentColor",
+                d: "m102 81 7-16q1-2 4-2h33q3 0 4 2l7 16h-18q0 11-9.5 11T120 81Z",
+                opacity: 0.15
+            }),
+            /*#__PURE__*/ jsxs("g", {
+                stroke: "currentColor",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: 1.5,
+                children: [
+                    /*#__PURE__*/ jsx("path", {
+                        d: "m95 81 8-22q1-3 4-3h45q3 0 4 3l8 22v17q0 6-6 6h-57q-6 0-6-6Z"
+                    }),
+                    /*#__PURE__*/ jsx("path", {
+                        d: "M96 81h5m5 0h12q2 0 2 2 0 10 9.5 10t9.5-10q0-2 2-2h22"
+                    }),
+                    /*#__PURE__*/ jsx("path", {
+                        d: "m108 38 9 8m13-12v12m22-8-9 8",
+                        opacity: 0.8
+                    })
+                ]
+            })
+        ]
+    });
+const history_emptyreact = SvgHistoryEmpty;
+const icons = {
+    conversation: conversationreact,
+    command: terminalreact,
+    history: historyreact,
+    newSession: new_sessionreact,
+    historyEmpty: history_emptyreact
+};
+function ConsoleIcon({ name }) {
+    const Icon = icons[name];
+    return /*#__PURE__*/ jsx(Icon, {
+        "aria-hidden": "true",
+        focusable: "false"
+    });
+}
+const subscribe = ()=>()=>{};
+const clientSnapshot = ()=>true;
+const serverSnapshot = ()=>false;
+function historyTime(record, locale) {
+    const date = new Date(record.createdAtMs ?? 0 / 0);
+    if (!Number.isFinite(date.getTime())) return record.createdAt ?? '';
+    const parts = Object.fromEntries(new Intl.DateTimeFormat(locale, {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23'
+    }).formatToParts(date).map(({ type, value })=>[
+            type,
+            value
+        ]));
+    return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute}`;
+}
+function ConsoleHistory({ records, isExecuting, locale, labels, onRecall }) {
+    const mounted = useSyncExternalStore(subscribe, clientSnapshot, serverSnapshot);
+    const native = mounted && 'popover' in HTMLElement.prototype && 'function' == typeof HTMLElement.prototype.showPopover;
+    const [open, setOpen] = useState(false);
+    const [surface, setSurface] = useState(null);
+    const trigger = useRef(null);
+    const id = useId();
+    const position = useOverlayPosition(open, trigger, surface, 'bottom', 'end');
+    const close = ()=>{
+        if (native) surface?.hidePopover();
+        else setOpen(false);
+    };
+    useEffect(()=>{
+        if (!native || !surface) return;
+        const onToggle = ()=>setOpen(surface.matches(':popover-open'));
+        surface.addEventListener('toggle', onToggle);
+        return ()=>surface.removeEventListener('toggle', onToggle);
+    }, [
+        native,
+        surface
+    ]);
+    useEffect(()=>{
+        if (native || !open) return;
+        const outside = (event)=>{
+            const target = event.target;
+            if (!trigger.current?.contains(target) && !surface?.contains(target)) setOpen(false);
+        };
+        const escape = (event)=>{
+            if ('Escape' !== event.key) return;
+            setOpen(false);
+            trigger.current?.querySelector('button')?.focus();
+        };
+        document.addEventListener('mousedown', outside);
+        document.addEventListener('keydown', escape);
+        return ()=>{
+            document.removeEventListener('mousedown', outside);
+            document.removeEventListener('keydown', escape);
+        };
+    }, [
+        native,
+        open,
+        surface
+    ]);
+    const invoker = native ? 'commandForElement' in HTMLButtonElement.prototype ? {
+        commandfor: id,
+        command: 'toggle-popover'
+    } : {
+        popovertarget: id
+    } : {};
     return /*#__PURE__*/ jsxs("div", {
+        className: "ov-console__history",
+        ref: trigger,
+        children: [
+            /*#__PURE__*/ jsx(Tooltip, {
+                content: labels.history,
+                className: "ov-console__action-tooltip",
+                children: /*#__PURE__*/ jsx("button", {
+                    ...invoker,
+                    type: "button",
+                    className: "ov-console__action",
+                    "aria-label": labels.history,
+                    "aria-haspopup": "dialog",
+                    "aria-controls": id,
+                    "aria-expanded": open,
+                    "data-open": open || void 0,
+                    onClick: native ? void 0 : ()=>setOpen(!open),
+                    children: /*#__PURE__*/ jsx(ConsoleIcon, {
+                        name: "history"
+                    })
+                })
+            }),
+            mounted ? /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx("div", {
+                ref: setSurface,
+                id: id,
+                popover: "auto",
+                role: "dialog",
+                "aria-label": labels.history,
+                hidden: !native && !open,
+                className: "ov-tooltip ov-console__history-content",
+                style: {
+                    top: position.top,
+                    left: position.left
+                },
+                children: records.length ? /*#__PURE__*/ jsx("ul", {
+                    children: [
+                        ...records
+                    ].reverse().map((record)=>/*#__PURE__*/ jsx("li", {
+                            children: /*#__PURE__*/ jsxs("button", {
+                                type: "button",
+                                disabled: isExecuting,
+                                onClick: ()=>{
+                                    close();
+                                    onRecall(record.command);
+                                },
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "ov-console__history-command",
+                                        children: record.command
+                                    }),
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "ov-console__history-time",
+                                        children: historyTime(record, locale)
+                                    })
+                                ]
+                            })
+                        }, record.id))
+                }) : /*#__PURE__*/ jsxs("div", {
+                    className: "ov-console__history-empty",
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            className: "ov-console__history-illustration",
+                            children: /*#__PURE__*/ jsx(ConsoleIcon, {
+                                name: "historyEmpty"
+                            })
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            children: labels.emptyHistory
+                        })
+                    ]
+                })
+            }), document.body) : null
+        ]
+    });
+}
+function ConsoleToolbar({ mode, panelId, locale, labels, records, isExecuting, onModeChange, onClear, onRecall, children, conversationActions }) {
+    const [sessionVersion, setSessionVersion] = useState(0);
+    return /*#__PURE__*/ jsxs("div", {
+        className: "ov-console__toolbar",
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: "ov-console__modes",
+                role: "group",
+                "aria-label": labels.mode,
+                children: [
+                    'conversation',
+                    'command'
+                ].map((value)=>/*#__PURE__*/ jsxs("button", {
+                        className: "ov-console__mode",
+                        type: "button",
+                        "aria-label": labels[value],
+                        title: labels[value],
+                        "aria-pressed": mode === value,
+                        "aria-controls": `${panelId}-${value}`,
+                        onClick: ()=>onModeChange(value),
+                        children: [
+                            /*#__PURE__*/ jsx(ConsoleIcon, {
+                                name: value
+                            }),
+                            mode === value ? /*#__PURE__*/ jsx("span", {
+                                children: labels[value]
+                            }) : null
+                        ]
+                    }, value))
+            }),
+            children ? /*#__PURE__*/ jsx("div", {
+                className: "ov-console__toolbar-slot",
+                children: children
+            }) : null,
+            'command' === mode ? /*#__PURE__*/ jsxs("div", {
+                className: "ov-console__actions",
+                children: [
+                    /*#__PURE__*/ jsx(ConsoleHistory, {
+                        records: records,
+                        isExecuting: isExecuting,
+                        locale: locale,
+                        labels: labels,
+                        onRecall: onRecall
+                    }, sessionVersion),
+                    /*#__PURE__*/ jsx(Tooltip, {
+                        content: labels.clear,
+                        className: "ov-console__action-tooltip",
+                        children: /*#__PURE__*/ jsx("button", {
+                            className: "ov-console__action",
+                            type: "button",
+                            "aria-label": labels.clear,
+                            onClick: ()=>{
+                                setSessionVersion((version)=>version + 1);
+                                onClear();
+                            },
+                            children: /*#__PURE__*/ jsx(ConsoleIcon, {
+                                name: "newSession"
+                            })
+                        })
+                    })
+                ]
+            }) : conversationActions
+        ]
+    });
+}
+const DEFAULT_QUICK_COMMANDS = [
+    'help',
+    'ls',
+    'find',
+    'read',
+    'status'
+];
+function Console({ mode, defaultMode, locale = 'en-US', quickCommands = DEFAULT_QUICK_COMMANDS, scopeKey, requestOptions, onModeChange, onOpenUri, conversation, slots, labels: overrides, className, ...rest }) {
+    const state = useConsole({
+        mode,
+        defaultMode,
+        locale,
+        scopeKey,
+        requestOptions,
+        onModeChange
+    });
+    const labels = consoleLabels(locale, overrides);
+    const { sessions, headerActions, ...conversationProps } = conversation ?? {};
+    const botLabels = {
+        ...labels.vikingBot,
+        ...conversationProps.labels
+    };
+    const id = useId();
+    const commandPanel = useRef(null);
+    const fillCommand = (command)=>{
+        state.setCommand(command);
+        commandPanel.current?.querySelector('textarea')?.focus({
+            preventScroll: true
+        });
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        ...rest,
         className: [
-            'ov-module-placeholder',
+            'ov-console',
             className
         ].filter(Boolean).join(' '),
-        style: style,
         children: [
-            /*#__PURE__*/ jsx("p", {
-                className: "ov-module-placeholder__title",
-                children: labels?.conversation ?? 'Console'
+            /*#__PURE__*/ jsx(ConsoleToolbar, {
+                mode: state.mode,
+                panelId: id,
+                locale: locale,
+                labels: labels,
+                records: state.records,
+                isExecuting: state.isExecuting,
+                onModeChange: (next)=>state.setMode(next),
+                onClear: ()=>{
+                    state.clear();
+                    fillCommand('');
+                },
+                onRecall: fillCommand,
+                conversationActions: /*#__PURE__*/ jsx(VikingBotSessionActions, {
+                    sessions: sessions,
+                    extra: headerActions,
+                    labels: botLabels,
+                    locale: locale
+                }),
+                children: slots?.toolbar
+            }),
+            /*#__PURE__*/ jsx("div", {
+                id: `${id}-conversation`,
+                className: "ov-console__panel",
+                hidden: 'conversation' !== state.mode,
+                children: 'conversation' === state.mode ? /*#__PURE__*/ jsx(VikingBot, {
+                    ...conversationProps,
+                    onOpenUri: conversationProps.onOpenUri ?? onOpenUri,
+                    messages: conversationProps.messages ?? [],
+                    draft: conversationProps.draft ?? state.conversationDraft,
+                    onDraftChange: void 0 === conversationProps.draft ? (value)=>{
+                        state.setConversationDraft(value);
+                        conversationProps.onDraftChange?.(value);
+                    } : conversationProps.onDraftChange,
+                    footer: slots?.conversationContext ?? conversationProps.footer,
+                    locale: conversationProps.locale ?? locale,
+                    labels: botLabels
+                }) : null
             }),
-            /*#__PURE__*/ jsx("p", {
-                className: "ov-module-placeholder__description",
-                children: labels?.description ?? 'Placeholder. Functionality is not available yet.'
+            /*#__PURE__*/ jsxs("div", {
+                id: `${id}-command`,
+                ref: commandPanel,
+                className: "ov-console__panel",
+                hidden: 'command' !== state.mode,
+                children: [
+                    slots?.commandHelp,
+                    /*#__PURE__*/ jsx(Tui, {
+                        records: state.records,
+                        value: state.command,
+                        commands: state.commands,
+                        locale: locale,
+                        disabled: state.isExecuting,
+                        quickCommands: quickCommands,
+                        onValueChange: state.setCommand,
+                        onSubmit: (command)=>void state.execute(command),
+                        onOpenUri: onOpenUri,
+                        labels: labels.tui
+                    })
+                ]
             })
         ]
     });
 }
-export { Console };
+export { Console, useConsole };