@columenlabs/lumen-ui 0.1.77 → 0.1.79

package/dist/assistant/client.d.ts

@@ -0,0 +1,42 @@
+import type { AssistantChat, AssistantChatRow, AssistantEvent, AssistantMessage, AssistantProvider, AssistantSettingsPatch, AssistantStatus, DraftItem, KeyState, StepItem } from '@columenlabs/lumen-ui-types/assistant';
+type Test = NonNullable<KeyState['test']>;
+export interface AssistantAdapter {
+    /** Names the cache its reads keep (two assistants on one page need two keys). */
+    key: string;
+    status(): Promise<AssistantStatus>;
+    settings(patch: AssistantSettingsPatch): Promise<AssistantStatus>;
+    /** Admin: what each person may spend a month on the app's keys. */
+    appCap(usd: number): Promise<AssistantStatus>;
+    /** Admin: the app's key of a provider (tested before it is kept); null removes it. */
+    appKey(provider: AssistantProvider, key: string | null): Promise<AssistantStatus>;
+    testAppKey(provider: AssistantProvider): Promise<Test>;
+    /** The person's own key of a provider; null removes it. */
+    ownKey(provider: AssistantProvider, key: string | null): Promise<AssistantStatus>;
+    /** What the person may spend a month on their own keys. */
+    ownCap(usd: number): Promise<AssistantStatus>;
+    testOwnKey(provider: AssistantProvider): Promise<Test>;
+    /** Starts a plan sign-in (ChatGPT): the address to open and the one it ends on. */
+    startSignin(provider: AssistantProvider): Promise<{
+        url: string;
+        redirect: string;
+    }>;
+    /** Finishes it from the address the sign-in tab ended on. */
+    finishSignin(provider: AssistantProvider, url: string): Promise<AssistantStatus>;
+    /** Admin: ScrapeQL's Access service token; null removes it. */
+    scrapeql(token: {
+        client_id: string;
+        client_secret: string;
+    } | null): Promise<AssistantStatus>;
+    testScrapeql(): Promise<Test>;
+    chats(): Promise<AssistantChatRow[]>;
+    chat(id: string): Promise<AssistantChat>;
+    removeChat(id: string): Promise<void>;
+    /** One answer: `onEvent` hears each event as it streams; abort `signal` to stop it. */
+    send(msg: AssistantMessage, onEvent: (e: AssistantEvent) => void, signal?: AbortSignal): Promise<void>;
+    settleDraft(chatId: string, draftId: string, action: 'save' | 'dismiss'): Promise<DraftItem>;
+    /** Takes back a change the assistant made at once. */
+    undoWrite(chatId: string, stepId: string): Promise<StepItem>;
+}
+/** The adapter over `assistantRoutes` mounted at `base` (`/api/assistant`). */
+export declare function assistantClient(base: string): AssistantAdapter;
+export {};

package/dist/assistant/client.js

