@4djs/assistant 0.0.0 → 0.1.0

package/src/core/llm-sse.ts

@@ -1,166 +0,0 @@
-import type { OpenAiToolCall } from "./llm-types.ts";
-
-interface ToolCallAccumulator {
-	id: string;
-	type: "function";
-	function: { name: string; arguments: string };
-}
-
-export interface ParsedStreamChunk {
-	contentDelta: string;
-	content: string;
-	toolCalls: OpenAiToolCall[];
-	model: string | null;
-	done: boolean;
-}
-
-export function createStreamParser() {
-	let content = "";
-	let model: string | null = null;
-	const toolAcc = new Map<number, ToolCallAccumulator>();
-
-	function toolCallAt(index: number): ToolCallAccumulator {
-		const existing = toolAcc.get(index);
-		if (existing) return existing;
-		const created: ToolCallAccumulator = {
-			id: "",
-			type: "function",
-			function: { name: "", arguments: "" },
-		};
-		toolAcc.set(index, created);
-		return created;
-	}
-
-	function ingestLine(line: string): ParsedStreamChunk | null {
-		const trimmed = line.trim();
-		if (!trimmed.startsWith("data:")) return null;
-
-		const data = trimmed.slice(5).trim();
-		if (data === "[DONE]") {
-			return {
-				contentDelta: "",
-				content,
-				toolCalls: finalizeToolCalls(),
-				model,
-				done: true,
-			};
-		}
-
-		let json: Record<string, unknown>;
-		try {
-			json = JSON.parse(data) as Record<string, unknown>;
-		} catch {
-			return null;
-		}
-
-		if (typeof json.model === "string") model = json.model;
-
-		const choice = (
-			json.choices as Array<Record<string, unknown>> | undefined
-		)?.[0];
-		const delta = choice?.delta as Record<string, unknown> | undefined;
-		if (!delta) return null;
-
-		let contentDelta = "";
-		if (typeof delta.content === "string" && delta.content.length > 0) {
-			contentDelta = delta.content;
-			content += contentDelta;
-		}
-
-		const toolDeltas = delta.tool_calls as
-			| Array<Record<string, unknown>>
-			| undefined;
-		if (toolDeltas) {
-			for (const toolDelta of toolDeltas) {
-				const index = (toolDelta.index as number | undefined) ?? 0;
-				const current = toolCallAt(index);
-				if (typeof toolDelta.id === "string") current.id = toolDelta.id;
-				const fn = toolDelta.function as Record<string, unknown> | undefined;
-				if (fn && typeof fn.name === "string") current.function.name = fn.name;
-				if (fn && typeof fn.arguments === "string") {
-					current.function.arguments += fn.arguments;
-				}
-			}
-		}
-
-		return {
-			contentDelta,
-			content,
-			toolCalls: finalizeToolCalls(),
-			model,
-			done: false,
-		};
-	}
-
-	function finalizeToolCalls(): OpenAiToolCall[] {
-		return [...toolAcc.entries()]
-			.sort(([a], [b]) => a - b)
-			.map(([, value]) => value)
-			.filter((value): value is ToolCallAccumulator =>
-				Boolean(value.id && value.function.name),
-			);
-	}
-
-	return { ingestLine };
-}
-
-export async function readSseStream(
-	body: ReadableStream<Uint8Array>,
-	onChunk: (chunk: ParsedStreamChunk) => void,
-	signal?: AbortSignal,
-): Promise<ParsedStreamChunk> {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	const parser = createStreamParser();
-	let buffer = "";
-	let last: ParsedStreamChunk = {
-		contentDelta: "",
-		content: "",
-		toolCalls: [],
-		model: null,
-		done: false,
-	};
-
-	const abort = () => {
-		void reader.cancel();
-	};
-
-	if (signal?.aborted) {
-		abort();
-		throw new DOMException("Aborted", "AbortError");
-	}
-
-	signal?.addEventListener("abort", abort, { once: true });
-
-	try {
-		while (true) {
-			if (signal?.aborted) {
-				throw new DOMException("Aborted", "AbortError");
-			}
-			const { done, value } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() ?? "";
-			for (const line of lines) {
-				const chunk = parser.ingestLine(line);
-				if (!chunk) continue;
-				last = chunk;
-				onChunk(chunk);
-				if (chunk.done) return chunk;
-			}
-		}
-	} finally {
-		signal?.removeEventListener("abort", abort);
-	}
-
-	if (buffer.trim()) {
-		const chunk = parser.ingestLine(buffer);
-		if (chunk) {
-			last = { ...chunk, done: true };
-			onChunk(last);
-		}
-	}
-
-	return { ...last, done: true };
-}

