@parallelworks/ui 0.18.0 → 0.19.1

package/dist/ai/core/KeyboardShortcutsProvider.d.ts

@@ -0,0 +1,5 @@
+interface KeyboardShortcutsProviderProps {
+    children: React.ReactNode;
+}
+export declare function KeyboardShortcutsProvider({ children }: KeyboardShortcutsProviderProps): import("react").JSX.Element;
+export {};

package/dist/ai/core/KeyboardShortcutsProvider.js

@@ -0,0 +1,9 @@
+import { useKeyboardShortcuts } from "./useKeyboardShortcuts.js";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/ai/core/KeyboardShortcutsProvider.tsx
+function KeyboardShortcutsProvider({ children }) {
+	useKeyboardShortcuts({ enabled: true });
+	return /* @__PURE__ */ jsx(Fragment, { children });
+}
+//#endregion
+export { KeyboardShortcutsProvider };

package/dist/ai/core/chatReducer.d.ts

@@ -0,0 +1,114 @@
+import type { PartDelta } from '../adapter/types.js';
+import type { ChatMessage, ChatModel, Conversation, ConversationSummary, MessagePart, ProviderInfo, UnreachableSession } from '../types.js';
+export interface ChatState {
+    conversations: ConversationSummary[];
+    currentConversation: Conversation | null;
+    providers: ProviderInfo[];
+    models: ChatModel[];
+    unreachableSessions: UnreachableSession[];
+    selectedProvider: string | null;
+    selectedAllocation: string | null;
+    isLoading: boolean;
+    isLoadingConversation: boolean;
+    isLoadingModels: boolean;
+    hasLoadedModels: boolean;
+    modelsError: string | null;
+    isStreaming: boolean;
+    isThinking: boolean;
+    streamingContent: string;
+    streamingReasoning: string;
+    streamingParts: MessagePart[];
+    thinkingStartTime: number | null;
+    sidebarCollapsed: boolean;
+    queuedMessages: ChatMessage[];
+}
+export type ChatAction = {
+    type: 'SET_CONVERSATIONS';
+    conversations: ConversationSummary[];
+} | {
+    type: 'SET_CURRENT_CONVERSATION';
+    conversation: Conversation | null;
+} | {
+    type: 'UPDATE_CURRENT_CONVERSATION_TITLE';
+    title: string;
+} | {
+    type: 'SET_PROVIDERS';
+    providers: ProviderInfo[];
+} | {
+    type: 'SET_MODELS';
+    models: ChatModel[];
+    unreachableSessions?: UnreachableSession[];
+} | {
+    type: 'SET_SELECTED_PROVIDER';
+    providerId: string | null;
+} | {
+    type: 'SET_SELECTED_ALLOCATION';
+    allocation: string | null;
+} | {
+    type: 'SET_LOADING';
+    isLoading: boolean;
+} | {
+    type: 'SET_LOADING_MODELS';
+    isLoadingModels: boolean;
+} | {
+    type: 'SET_MODELS_ERROR';
+    error: string | null;
+} | {
+    type: 'SET_STREAMING';
+    isStreaming: boolean;
+    conversationId?: string;
+} | {
+    type: 'SET_THINKING';
+    isThinking: boolean;
+} | {
+    type: 'APPEND_STREAMING_CONTENT';
+    content: string;
+    conversationId: string;
+} | {
+    type: 'APPEND_STREAMING_REASONING';
+    reasoning: string;
+    conversationId: string;
+} | {
+    type: 'APPLY_STREAMING_PART';
+    delta: PartDelta;
+    conversationId: string;
+} | {
+    type: 'CLEAR_STREAMING_CONTENT';
+    conversationId?: string;
+} | {
+    type: 'ADD_MESSAGE';
+    message: ChatMessage;
+    conversationId: string;
+} | {
+    type: 'UPDATE_MESSAGE';
+    messageId: string;
+    updates: Partial<ChatMessage>;
+    conversationId: string;
+} | {
+    type: 'TOGGLE_SIDEBAR';
+} | {
+    type: 'ADD_CONVERSATION';
+    conversation: ConversationSummary;
+} | {
+    type: 'REMOVE_CONVERSATION';
+    conversationId: string;
+} | {
+    type: 'SET_LOADING_CONVERSATION';
+    isLoadingConversation: boolean;
+} | {
+    type: 'RESTORE_BACKGROUND_STREAM';
+    content: string;
+    reasoning: string;
+    parts?: MessagePart[];
+} | {
+    type: 'ADD_QUEUED_MESSAGE';
+    message: ChatMessage;
+    conversationId?: string;
+} | {
+    type: 'REMOVE_QUEUED_MESSAGE';
+    id: string;
+} | {
+    type: 'CLEAR_QUEUED_MESSAGES';
+};
+export declare const initialState: ChatState;
+export declare function chatReducer(state: ChatState, action: ChatAction): ChatState;

