@openviking/react 0.1.0 → 0.1.2

package/dist/ark-message-list-view~0.js

@@ -0,0 +1,310 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { ChatMessageList } from "@ark-design/ui/message-list";
+import { Bubble } from "@ark-design/ui/bubble";
+import { ErrorCard } from "@ark-design/ui/error-card";
+import { ActivityTimeline } from "@ark-design/ui/activity-timeline";
+import { MDRenderer } from "@ark-design/ui/markdown-renderer";
+import { useState } from "react";
+import { groupActivityParts, toRenderItems, DEFAULT_LABELS } from "./c~0.js";
+import { messageText, groupMessages } from "./h~0.js";
+function renderPart(part, context) {
+    const { labels, onOpenUri } = context;
+    if ('text' === part.type) return 'markdown' === part.format ? /*#__PURE__*/ jsx("div", {
+        className: "ov-viking-bot__text ov-viking-bot__text--markdown",
+        children: part.text
+    }) : /*#__PURE__*/ jsx("div", {
+        className: "ov-viking-bot__text",
+        children: part.text
+    });
+    if ('reasoning' === part.type) return /*#__PURE__*/ jsxs("details", {
+        className: "ov-viking-bot__reasoning",
+        open: part.running,
+        children: [
+            /*#__PURE__*/ jsxs("summary", {
+                children: [
+                    labels.reasoning,
+                    part.durationMs ? ` · ${Math.round(part.durationMs / 1000)}s` : ''
+                ]
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "ov-viking-bot__reasoning-body",
+                children: part.text
+            })
+        ]
+    });
+    if ('iteration' === part.type) return /*#__PURE__*/ jsxs("div", {
+        className: "ov-viking-bot__iteration",
+        role: "separator",
+        children: [
+            "#",
+            part.iteration
+        ]
+    });
+    if ('context' === part.type) return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        className: "ov-viking-bot__context",
+        title: part.abstract,
+        onClick: ()=>onOpenUri?.(part.uri),
+        children: part.label ?? part.uri
+    });
+    if ('tool' === part.type) return /*#__PURE__*/ jsxs("details", {
+        className: "ov-viking-bot__tool",
+        open: 'running' === part.status,
+        children: [
+            /*#__PURE__*/ jsxs("summary", {
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-viking-bot__tool-name",
+                        children: part.name
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "ov-viking-bot__tool-status",
+                        children: labels[`tool${capitalize(part.status)}`] ?? part.status
+                    }),
+                    part.durationMs ? /*#__PURE__*/ jsx("span", {
+                        children: `${part.durationMs}ms`
+                    }) : null
+                ]
+            }),
+            part.input ? /*#__PURE__*/ jsx("pre", {
+                className: "ov-viking-bot__tool-input",
+                children: JSON.stringify(part.input, null, 2)
+            }) : null,
+            part.output ? /*#__PURE__*/ jsx("pre", {
+                className: "ov-viking-bot__tool-output",
+                children: part.output
+            }) : null
+        ]
+    });
+    if ('tool_result' === part.type) return /*#__PURE__*/ jsx("pre", {
+        className: part.isError ? 'ov-viking-bot__tool-output ov-viking-bot__tool-output--error' : 'ov-viking-bot__tool-output',
+        children: part.output
+    });
+    if ('image' === part.type) return /*#__PURE__*/ jsx("img", {
+        className: "ov-viking-bot__image",
+        src: part.src,
+        alt: part.alt ?? ''
+    });
+    return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        className: "ov-viking-bot__attachment",
+        onClick: ()=>part.uri && onOpenUri?.(part.uri),
+        children: part.name
+    });
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function MessageText({ text, streaming, format }) {
+    if ('plain' === format) return /*#__PURE__*/ jsx("div", {
+        className: "ov-viking-bot__text",
+        children: text
+    });
+    return /*#__PURE__*/ jsx(MDRenderer, {
+        className: "ov-viking-bot__text ov-viking-bot__text--markdown",
+        markdown: text,
+        showIndicator: streaming
+    });
+}
+function ActivityGroup({ id, items, running, labels, onOpenUri }) {
+    const [expanded, setExpanded] = useState(running);
+    const duration = items.reduce((total, item)=>total + (item.durationMs ?? 0), 0);
+    const summary = running ? labels.thinking : duration > 0 ? `${labels.reasoning} · ${Math.round(duration / 1000)}s` : labels.reasoning;
+    return /*#__PURE__*/ jsxs("section", {
+        className: "ov-viking-bot__activity",
+        "data-group": id,
+        children: [
+            /*#__PURE__*/ jsx("button", {
+                type: "button",
+                className: "ov-viking-bot__activity-toggle",
+                "aria-expanded": expanded,
+                onClick: ()=>setExpanded((current)=>!current),
+                children: summary
+            }),
+            expanded ? /*#__PURE__*/ jsx(ActivityTimeline, {
+                items: items,
+                density: "compact",
+                defaultExpanded: true,
+                onOpenSearchResult: (result)=>onOpenUri?.(result.url)
+            }) : null
+        ]
+    });
+}
+function MessageBody({ message, labels, onOpenUri }) {
+    const activity = message.parts.filter((part)=>'reasoning' === part.type || 'tool' === part.type);
+    const rest = message.parts.filter((part)=>'reasoning' !== part.type && 'tool' !== part.type);
+    const { groups, order } = groupActivityParts(activity);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            order.map((key)=>{
+                const group = groups.get(key);
+                if (!group) return null;
+                return /*#__PURE__*/ jsx(ActivityGroup, {
+                    id: group.id,
+                    items: group.items,
+                    running: group.items.some((item)=>'running' === item.status),
+                    labels: labels,
+                    onOpenUri: onOpenUri
+                }, group.id);
+            }),
+            rest.map((part, index)=>'text' === part.type ? /*#__PURE__*/ jsx(MessageText, {
+                    text: part.text,
+                    format: part.format,
+                    streaming: message.streaming
+                }, index) : /*#__PURE__*/ jsx("div", {
+                    children: renderPart(part, {
+                        labels,
+                        onOpenUri
+                    })
+                }, index))
+        ]
+    });
+}
+function MessageActions({ message, labels, onCopy, onMessageAction }) {
+    const text = messageText(message);
+    const actions = message.actions ?? (message.action ? [
+        {
+            messageId: message.id,
+            action: message.action
+        }
+    ] : []);
+    if (0 === actions.length && !onCopy) return null;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "ov-viking-bot__message-actions",
+        children: [
+            actions.map(({ messageId, action })=>/*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    className: "ov-viking-bot__message-action",
+                    disabled: Boolean(action.disabledReason) || 'pending' === action.status || 'success' === action.status,
+                    title: action.disabledReason,
+                    onClick: ()=>onMessageAction?.(messageId, action.key),
+                    children: action.label ?? action.key
+                }, `${messageId}:${action.key}`)),
+            onCopy && text ? /*#__PURE__*/ jsx("button", {
+                type: "button",
+                className: "ov-viking-bot__copy",
+                onClick: ()=>onCopy(text),
+                children: labels.copy
+            }) : null
+        ]
+    });
+}
+function VikingBotMessageRow({ message, labels, onOpenUri, onCopy, onMessageAction, renderMessage }) {
+    if (renderMessage) return /*#__PURE__*/ jsx("div", {
+        className: "ov-viking-bot__message",
+        children: renderMessage(message)
+    });
+    if ('system' === message.role) return /*#__PURE__*/ jsx(ErrorCard, {
+        className: 'error' === message.tone ? 'ov-viking-bot__notice ov-viking-bot__notice--error' : 'ov-viking-bot__notice',
+        content: messageText(message)
+    });
+    return /*#__PURE__*/ jsx(Bubble, {
+        className: `ov-viking-bot__message ov-viking-bot__message--${message.role}`,
+        placement: 'user' === message.role ? 'end' : 'start',
+        variant: 'user' === message.role ? 'filled' : 'text',
+        content: null,
+        footer: /*#__PURE__*/ jsx(MessageActions, {
+            message: message,
+            labels: labels,
+            onCopy: onCopy,
+            onMessageAction: onMessageAction
+        }),
+        children: /*#__PURE__*/ jsx(MessageBody, {
+            message: message,
+            labels: labels,
+            onOpenUri: onOpenUri
+        })
+    });
+}
+function VikingBotStreamingRow({ streaming, labels, onOpenUri }) {
+    if (0 === streaming.parts.length) return /*#__PURE__*/ jsx(Bubble, {
+        className: "ov-viking-bot__message ov-viking-bot__message--assistant",
+        placement: "start",
+        variant: "text",
+        loading: true
+    });
+    return /*#__PURE__*/ jsx(Bubble, {
+        className: "ov-viking-bot__message ov-viking-bot__message--assistant",
+        placement: "start",
+        variant: "text",
+        content: null,
+        children: /*#__PURE__*/ jsx(MessageBody, {
+            message: {
+                id: '__streaming__',
+                role: 'assistant',
+                parts: streaming.parts,
+                streaming: true
+            },
+            labels: labels,
+            onOpenUri: onOpenUri
+        })
+    });
+}
+const INITIAL_TARGET = {
+    kind: 'end',
+    behavior: 'auto'
+};
+const SCROLLER_STYLE = {
+    paddingLeft: 16,
+    paddingRight: 16,
+    paddingBottom: 24
+};
+const TURN_ANCHOR = {
+    behavior: 'smooth',
+    mode: 'bottom'
+};
+const AT_END_THRESHOLD = 8;
+const estimateSize = (item)=>{
+    if (item.streaming) return 96;
+    const message = item.message;
+    if (!message) return 96;
+    if ('system' === message.role) return 56;
+    const textLength = message.parts.reduce((total, part)=>total + ('text' === part.type ? part.text.length : 0), 0);
+    const activityCount = message.parts.filter((part)=>'reasoning' === part.type || 'tool' === part.type).length;
+    return Math.max(72, Math.min(640, 72 + 0.4 * textLength + 48 * activityCount));
+};
+function VikingBotMessageListView({ messages, className, streaming, footer, listKey, onOpenUri, onCopy, onMessageAction, renderMessage, labels: overrides }) {
+    const labels = {
+        ...DEFAULT_LABELS,
+        ...overrides
+    };
+    const items = toRenderItems(messages, streaming, groupMessages);
+    return /*#__PURE__*/ jsxs("div", {
+        className: [
+            'ov-viking-bot__list',
+            className
+        ].filter(Boolean).join(' '),
+        children: [
+            /*#__PURE__*/ jsx(ChatMessageList, {
+                listKey: listKey ?? 'viking-bot',
+                items: items,
+                getItemKey: (item)=>item.id,
+                estimateItemSize: estimateSize,
+                initialTarget: INITIAL_TARGET,
+                followOutput: streaming ? 'smooth' : false,
+                turnAnchor: TURN_ANCHOR,
+                atEndThreshold: AT_END_THRESHOLD,
+                scrollerStyle: SCROLLER_STYLE,
+                shortContentAlign: "start",
+                overscan: 480,
+                renderItem: ({ item })=>item.streaming ? /*#__PURE__*/ jsx(VikingBotStreamingRow, {
+                        streaming: item.streaming,
+                        labels: labels,
+                        onOpenUri: onOpenUri
+                    }) : item.message ? /*#__PURE__*/ jsx(VikingBotMessageRow, {
+                        message: item.message,
+                        labels: labels,
+                        onOpenUri: onOpenUri,
+                        onCopy: onCopy,
+                        onMessageAction: onMessageAction,
+                        renderMessage: renderMessage
+                    }) : null
+            }),
+            footer ? /*#__PURE__*/ jsx("div", {
+                className: "ov-viking-bot__footer",
+                children: footer
+            }) : null
+        ]
+    });
+}
+export { VikingBotMessageListView };