package/src/core/llm-types.ts

@@ -1,52 +0,0 @@
-import type { JsonSchema } from "./types.ts";
-
-export interface OpenAiToolCall {
-	id: string;
-	type: "function";
-	function: {
-		name: string;
-		arguments: string;
-	};
-}
-
-export interface LlmChatMessage {
-	role: "system" | "user" | "assistant" | "tool";
-	content?: string | null;
-	tool_call_id?: string;
-	tool_calls?: OpenAiToolCall[];
-}
-
-export interface ClientToolDefinition {
-	name: string;
-	description: string;
-	inputSchema: JsonSchema;
-}
-
-export interface ChatCompletionRequest {
-	messages: LlmChatMessage[];
-	tools?: ClientToolDefinition[];
-	stream?: boolean;
-	model?: string;
-	systemPrompt?: string;
-	responseFormat?: { type: "json_object" };
-}
-
-export interface ChatCompletionResult {
-	message: {
-		role: "assistant";
-		content: string | null;
-		tool_calls?: OpenAiToolCall[];
-	};
-	model: string;
-	usage?: {
-		prompt_tokens?: number;
-		completion_tokens?: number;
-		total_tokens?: number;
-	};
-}
-
-export interface LlmStatusResponse {
-	enabled: boolean;
-	model: string | null;
-	models: string[];
-}

package/src/core/markdown-utils.ts

@@ -1,11 +0,0 @@
-import { isValidElement, type ReactNode } from "react";
-
-export function childrenToText(children: ReactNode): string {
-	if (typeof children === "string") return children;
-	if (typeof children === "number") return String(children);
-	if (Array.isArray(children)) return children.map(childrenToText).join("");
-	if (isValidElement<{ children?: ReactNode }>(children)) {
-		return childrenToText(children.props.children);
-	}
-	return "";
-}

package/src/core/prepare-markdown.ts

@@ -1,38 +0,0 @@
-/**
- * Normalize LaTeX for remark-math + KaTeX.
- * - `\[...\]` → `$$...$$` (display)
- * - `\(...\)` → `$...$` (inline)
- */
-export function prepareMarkdown(message: string): string {
-	let text = convertLatexDisplayMath(message.trimStart());
-	text = convertLatexInlineMath(text);
-	return text.replace(/\n{3,}/g, "\n\n").trimEnd();
-}
-
-function convertLatexInlineMath(message: string): string {
-	return message.replace(
-		/\\\(([\s\S]*?)\\\)/g,
-		(_, math) => `$${math.trim()}$`,
-	);
-}
-
-function convertLatexDisplayMath(message: string): string {
-	return message.replace(
-		/(^|\n)([ \t]*?)\\\[([\s\S]*?)\\\]/g,
-		(_full, lineStart, indent, rawMath) => {
-			const mathLines = rawMath
-				.split("\n")
-				.map((line: string) => line.trim())
-				.filter((line: string) => line.length > 0);
-
-			if (mathLines.length === 0) {
-				return _full;
-			}
-
-			const pad = indent.length > 0 ? "   " : "";
-			const body = mathLines.map((line: string) => `${pad}${line}`).join("\n");
-
-			return `${lineStart}${pad}$$\n${body}\n${pad}$$`;
-		},
-	);
-}

package/src/core/types.ts

