@itechchoice/prime-chatkit 0.1.0-alpha.0

package/dist/types/components/ui/collaboration-stream-clean.d.ts

@@ -0,0 +1,98 @@
+import { type ReactNode } from "react";
+export type StreamKind = "ask" | "reply" | "handoff" | "share" | "question" | "spawn";
+export type StreamAgent = {
+    id: string;
+    name: string;
+    /** The model – shown in the agent's tooltip */
+    model?: string;
+    /** A small mark instead of its pixel mark, e.g. the model maker's logo */
+    avatar?: ReactNode;
+};
+export type StreamAttachment = {
+    label: string;
+    /** Picks its icon – left out, it's told from the label: "…/" is a folder, ".csv" a table, any other extension a file */
+    kind?: "file" | "folder" | "table" | "tool" | "link";
+    /** What its preview window shows – a table as CSV, a folder's entries one per line ("…/" for a folder), anything else as text */
+    preview?: string;
+    /** A short line under its name in the preview, like "4 rows" or "2 KB" */
+    meta?: string;
+};
+export type StreamMessage = {
+    id: string;
+    /** Who speaks – an agent's id, or "you" */
+    from: string;
+    /** Who it's for – one agent, several, "all" or "you" */
+    to: string | string[];
+    kind: StreamKind;
+    text: string;
+    /** When, already formatted – e.g. "14:02" or "2m ago" */
+    at?: string;
+    /** The message it answers – shown as a quote, a click on it jumps there */
+    replyTo?: string;
+    /** Still being written – "writing" shimmers and the sender's mark twinkles */
+    typing?: boolean;
+    attachments?: StreamAttachment[];
+    /** What opens under the message when it's clicked: a few facts, and what it used or points to */
+    details?: StreamDetails;
+};
+export type StreamDetails = {
+    /** Short facts in a row, e.g. { label: "Model", value: "Opus 5.5" }, tokens, cost, time */
+    facts?: {
+        label: string;
+        value: ReactNode;
+    }[];
+    /** What it used or points to – tools, pages, files – each with an optional logo */
+    items?: {
+        label: string;
+        detail?: string;
+        icon?: ReactNode;
+    }[];
+};
+export type CollaborationStreamProps = {
+    agents: StreamAgent[];
+    /** The messages in the order they were sent – a "spawn" message shows as a quiet line */
+    messages: StreamMessage[];
+    /** What the run is about – shown muted next to the title */
+    task?: string;
+    /** The run is still going – the stream follows new messages */
+    live?: boolean;
+    /** Controlled id of the picked message – its details open, the rest fades */
+    selected?: string | null;
+    onSelectedChange?: (id: string | null) => void;
+    /** Controlled id of the agent whose messages are picked out */
+    focusAgent?: string | null;
+    onFocusAgentChange?: (id: string | null) => void;
+    /** The stream scrolls past this height (px) – with a composer it is the stream's fixed height, so the composer never moves */
+    maxHeight?: number;
+    /** Write into the stream. With it, a composer sits under the stream – "@" names the agents it's for, and a question
+     *  for you can be answered right from its message */
+    onSend?: (message: {
+        text: string;
+        to: string[];
+        replyTo?: string;
+    }) => void;
+    /** The composer's placeholder */
+    placeholder?: string;
+    /** Companies or products whose name gets its logo in the text, e.g. { Notion: <NotionLogo />, Stripe: <StripeLogo /> } */
+    logos?: Record<string, ReactNode>;
+    title?: string;
+    className?: string;
+    labels?: {
+        close?: string;
+        noPreview?: (name: string) => string;
+    };
+};
+export type PreviewWindowProps = {
+    title: string;
+    meta?: ReactNode;
+    icon?: ReactNode;
+    onClose: () => void;
+    children: ReactNode;
+    placement?: "inside" | "viewport";
+    size?: "default" | "large";
+    labels?: {
+        close?: string;
+    };
+};
+export declare function PreviewWindow({ title, meta, icon, onClose, children, placement, size, labels }: PreviewWindowProps): import("react").JSX.Element;
+export declare function CollaborationStream({ agents, messages, task, live, selected: selectedProp, onSelectedChange, focusAgent: focusProp, onFocusAgentChange, maxHeight, logos, onSend, placeholder, title, className, labels, }: CollaborationStreamProps): import("react").JSX.Element;

package/dist/types/components/ui/command-menu-clean.d.ts

