@osvi-ai/chat 0.0.0-stage → 0.1.1

package/dist/types/core/interactions.d.ts

@@ -0,0 +1,50 @@
+import type { Snapshot } from './http';
+import type { TranscriptItem } from './state';
+import { type InteractionMessage, type InteractionResponse, type PublicRow, type WireEnvelope, type WriteResult } from './protocol/types';
+export interface InteractionHost {
+    sessionId(): string | null;
+    humanConnected(): boolean;
+    sendFrame(frame: Record<string, unknown>): boolean;
+    updateItems(fn: (items: TranscriptItem[]) => TranscriptItem[]): void;
+    refreshSnapshot(): Promise<Snapshot | null>;
+    onChange(): void;
+    newId(): string;
+}
+export type InteractionError = {
+    code: 'interaction_not_pending' | 'interaction_suspended' | 'invalid_interaction' | 'network';
+    message: string;
+};
+export declare class InteractionController {
+    private readonly host;
+    private _active;
+    private _cursor;
+    private _pending;
+    private _error;
+    private operations;
+    private operation;
+    private generation;
+    private refreshInFlight;
+    private recoveryCursor;
+    constructor(host: InteractionHost);
+    get active(): InteractionMessage | null;
+    get cursor(): string;
+    get pending(): boolean;
+    get error(): InteractionError | null;
+    private setActive;
+    private setCursor;
+    private setSelectionPending;
+    private setInteractionError;
+    private setRows;
+    reset(): void;
+    private reject;
+    private mergeProjection;
+    private refreshMissingOutcome;
+    private hasMissingOutcome;
+    applySnapshot(snapshot: Snapshot): void;
+    applyEvent(event: WireEnvelope): boolean;
+    handleWriteResult(result: WriteResult): boolean;
+    respond(interactionId: string, response: InteractionResponse): boolean;
+    onConnectionOpen(): void;
+}
+export declare function toRows(items: TranscriptItem[]): PublicRow[];
+export declare function fromRows(rows: PublicRow[], previous: TranscriptItem[]): TranscriptItem[];

package/dist/types/core/protocol/envelope.d.ts

@@ -0,0 +1,2 @@
+import type { WireEnvelope } from './types';
+export declare function parseEnvelope(data: unknown): WireEnvelope | null;

package/dist/types/core/protocol/readers.d.ts

@@ -0,0 +1,14 @@
+import type { InteractionMessage, PublicRow, WireMessage } from './types';
+export declare function readInteraction(value: unknown): (InteractionMessage & {
+    role: 'assistant';
+}) | null;
+export declare function readPublicMessage(value: unknown): PublicRow | null;
+export declare function interactionCursor(value: unknown): string | null;
+export declare function compareCursors(left: string, right: string): number;
+export declare function mergeItems<T extends {
+    id: string;
+    interaction_id?: string;
+    interaction_revision?: number;
+    interaction_status?: string;
+}>(current: T[], additions: T[]): T[];
+export declare function readWireMessage(v: unknown): WireMessage | null;

package/dist/types/core/protocol/types.d.ts