package/dist/ai/core/chatReducer.js

@@ -0,0 +1,223 @@
+import { applyPartDelta } from "./parts.js";
+//#region src/ai/core/chatReducer.ts
+var initialState = {
+	conversations: [],
+	currentConversation: null,
+	providers: [],
+	models: [],
+	unreachableSessions: [],
+	selectedProvider: null,
+	selectedAllocation: null,
+	isLoading: false,
+	isLoadingConversation: false,
+	isLoadingModels: false,
+	hasLoadedModels: false,
+	modelsError: null,
+	isStreaming: false,
+	isThinking: false,
+	streamingContent: "",
+	streamingReasoning: "",
+	streamingParts: [],
+	thinkingStartTime: null,
+	sidebarCollapsed: false,
+	queuedMessages: []
+};
+function chatReducer(state, action) {
+	switch (action.type) {
+		case "SET_CONVERSATIONS": return {
+			...state,
+			conversations: action.conversations
+		};
+		case "SET_CURRENT_CONVERSATION":
+			if (action.conversation) {
+				const isNewConversation = state.currentConversation?.id !== action.conversation.id;
+				let restoredProvider = state.selectedProvider;
+				if (isNewConversation) {
+					const messages = action.conversation.messages || [];
+					for (let i = messages.length - 1; i >= 0; i--) {
+						const msg = messages[i];
+						if (msg.role === "assistant" && msg.model) {
+							if (!state.hasLoadedModels || state.models.some((m) => m.id === msg.model)) restoredProvider = msg.model;
+							break;
+						}
+					}
+				}
+				return {
+					...state,
+					currentConversation: {
+						...action.conversation,
+						messages: action.conversation.messages || []
+					},
+					selectedProvider: restoredProvider,
+					...isNewConversation && {
+						streamingContent: "",
+						streamingReasoning: "",
+						streamingParts: [],
+						isStreaming: false,
+						isThinking: false,
+						thinkingStartTime: null,
+						queuedMessages: []
+					}
+				};
+			}
+			return {
+				...state,
+				currentConversation: null,
+				isLoadingConversation: false,
+				streamingContent: "",
+				streamingReasoning: "",
+				streamingParts: [],
+				isStreaming: false,
+				isThinking: false,
+				thinkingStartTime: null,
+				queuedMessages: []
+			};
+		case "UPDATE_CURRENT_CONVERSATION_TITLE":
+			if (!state.currentConversation) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					title: action.title
+				}
+			};
+		case "SET_PROVIDERS": return {
+			...state,
+			providers: action.providers
+		};
+		case "SET_MODELS": return {
+			...state,
+			models: action.models,
+			unreachableSessions: action.unreachableSessions || [],
+			hasLoadedModels: true,
+			modelsError: null
+		};
+		case "SET_SELECTED_PROVIDER": return {
+			...state,
+			selectedProvider: action.providerId
+		};
+		case "SET_SELECTED_ALLOCATION": return {
+			...state,
+			selectedAllocation: action.allocation
+		};
+		case "SET_LOADING": return {
+			...state,
+			isLoading: action.isLoading
+		};
+		case "SET_LOADING_MODELS": return {
+			...state,
+			isLoadingModels: action.isLoadingModels
+		};
+		case "SET_MODELS_ERROR": return {
+			...state,
+			modelsError: action.error,
+			hasLoadedModels: true
+		};
+		case "SET_STREAMING":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				isStreaming: action.isStreaming
+			};
+		case "SET_THINKING": return {
+			...state,
+			isThinking: action.isThinking,
+			thinkingStartTime: action.isThinking ? Date.now() : state.thinkingStartTime
+		};
+		case "APPEND_STREAMING_CONTENT":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingContent: state.streamingContent + action.content,
+				isThinking: false
+			};
+		case "APPEND_STREAMING_REASONING":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingReasoning: state.streamingReasoning + action.reasoning,
+				isThinking: true,
+				thinkingStartTime: state.thinkingStartTime || Date.now()
+			};
+		case "APPLY_STREAMING_PART":
+			if (state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingParts: applyPartDelta(state.streamingParts, action.delta)
+			};
+		case "CLEAR_STREAMING_CONTENT":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				streamingContent: "",
+				streamingReasoning: "",
+				streamingParts: [],
+				isThinking: false,
+				thinkingStartTime: null
+			};
+		case "ADD_MESSAGE":
+			if (!state.currentConversation || state.currentConversation.id !== action.conversationId) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					messages: [...state.currentConversation.messages || [], action.message],
+					activeBranchId: action.message.id
+				}
+			};
+		case "UPDATE_MESSAGE":
+			if (!state.currentConversation || state.currentConversation.id !== action.conversationId) return state;
+			return {
+				...state,
+				currentConversation: {
+					...state.currentConversation,
+					messages: (state.currentConversation.messages || []).map((msg) => msg.id === action.messageId ? {
+						...msg,
+						...action.updates
+					} : msg)
+				}
+			};
+		case "TOGGLE_SIDEBAR": return {
+			...state,
+			sidebarCollapsed: !state.sidebarCollapsed
+		};
+		case "ADD_CONVERSATION":
+			if (state.conversations.some((c) => c.id === action.conversation.id)) return state;
+			return {
+				...state,
+				conversations: [action.conversation, ...state.conversations]
+			};
+		case "REMOVE_CONVERSATION": return {
+			...state,
+			conversations: state.conversations.filter((c) => c.id !== action.conversationId)
+		};
+		case "SET_LOADING_CONVERSATION": return {
+			...state,
+			isLoadingConversation: action.isLoadingConversation
+		};
+		case "RESTORE_BACKGROUND_STREAM": return {
+			...state,
+			streamingContent: action.content,
+			streamingReasoning: action.reasoning,
+			streamingParts: action.parts ?? [],
+			isStreaming: true
+		};
+		case "ADD_QUEUED_MESSAGE":
+			if (action.conversationId && state.currentConversation?.id !== action.conversationId) return state;
+			return {
+				...state,
+				queuedMessages: [...state.queuedMessages, action.message]
+			};
+		case "REMOVE_QUEUED_MESSAGE": return {
+			...state,
+			queuedMessages: state.queuedMessages.filter((m) => m.id !== action.id)
+		};
+		case "CLEAR_QUEUED_MESSAGES": return {
+			...state,
+			queuedMessages: []
+		};
+		default: return state;
+	}
+}
+//#endregion
+export { chatReducer, initialState };