@@ -0,0 +1,57 @@
+import { type ReactNode } from "react";
+export type Command = {
+    id: string;
+    label: string;
+    /** Lighter text after the label, e.g. a person, a channel or a page */
+    hint?: string;
+    /** "logo" sits on a small white tile; "icon" is a plain glyph */
+    icon?: ReactNode;
+    logo?: ReactNode;
+    /** Keys shown on the right, e.g. ["G", "I"] – suggestions get ⌘1–⌘5 automatically */
+    keys?: string[];
+    /** Extra words that should find this command */
+    keywords?: string;
+    actions?: {
+        id: string;
+        label: string;
+        icon?: ReactNode;
+    }[];
+    editing?: boolean;
+};
+export type CommandGroup = {
+    id: string;
+    label: string;
+    commands: Command[];
+};
+export type CommandMenuLabels = {
+    placeholder: string;
+    jumpSections: string;
+    open: string;
+    assistant: string;
+    ask: (query: string) => string;
+    asked: (query: string) => string;
+    ran: (label: string) => string;
+    command: string;
+    commands: string;
+};
+export declare const defaultCommandMenuLabels: CommandMenuLabels;
+export type CommandMenuProps = {
+    groups?: CommandGroup[];
+    placeholder?: string;
+    /** Called with the command id; for the assistant fallback with "ask" and the typed text */
+    onRun?: (id: string, query?: string) => void;
+    /** Runs on Esc in an empty search */
+    onClose?: () => void;
+    /** Focus the field when the menu appears */
+    autoFocus?: boolean;
+    className?: string;
+    onAction?: (commandId: string, actionId: string) => void;
+    onEditSubmit?: (commandId: string, value: string) => void;
+    onEditCancel?: (commandId: string) => void;
+    ask?: boolean;
+    hotkey?: boolean;
+    labels?: Partial<CommandMenuLabels>;
+};
+/** Sample commands – replace with your own */
+export declare const defaultGroups: CommandGroup[];
+export declare function CommandMenu({ groups, placeholder, onAction, onEditSubmit, onEditCancel, ask, hotkey, labels: labelOverrides, onRun, onClose, autoFocus, className, }: CommandMenuProps): import("react").JSX.Element;

package/dist/types/components/ui/decision-card-clean.d.ts

@@ -0,0 +1,87 @@
+import { type ReactNode } from "react";
+export type DecisionKind = "decision" | "pick" | "approval";
+/** A gray block of a preview tile, on a 120 × 80 grid */
+export type DecisionBlock = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    r?: number;
+    tone?: "ink" | "mid" | "soft";
+};
+export type DecisionOption = {
+    id: string;
+    title: string;
+    /** One line – it ends in … when it doesn't fit */
+    summary?: string;
+    /** A small gray Recommended tag – the row is also where the focus starts */
+    recommended?: boolean;
+    /** pick: what the tile shows – your own node, or gray blocks on a 120 × 80 grid */
+    preview?: ReactNode;
+    blocks?: DecisionBlock[];
+};
+export type Decision = {
+    id: string;
+    question: string;
+    /** The task it belongs to – shown muted in the head */
+    task?: string;
+    /** decision: rows to pick from · pick: preview tiles · approval: facts, then Approve / Decline (default: decision) */
+    kind?: DecisionKind;
+    /** decision and pick – all supplied options */
+    options?: DecisionOption[];
+    own?: boolean;
+    multiple?: {
+        min?: number;
+        max?: number;
+    };
+    validate?: (text: string) => string | null;
+    inputMode?: "text" | "decimal" | "numeric";
+    placeholder?: string;
+    readOnly?: boolean;
+    /** approval – two or three lines of what it will do */
+    facts?: {
+        label: string;
+        value: string;
+    }[];
+};
+/** What you answered: an option or your own words – or approve / decline */
+export type DecisionAnswer = {
+    option?: string;
+    text?: string;
+    options?: never;
+} | {
+    options: string[];
+    option?: never;
+    text?: never;
+} | "approve" | "decline";
+export type DecisionCardLabels = {
+    needsYou: string;
+    later: string;
+    show: string;
+    recommended: string;
+    approve: string;
+    decline: string;
+    own: string;
+    send: string;
+    confirm: string;
+    answered: string;
+    previous: string;
+    next: string;
+    allDone: string;
+    waiting: (n: number) => string;
+    of: (i: number, n: number) => string;
+};
+export type DecisionCardProps = {
+    /** The open decisions, oldest first – answered ones leave the card at once; drop them from the array in onDecide */
+    decisions: Decision[];
+    onDecide?: (id: string, answer: DecisionAnswer) => void;
+    /** Later or Esc folded the card to one line */
+    onLater?: (id: string) => void;
+    /** Start folded to "2 decisions waiting · Show" */
+    defaultFolded?: boolean;
+    /** Change it (e.g. a counter) to bring the card up from elsewhere – it unfolds, pulses gray once and takes the focus */
+    reveal?: number;
+    labels?: Partial<DecisionCardLabels>;
+    className?: string;
+};
+export declare function DecisionCard({ decisions, onDecide, onLater, defaultFolded, reveal, labels, className }: DecisionCardProps): import("react").JSX.Element;