@@ -1,86 +0,0 @@
-import type { ChatActivityStep } from "./chat-activity.ts";
-import type { ReplySuggestions } from "./interactive-tools/index.ts";
-
-export type JsonSchema = Record<string, unknown>;
-
-export interface AssistantToolDefinition {
-	name: string;
-	description: string;
-	inputSchema: JsonSchema;
-}
-
-export interface AssistantToolContent {
-	type: string;
-	text?: string;
-}
-
-export interface AssistantToolResult {
-	isError?: boolean;
-	content: AssistantToolContent[];
-	structuredContent?: unknown;
-}
-
-export interface AssistantMessage {
-	id: string;
-	role: "user" | "assistant" | "system";
-	content: string;
-	activity?: ChatActivityStep[];
-	toolCall?: { name: string; args: Record<string, unknown> };
-	replySuggestions?: ReplySuggestions;
-	isError?: boolean;
-	llmSetupRequired?: boolean;
-	streaming?: boolean;
-	timestamp: number;
-}
-
-export interface AssistantSuggestedPrompt {
-	id: string;
-	label: string;
-	description?: string;
-	prompt: string;
-	/** Icon name for dynamic prompts (e.g. "database", "search") */
-	icon?: string;
-}
-
-export interface AssistantLlmSettings {
-	enabled: boolean;
-	baseUrl: string;
-	apiKey: string | null;
-	model: string;
-	/** Optional static model list; fetched from the provider when omitted */
-	models?: string[];
-	/** Default system prompt prepended to each completion request */
-	systemPrompt?: string;
-}
-
-export type AssistantLlmConfig =
-	| AssistantLlmSettings
-	| (() => AssistantLlmSettings | Promise<AssistantLlmSettings>);
-
-export interface AssistantStorageKeys {
-	history?: string;
-	/** @deprecated Legacy model key migrated into llmSettings on load */
-	model?: string;
-	llmSettings?: string;
-}
-
-export interface AssistantWelcomeContext {
-	llmEnabled: boolean;
-	model: string | null;
-}
-
-export interface AssistantStoreDependencies {
-	llm?: AssistantLlmConfig;
-	storageKeys?: AssistantStorageKeys;
-	welcomeMessage: (ctx: AssistantWelcomeContext) => AssistantMessage;
-	listTools: () => Promise<AssistantToolDefinition[]>;
-	invokeTool: (
-		name: string,
-		args: Record<string, unknown>,
-	) => Promise<AssistantToolResult>;
-	onToolInvoked?: (result: AssistantToolResult) => void;
-	fallbackHandler?: (input: {
-		message: string;
-		tools: AssistantToolDefinition[];
-	}) => Promise<AssistantMessage | null>;
-}

package/src/css.d.ts

@@ -1 +0,0 @@
-declare module "*.css";

package/src/react/Assistant.tsx