package/dist/ai/core/config.d.ts

@@ -0,0 +1,47 @@
+import { type ComponentType, type MouseEventHandler, type ReactNode } from 'react';
+import type { Components } from 'streamdown';
+import { type ChatStrings } from '../strings.js';
+import type { ApprovalAnswerValue, ChatLinkTarget, ChatMessage, CspKind, MessagePart, MessagePartKind } from '../types.js';
+export interface PartRendererProps {
+    part: MessagePart;
+    message: ChatMessage;
+    isStreaming?: boolean;
+    onApprovalAnswer?: (id: string, answer: ApprovalAnswerValue) => void;
+}
+export interface ChatLinkProps {
+    target: ChatLinkTarget;
+    className?: string;
+    title?: string;
+    onClick?: MouseEventHandler;
+    children: ReactNode;
+}
+export interface ChatUIConfig {
+    LinkComponent?: ComponentType<ChatLinkProps>;
+    extraLinks?: {
+        connectTools?: string;
+        manageProviders?: string;
+        addProvider?: string;
+        providerSettings?: (owner: string, name: string) => string;
+    };
+    slots?: {
+        composerUsage?: ReactNode;
+        providerIcon?: (cspKind: CspKind, className?: string) => ReactNode;
+        partRenderers?: Partial<Record<MessagePartKind, ComponentType<PartRendererProps>>>;
+    };
+    strings?: {
+        [S in keyof ChatStrings]?: Partial<ChatStrings[S]>;
+    };
+    markdownComponents?: Components;
+    suggestedPrompts?: string[];
+}
+export interface ResolvedChatConfig {
+    LinkComponent: ComponentType<ChatLinkProps>;
+    extraLinks: NonNullable<ChatUIConfig['extraLinks']>;
+    slots: NonNullable<ChatUIConfig['slots']>;
+    strings: ChatStrings;
+    markdownComponents?: Components;
+    suggestedPrompts?: string[];
+}
+export declare function resolveChatConfig(config?: ChatUIConfig): ResolvedChatConfig;
+export declare const ChatConfigProvider: import("react").Provider<ResolvedChatConfig>;
+export declare function useChatConfig(): ResolvedChatConfig;

