@openviking/react 0.1.2 → 0.1.3

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 };

package/dist/2~0.js

@@ -0,0 +1,122 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+function Divider({ orientation = 'vertical', length, thickness = 1, color, className, style, ...rest }) {
+    const vertical = 'vertical' === orientation;
+    const size = vertical ? {
+        flex: 'none',
+        width: thickness,
+        height: length
+    } : {
+        flex: 'none',
+        width: length ?? '100%',
+        height: thickness
+    };
+    return /*#__PURE__*/ jsx("div", {
+        ...rest,
+        role: "separator",
+        "aria-orientation": orientation,
+        className: [
+            'ov-divider',
+            className
+        ].filter(Boolean).join(' '),
+        style: {
+            background: color ?? 'var(--ov-ui-color-border-2, var(--ov-ui-border-2-default, #e1e4f2))',
+            ...size,
+            ...style
+        }
+    });
+}
+function ConnectAgentIcon() {
+    return /*#__PURE__*/ jsx("svg", {
+        width: "14",
+        height: "14",
+        viewBox: "0 0 14 14",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "1.4",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        focusable: "false",
+        children: /*#__PURE__*/ jsx("path", {
+            d: "M5.187 1.75V3.736M8.876 1.75V3.736M7.031 10.547V12.25M4.052 3.736H10.011A1.135 1.135 0 0 1 11.147 4.872V8.277A2.27 2.27 0 0 1 8.876 10.547H5.187A2.27 2.27 0 0 1 2.917 8.277V4.872A1.135 1.135 0 0 1 4.052 3.736Z"
+        })
+    });
+}
+function ImportResourcesIcon() {
+    return /*#__PURE__*/ jsx("svg", {
+        width: "12",
+        height: "12",
+        viewBox: "0 0 12 12",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "1.4",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        "aria-hidden": "true",
+        focusable: "false",
+        children: /*#__PURE__*/ jsx("path", {
+            d: "M10.5 7.5V8.1C10.5 8.94008 10.5 9.36012 10.3365 9.68099C10.1927 9.96323 9.96323 10.1927 9.68099 10.3365C9.36012 10.5 8.94008 10.5 8.1 10.5H3.9C3.05992 10.5 2.63988 10.5 2.31901 10.3365C2.03677 10.1927 1.8073 9.96323 1.66349 9.68099C1.5 9.36012 1.5 8.94008 1.5 8.1V7.5M3.5 4L6 1.5L8.5 4M6 1.5V7.5"
+        })
+    });
+}
+const DEFAULT_LABELS = {
+    connectAgent: 'Connect agent',
+    importResources: 'Import resources'
+};
+function FileBrowserEntries({ onConnectAgent, onImportResources, labels, className, ...rest }) {
+    const text = {
+        ...DEFAULT_LABELS,
+        ...labels
+    };
+    if (!onConnectAgent && !onImportResources) return null;
+    return /*#__PURE__*/ jsxs("div", {
+        ...rest,
+        className: [
+            'ov-file-browser-entries',
+            className
+        ].filter(Boolean).join(' '),
+        children: [
+            onConnectAgent ? /*#__PURE__*/ jsxs("button", {
+                type: "button",
+                className: "ov-file-browser-entries__entry",
+                onClick: onConnectAgent,
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__icon",
+                        "aria-hidden": "true",
+                        children: /*#__PURE__*/ jsx(ConnectAgentIcon, {})
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__label",
+                        children: text.connectAgent
+                    })
+                ]
+            }) : null,
+            onConnectAgent && onImportResources ? /*#__PURE__*/ jsx(Divider, {
+                className: "ov-file-browser-entries__divider",
+                length: 12,
+                color: "var(--ov-ui-color-primary, var(--ov-ui-primary-default, #5252ff))",
+                style: {
+                    opacity: 0.5
+                }
+            }) : null,
+            onImportResources ? /*#__PURE__*/ jsxs("button", {
+                type: "button",
+                className: "ov-file-browser-entries__entry",
+                onClick: onImportResources,
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__icon",
+                        "aria-hidden": "true",
+                        children: /*#__PURE__*/ jsx(ImportResourcesIcon, {})
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-file-browser-entries__label",
+                        children: text.importResources
+                    })
+                ]
+            }) : null
+        ]
+    });
+}
+export { FileBrowserEntries };