@@ -1,358 +0,0 @@
-import { Sparkles, X } from "lucide-react";
-import {
-	type KeyboardEvent,
-	type ReactNode,
-	useEffect,
-	useMemo,
-	useRef,
-	useState,
-} from "react";
-import { runAssistantChatCommand } from "../core/chat-commands.ts";
-import { isLlmUnavailableMessage } from "../core/llm-config.ts";
-import { ChatComposer } from "./components/chat/ChatComposer.tsx";
-import { ChatEmptyState } from "./components/chat/ChatEmptyState.tsx";
-import { ChatMessageView } from "./components/chat/ChatMessage.tsx";
-import { ChatMessageScroll } from "./components/chat/ChatMessageScroll.tsx";
-import { LlmSettingsStrip } from "./components/chat/LlmSettingsStrip.tsx";
-import { LlmUnavailableBanner } from "./components/chat/LlmUnavailableBanner.tsx";
-import { SuggestedPromptsStrip } from "./components/chat/SuggestedPromptsStrip.tsx";
-import {
-	AssistantBootstrap,
-	AssistantProvider,
-	useAssistant,
-	useAssistantActions,
-	useAssistantContext,
-} from "./context.tsx";
-import { useComposerCommands } from "./hooks/use-composer-commands.ts";
-import { useSuggestedPrompts } from "./hooks/use-suggested-prompts.ts";
-import type { AssistantConfig, AssistantProps } from "./types.ts";
-
-function AssistantPanel({
-	className,
-	header: headerOverride,
-	emptyState: emptyStateOverride,
-	ui: uiOverride,
-}: AssistantProps) {
-	const { config } = useAssistantContext();
-	const messages = useAssistant((s) => s.messages);
-	const chatLoading = useAssistant((s) => s.chatLoading);
-	const llmEnabled = useAssistant((s) => s.llmEnabled);
-	const selectedModel = useAssistant((s) => s.selectedModel);
-	const { sendChat, stopChat, clearChatHistory, retryLastChat } =
-		useAssistantActions();
-
-	const header = { ...config.header, ...headerOverride };
-	const emptyState = { ...config.emptyState, ...emptyStateOverride };
-	const ui = { ...config.ui, ...uiOverride };
-
-	const HeaderIcon = header.icon ?? Sparkles;
-
-	const [input, setInput] = useState("");
-	const [commandError, setCommandError] = useState<string | null>(null);
-	const [suggestionsOpen, setSuggestionsOpen] = useState(false);
-	const [llmSettingsOpen, setLlmSettingsOpen] = useState(false);
-	const textareaRef = useRef<HTMLTextAreaElement>(null);
-
-	function focusComposer() {
-		requestAnimationFrame(() => {
-			textareaRef.current?.focus({ preventScroll: true });
-		});
-	}
-
-	function handleClearChat() {
-		clearChatHistory();
-		focusComposer();
-	}
-
-	function handleCloseLlmSettings() {
-		setLlmSettingsOpen(false);
-		focusComposer();
-	}
-
-	const suggestions = useSuggestedPrompts({
-		staticPrompts: emptyState?.suggestedPrompts,
-		llmEnabled,
-		model: selectedModel,
-		enabled: true,
-		dynamicSuggestedPrompts: emptyState?.dynamicSuggestedPrompts,
-		listTools: config.listTools,
-		fetchSuggestedPrompts: config.fetchSuggestedPrompts,
-	});
-
-	const visibleMessages = useMemo(
-		() =>
-			messages.filter(
-				(message) =>
-					message.id !== "welcome" &&
-					(message.role === "user" || message.role === "assistant"),
-			),
-		[messages],
-	);
-
-	const lastErrorMessageId = useMemo(() => {
-		for (let i = visibleMessages.length - 1; i >= 0; i--) {
-			const message = visibleMessages[i];
-			if (message?.isError) return message.id;
-		}
-		return null;
-	}, [visibleMessages]);
-
-	const isStreaming = messages.some((message) => message.streaming);
-	const streaming = chatLoading || isStreaming;
-	const scrollKey = visibleMessages
-		.map((message) => {
-			const activityKey = (message.activity ?? [])
-				.map((step) => `${step.id}:${step.status}`)
-				.join(",");
-			return `${message.id}:${message.content.length}:${message.streaming}:${activityKey}`;
-		})
-		.join("|");
-
-	useEffect(() => {
-		if (!chatLoading && !isStreaming) {
-			textareaRef.current?.focus({ preventScroll: true });
-		}
-	}, [chatLoading, isStreaming]);
-
-	function openLlmSettings() {
-		setSuggestionsOpen(false);
-		setLlmSettingsOpen(true);
-	}
-
-	async function handleSubmit(textOverride?: string) {
-		const text = (textOverride ?? input).trim();
-		if (!text) return;
-
-		const commandResult = await runAssistantChatCommand(text, {
-			clearMessages: handleClearChat,
-			setError: setCommandError,
-			streaming,
-		});
-
-		if (commandResult.handled) {
-			if (commandResult.clearInput) {
-				setInput("");
-			}
-			if (commandResult.error) {
-				setCommandError(commandResult.error);
-			}
-			return;
-		}
-
-		setCommandError(null);
-		setInput("");
-		setSuggestionsOpen(false);
-		await sendChat(text);
-	}
-
-	const {
-		suggestions: commandSuggestions,
-		menuOpen: commandMenuOpen,
-		selectedIndex: selectedCommandIndex,
-		completeCommand,
-		handleKeyDown: handleCommandKeyDown,
-		handleInputChange: handleCommandInputChange,
-	} = useComposerCommands({
-		value: input,
-		onChange: (value) => {
-			setCommandError(null);
-			setInput(value);
-		},
-		surface: "assistant",
-		disabled: streaming,
-		onExecute: async (commandText) => {
-			await handleSubmit(commandText);
-		},
-	});
-
-	function handleKeyDown(event: KeyboardEvent<HTMLTextAreaElement>) {
-		if (handleCommandKeyDown(event)) {
-			return;
-		}
-
-		if (event.key === "Enter" && !event.shiftKey) {
-			event.preventDefault();
-			void handleSubmit();
-		}
-	}
-
-	const showEmptyState =
-		visibleMessages.length === 0 && !chatLoading && !isStreaming;
-	const hasLlmSetupInChat = visibleMessages.some((message) =>
-		isLlmUnavailableMessage(message),
-	);
-	const showClearButton = header.showClearButton !== false;
-	const showModelSelector = ui.showModelSelector !== false;
-	const showLlmSettings = ui.showLlmSettings !== false;
-	const canSuggest =
-		llmEnabled &&
-		Boolean(config.fetchSuggestedPrompts) &&
-		emptyState?.dynamicSuggestedPrompts !== false;
-	const showSuggestionsButton =
-		canSuggest && header.showSuggestionsButton !== false;
-
-	function handleSuggestionsClick() {
-		setLlmSettingsOpen(false);
-		if (showEmptyState) {
-			void suggestions.refresh();
-			return;
-		}
-		setSuggestionsOpen(true);
-		void suggestions.refresh();
-	}
-
-	function handleRegenerateSuggestions() {
-		void suggestions.refresh();
-	}
-
-	useEffect(() => {
-		if (showEmptyState) {
-			setSuggestionsOpen(false);
-		}
-	}, [showEmptyState]);
-
-	return (
-		<section
-			className={`assistant-panel ${className ?? ""} ${ui.className ?? ""}`.trim()}
-			style={ui.maxWidth ? { maxWidth: ui.maxWidth } : undefined}
-		>
-			<div className="assistant-panel__header">
-				<div className="assistant-panel__header-main">
-					<div className="assistant-panel__header-icon" aria-hidden>
-						<HeaderIcon size={16} strokeWidth={2} />
-					</div>
-					<div className="assistant-panel__header-text">
-						<h2 className="assistant-panel__title">
-							{header.title ?? "Assistant"}
-						</h2>
-						{header.subtitle ? (
-							<p className="assistant-panel__subtitle">{header.subtitle}</p>
-						) : null}
-					</div>
-				</div>
-			</div>
-
-			<ChatMessageScroll dependencyKey={scrollKey}>
-				{showEmptyState && emptyState?.title && emptyState.description ? (
-					<ChatEmptyState
-						config={{
-							title: emptyState.title,
-							description: emptyState.description,
-							suggestedPrompts: emptyState.suggestedPrompts,
-							dynamicSuggestedPrompts: emptyState.dynamicSuggestedPrompts,
-						}}
-						suggestions={suggestions}
-						onSelect={(prompt) => void handleSubmit(prompt)}
-					/>
-				) : null}
-				{visibleMessages.map((message) => (
-					<ChatMessageView
-						key={message.id}
-						message={message}
-						onSuggestionSelect={(reply) => void handleSubmit(reply)}
-						onOpenLlmSettings={showLlmSettings ? openLlmSettings : undefined}
-						onRetryError={
-							message.isError && message.id === lastErrorMessageId && llmEnabled
-								? () => void retryLastChat()
-								: undefined
-						}
-						retryErrorLoading={chatLoading && message.id === lastErrorMessageId}
-					/>
-				))}
-			</ChatMessageScroll>
-
-			<footer className="assistant-panel__footer">
-				{!llmEnabled && !hasLlmSetupInChat ? (
-					<LlmUnavailableBanner onConfigure={openLlmSettings} />
-				) : null}
-				{llmSettingsOpen ? (
-					<LlmSettingsStrip
-						open={llmSettingsOpen}
-						onClose={handleCloseLlmSettings}
-					/>
-				) : null}
-				{!showEmptyState && suggestionsOpen ? (
-					<SuggestedPromptsStrip
-						open={suggestionsOpen}
-						onClose={() => setSuggestionsOpen(false)}
-						onRefresh={handleRegenerateSuggestions}
-						onSelect={(prompt) => void handleSubmit(prompt)}
-						suggestions={suggestions}
-					/>
-				) : null}
-				{commandError ? (
-					<div className="assistant-command-error" role="alert">
-						<p className="assistant-command-error__text">{commandError}</p>
-						<button
-							type="button"
-							className="assistant-command-error__dismiss"
-							aria-label="Dismiss"
-							onClick={() => setCommandError(null)}
-						>
-							<X size={14} aria-hidden />
-						</button>
-					</div>
-				) : null}
-				<ChatComposer
-					input={input}
-					onInputChange={handleCommandInputChange}
-					onSubmit={() => void handleSubmit()}
-					onKeyDown={handleKeyDown}
-					streaming={streaming}
-					onStop={stopChat}
-					textareaRef={textareaRef}
-					llmEnabled={llmEnabled && showModelSelector}
-					inputDisabled={!llmEnabled}
-					placeholder={
-						llmEnabled
-							? ui.composerPlaceholder
-							: "LLM not configured — chat is disabled"
-					}
-					toolbar={{
-						showLlmSettings,
-						onOpenLlmSettings: openLlmSettings,
-						showGenerateSuggestions: showSuggestionsButton,
-						onGenerateSuggestions: handleSuggestionsClick,
-						suggestionsLoading: suggestions.loading,
-						showClear: showClearButton,
-						onClear: handleClearChat,
-						clearDisabled: visibleMessages.length === 0,
-					}}
-					commandMenu={{
-						open: commandMenuOpen,
-						commands: commandSuggestions,
-						selectedIndex: selectedCommandIndex,
-						onSelect: completeCommand,
-					}}
-				/>
-			</footer>
-		</section>
-	);
-}
-
-/** Full assistant UI — requires `AssistantProvider` ancestor. */
-export function Assistant(props: AssistantProps) {
-	return (
-		<AssistantBootstrap>
-			<AssistantPanel {...props} />
-		</AssistantBootstrap>
-	);
-}
-
-/** Provider + bootstrap + default UI in one component. */
-export function AssistantRoot({
-	config,
-	children,
-	...props
-}: AssistantProps & {
-	config: AssistantConfig;
-	children?: ReactNode;
-}) {
-	return (
-		<AssistantProvider config={config}>
-			<AssistantBootstrap>
-				{children ?? <AssistantPanel {...props} />}
-			</AssistantBootstrap>
-		</AssistantProvider>
-	);
-}