package/dist/types/components/ui/dropzone-clean.d.ts

@@ -0,0 +1,70 @@
+export type UploadStatus = "uploading" | "done" | "error";
+export type UploadItem = {
+    id: string;
+    name: string;
+    /** In bytes */
+    size: number;
+    status: UploadStatus;
+    /** 0 to 1 */
+    progress: number;
+    error?: string;
+    /** The real file – missing for the sample files */
+    file?: File;
+};
+export type DropzoneProps = {
+    labels?: Partial<DropzoneLabels>;
+    /** Allowed extensions, e.g. [".pdf", ".png"] – any file when left out */
+    accept?: string[];
+    /** Largest file in bytes */
+    maxSize?: number;
+    /** Upload a file and report its progress (0–1); throw to mark it as failed. Simulated when left out */
+    onUpload?: (file: File, onProgress: (progress: number) => void) => Promise<void>;
+    /** Called whenever the list changes */
+    onChange?: (items: UploadItem[]) => void;
+    /** Text under the title – defaults to the accepted types and size */
+    hint?: string;
+    /** Plays a sample drop on its own – nice for previews */
+    autoplay?: boolean;
+    className?: string;
+};
+export declare const defaultDropzoneLabels: {
+    dropFiles: string;
+    browse: string;
+    tapTo: string;
+    chooseFiles: string;
+    release: (n: number) => string;
+    anyFile: string;
+    acceptedTypes: (types: string[]) => string;
+    hint: (types: string, size: string) => string;
+    unsupportedType: (extension: string) => string;
+    tooLarge: (size: string) => string;
+    uploadFailed: string;
+    connectionLost: string;
+    failedAnnouncement: (name: string) => string;
+    errorAnnouncement: (name: string, error: string) => string;
+    uploadedAnnouncement: (name: string) => string;
+    uploading: (n: number, total: number) => string;
+    partiallyUploaded: (n: number, total: number) => string;
+    allUploaded: (n: number) => string;
+    uploads: string;
+    uploaded: string;
+    noFiles: string;
+    clear: string;
+    uploadProgress: (name: string) => string;
+    retry: (name: string) => string;
+    remove: (name: string) => string;
+    bytes: string;
+    kilobytes: string;
+    megabytes: string;
+    gigabytes: string;
+    sentOf: (sent: string, total: string) => string;
+    starting: string;
+    almostDone: string;
+    secondsLeft: (n: number) => string;
+    minutesLeft: (n: number) => string;
+    hoursLeft: (n: number) => string;
+    daysLeft: (n: number) => string;
+    fileBadge: (extension: string) => string;
+};
+export type DropzoneLabels = typeof defaultDropzoneLabels;
+export declare function Dropzone({ labels: labelProp, accept, maxSize, onUpload, onChange, hint, autoplay, className, }: DropzoneProps): import("react").JSX.Element;

package/dist/types/components/ui/tool-call-card-clean.d.ts