package/dist/ai/core/config.js

@@ -0,0 +1,45 @@
+import { defaultChatStrings } from "../strings.js";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/ai/core/config.tsx
+function hrefFor(target) {
+	switch (target.kind) {
+		case "conversation": return `/chat/${target.id}`;
+		case "attachments": return "/chat/attachments";
+		case "external": return target.href;
+	}
+}
+function DefaultLink({ target, className, title, onClick, children }) {
+	return /* @__PURE__ */ jsx("a", {
+		href: hrefFor(target),
+		className,
+		title,
+		onClick,
+		children
+	});
+}
+function resolveStrings(overrides) {
+	const merged = {};
+	for (const key of Object.keys(defaultChatStrings)) merged[key] = {
+		...defaultChatStrings[key],
+		...overrides?.[key]
+	};
+	return merged;
+}
+function resolveChatConfig(config) {
+	return {
+		LinkComponent: config?.LinkComponent ?? DefaultLink,
+		extraLinks: config?.extraLinks ?? {},
+		slots: config?.slots ?? {},
+		strings: resolveStrings(config?.strings),
+		...config?.markdownComponents ? { markdownComponents: config.markdownComponents } : {},
+		...config?.suggestedPrompts ? { suggestedPrompts: config.suggestedPrompts } : {}
+	};
+}
+var ChatConfigContext = createContext(resolveChatConfig());
+var ChatConfigProvider = ChatConfigContext.Provider;
+function useChatConfig() {
+	return useContext(ChatConfigContext);
+}
+//#endregion
+export { ChatConfigProvider, resolveChatConfig, useChatConfig };

package/dist/ai/core/events.d.ts

@@ -0,0 +1 @@
+export declare const FOCUS_SIDEBAR_SEARCH_EVENT = "aichat:focus-sidebar-search";

package/dist/ai/core/events.js

@@ -0,0 +1,4 @@
+//#region src/ai/core/events.ts
+var FOCUS_SIDEBAR_SEARCH_EVENT = "aichat:focus-sidebar-search";
+//#endregion
+export { FOCUS_SIDEBAR_SEARCH_EVENT };

package/dist/ai/core/exportConversation.d.ts

@@ -0,0 +1,4 @@
+import type { Conversation } from '../types.js';
+export declare function conversationToMarkdown(conversation: Conversation): string;
+export declare function exportFilename(title?: string | null): string;
+export declare function downloadText(filename: string, text: string): void;

package/dist/ai/core/exportConversation.js

