@openviking/react 0.1.1 → 0.1.3

package/README.md

@@ -2,29 +2,32 @@
 
 English / [中文](README_CN.md)
 
-React foundations for OpenViking AI application interfaces: build tooling, documentation, layered directories, and scoped styles. FileTree and FilePreview provide placeholder views, alongside five file-type icons. Three business module placeholders support early layout integration; ScopeCascade provides a working cascade Hook and composition.
+React foundations for OpenViking AI application interfaces: build tooling, documentation, layered directories, and scoped styles. FileTree, Tui and FilePreview provide working views, alongside five file-type icons. Two business module placeholders support early layout integration; ScopeCascade provides a working cascade Hook and composition.
 
 This package inherits the repository's AGPL-3.0-only license. The release workflow publishes it to npm when a `react@<version>` tag matches the version in this package's manifest.
 
 ## Module map
 
-| Source directory                                                       | Public entry                                  | Responsibility                                                                            |
-| ---------------------------------------------------------------------- | --------------------------------------------- | ----------------------------------------------------------------------------------------- |
-| [components/file-tree](./src/components/file-tree/README.md)           | `@openviking/react/components/file-tree`      | Directory tree rendering, expansion, selection and event callbacks; view is a placeholder |
-| [components/file-preview](./src/components/file-preview/README.md)     | `@openviking/react/components/file-preview`   | Read-only preview state and extension tabs; view is a placeholder                         |
-| [components/tui](./src/components/tui/README.md)                       | `@openviking/react/components/tui`            | Reviewed command record, result and input types; view is a placeholder                    |
-| [components/scope-switcher](./src/components/scope-switcher/README.md) | `@openviking/react/components/scope-switcher` | Stateless scope layout and independent ScopeSelector options, panels and search           |
-| [components/agent-connect](./src/components/agent-connect/README.md)   | `@openviking/react/components/agent-connect`  | Agent connection tab, list and detail contract; view is a placeholder                     |
-| [modules](./src/modules/README.md)                                     | `@openviking/react/modules/<module>`          | ScopeCascade Hooks and composition, plus three placeholder business modules               |
-| [client](./src/client/index.ts)                                        | `@openviking/react/client`                    | Framework-neutral request client: `createOvClient`, `OvClient`, `OvClientError`           |
-| [hooks](./src/hooks/README.md), [utils](./src/utils/README.md)         | Internal only                                 | Cross-module Hooks and pure utilities                                                     |
+| Source directory                                                       | Public entry                                  | Responsibility                                                                        |
+| ---------------------------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------- |
+| [components/file-tree](./src/components/file-tree/README.md)           | `@openviking/react/components/file-tree`      | Directory tree rendering, expansion, selection and event callbacks                    |
+| [components/file-preview](./src/components/file-preview/README.md)     | `@openviking/react/components/file-preview`   | Read-only preview state and extension tabs; view is a placeholder                     |
+| [components/tui](./src/components/tui/README.md)                       | `@openviking/react/components/tui`            | Command record, result and input views with host-provided command metadata            |
+| [components/scope-switcher](./src/components/scope-switcher/README.md) | `@openviking/react/components/scope-switcher` | Stateless scope layout and independent ScopeSelector options, panels and search       |
+| [components/agent-connect](./src/components/agent-connect/README.md)   | `@openviking/react/components/agent-connect`  | Fixed Figma connection view with original icons, built-in copy and clipboard feedback |
+| [components/viking-bot](./src/components/viking-bot/README.md)         | `@openviking/react/components/viking-bot`     | Conversation contract with a placeholder view rendering against it                    |
+| [modules](./src/modules/README.md)                                     | `@openviking/react/modules/<module>`          | ScopeCascade Hooks and composition, plus two placeholder business modules             |
+| [client](./src/client/index.ts)                                        | `@openviking/react/client`                    | Framework-neutral request client: `createOvClient`, `OvClient`, `OvClientError`       |
+| [hooks](./src/hooks/README.md), [utils](./src/utils/README.md)         | Internal only                                 | Cross-module Hooks and pure utilities                                                 |
 