@@ -0,0 +1,81 @@
+import { ApiError, apiJson } from '../api-fetch.js';
+/** Reads `event:` / `data:` blocks off a server-sent event stream. */
+async function readEvents(body, on) {
+    const reader = body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buf += dec.decode(value, { stream: true });
+        let at = buf.indexOf('\n\n');
+        while (at >= 0) {
+            const block = buf.slice(0, at);
+            buf = buf.slice(at + 2);
+            let event = 'message';
+            let data = '';
+            for (const line of block.split('\n')) {
+                if (line.startsWith('event:'))
+                    event = line.slice(6).trim();
+                else if (line.startsWith('data:'))
+                    data += line.slice(5).trim();
+            }
+            if (data) {
+                try {
+                    on({ event, data: JSON.parse(data) });
+                }
+                catch { }
+            }
+            at = buf.indexOf('\n\n');
+        }
+    }
+}
+/** The adapter over `assistantRoutes` mounted at `base` (`/api/assistant`). */
+export function assistantClient(base) {
+    const root = base.replace(/\/+$/, '');
+    const get = (path) => apiJson(`${root}${path}`, {}, 'assistant');
+    const send = (method, path, body = {}) => apiJson(`${root}${path}`, { method, body: JSON.stringify(body) }, 'assistant');
+    return {
+        key: `assistant:${root}`,
+        status: () => get('/status'),
+        settings: (patch) => send('PUT', '/settings', patch),
+        appCap: (usd) => send('PUT', '/app', { cap_usd: usd }),
+        appKey: (p, key) => key
+            ? send('PUT', `/key?provider=${p}`, { api_key: key })
+            : send('DELETE', `/key?provider=${p}`),
+        testAppKey: (p) => send('POST', `/key/test?provider=${p}`),
+        ownKey: (p, key) => key
+            ? send('PUT', `/my-key?provider=${p}`, { api_key: key })
+            : send('DELETE', `/my-key?provider=${p}`),
+        ownCap: (usd) => send('PUT', '/my-key/cap', { cap_usd: usd }),
+        testOwnKey: (p) => send('POST', `/my-key/test?provider=${p}`),
+        startSignin: (p) => send('POST', `/my-signin?provider=${p}`),
+        finishSignin: (p, url) => send('POST', `/my-signin/finish?provider=${p}`, { url }),
+        scrapeql: (token) => token ? send('PUT', '/web/scrapeql', token) : send('DELETE', '/web/scrapeql'),
+        testScrapeql: () => send('POST', '/web/test'),
+        chats: () => get('/chats'),
+        chat: (id) => get(`/chats/${encodeURIComponent(id)}`),
+        removeChat: async (id) => {
+            await send('DELETE', `/chats/${encodeURIComponent(id)}`);
+        },
+        settleDraft: (chatId, draftId, action) => send('POST', `/chats/${encodeURIComponent(chatId)}/drafts/${encodeURIComponent(draftId)}`, {
+            action,
+        }),
+        undoWrite: (chatId, stepId) => send('POST', `/chats/${encodeURIComponent(chatId)}/writes/${encodeURIComponent(stepId)}/undo`),
+        async send(msg, onEvent, signal) {
+            const url = `${root}/chat`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', accept: 'text/event-stream' },
+                body: JSON.stringify(msg),
+                ...(signal ? { signal } : {}),
+            });
+            if (!res.ok || !res.body) {
+                const b = (await res.json().catch(() => ({})));
+                throw new ApiError(b.error ?? `The answer failed (${res.status})`, 'POST', url, res.status, b.code);
+            }
+            await readEvents(res.body, onEvent);
+        },
+    };
+}

package/dist/assistant/index.d.ts

@@ -0,0 +1,5 @@
+export { type AssistantAdapter, assistantClient } from './client.js';
+export { type AssistantCommand, type ComposerExtra, LumenAssistant, type LumenAssistantProps, LumenComposer, assistantStatusKey, useAssistantStatus, useLumenAssistantDock, } from './lumen-assistant.js';
+export { assistantSettingsSections } from './settings.js';
+export { type AssistantSource, type AssistantSourceItem, type ComposeRequest, type PageSelection, composeAssistant, selectionRef, useAssistantSource, usePageSelection, useShownAssistantSources, } from './sources.js';
+export { type AssistantChatState, type LiveItem, applyEvent, useAssistantChat, } from './use-assistant-chat.js';

package/dist/assistant/index.js

@@ -0,0 +1,8 @@
+// `@columenlabs/lumen-ui/assistant`: an assistant's chat panel and Settings sections, over the
+// routes of `@columenlabs/lumen-ai/assistant`; the shapes both share are
+// `@columenlabs/lumen-ui-types/assistant`.
+export { assistantClient } from './client.js';
+export { LumenAssistant, LumenComposer, assistantStatusKey, useAssistantStatus, useLumenAssistantDock, } from './lumen-assistant.js';
+export { assistantSettingsSections } from './settings.js';
+export { composeAssistant, selectionRef, useAssistantSource, usePageSelection, useShownAssistantSources, } from './sources.js';
+export { applyEvent, useAssistantChat, } from './use-assistant-chat.js';

package/dist/assistant/lumen-assistant.d.ts