@@ -0,0 +1,118 @@
+export interface InteractionCapability {
+    tool_type: string;
+    schema_version: number;
+}
+export interface ChoiceOption {
+    id: string;
+    label: string;
+    description?: string;
+    allow_input?: true;
+    input_placeholder?: string;
+}
+export interface ChoicePresentation {
+    label: string;
+    description?: string;
+    options: ChoiceOption[];
+}
+export interface CarouselImage {
+    url: string;
+    alt: string;
+}
+export interface CarouselItem {
+    id: string;
+    title: string;
+    description?: string;
+    image?: CarouselImage;
+    action_label?: string;
+}
+export interface CarouselPresentation {
+    label: string;
+    description?: string;
+    items: CarouselItem[];
+}
+export interface DatePickerPresentation {
+    label: string;
+    description?: string;
+    selection_mode: 'single' | 'range';
+    min_date?: string;
+    max_date?: string;
+    confirm_label?: string;
+}
+export type InteractionPresentation = ChoicePresentation | CarouselPresentation | DatePickerPresentation;
+export type InteractionResponse = {
+    kind: 'selection';
+    value: string;
+} | {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'date';
+    value: string;
+} | {
+    kind: 'date_range';
+    value: {
+        start_date: string;
+        end_date: string;
+    };
+};
+export interface InteractionMessage {
+    id: string;
+    type: 'interaction';
+    role: string;
+    content: string;
+    created_at?: string;
+    interaction_id: string;
+    tool_type: string;
+    schema_version: number;
+    presentation: InteractionPresentation;
+    interaction_status: 'preparing' | 'pending' | 'accepted' | 'resumed' | 'cancelled' | 'expired';
+    interaction_revision: number;
+    selected_option_id?: string | null;
+    response_payload?: InteractionResponse | null;
+}
+export declare const SUPPORTED_INTERACTIONS: readonly [{
+    readonly tool_type: "ui_buttons";
+    readonly schema_version: 1;
+}, {
+    readonly tool_type: "ui_buttons";
+    readonly schema_version: 2;
+}, {
+    readonly tool_type: "ui_carousel";
+    readonly schema_version: 1;
+}, {
+    readonly tool_type: "ui_date_picker";
+    readonly schema_version: 1;
+}];
+export interface WireEnvelope {
+    type: string;
+    session_id?: string;
+    account_id?: number | string;
+    ts?: string;
+    event_id?: string | number;
+    payload: Record<string, unknown>;
+}
+export type WriteState = 'accepted' | 'merged' | 'done' | 'failed' | 'busy' | 'invalid' | 'error';
+export interface WriteResult {
+    state: WriteState;
+    error?: string;
+    message_id?: string;
+    turn_id?: string;
+    interaction_id?: string;
+    merged_into?: string;
+}
+export interface WireMessage {
+    id: string;
+    role: 'user' | 'ai' | 'assistant' | 'operator' | 'support' | 'system';
+    content: string;
+    created_at?: string;
+    type?: 'message' | 'interaction';
+}
+export interface PublicRow extends Partial<Omit<InteractionMessage, 'id' | 'role' | 'content' | 'type' | 'presentation'>> {
+    id: string;
+    role: 'assistant' | 'user' | 'operator' | 'system';
+    content: string;
+    ts: string;
+    type?: 'message' | 'interaction';
+    presentation?: unknown;
+    local?: true;
+}

package/dist/types/core/protocol/validators.d.ts

@@ -0,0 +1,10 @@
+import type { CarouselPresentation, ChoicePresentation, DatePickerPresentation, InteractionCapability, InteractionPresentation, InteractionResponse } from './types';
+export declare function isProxyImageUrl(value: unknown): value is string;
+export declare function isPublicHttpsUrl(value: unknown): value is string;
+export declare function isChoicePresentation(value: unknown, maximum?: number): value is ChoicePresentation;
+export declare function isButtonsV1Presentation(value: unknown, maximum?: number): value is ChoicePresentation;
+export declare function isCarouselPresentation(value: unknown, maximum?: number, allowProxy?: boolean): value is CarouselPresentation;
+export declare function isCalendarDate(value: unknown): value is string;
+export declare function isDatePickerPresentation(value: unknown): value is DatePickerPresentation;
+export declare function isInteractionPresentation(pair: InteractionCapability, value: unknown): value is InteractionPresentation;
+export declare function isInteractionResponse(pair: InteractionCapability, value: unknown): value is InteractionResponse;

package/dist/types/core/state.d.ts

@@ -0,0 +1,23 @@
+import type { InteractionMessage } from './protocol/types';
+export type MessageRole = 'user' | 'assistant' | 'human';
+export interface Message {
+    kind: 'message';
+    id: string;
+    role: MessageRole;
+    content: string;
+    createdAt: string;
+    status: 'sending' | 'sent' | 'failed';
+    serverId?: string;
+    idempotencyKey?: string;
+}
+export interface InteractionItem {
+    kind: 'interaction';
+    id: string;
+    interaction: InteractionMessage;
+}
+export interface Divider {
+    kind: 'divider';
+    id: string;
+    reason: 'session_ended';
+}
+export type TranscriptItem = Message | InteractionItem | Divider;

package/dist/types/core/storage.d.ts