package/dist/a~0.js

@@ -0,0 +1,21 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+function Console({ className, style, labels }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: [
+            'ov-module-placeholder',
+            className
+        ].filter(Boolean).join(' '),
+        style: style,
+        children: [
+            /*#__PURE__*/ jsx("p", {
+                className: "ov-module-placeholder__title",
+                children: labels?.conversation ?? 'Console'
+            }),
+            /*#__PURE__*/ jsx("p", {
+                className: "ov-module-placeholder__description",
+                children: labels?.description ?? 'Placeholder. Functionality is not available yet.'
+            })
+        ]
+    });
+}
+export { Console };

package/dist/c7~0.js

@@ -0,0 +1,24 @@
+const DEFAULT_INTERACTION_LABELS = {
+    title: 'Needs your input',
+    submit: 'Submit',
+    cancel: 'Cancel',
+    other: 'Other',
+    submitted: 'Submitted',
+    cancelled: 'Cancelled',
+    progress: (index, total)=>`${index + 1} / ${total}`,
+    scheduleNone: 'Do not schedule',
+    scheduleDaily: 'Every day',
+    scheduleWeekly: 'Every week',
+    scheduleTime: 'Time',
+    scheduleWeekday: 'Weekday',
+    weekdays: [
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday',
+        'Sunday'
+    ]
+};
+export { DEFAULT_INTERACTION_LABELS };