@@ -0,0 +1,42 @@
+import { DateTime } from "luxon";
+//#region src/ai/core/exportConversation.ts
+function conversationToMarkdown(conversation) {
+	const lines = [];
+	lines.push(`# ${conversation.title?.trim() || "Conversation"}`);
+	if (conversation.createdAt) {
+		const dt = DateTime.fromISO(conversation.createdAt);
+		if (dt.isValid) {
+			lines.push("");
+			lines.push(`> Started ${dt.toLocaleString(DateTime.DATETIME_MED)}`);
+		}
+	}
+	for (const message of conversation.messages) {
+		if (message.role !== "user" && message.role !== "assistant") continue;
+		const hasAttachments = (message.attachments?.length ?? 0) > 0;
+		if (!message.content?.trim() && !hasAttachments && !message.error) continue;
+		lines.push("");
+		lines.push(message.role === "user" ? "## User" : "## Assistant");
+		lines.push("");
+		if (message.content?.trim()) lines.push(message.content.trim());
+		for (const attachment of message.attachments ?? []) lines.push(`> Attached: ${attachment.filename}`);
+		if (message.error) lines.push(`> Error: ${message.error}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function exportFilename(title) {
+	return `${(title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "conversation"}.md`;
+}
+function downloadText(filename, text) {
+	const blob = new Blob([text], { type: "text/markdown;charset=utf-8" });
+	const url = URL.createObjectURL(blob);
+	const anchor = document.createElement("a");
+	anchor.href = url;
+	anchor.download = filename;
+	document.body.appendChild(anchor);
+	anchor.click();
+	anchor.remove();
+	URL.revokeObjectURL(url);
+}
+//#endregion
+export { conversationToMarkdown, downloadText, exportFilename };

package/dist/ai/core/greeting.d.ts

@@ -0,0 +1,3 @@
+export declare function getGreeting(user: {
+    name?: string | null;
+} | null): string;

package/dist/ai/core/greeting.js

@@ -0,0 +1,38 @@
+//#region src/ai/core/greeting.ts
+function getGreeting(user) {
+	const hour = (/* @__PURE__ */ new Date()).getHours();
+	let timeOfDay;
+	if (hour >= 5 && hour < 12) timeOfDay = "morning";
+	else if (hour >= 12 && hour < 18) timeOfDay = "afternoon";
+	else timeOfDay = "evening";
+	const greetings = {
+		morning: [
+			`Good morning[name]! How can I help you today?`,
+			`Morning[name]! What can I assist you with?`,
+			`Rise and shine[name]! What's on your mind this morning?`,
+			`Good morning[name]! How can I make your day easier?`
+		],
+		afternoon: [
+			`Good afternoon[name]! What can I help you with today?`,
+			`Hello[name]! How can I assist you this afternoon?`,
+			`What can I help you accomplish today[name]?`,
+			`Afternoon[name]! What questions do you have?`
+		],
+		evening: [
+			`Good evening[name]! How can I assist you?`,
+			`Evening[name]! What's on your mind?`,
+			`How can I help you tonight[name]?`,
+			`What can I do for you this evening[name]?`
+		]
+	};
+	const randomIndex = Math.floor(Math.random() * greetings[timeOfDay].length);
+	let greeting = greetings[timeOfDay][randomIndex] ?? "";
+	if (user?.name) {
+		const firstName = user.name.split(" ")[0];
+		if (Math.random() > .5) greeting = greeting.replace("[name]", `, ${firstName}`);
+	}
+	greeting = greeting.replace("[name]", "");
+	return greeting;
+}
+//#endregion
+export { getGreeting };

package/dist/ai/core/parts.d.ts

@@ -0,0 +1,11 @@
+import type { PartDelta } from '../adapter/types.js';
+import type { MessagePart } from '../types.js';
+/** Fold one streamed PartDelta into a parts timeline. Pure: returns a new
+ *  array, leaving the input untouched, so it works for both reducer state
+ *  and the provider's local accumulation. Unknown target ids are dropped
+ *  rather than invented — an end without a start has nothing to render. */
+export declare function applyPartDelta(parts: MessagePart[], delta: PartDelta): MessagePart[];
+/** A turn can end (completed or stopped) with tool calls still marked
+ *  running — the transport died before their tool_end arrived. A stored
+ *  message must not spin forever, so close them out as interrupted. */
+export declare function finalizeParts(parts: MessagePart[]): MessagePart[];

package/dist/ai/core/parts.js

@@ -0,0 +1,84 @@
+//#region src/ai/core/parts.ts
+/** Fold one streamed PartDelta into a parts timeline. Pure: returns a new
+*  array, leaving the input untouched, so it works for both reducer state
+*  and the provider's local accumulation. Unknown target ids are dropped
+*  rather than invented — an end without a start has nothing to render. */
+function applyPartDelta(parts, delta) {
+	switch (delta.type) {
+		case "tool_start": return [...parts, {
+			kind: "tool_call",
+			id: delta.id,
+			name: delta.name,
+			args: delta.args,
+			status: "running",
+			...delta.startLine !== void 0 ? { startLine: delta.startLine } : {}
+		}];
+		case "tool_update": return parts.map((p) => p.kind === "tool_call" && p.id === delta.id ? {
+			...p,
+			args: p.args + delta.args
+		} : p);
+		case "tool_end": return parts.map((p) => p.kind === "tool_call" && p.id === delta.id ? {
+			...p,
+			status: delta.isError ? "error" : "ok",
+			result: delta.result
+		} : p);
+		case "subagent_start": {
+			const part = {
+				kind: "subagent",
+				id: delta.id,
+				status: "running",
+				actions: [],
+				...delta.agentType !== void 0 ? { agentType: delta.agentType } : {},
+				...delta.color !== void 0 ? { color: delta.color } : {},
+				...delta.background !== void 0 ? { background: delta.background } : {},
+				...delta.description !== void 0 ? { description: delta.description } : {}
+			};
+			return [...parts, part];
+		}
+		case "subagent_action": return parts.map((p) => p.kind === "subagent" && p.id === delta.id ? {
+			...p,
+			actions: [...p.actions ?? [], delta.action]
+		} : p);
+		case "subagent_end": return parts.map((p) => p.kind === "subagent" && p.id === delta.id ? {
+			...p,
+			status: delta.ok ? "done" : "failed",
+			...delta.summary !== void 0 ? { summary: delta.summary } : {},
+			...delta.report !== void 0 ? { report: delta.report } : {}
+		} : p);
+		case "approval_request": return [...parts, delta.approval];
+		case "approval_resolved": return parts.map((p) => p.kind === "approval" && p.id === delta.id ? {
+			...p,
+			resolved: true,
+			...delta.answer !== void 0 ? { answer: delta.answer } : {}
+		} : p);
+		case "notice":
+		case "warning": return [...parts, {
+			kind: delta.type,
+			text: delta.text
+		}];
+		case "todo_snapshot": {
+			const idx = parts.findLastIndex((p) => p.kind === "todo_snapshot");
+			if (idx === -1) return [...parts, {
+				kind: "todo_snapshot",
+				todos: delta.todos
+			}];
+			return parts.map((p, i) => i === idx ? {
+				kind: "todo_snapshot",
+				todos: delta.todos
+			} : p);
+		}
+		default: return parts;
+	}
+}
+/** A turn can end (completed or stopped) with tool calls still marked
+*  running — the transport died before their tool_end arrived. A stored
+*  message must not spin forever, so close them out as interrupted. */
+function finalizeParts(parts) {
+	return parts.map((p) => p.kind === "tool_call" && p.status === "running" ? {
+		...p,
+		status: "error",
+		result: p.result ?? "interrupted"
+	} : p);
+}
+//#endregion
+export { applyPartDelta, finalizeParts };

package/dist/ai/core/useDragDrop.d.ts

@@ -0,0 +1,14 @@
+import { type DragEvent } from 'react';
+interface UseDragDropOptions {
+    onFilesDropped: (files: FileList) => void;
+}
+export default function useDragDrop({ onFilesDropped }: UseDragDropOptions): {
+    isDragging: boolean;
+    dragHandlers: {
+        onDragEnter: (e: DragEvent) => void;
+        onDragLeave: (e: DragEvent) => void;
+        onDragOver: (e: DragEvent) => void;
+        onDrop: (e: DragEvent) => void;
+    };
+};
+export {};