-Components implement their reviewed contracts incrementally. FileTree renders every documented row type with keyboard interaction; FilePreview implements the tab shell, header actions and the plain-text preview and editing foundation, with its body not yet wired to FileViewer. ScopeSwitcher is a stateless layout container; independently rendered ScopeSelector children own visibility, with host-owned per-level data subscriptions, search and requests. Tui and AgentConnect render a fixed-size shell only. Limits are described in each component's own docs. The package also ships five file-type icons.
+Components implement their reviewed contracts incrementally. FileTree renders every documented row type with keyboard interaction; FilePreview implements the tab shell, header actions and the plain-text preview and editing foundation, with its body not yet wired to FileViewer. ScopeSwitcher is a stateless layout container; independently rendered ScopeSelector children own visibility, with host-owned per-level data subscriptions, search and requests. Tui renders records, results and the input. AgentConnect follows the Figma layout with built-in bilingual agent and developer integration content, host-provided credentials and locale, optional controlled selection and clipboard feedback. VikingBot provides a working view pending design review. Limits are described in each component's own docs. The package also ships five file-type icons.
 
-Components receive view data and state through props and express user intent through callbacks, following the [component directory conventions](./src/components/AGENTS.md). [modules](./src/modules/README.md) plan Hooks and views per business capability: Hooks load data, hold state and expose operations, and composite views wire them into components. Full pages and product-specific flows belong to the host; the admin console is out of scope for this phase. `file-browser`, `console` and `task-center` currently ship placeholder components, base Props / Labels types and styles so hosts can integrate layout first; business Hooks, data loading and cross-component coordination are not implemented yet.
+Components receive view data and state through props and express user intent through callbacks, following the [component directory conventions](./src/components/AGENTS.md). [modules](./src/modules/README.md) plan Hooks and views per business capability: Hooks load data, hold state and expose operations, and composite views wire them into components. Full pages and product-specific flows belong to the host; the admin console is out of scope for this phase. `file-browser` and `console` currently ship placeholder components, base Props / Labels types and styles so hosts can integrate layout first; business Hooks, data loading and cross-component coordination are not implemented yet.
 
 Modules consume the native OpenViking API through a shared Client by default, with the Provider supplying `baseURL`, headers and other configuration, and modules or standalone Hooks overriding individual fields through `requestOptions`. Standard integration needs no per-module Adapter; nonstandard gateways are adapted at the host's request boundary. The request contract — `OvRequestOptions`, `OvClient` and `OvClientError` — comes from the `@openviking/react/client` subpath, which ships a `fetch`-based `createOvClient`; the Provider is exported from the same subpath; these native API module Hooks are not implemented yet. ScopeCascade instead accepts three host API adapters and needs no Provider. See [request conventions](./src/modules/README.md#request-conventions-and-default-configuration).
 
+Tui preserves JSON numeric tokens when indenting output. Structured resource links allow only `viking://`, `https://`, and `http://`; other targets render as text. Resource tables retain entry titles, native links and metadata. Output follows updates only near the bottom or after explicit submission. Read-only and disabled consoles cannot submit or insert help commands. `labels.resource` customizes the resource identity column.
+
 ### Props conventions
 
 The same props are consumed by different hosts. Hosts differ in flows and interfaces while matching in interaction and UI, so:
@@ -37,7 +40,7 @@ The same props are consumed by different hosts. Hosts differ in flows and interf
 
 ## Public entries and styles
 
-- The root entry exports each component and each business module placeholder with its main Props type (`<Component>Props`) only — currently `FileTree`, `Tui`, `ScopeSwitcher`, `ScopeSelector`, `ScopeCascade`, `AgentConnect` and the three business module placeholders. Row types, option types, handles and label bags come from the `components/<component>` and `modules/<module>` subpaths. `FilePreview` is not on the root entry: its types reference the optional `@ark-design/ui`, and putting it there would make that peer required. ScopeCascade exports a working three-level composition and per-level subscription Hooks from `modules/scope-cascade`; other business modules remain placeholders. No aggregate `@openviking/react/components` or `@openviking/react/modules` JavaScript entry. Package exports are listed explicitly and internal files stay closed.
+- The root entry exports each component and each business module placeholder with its main Props type (`<Component>Props`) only — currently `FileTree`, `Tui`, `ScopeSwitcher`, `ScopeSelector`, `ScopeCascade`, `AgentConnect` and the two business module placeholders. Row types, option types, handles and label bags come from the `components/<component>` and `modules/<module>` subpaths. `FilePreview` is not on the root entry: its types reference the optional `@ark-design/ui`, and putting it there would make that peer required. ScopeCascade exports a working three-level composition and per-level subscription Hooks from `modules/scope-cascade`; other business modules remain placeholders. No aggregate `@openviking/react/components` or `@openviking/react/modules` JavaScript entry. Package exports are listed explicitly and internal files stay closed.
 - Components expose only the explicitly listed layered subpaths, with no legacy path aliases.
 - JS entries share implementations and never load CSS implicitly. Whole-package, component-set and single-module stylesheets are built from the same source, so import the scope you need.
 