@@ -0,0 +1,76 @@
+import { type ReactNode } from "react";
+export type ToolCallStatus = "running" | "success" | "error";
+export declare const defaultToolCallLabels: {
+    failed: string;
+    error: string;
+    retry: string;
+    arguments: string;
+    result: string;
+    waiting: string;
+    empty: string;
+    showAll: string;
+    showLess: string;
+    copied: string;
+    copyArguments: string;
+    copyResult: string;
+    running: (name: string) => string;
+    finished: (name: string) => string;
+    failedAnnouncement: (name: string, error?: string) => string;
+    duration: (ms: number, live: boolean) => string;
+    usingTools: string;
+    usedTools: (n: number) => string;
+    failedTools: (n: number) => string;
+    groupAnnouncement: (count: string, failed: number) => string;
+};
+export type ToolCallLabels = typeof defaultToolCallLabels;
+export type ToolCallCardLabels = ToolCallLabels;
+export type ToolCallGroupLabels = ToolCallLabels;
+export type ToolCallCardProps = {
+    labels?: Partial<ToolCallLabels>;
+    /** Tool name as the agent calls it, shown in mono – e.g. "search_web" */
+    name: string;
+    /** Short human summary – e.g. "Searched the web for 'CRM pricing 2026'" */
+    summary?: ReactNode;
+    /** Icon in the tile on the left – defaults to a wrench */
+    icon?: ReactNode;
+    status: ToolCallStatus;
+    /** Arguments the tool was called with – objects are pretty-printed, JSON strings parsed */
+    args?: unknown;
+    /** What the tool returned – objects are pretty-printed, JSON strings parsed, other text shown as is */
+    result?: unknown;
+    /** Error message, shown when status is "error" */
+    error?: string;
+    /** When the call started (ms since epoch, e.g. Date.now()) – the live timer counts from here */
+    startedAt?: number;
+    /** Final duration in ms – otherwise measured while the card shows "running" */
+    duration?: number;
+    /** Start expanded (uncontrolled) */
+    defaultOpen?: boolean;
+    /** Expanded state (controlled) */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Opens the card when the call fails and closes it again on the next run, unless someone toggled it */
+    openOnError?: boolean;
+    /** Shows a Retry button next to the error */
+    onRetry?: () => void;
+    /** Height in px after which arguments and result are capped with a fade and "Show all" */
+    maxCodeHeight?: number;
+    className?: string;
+};
+export type ToolCallGroupProps = {
+    labels?: Partial<ToolCallGroupLabels>;
+    /** ToolCallCard elements – the group reads their name, icon, status and duration */
+    children: ReactNode;
+    /** Label once all calls are done – defaults to "Used 3 tools" */
+    label?: string;
+    /** Label while any call is running */
+    runningLabel?: string;
+    /** Total duration in ms – otherwise the sum of the cards' durations, or the time measured while running */
+    duration?: number;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+};
+export declare function ToolCallCard({ name, summary, icon, status, args, result, error, startedAt, duration, defaultOpen, open: openProp, onOpenChange, openOnError, onRetry, maxCodeHeight, className, labels: labelProp, }: ToolCallCardProps): import("react").JSX.Element;
+export declare function ToolCallGroup({ children, label, runningLabel, duration, defaultOpen, open: openProp, onOpenChange, className, labels: labelProp, }: ToolCallGroupProps): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import type { ChatMessage } from "./types";
+/** Map a chronological history page without mutating records or consulting the clock. */
+export declare function messagesFromHistory(records: unknown[]): ChatMessage[];

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

@@ -0,0 +1,34 @@
+/**
+ * Pure reducer: prime-chatkit SSE events → Run view model.
+ * Event names and fields follow the prime-chatkit SDK 1.0.2 BFF contract (see prime-via docs/abc-prime-chat-frontend-api.md
+ * and the captures in demo/fixtures). Unknown events are ignored, never thrown on.
+ */
+import type { Run, StreamEvent, Turn } from "./types";
+export declare function num(v: unknown): number | undefined;
+/** Only decimal event ids can participate in replay detection or stream resumption. */
+export declare function eventIdOf(raw: string | undefined): string | undefined;
+/** Decimal-string compare for snowflake ids; never convert to Number */
+export declare function idGreater(a: string, b: string): boolean;
+export declare function createRun(taskId: string, now?: number): Run;
+/** Text the user should read as the answer right now: the confirmed final text, else the newest turn still writing */
+export declare function answerText(run: Run): string;
+export type AnswerSource = {
+    label: string;
+    href?: string;
+};
+/**
+ * The backend appends a "### Sources" section to the final answer (e.g. "### Sources\n\nThaleonmcp").
+ * Split it off so the UI can show the sources as badges instead of a heading and a paragraph.
+ */
+export declare function splitSources(text: string): {
+    body: string;
+    sources: AnswerSource[];
+};
+/** Narration of turns that called tools (shown inside the process, not as the answer) */
+export declare function isNarration(run: Run, turn: Turn): boolean;
+export declare function toolCount(run: Run): number;
+export type ApplyResult = {
+    run: Run;
+    title?: string;
+};
+export declare function applyEvent(run: Run, ev: StreamEvent, now?: number): ApplyResult;

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