package/dist/client/client.d.ts

@@ -0,0 +1,12 @@
+import type { OvClient, OvClientOptions } from './types.js';
+/**
+ * 用 `fetch` 实现 {@link OvClient}。这是库自带的默认传输层，调用方只需给服务
+ * 地址和身份字段；要换传输方式（例如复用宿主已有的 axios 实例）时才需要自己
+ * 实现 {@link OvClient}。
+ *
+ * Implements {@link OvClient} with `fetch`. This is the library's default
+ * transport, so a caller supplies only the service address and identity fields.
+ * Implement {@link OvClient} yourself only to replace the transport, for example
+ * to reuse the host's existing axios instance.
+ */
+export declare function createOvClient(options?: OvClientOptions): OvClient;

package/dist/client/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 请求失败的统一错误。区分 HTTP 失败与原生响应里的 `status: 'error'`，
+ * 保留服务端错误码、状态与请求标识。
+ * The single error a failed request raises. It distinguishes an HTTP failure
+ * from a native `status: 'error'` response and keeps the server error code,
+ * status and request identifier.
+ */
+export declare class OvClientError extends Error {
+    /** 服务端错误码，HTTP 失败时为 `HTTP_<status>` 或 `NETWORK_ERROR`。 */
+    readonly code: string;
+    /** HTTP 状态码；请求未到达服务端时省略。 */
+    readonly statusCode?: number;
+    /** 服务端返回的附加信息。 */
+    readonly details?: unknown;
+    /** 服务端请求标识，便于与服务端日志对应。 */
+    readonly requestId?: string;
+    /** 原始响应体，便于诊断无法归一的响应。 */
+    readonly responseBody?: unknown;
+    constructor(options: {
+        code: string;
+        message: string;
+        statusCode?: number;
+        details?: unknown;
+        requestId?: string;
+        responseBody?: unknown;
+        cause?: unknown;
+    });
+}
+/** 判断一个值是否为 {@link OvClientError}。 */
+export declare function isOvClientError(value: unknown): value is OvClientError;

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { createOvClient } from './client.js';
+export { OvClientError, isOvClientError } from './errors.js';
+export { OpenVikingProvider, type OpenVikingProviderProps, } from './provider.js';
+export type { OvClient, OvClientOptions, OvErrorEnvelope, OvIdentityValue, OvQueryValue, OvRequestOptions, OvRequestSpec, OvResolvedOptions, OvSuccessEnvelope, } from './types.js';