@@ -0,0 +1,84 @@
+import type { AssistantMessage, AssistantRefNote, AssistantStatus } from '@columenlabs/lumen-ui-types/assistant';
+import { type LumenOption } from '../lumen-selector.js';
+import type { AssistantAdapter } from './client.js';
+import { type AssistantSource } from './sources.js';
+import { type AssistantChatState } from './use-assistant-chat.js';
+export declare const assistantStatusKey: (client: AssistantAdapter) => string[];
+/** The person's assistant status, shared by the panel and Settings. */
+export declare function useAssistantStatus(client: AssistantAdapter): import("@tanstack/react-query").UseQueryResult<AssistantStatus, Error>;
+export declare const usd: (n: number) => string;
+export interface LumenAssistantProps {
+    client: AssistantAdapter;
+    /** The page the person is on, sent with each message. */
+    context?: AssistantMessage['context'];
+    /** Opens the app's Settings at the assistant (from a "not connected" line). */
+    onSettings?: () => void;
+    /** Days chats are kept, for the Chats menu's line. */
+    keepDays?: number;
+    /** Closes the panel (its ✕). */
+    onClose?: () => void;
+    /** An outside chat state (the dock shares one between the button and the panel). */
+    chat?: AssistantChatState;
+    /**
+     * The app's own slash commands, listed before the server's (`createAssistant` `commands`) and the
+     * kit's: /compact, /clear, /model and /escalate.
+     */
+    commands?: AssistantCommand[];
+    /** What `#` lists everywhere; a page adds its own with `useAssistantSource`. */
+    sources?: readonly AssistantSource[];
+}
+/** A slash command: typing `/` in the composer lists them. */
+export interface AssistantCommand {
+    /** Typed after the slash: `story`. */
+    name: string;
+    /** One line in the list. */
+    about: string;
+    /** What follows the name, shown in the list (`<words>`). Without it, picking it runs it. */
+    args?: string;
+    /** Choices for the words after it, listed as they are typed (a tier, a saved search). */
+    options?: () => LumenOption[];
+    /** Runs it: a string is sent as the message; nothing when the command acted itself. */
+    run: (args: string) => string | undefined | Promise<string | undefined>;
+}
+/** The assistant's chat: header, messages and composer. */
+export declare function LumenAssistant({ client, context, onSettings, keepDays, onClose, chat: outside, commands, sources, }: LumenAssistantProps): import("react").JSX.Element;
+/** What the composer sends with the text: the tier picked with `@` and the things pointed at with `#`. */
+export interface ComposerExtra {
+    tier?: string;
+    refs?: AssistantRefNote[];
+}
+/**
+ * The message box: Enter sends, Shift+Enter breaks a line; Stop while an answer runs. Three
+ * triggers list what can follow them as it is typed: `/` at the start a command, `@` a tier for
+ * this message, `#` a thing to point at (the `sources`); a picked tier or thing shows as a chip.
+ */
+export declare function LumenComposer({ name, busy, queued, disabled, commands, tiers, sources, onSend, onStop, }: {
+    name: string;
+    busy: boolean;
+    queued: string | null;
+    disabled?: boolean;
+    commands?: AssistantCommand[];
+    /** What `@` lists. */
+    tiers?: {
+        id: string;
+        label: string;
+        model_label?: string;
+    }[];
+    /** What `#` lists, a group each. */
+    sources?: readonly AssistantSource[];
+    onSend: (text: string, extra: ComposerExtra) => void;
+    onStop: () => void;
+}): import("react").JSX.Element;
+/**
+ * The assistant docked in LumenShell: put `button` in `headerActions` and `panel` in `panel`.
+ * Open or closed is this browser tab's own, and ⌘J toggles it.
+ */
+export declare function useLumenAssistantDock(client: AssistantAdapter, o?: Omit<LumenAssistantProps, 'client' | 'chat' | 'onClose'> & {
+    name: string;
+}): {
+    open: boolean;
+    setOpen: (v: boolean) => void;
+    chat: AssistantChatState;
+    button: import("react").JSX.Element;
+    panel: import("react").JSX.Element;
+};