@@ -0,0 +1,10 @@
+export interface KeyValueStore {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+}
+export declare const VISITOR_KEY = "osvi.chat.visitor";
+export declare function memoryStore(): KeyValueStore;
+export declare function browserStore(): KeyValueStore;
+export declare function getVisitorId(store: KeyValueStore, random?: () => Uint8Array): string;
+export declare function sessionHintKey(agentId: string): string;

package/dist/types/core/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION: string;

package/dist/types/ui/define.d.ts

@@ -0,0 +1 @@
+export declare function defineOnce(name: string, ctor: CustomElementConstructor): void;

package/dist/types/ui/icons.d.ts

@@ -0,0 +1,9 @@
+export declare const chatIcon: import("lit-html").TemplateResult<2>;
+export declare const newChatIcon: import("lit-html").TemplateResult<2>;
+export declare const closeIcon: import("lit-html").TemplateResult<2>;
+export declare const launcherChatIcon: import("lit-html").TemplateResult<2>;
+export declare const launcherCloseIcon: import("lit-html").TemplateResult<2>;
+export declare const sendIcon: import("lit-html").TemplateResult<2>;
+export declare const leftIcon: import("lit-html").TemplateResult<2>;
+export declare const rightIcon: import("lit-html").TemplateResult<2>;
+export declare const osviLogo: import("lit-html").TemplateResult<2>;

package/dist/types/ui/index.d.ts

@@ -0,0 +1,9 @@
+import { OsviChat } from './osvi-chat';
+import { OsviButtons } from './tools/osvi-buttons';
+import { OsviCarousel } from './tools/osvi-carousel';
+import { OsviDatePicker } from './tools/osvi-date-picker';
+export { OsviButtons, OsviCarousel, OsviDatePicker };
+export { defineOnce } from './define';
+export { themeVariables, explicitThemeVariables, applyTheme, cssVar, type ChatTheme, type Variants } from './theme';
+export { OsviChat };
+export { DEFAULT_STRINGS, type ChatStrings } from './strings';

package/dist/types/ui/osvi-chat.d.ts