package/dist/client/options.d.ts

@@ -0,0 +1,101 @@
+import type { OvClientOptions, OvIdentityValue, OvQueryValue, OvRequestOptions, OvResolvedOptions } from './types.js';
+/**
+ * 身份字段到请求头的映射。宿主传字段值，Client 负责组装，不暴露 header 名称。
+ * Mapping from identity fields to request headers. A host passes field values and
+ * the Client assembles the headers, so header names stay internal.
+ */
+export declare const IDENTITY_HEADERS: {
+    readonly apiKey: 'X-API-Key';
+    readonly accountId: 'X-OpenViking-Account';
+    readonly userId: 'X-OpenViking-User';
+    readonly resourceId: 'V-Resource-Id';
+};
+export type OvIdentityField = keyof typeof IDENTITY_HEADERS;
+/**
+ * 求值一层身份字段，保留空字符串，以便区分「未提供」与「显式清除」。
+ * Evaluates one identity layer, keeping empty strings so that "absent" and
+ * "explicitly cleared" stay distinguishable.
+ */
+export declare function resolveIdentityLayer(options: OvRequestOptions | undefined): Promise<OvIdentityLayer>;
+/**
+ * 合并两层身份字段：近的一层覆盖远的一层，近层显式传空字符串即清除该字段。
+ * Merges two identity layers: the nearer one wins, and an explicit empty string
+ * in it clears the field.
+ */
+export declare function mergeIdentityLayers(far: OvIdentityLayer, near: OvIdentityLayer): OvIdentityLayer;
+/**
+ * 把身份字段转成请求头。空字符串表示清除，不发送对应请求头。
+ * Turns identity fields into headers. An empty string means cleared, so that
+ * header is not sent.
+ */
+export declare function toHeaders(layer: OvIdentityLayer): Record<string, string>;
+/**
+ * 解析客户端级配置。`baseURL` 缺省为空字符串，表示浏览器同源请求。
+ *
+ * 身份层由调用方求值后传入：函数形式的身份字段每次请求只应求值一次，父层配置
+ * 与请求覆盖必须复用同一份结果，否则会重复刷新凭证并可能发出旧值。
+ *
+ * Resolves client-level configuration. A missing `baseURL` is an empty string,
+ * meaning a same-origin browser request.
+ *
+ * The caller passes an already-evaluated identity layer: a function-form
+ * identity field must be evaluated once per request, and both the parent
+ * configuration and the request override must reuse that one result. Evaluating
+ * twice would refresh a credential twice and could send the older value.
+ */
+export declare function resolveClientOptions(options: OvClientOptions, identity: OvIdentityLayer): OvResolvedOptions;
+/**
+ * 在已解析的客户端配置上叠加一次请求的覆盖。`baseURL` 传空字符串表示同源，
+ * 只有 `undefined` 才继承。
+ *
+ * Applies one request's override on top of resolved client configuration. An
+ * empty `baseURL` means same origin; only `undefined` inherits.
+ */
+export declare function resolveRequestOptions(local: OvRequestOptions | undefined, parent: OvResolvedOptions, mergedLayer: OvIdentityLayer): OvResolvedOptions;
+/**
+ * 拼接服务地址与接口路径。拼接只在这里做：`/gateway/ov` 加 `/api/v1/fs/ls`
+ * 得到 `/gateway/ov/api/v1/fs/ls`，接口路径以 `/` 开头也不会丢掉前缀。
+ *
+ * Joins the service address and the API path. Joining happens only here:
+ * `/gateway/ov` plus `/api/v1/fs/ls` yields `/gateway/ov/api/v1/fs/ls`, and a
+ * leading `/` in the path never drops the prefix.
+ */
+export declare function joinUrl(baseURL: string, path: string): string;
+/**
+ * 把查询参数序列化为查询串，跳过 `undefined` 与 `null`，数组按键重复。
+ * Serialises query parameters, skipping `undefined` and `null`; arrays repeat
+ * the key.
+ */
+export declare function buildQuery(query: Readonly<Record<string, OvQueryValue>> | undefined): string;
+/**
+ * 一层已求值的身份字段：`undefined` 表示未提供，空字符串表示显式清除，其余
+ * 为要发送的值。
+ * One evaluated identity layer: `undefined` means absent, an empty string means
+ * explicitly cleared, anything else is the value to send.
+ */
+export type OvIdentityLayer = Partial<Record<OvIdentityField, string>>;
+/**
+ * 一层未求值的身份字段，供 Provider 逐层合并。函数形式原样保留，由客户端在
+ * 每次请求时求值。
+ * One unevaluated identity layer for Provider merging. Function values are kept
+ * as-is so the client evaluates them per request.
+ */
+export type OvIdentityConfig = Partial<Record<OvIdentityField, OvIdentityValue>>;
+/** Provider 已解析的配置，供嵌套 Provider 继续继承。 */
+export interface OvProviderBase {
+    baseURL?: string;
+    credentials?: RequestCredentials;
+    signal?: AbortSignal;
+    /** 传输层覆盖。内层未声明时继承外层，否则内层会丢掉外层的自定义 fetch。 */
+    fetch?: typeof globalThis.fetch;
+    identity: OvIdentityConfig;
+}
+/**
+ * 把本层配置叠加到父层之上。只覆盖本层显式声明的字段：`undefined` 表示继承，
+ * 空字符串表示清除继承到的值。
+ *
+ * Applies one layer of configuration on top of its parent. Only fields this
+ * layer declares are overridden: `undefined` inherits, and an empty string
+ * clears the inherited value.
+ */
+export declare function mergeProviderConfig(inherited: OvProviderBase | undefined, local: OvClientOptions): OvProviderBase;