@@ -60,7 +63,7 @@ import '@openviking/react/modules/file-browser/style.css';
 />;
 ```
 
-The other modules export `Console` and `TaskCenter`; all currently accept `className`, `style` and `labels`, and need no Provider or request configuration.
+The remaining module exports `Console`; it currently accepts `className`, `style` and `labels`, and needs no Provider or request configuration.
 
 Experience dashboards belong to preview extensions; task progress starts inside its owning module; API Key display controls are reused on demand while credential creation and management belong to the host. No separate modules are added for these now.
 

package/dist/1~0.js

@@ -0,0 +1,506 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+class OvClientError extends Error {
+    code;
+    statusCode;
+    details;
+    requestId;
+    responseBody;
+    constructor(options){
+        super(options.message, void 0 === options.cause ? void 0 : {
+            cause: options.cause
+        });
+        this.name = 'OvClientError';
+        this.code = options.code;
+        this.statusCode = options.statusCode;
+        this.details = options.details;
+        this.requestId = options.requestId;
+        this.responseBody = options.responseBody;
+    }
+}
+function isOvClientError(value) {
+    return value instanceof OvClientError;
+}
+const IDENTITY_HEADERS = {
+    apiKey: 'X-API-Key',
+    accountId: 'X-OpenViking-Account',
+    userId: 'X-OpenViking-User',
+    resourceId: 'V-Resource-Id'
+};
+async function evaluate(value) {
+    if (void 0 === value) return;
+    return 'function' == typeof value ? await value() : value;
+}
+async function resolveIdentityLayer(options) {
+    const layer = {};
+    for (const field of Object.keys(IDENTITY_HEADERS)){
+        const value = await evaluate(options?.[field]);
+        if (void 0 !== value) layer[field] = value;
+    }
+    return layer;
+}
+function mergeIdentityLayers(far, near) {
+    return {
+        ...far,
+        ...near
+    };
+}
+function toHeaders(layer) {
+    const out = {};
+    for (const field of Object.keys(IDENTITY_HEADERS)){
+        const value = layer[field]?.trim();
+        if (value) out[IDENTITY_HEADERS[field].toLowerCase()] = value;
+    }
+    return out;
+}
+function resolveClientOptions(options, identity) {
+    return {
+        baseURL: options.baseURL ?? '',
+        credentials: options.credentials ?? 'same-origin',
+        headers: toHeaders(identity),
+        signal: options.signal
+    };
+}
+function resolveRequestOptions(local, parent, mergedLayer) {
+    const headers = {
+        ...parent.headers
+    };
+    for (const field of Object.keys(IDENTITY_HEADERS)){
+        const value = mergedLayer[field];
+        if (void 0 === value) continue;
+        const name = IDENTITY_HEADERS[field].toLowerCase();
+        if (value.trim()) headers[name] = value;
+        else delete headers[name];
+    }
+    return {
+        baseURL: local?.baseURL ?? parent.baseURL,
+        credentials: parent.credentials,
+        headers,
+        signal: local?.signal ?? parent.signal
+    };
+}
+function joinUrl(baseURL, path) {
+    const prefix = baseURL.replace(/\/+$/, '');
+    return `${prefix}${path.startsWith('/') ? path : `/${path}`}`;
+}
+function buildQuery(query) {
+    if (!query) return '';
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query))if (null != value) {
+        if (Array.isArray(value)) {
+            for (const item of value)params.append(key, String(item));
+            continue;
+        }
+        params.set(key, String(value));
+    }
+    const text = params.toString();
+    return text ? `?${text}` : '';
+}
+function mergeProviderConfig(inherited, local) {
+    const declared = {};
+    if (void 0 !== local.apiKey) declared.apiKey = local.apiKey;
+    if (void 0 !== local.accountId) declared.accountId = local.accountId;
+    if (void 0 !== local.userId) declared.userId = local.userId;
+    if (void 0 !== local.resourceId) declared.resourceId = local.resourceId;
+    return {
+        baseURL: local.baseURL ?? inherited?.baseURL,
+        credentials: local.credentials ?? inherited?.credentials,
+        signal: local.signal ?? inherited?.signal,
+        fetch: local.fetch ?? inherited?.fetch,
+        identity: {
+            ...inherited?.identity,
+            ...declared
+        }
+    };
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function readEnvelope(value) {
+    return isRecord(value) ? value : {};
+}
+function parseJson(raw) {
+    if (!raw.trim()) return;
+    try {
+        return JSON.parse(raw);
+    } catch  {
+        return;
+    }
+}
+function isAbortError(error) {
+    return isRecord(error) && ('AbortError' === error.name || 'ABORT_ERR' === error.code);
+}
+function normalizeTransportError(error, signal) {
+    if (isAbortError(error) || signal?.aborted) throw error;
+    throw new OvClientError({
+        code: 'NETWORK_ERROR',
+        message: error instanceof Error ? error.message : 'Network request failed',
+        cause: error
+    });
+}
+async function readText(response, signal) {
+    try {
+        return await response.text();
+    } catch (error) {
+        normalizeTransportError(error, signal);
+    }
+}
+async function readBlob(response, signal) {
+    try {
+        return await response.blob();
+    } catch (error) {
+        normalizeTransportError(error, signal);
+    }
+}
+function toClientError(response, body, fallbackCode) {
+    const envelope = readEnvelope(body);
+    return new OvClientError({
+        code: envelope.error?.code ?? fallbackCode ?? `HTTP_${response.status}`,
+        message: envelope.error?.message ?? response.statusText,
+        statusCode: response.status,
+        details: envelope.error?.details,
+        requestId: response.headers.get('x-request-id') ?? void 0,
+        responseBody: body
+    });
+}
+function throwIfErrorEnvelope(response, body) {
+    const envelope = readEnvelope(body);
+    if ('error' !== envelope.status) return;
+    throw toClientError(response, body, 'UNKNOWN');
+}
+function parseEvent(lines) {
+    let data;
+    let event;
+    let id;
+    let retry;
+    for (const line of lines){
+        if (!line || line.startsWith(':')) continue;
+        const colon = line.indexOf(':');
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' ')) value = value.slice(1);
+        if ('data' === field) data = void 0 === data ? value : `${data}\n${value}`;
+        else if ('event' === field) event = value;
+        else if ('id' === field) id = value;
+        else if ('retry' === field) {
+            const parsed = Number.parseInt(value, 10);
+            if (Number.isFinite(parsed)) retry = parsed;
+        }
+    }
+    if (void 0 === data && void 0 === event && void 0 === id) return;
+    const result = {
+        data: data ?? ''
+    };
+    if (void 0 !== event) result.event = event;
+    if (void 0 !== id) result.id = id;
+    if (void 0 !== retry) result.retry = retry;
+    return result;
+}
+function createDecoder() {
+    if ("u" > typeof TextDecoderStream) return new TextDecoderStream();
+    const decoder = new TextDecoder('utf-8');
+    return new TransformStream({
+        transform (bytes, controller) {
+            controller.enqueue(decoder.decode(bytes, {
+                stream: true
+            }));
+        },
+        flush (controller) {
+            const rest = decoder.decode();
+            if (rest) controller.enqueue(rest);
+        }
+    });
+}
+function decodeEventStream(body) {
+    let line = '';
+    let block = [];
+    let skipLf = false;
+    return body.pipeThrough(createDecoder()).pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            const finishLine = ()=>{
+                if ('' === line) {
+                    const parsed = parseEvent(block);
+                    block = [];
+                    if (parsed) controller.enqueue(parsed);
+                    return;
+                }
+                block.push(line);
+                line = '';
+            };
+            for (const char of chunk)if ('\r' === char) {
+                finishLine();
+                skipLf = true;
+            } else if ('\n' === char) if (skipLf) skipLf = false;
+            else finishLine();
+            else {
+                skipLf = false;
+                line += char;
+            }
+        },
+        flush (controller) {
+            if ('' !== line) block.push(line);
+            line = '';
+            const parsed = parseEvent(block);
+            block = [];
+            if (parsed) controller.enqueue(parsed);
+        }
+    }));
+}
+const EVENT_STREAM = 'text/event-stream';
+async function openStream(spec, { send, resolveFor, defaults }) {
+    const controller = new AbortController();
+    let releaseAbort;
+    const aborted = new Promise((resolve)=>{
+        releaseAbort = ()=>resolve('aborted');
+    });
+    const stop = ()=>{
+        releaseAbort?.();
+        controller.abort();
+    };
+    const resolved = await resolveFor(defaults, spec.options);
+    const callerSignals = [
+        resolved.signal,
+        spec.options?.signal
+    ].filter((candidate)=>Boolean(candidate));
+    let onCallerAbort = ()=>stop();
+    const forward = ()=>onCallerAbort();
+    for (const callerSignal of callerSignals){
+        if (callerSignal.aborted) {
+            forward();
+            break;
+        }
+        callerSignal.addEventListener('abort', forward, {
+            once: true
+        });
+    }
+    const detach = ()=>{
+        for (const callerSignal of callerSignals)callerSignal.removeEventListener('abort', forward);
+    };
+    let response;
+    try {
+        ({ response } = await send(spec, {
+            accept: EVENT_STREAM,
+            ...spec.headers
+        }, controller.signal, resolved));
+    } catch (error) {
+        detach();
+        throw error;
+    }
+    let body;
+    try {
+        if (!response.ok) {
+            const raw = await readText(response, controller.signal);
+            throw toClientError(response, parseJson(raw) ?? raw);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes(EVENT_STREAM) || !response.body) {
+            const envelope = parseJson(await readText(response, controller.signal));
+            if (void 0 !== envelope) throwIfErrorEnvelope(response, envelope);
+            throw new OvClientError({
+                code: 'UNEXPECTED_CONTENT_TYPE',
+                message: `Expected ${EVENT_STREAM}, got ${contentType || 'no content type'}`,
+                statusCode: response.status,
+                requestId: response.headers.get('x-request-id') ?? void 0,
+                responseBody: envelope
+            });
+        }
+        body = response.body;
+    } catch (error) {
+        detach();
+        throw error;
+    }
+    const reader = decodeEventStream(body).getReader();
+    let released = false;
+    const release = ()=>{
+        if (released) return;
+        released = true;
+        detach();
+        reader.cancel().catch(()=>{});
+    };
+    onCallerAbort = ()=>{
+        stop();
+        release();
+    };
+    if (controller.signal.aborted) release();
+    async function* iterate() {
+        try {
+            for(;;){
+                const next = await Promise.race([
+                    reader.read(),
+                    aborted
+                ]);
+                if ('aborted' === next) return;
+                if (next.done) return;
+                yield next.value;
+            }
+        } catch (error) {
+            if (isAbortError(error)) return;
+            throw error;
+        } finally{
+            release();
+        }
+    }
+    return {
+        abort: ()=>{
+            stop();
+            release();
+        },
+        [Symbol.asyncIterator]: iterate
+    };
+}
+async function client_resolveFor(defaults, override) {
+    const baseLayer = await resolveIdentityLayer(defaults);
+    const localLayer = await resolveIdentityLayer(override);
+    const parent = resolveClientOptions(defaults, baseLayer);
+    return resolveRequestOptions(override, parent, mergeIdentityLayers(baseLayer, localLayer));
+}
+function buildRequest(effective, spec, headers) {
+    const hasBody = void 0 !== spec.body;
+    return {
+        url: joinUrl(effective.baseURL, spec.path) + buildQuery(spec.query),
+        init: {
+            method: spec.method,
+            headers: hasBody ? {
+                'content-type': 'application/json',
+                ...headers
+            } : headers,
+            body: hasBody ? JSON.stringify(spec.body) : void 0,
+            credentials: effective.credentials
+        }
+    };
+}
+function createOvClient(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) throw new Error('createOvClient needs a fetch implementation. Pass `fetch` on platforms without a global one.');
+    const defaults = options;
+    async function send(spec, headers, signal, resolved) {
+        const effective = resolved ?? await client_resolveFor(defaults, spec.options);
+        const { url, init } = buildRequest(effective, spec, {
+            ...headers,
+            ...effective.headers
+        });
+        const active = signal ?? effective.signal;
+        try {
+            return {
+                response: await fetchImpl(url, {
+                    ...init,
+                    signal: active
+                }),
+                effective
+            };
+        } catch (error) {
+            normalizeTransportError(error, active);
+        }
+    }
+    async function requestJson(spec) {
+        const { response, effective } = await send(spec);
+        const raw = await readText(response, effective.signal);
+        const parsed = parseJson(raw);
+        const body = void 0 !== parsed ? parsed : raw.trim() ? raw : void 0;
+        if (!response.ok) throw toClientError(response, body);
+        throwIfErrorEnvelope(response, body);
+        const envelope = readEnvelope(body);
+        return {
+            result: 'result' in envelope ? envelope.result : body,
+            hasMore: true === envelope.has_more
+        };
+    }
+    const client = {
+        get baseURL () {
+            return defaults.baseURL ?? '';
+        },
+        async request (spec) {
+            if ('blob' === spec.responseType) {
+                const { response, effective } = await send(spec);
+                if (!response.ok) {
+                    const raw = await readText(response, effective.signal);
+                    throw toClientError(response, parseJson(raw) ?? raw);
+                }
+                return await readBlob(response, effective.signal);
+            }
+            const { result } = await requestJson(spec);
+            return result;
+        },
+        requestEnvelope (spec) {
+            if ('blob' === spec.responseType) return Promise.reject(new OvClientError({
+                code: 'INVALID_REQUEST',
+                message: 'requestEnvelope does not support responseType: blob'
+            }));
+            return requestJson(spec);
+        },
+        stream (spec) {
+            return openStream(spec, {
+                send,
+                resolveFor: client_resolveFor,
+                defaults
+            });
+        }
+    };
+    return client;
+}
+const OvClientContext = /*#__PURE__*/ createContext(null);
+function OpenVikingProvider({ baseURL, apiKey, accountId, userId, resourceId, credentials, signal, fetch, children }) {
+    const parent = useContext(OvClientContext);
+    const value = useMemo(()=>{
+        const base = mergeProviderConfig(parent?.base, {
+            baseURL,
+            apiKey,
+            accountId,
+            userId,
+            resourceId,
+            credentials,
+            signal,
+            fetch
+        });
+        return {
+            base,
+            client: createOvClient({
+                ...base.identity,
+                baseURL: base.baseURL,
+                credentials: base.credentials,
+                signal: base.signal,
+                fetch: base.fetch
+            })
+        };
+    }, [
+        parent,
+        baseURL,
+        apiKey,
+        accountId,
+        userId,
+        resourceId,
+        credentials,
+        signal,
+        fetch
+    ]);
+    return /*#__PURE__*/ jsx(OvClientContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+function useOvClient() {
+    return useContext(OvClientContext)?.client ?? null;
+}
+const OV_PATHS = {
+    fsLs: '/api/v1/fs/ls',
+    fsStat: '/api/v1/fs/stat',
+    fsTree: '/api/v1/fs/tree',
+    fsMkdir: '/api/v1/fs/mkdir',
+    fsMv: '/api/v1/fs/mv',
+    contentRead: '/api/v1/content/read',
+    contentAbstract: '/api/v1/content/abstract',
+    contentOverview: '/api/v1/content/overview',
+    contentDownload: '/api/v1/content/download',
+    contentWrite: '/api/v1/content/write',
+    searchGlob: '/api/v1/search/glob',
+    searchFind: '/api/v1/search/find',
+    searchGrep: '/api/v1/search/grep',
+    sessions: '/api/v1/sessions',
+    botChat: '/bot/v1/chat',
+    botChatStream: '/bot/v1/chat/stream'
+};
+const OV_PATH_BUILDERS = {
+    session: (sessionId)=>`${OV_PATHS.sessions}/${encodeURIComponent(sessionId)}`,
+    sessionMessages: (sessionId)=>`${OV_PATH_BUILDERS.session(sessionId)}/messages`
+};
+export { OV_PATHS, OV_PATH_BUILDERS, OpenVikingProvider, OvClientError, createOvClient, isOvClientError, useOvClient };