@@ -0,0 +1,16 @@
+export type ChatScopeType = "GLOBAL" | "CLIENT" | "PRODUCT";
+export type ChatScope = {
+    scopeType: ChatScopeType;
+    scopeId?: string;
+    pending?: boolean;
+};
+export declare const CHAT_SCOPE_TYPE: {
+    readonly GLOBAL: "GLOBAL";
+    readonly CLIENT: "CLIENT";
+    readonly PRODUCT: "PRODUCT";
+};
+export declare function scopeKeyOf(scope: ChatScope | null | undefined): string | null;
+export declare function turnIdsOf(scope: ChatScope | null | undefined): {
+    clientId?: string;
+    productId?: string;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Minimal SSE parser (text/event-stream). Fields may come in any order inside a block; blocks end on a blank line.
+ * Used for the live stream and for replaying recorded captures in tests and the demo.
+ */
+import type { StreamEvent } from "./types";
+/** Parse a whole recorded stream */
+export declare function parseSse(text: string): StreamEvent[];
+/** Incremental parser: feed chunks, get complete events back */
+export declare function createSseParser(): {
+    push(chunk: string): StreamEvent[];
+    flush(): StreamEvent[];
+};

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

@@ -0,0 +1,83 @@
+export type SuspensionIdentity = {
+    requestId?: string;
+    sessionId?: string;
+    checkpointId?: string;
+    checkpointDigest?: string;
+};
+export type SuspensionStep = {
+    id: string;
+    question: string;
+    header?: string;
+    type: "single" | "multi" | "boolean" | "number" | "text";
+    options?: {
+        id: string;
+        label: string;
+        description?: string;
+        value?: string | number | boolean;
+    }[];
+    required: boolean;
+    customField?: string;
+    integer?: boolean;
+    minItems?: number;
+    maxItems?: number;
+};
+export type Suspension = {
+    kind: "approval";
+    id: string;
+    taskId: string;
+    title?: string;
+    toolName?: string;
+    capability?: string;
+    allowRemember: boolean;
+    readOnly?: true;
+    actions: string[];
+    identity: SuspensionIdentity;
+} | {
+    kind: "questions";
+    id: string;
+    taskId: string;
+    title?: string;
+    message?: string;
+    steps: SuspensionStep[];
+    canCancel: boolean;
+    actions: string[];
+    identity: SuspensionIdentity;
+} | {
+    kind: "link";
+    id: string;
+    taskId: string;
+    title?: string;
+    message?: string;
+    url: string;
+    canCancel: boolean;
+    actions: string[];
+    identity: SuspensionIdentity;
+} | {
+    kind: "wait";
+    id: string;
+    taskId: string;
+    title?: string;
+    message?: string;
+    waitingOn?: string;
+    canCancel: boolean;
+    actions: string[];
+    identity: SuspensionIdentity;
+};
+export type SuspensionAnswer = {
+    kind: "approval";
+    decision: "approve" | "approve-session" | "reject";
+    comment?: string;
+} | {
+    kind: "questions";
+    values: Record<string, string | string[]>;
+    custom?: Record<string, string>;
+};
+/** Read only the active gate; resolved recordings may be explicitly supplied as that gate. */
+export declare function suspensionOf(taskDetail: {
+    taskId: string;
+    activeSuspension?: unknown;
+}): Suspension | undefined;
+export declare function resumeRequestFor(s: Suspension, a: SuspensionAnswer): {
+    action: "APPROVE" | "REJECT" | "SUBMIT";
+    payload: Record<string, unknown>;
+};

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

@@ -0,0 +1,15 @@
+import type { ToolCall } from "./types";
+export declare function toolKind(capabilityType: unknown): ToolCall["kind"];
+export declare function shortName(capability: string, toolName?: unknown): string;
+/** First sentence of an MCP tool description, without the "[MCP:server]" prefix */
+export declare function summaryFromDefinition(def: unknown): string | undefined;
+export declare function parseResult(result: unknown): {
+    value?: unknown;
+    ok?: boolean;
+    error?: string;
+};
+/** History encodes the MCP server in the capability; live events supply explicit identity fields. */
+export declare function toolIdentity(capability: string, capabilityType: unknown, liveIdentity?: {
+    name?: unknown;
+    server?: unknown;
+}): Pick<ToolCall, "name" | "server" | "kind">;