package/dist/client/provider.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import type { OvClient, OvClientOptions } from './types.js';
+/**
+ * {@link OpenVikingProvider} 的属性。字段与 {@link OvClientOptions} 同形：
+ * 服务地址、身份与作用域、Cookie 策略，都按字段传值。
+ * Props of {@link OpenVikingProvider}, the same shape as {@link OvClientOptions}:
+ * the service address, identity and scope, and the cookie policy are all passed
+ * as fields.
+ */
+export interface OpenVikingProviderProps extends OvClientOptions {
+    children?: ReactNode;
+}
+/**
+ * 向子树下发请求配置。模块通过内部的 `useOvClient` 取用，宿主只需在应用根部
+ * 配置一次服务地址与身份字段，不必自己组装请求头。
+ *
+ * 开源版传 `apiKey`、`accountId`、`userId`；商业版由浏览器 Cookie 鉴权，只传
+ * `accountId`、`userId`、`resourceId`，并按需把 `credentials` 设为 `include`。
+ *
+ * 嵌套时内层只覆盖自己声明的字段，其余继承外层：外层配好服务地址与凭证后，
+ * 内层可以只改 `userId`。显式传空字符串表示清除继承到的值。
+ *
+ * 不传 `baseURL` 时按浏览器同源请求。挂载本身不发请求，也不读取浏览器里保存
+ * 的凭证。
+ *
+ * Provides request configuration to a subtree. Modules read it through the
+ * internal `useOvClient`, so a host configures the service address and identity
+ * fields once at the application root and never assembles headers itself.
+ *
+ * The open-source edition passes `apiKey`, `accountId` and `userId`; the
+ * commercial edition authenticates with a browser cookie, so it passes
+ * `accountId`, `userId` and `resourceId`, and sets `credentials` to `include`
+ * where needed.
+ *
+ * Nesting overrides only the fields the inner Provider declares and inherits the
+ * rest, so an outer Provider can own the service address and credential while an
+ * inner one changes only `userId`. An explicit empty string clears an inherited
+ * value.
+ *
+ * Without `baseURL` it targets the browser's own origin. Mounting it sends no
+ * request and reads no credential stored in the browser.
+ */
+export declare function OpenVikingProvider({ baseURL, apiKey, accountId, userId, resourceId, credentials, signal, fetch, children, }: OpenVikingProviderProps): import("react").JSX.Element;
+/**
+ * 读取最近的 Provider 提供的客户端。仅供模块内部使用，不从包入口导出：
+ * 调用方不需要知道该发什么请求，也就不会直接用它。
+ *
+ * Reads the client from the nearest Provider. Internal to modules and not
+ * exported from the package: a caller does not need to know which requests to
+ * send, so it has no reason to use this directly.
+ */
+export declare function useOvClient(): OvClient | null;