@@ -0,0 +1,70 @@
+import { LitElement } from 'lit';
+import { createChatClient, type ChatClient } from '../core';
+import { type ChatTheme, type Variants } from './theme';
+import { type ChatStrings } from './strings';
+export declare class OsviChat extends LitElement {
+    static clientFactory: typeof createChatClient;
+    static properties: {
+        themeAttribute: {
+            attribute: string;
+        };
+        stringsAttribute: {
+            attribute: string;
+        };
+    };
+    static styles: import("lit").CSSResult;
+    agentId: string;
+    baseUrl: string;
+    client: ChatClient | null;
+    theme: ChatTheme;
+    variants: Variants;
+    strings: Partial<ChatStrings>;
+    poweredBy: boolean;
+    newChat: boolean;
+    newChatHistory: string | undefined;
+    header: {
+        title?: string;
+        subtitle?: string;
+        avatarUrl?: string;
+    };
+    closable: boolean;
+    headerTitle: string | undefined;
+    headerSubtitle: string | undefined;
+    headerAvatar: string | undefined;
+    primaryColor: string | undefined;
+    radius: string | undefined;
+    mode: string | undefined;
+    buttons: string | undefined;
+    carousel: string | undefined;
+    themeAttribute: string | undefined;
+    stringsAttribute: string | undefined;
+    private chatState;
+    private draft;
+    private busy;
+    private typed;
+    private ownClient;
+    private boundClient;
+    private ownKey;
+    private unsubscribe;
+    private generation;
+    private followBottom;
+    private focusedInteraction;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private releaseClient;
+    private syncClient;
+    protected willUpdate(): void;
+    private mergedTheme;
+    private get labels();
+    private get blocked();
+    private get sessionBusy();
+    private run;
+    private restoreDraft;
+    private send;
+    private respond;
+    private requestInput;
+    focusActiveInteraction(): Promise<void>;
+    protected updated(): void;
+    private statusText;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/types/ui/panel/attrs.d.ts

@@ -0,0 +1,6 @@
+import type { ChatTheme } from '../theme';
+export declare function oneOf<T extends string>(value: string | null | undefined, allowed: readonly T[]): T | undefined;
+export declare function parseRadius(value: string | null | undefined): ChatTheme['radius'] | undefined;
+export declare function safeBaseUrl(value: string | null | undefined): string | undefined;
+export declare function safeAvatar(value: string | null | undefined): string | undefined;
+export declare function parseJsonAttr(name: string, value: string | null | undefined): Record<string, unknown> | undefined;

package/dist/types/ui/panel/composer.d.ts

@@ -0,0 +1,10 @@
+import type { ChatStrings } from '../strings';
+export interface ComposerOptions {
+    strings: ChatStrings;
+    draft: string;
+    placeholder: string;
+    disabled: boolean;
+    input: (event: Event) => void;
+    send: () => void;
+}
+export declare function renderComposer(o: ComposerOptions): import("lit-html").TemplateResult<1>;

package/dist/types/ui/panel/linkify.d.ts

@@ -0,0 +1,7 @@
+export type LinkPart = {
+    text: string;
+} | {
+    href: string;
+    text: string;
+};
+export declare function linkify(text: string): LinkPart[];

package/dist/types/ui/panel/transcript.d.ts

@@ -0,0 +1,4 @@
+import type { ChatState } from '../../core';
+import type { ChatStrings } from '../strings';
+import type { Variants } from '../theme';
+export declare function renderTranscript(state: ChatState, strings: ChatStrings, variants: Variants, baseUrl: string, retry: (id: string) => void): import("lit-html").TemplateResult<1>;

package/dist/types/ui/strings.d.ts

@@ -0,0 +1,27 @@
+export declare const DEFAULT_STRINGS: {
+    placeholder: string;
+    send: string;
+    typing: string;
+    humanJoined: string;
+    chooseOption: string;
+    typeAnswer: string;
+    sending: string;
+    pausedForHuman: string;
+    sendFailed: string;
+    retry: string;
+    sessionEnded: string;
+    reconnecting: string;
+    offline: string;
+    unavailable: string;
+    originBlocked: string;
+    rateLimited: string;
+    tryAgain: string;
+    closeChat: string;
+    poweredBy: string;
+    newChat: string;
+    emptyState: string;
+    defaultTitle: string;
+};
+export type ChatStrings = {
+    [K in keyof typeof DEFAULT_STRINGS]: string;
+};

package/dist/types/ui/styles.d.ts

@@ -0,0 +1 @@
+export declare const toolStyles: import("lit").CSSResult;

package/dist/types/ui/theme.d.ts

@@ -0,0 +1,22 @@
+export interface ChatTheme {
+    colors?: Partial<Record<'primary' | 'background' | 'surface' | 'text' | 'userBubble' | 'assistantBubble', string>>;
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'full' | number;
+    mode?: 'light' | 'dark';
+}
+export interface Variants {
+    buttons?: 'chips' | 'list';
+    carousel?: 'slider' | 'list';
+}
+declare const LIGHT: {
+    primary: string;
+    background: string;
+    surface: string;
+    text: string;
+    userBubble: string;
+    assistantBubble: string;
+};
+export declare const cssVar: (key: keyof typeof LIGHT) => string;
+export declare function themeVariables(theme: ChatTheme | undefined): Record<string, string>;
+export declare function explicitThemeVariables(theme: ChatTheme | undefined): Record<string, string>;
+export declare function applyTheme(host: HTMLElement, theme: ChatTheme | undefined): void;
+export {};

package/dist/types/ui/tools/base.d.ts

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+import type { InteractionMessage, InteractionResponse } from '../../core/protocol/types';
+import { type ChatTheme } from '../theme';
+export declare abstract class ToolElement extends LitElement {
+    interaction: InteractionMessage | null;
+    disabled: boolean;
+    theme: ChatTheme | undefined;
+    baseUrl: string;
+    protected abstract readonly toolType: string;
+    protected get live(): boolean;
+    protected get valid(): boolean;
+    protected respond(response: InteractionResponse): void;
+    protected updated(changed: Map<PropertyKey, unknown>): void;
+}

package/dist/types/ui/tools/osvi-buttons.d.ts

@@ -0,0 +1,10 @@
+import { nothing } from 'lit';
+import { ToolElement } from './base';
+export declare class OsviButtons extends ToolElement {
+    static styles: import("lit").CSSResult;
+    protected readonly toolType = "ui_buttons";
+    variant: 'chips' | 'list';
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    private pick;
+    private onKey;
+}

package/dist/types/ui/tools/osvi-carousel.d.ts

@@ -0,0 +1,16 @@
+import { nothing } from 'lit';
+import { ToolElement } from './base';
+export declare class OsviCarousel extends ToolElement {
+    static styles: import("lit").CSSResult;
+    protected readonly toolType = "ui_carousel";
+    variant: 'slider' | 'list';
+    private index;
+    private imageFailed;
+    private pointerStart;
+    private suppressPointerClick;
+    protected willUpdate(changed: Map<PropertyKey, unknown>): void;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    private navigate;
+    private select;
+    private card;
+}

package/dist/types/ui/tools/osvi-date-picker.d.ts

@@ -0,0 +1,17 @@
+import { nothing } from 'lit';
+import { ToolElement } from './base';
+export declare class OsviDatePicker extends ToolElement {
+    static styles: import("lit").CSSResult;
+    protected readonly toolType = "ui_date_picker";
+    variant: string;
+    private month;
+    private start;
+    private end;
+    private earliest;
+    protected willUpdate(changed: Map<PropertyKey, unknown>): void;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    private moveMonth;
+    private pick;
+    private confirm;
+    private onKey;
+}

package/dist/types/widget/config.d.ts

@@ -0,0 +1,23 @@
+import type { ChatAuth } from '../core';
+import type { ChatTheme, Variants } from '../ui/theme';
+import type { ChatStrings } from '../ui/strings';
+export interface WidgetConfig {
+    agentId: string;
+    baseUrl?: string;
+    position?: 'right' | 'left';
+    launcher?: 'bubble' | 'none';
+    greeting?: string;
+    theme?: ChatTheme;
+    variants?: Variants;
+    strings?: Partial<ChatStrings>;
+    poweredBy?: boolean;
+    newChat?: boolean;
+    newChatHistory?: 'clear' | 'keep';
+    header?: {
+        title?: string;
+        subtitle?: string;
+        avatarUrl?: string;
+    };
+    auth?: ChatAuth;
+}
+export declare function readConfig(script: HTMLScriptElement | null, global: unknown): WidgetConfig;

package/dist/types/widget/index.d.ts

@@ -0,0 +1 @@
+import '../ui/index';

package/dist/types/widget/launcher.d.ts

@@ -0,0 +1,35 @@
+import { LitElement } from 'lit';
+import type { ChatClient } from '../core';
+import type { OsviChat } from '../ui/osvi-chat';
+import type { WidgetConfig } from './config';
+export declare class OsviChatWidget extends LitElement {
+    static properties: {
+        config: {
+            attribute: boolean;
+        };
+        client: {
+            attribute: boolean;
+        };
+        opened: {
+            type: BooleanConstructor;
+        };
+        badge: {
+            type: NumberConstructor;
+        };
+        greetingDismissed: {
+            type: BooleanConstructor;
+        };
+    };
+    config: WidgetConfig;
+    client: ChatClient | null;
+    opened: boolean;
+    badge: number;
+    greetingDismissed: boolean;
+    onToggle: () => void;
+    onClose: () => void;
+    onDismiss: () => void;
+    static styles: import("lit").CSSResult;
+    get panel(): OsviChat | null;
+    focusLauncher(): void;
+    render(): import("lit-html").TemplateResult<1>;
+}

package/dist/types/widget/widget.d.ts

@@ -0,0 +1,13 @@
+import { type WidgetConfig } from './config';
+export interface WidgetApi {
+    open(): void;
+    close(): void;
+    toggle(): void;
+    destroy(): void;
+    init(config?: Partial<WidgetConfig>): void;
+}
+export declare const GREETING_KEY: (agentId: string) => string;
+export declare const SEEN_KEY: (agentId: string) => string;
+export declare const BADGE_RECHECK_MS = 30000;
+export declare function unmountWidget(): void;
+export declare function mountWidget(initial: WidgetConfig): WidgetApi;