@4djs/assistant 0.0.0

package/src/core/create-assistant-store.ts

@@ -0,0 +1,639 @@
+import { create } from "zustand";
+import type { ChatActivityStep } from "./chat-activity.ts";
+import { summarizeActivityResult } from "./chat-activity.ts";
+import { createChatHistoryHelpers } from "./chat-history.ts";
+import {
+	rejectAllInteractiveToolWaiters,
+	resolveInteractiveToolResult,
+} from "./interactive-tools/index.ts";
+import {
+	buildLlmHistory,
+	ChatAbortedError,
+	fetchLlmStatus,
+	runLlmAgent,
+} from "./llm-chat.ts";
+import {
+	DEFAULT_ASSISTANT_SYSTEM_PROMPT,
+	DEFAULT_LLM_MODEL,
+	isLocalLlmBaseUrl,
+	LLM_UNAVAILABLE_MESSAGE,
+} from "./llm-config.ts";
+import {
+	configureAssistantLlm,
+	resolveAssistantLlmSettings,
+	testLlmConnection,
+} from "./llm-provider.ts";
+import {
+	buildDefaultLlmSettings,
+	createDefaultStoredSettings,
+	createLlmSettingsFormState,
+	createLlmSettingsFormStateFromStored,
+	createLlmSettingsStorage,
+	type LlmSettingsFormState,
+	type LlmSettingsFormValues,
+	mergeLlmSettings,
+	migrateLegacyModelStorage,
+	normalizeStoredSystemPrompt,
+	peekStoredModel,
+	persistStoredModelSelection,
+	resolveSelectedModel,
+	storedSettingsHaveOverrides,
+	toStoredSettings,
+} from "./llm-settings-storage.ts";
+import type {
+	AssistantLlmSettings,
+	AssistantMessage,
+	AssistantStoreDependencies,
+} from "./types.ts";
+
+export interface AssistantState {
+	messages: AssistantMessage[];
+	chatLoading: boolean;
+	llmEnabled: boolean;
+	llmModel: string | null;
+	llmModels: string[];
+	llmModelsLoading: boolean;
+	selectedModel: string | null;
+
+	loadLlmStatus: () => Promise<void>;
+	getLlmSettingsForm: () => Promise<LlmSettingsFormState>;
+	saveLlmSettings: (values: LlmSettingsFormValues) => Promise<void>;
+	clearLlmSettings: () => Promise<void>;
+	testLlmSettings: (
+		values: LlmSettingsFormValues,
+	) => Promise<{ ok: true; model: string } | { ok: false; error: string }>;
+	llmSettingsHasOverrides: () => Promise<boolean>;
+	setSelectedModel: (model: string) => void;
+	sendChat: (message: string) => Promise<void>;
+	retryLastChat: () => Promise<void>;
+	clearChatHistory: () => void;
+	stopChat: () => void;
+	submitInteractiveToolResult: (callId: string, result: unknown) => void;
+	cancelInteractiveToolResult: (callId: string) => void;
+}
+
+function patchWelcomeMessage(
+	messages: AssistantMessage[],
+	welcomeMessage: AssistantStoreDependencies["welcomeMessage"],
+	model: string | null,
+	llmEnabled: boolean,
+): AssistantMessage[] {
+	const welcome = welcomeMessage({ llmEnabled, model });
+	return messages.map((message) =>
+		message.id === "welcome"
+			? { ...message, content: welcome.content }
+			: message,
+	);
+}
+
+function patchTurnMessage(
+	messages: AssistantMessage[],
+	turnId: string,
+	patch: (message: AssistantMessage) => AssistantMessage,
+): AssistantMessage[] {
+	return messages.map((message) =>
+		message.id === turnId ? patch(message) : message,
+	);
+}
+
+function createTurnMessage(turnId: string): AssistantMessage {
+	return {
+		id: turnId,
+		role: "assistant",
+		content: "",
+		activity: [],
+		streaming: true,
+		timestamp: Date.now(),
+	};
+}
+
+function appendActivityStep(
+	messages: AssistantMessage[],
+	turnId: string,
+	step: ChatActivityStep,
+): AssistantMessage[] {
+	return patchTurnMessage(messages, turnId, (message) => ({
+		...message,
+		activity: [...(message.activity ?? []), step],
+	}));
+}
+
+function finishActivityStep(
+	messages: AssistantMessage[],
+	turnId: string,
+	stepId: string,
+	update: Pick<ChatActivityStep, "status" | "result" | "error">,
+): AssistantMessage[] {
+	return patchTurnMessage(messages, turnId, (message) => ({
+		...message,
+		activity: (message.activity ?? []).map((step) =>
+			step.id === stepId ? { ...step, ...update } : step,
+		),
+	}));
+}
+
+function finalizeStoppedMessages(
+	messages: AssistantMessage[],
+): AssistantMessage[] {
+	return messages.map((message) => {
+		if (!message.streaming) return message;
+		const activity = (message.activity ?? []).map((step) =>
+			step.status === "active"
+				? { ...step, status: "error" as const, error: "Stopped" }
+				: step,
+		);
+		return {
+			...message,
+			streaming: false,
+			activity,
+			content: message.content.trim() || "_(stopped)_",
+		};
+	});
+}
+
+function finalizeErroredMessages(
+	messages: AssistantMessage[],
+	errorMessage: string,
+): AssistantMessage[] {
+	const hasStreaming = messages.some((message) => message.streaming);
+	if (!hasStreaming) {
+		return [
+			...messages,
+			{
+				id: crypto.randomUUID(),
+				role: "assistant",
+				content: errorMessage,
+				isError: true,
+				timestamp: Date.now(),
+			},
+		];
+	}
+
+	return messages.map((message) => {
+		if (!message.streaming) return message;
+		const activity = (message.activity ?? []).map((step) =>
+			step.status === "active"
+				? { ...step, status: "error" as const, error: errorMessage }
+				: step,
+		);
+		return {
+			...message,
+			streaming: false,
+			isError: true,
+			activity,
+			content: errorMessage,
+		};
+	});
+}
+
+function clearReplySuggestions(
+	messages: AssistantMessage[],
+): AssistantMessage[] {
+	return messages.map((message) =>
+		message.replySuggestions
+			? { ...message, replySuggestions: undefined }
+			: message,
+	);
+}
+
+export function createAssistantStore(deps: AssistantStoreDependencies) {
+	const historyKey = deps.storageKeys?.history ?? "assistant-chat-history";
+	const llmSettingsKey =
+		deps.storageKeys?.llmSettings ?? "assistant-llm-settings";
+	const llmSettingsStorage = createLlmSettingsStorage(llmSettingsKey);
+
+	async function resolveBaseLlmSettings(): Promise<AssistantLlmSettings> {
+		if (!deps.llm) return buildDefaultLlmSettings();
+		return typeof deps.llm === "function" ? await deps.llm() : deps.llm;
+	}
+
+	async function ensureLlmSettingsStored(): Promise<void> {
+		const base = await resolveBaseLlmSettings();
+		migrateLegacyModelStorage(llmSettingsKey, deps.storageKeys?.model, base);
+		if (llmSettingsStorage.hasStored()) return;
+		llmSettingsStorage.save(createDefaultStoredSettings(base));
+	}
+
+	async function resolveMergedLlmSettings(): Promise<AssistantLlmSettings> {
+		const base = await resolveBaseLlmSettings();
+		const stored = llmSettingsStorage.load(base);
+		return mergeLlmSettings(base, stored);
+	}
+
+	configureAssistantLlm(resolveMergedLlmSettings);
+
+	const history = createChatHistoryHelpers({
+		storageKey: historyKey,
+		welcomeMessage: deps.welcomeMessage,
+	});
+	const initialSelectedModel = peekStoredModel(llmSettingsKey);
+
+	let chatAbortController: AbortController | null = null;
+	const messages = history.loadInitial({
+		llmEnabled: false,
+		model: initialSelectedModel,
+	});
+
+	const store = create<AssistantState>((set, get) => {
+		async function runLlmChatTurn(message: string) {
+			const tools = await deps.listTools();
+			const storedMessages = get().messages.filter((m) => m.id !== "welcome");
+			// sendChat already appended the current user message; runLlmAgent adds it again.
+			const priorMessages =
+				storedMessages.at(-1)?.role === "user"
+					? storedMessages.slice(0, -1)
+					: storedMessages;
+			const llmHistory = buildLlmHistory(priorMessages);
+			const turnId = crypto.randomUUID();
+
+			set((state) => ({
+				messages: [...state.messages, createTurnMessage(turnId)],
+			}));
+
+			await runLlmAgent({
+				userMessage: message,
+				history: llmHistory,
+				tools,
+				model: get().selectedModel ?? undefined,
+				signal: chatAbortController?.signal,
+				stream: {
+					turnId,
+					onUpdate: (content) => {
+						set((state) => ({
+							messages: patchTurnMessage(state.messages, turnId, (msg) => ({
+								...msg,
+								content,
+							})),
+						}));
+					},
+				},
+				toolHandlers: {
+					onStart: ({ id, name, args, callId }) => {
+						set((state) => ({
+							messages: appendActivityStep(state.messages, turnId, {
+								id,
+								kind: "tool",
+								name,
+								args,
+								callId,
+								status: "active",
+							}),
+						}));
+					},
+					onFinish: (stepId, update) => {
+						set((state) => ({
+							messages: finishActivityStep(state.messages, turnId, stepId, {
+								status: update.status,
+								result: summarizeActivityResult(update.result),
+								error: update.error,
+							}),
+						}));
+					},
+				},
+				onPostResponseTool: (suggestions) => {
+					set((state) => ({
+						messages: patchTurnMessage(state.messages, turnId, (msg) => ({
+							...msg,
+							replySuggestions: suggestions,
+						})),
+					}));
+				},
+				invokeTool: async (name, args) => {
+					const result = await deps.invokeTool(name, args);
+					deps.onToolInvoked?.(result);
+					return result;
+				},
+			});
+
+			set((state) => ({
+				messages: state.messages.map((msg) =>
+					msg.id === turnId
+						? {
+								...msg,
+								streaming: false,
+								content:
+									msg.content.trim() ||
+									(msg.activity?.length
+										? ""
+										: "I couldn't produce a response."),
+							}
+						: msg,
+				),
+				chatLoading: false,
+			}));
+		}
+
+		return {
+			messages,
+			chatLoading: false,
+			llmEnabled: false,
+			llmModel: null,
+			llmModels: [],
+			llmModelsLoading: false,
+			selectedModel: initialSelectedModel,
+
+			loadLlmStatus: async () => {
+				set({ llmModelsLoading: true });
+				try {
+					await ensureLlmSettingsStored();
+					const base = await resolveBaseLlmSettings();
+					const stored =
+						llmSettingsStorage.load(base) ?? createDefaultStoredSettings(base);
+					const status = await fetchLlmStatus();
+					const defaultModel =
+						status.model ?? stored.model ?? DEFAULT_LLM_MODEL;
+					const baseModels = status.models.length
+						? status.models
+						: [defaultModel];
+					const selectedModel = resolveSelectedModel(
+						stored.model,
+						defaultModel,
+						baseModels,
+					);
+					const llmModels =
+						selectedModel && !baseModels.includes(selectedModel)
+							? [selectedModel, ...baseModels]
+							: baseModels;
+					set((state) => ({
+						llmEnabled: status.enabled,
+						llmModel: defaultModel,
+						llmModels,
+						selectedModel,
+						messages: patchWelcomeMessage(
+							state.messages,
+							deps.welcomeMessage,
+							selectedModel,
+							status.enabled,
+						),
+					}));
+				} finally {
+					set({ llmModelsLoading: false });
+				}
+			},
+
+			getLlmSettingsForm: async () => {
+				await ensureLlmSettingsStored();
+				const base = await resolveBaseLlmSettings();
+				const defaultSystemPrompt =
+					base.systemPrompt?.trim() || DEFAULT_ASSISTANT_SYSTEM_PROMPT;
+				const stored = llmSettingsStorage.load(base);
+				if (stored) {
+					return createLlmSettingsFormStateFromStored(
+						{
+							...stored,
+							systemPrompt: normalizeStoredSystemPrompt(
+								stored.systemPrompt,
+								base,
+							),
+						},
+						defaultSystemPrompt,
+					);
+				}
+				return createLlmSettingsFormState(
+					base,
+					Boolean(base.apiKey),
+					defaultSystemPrompt,
+				);
+			},
+
+			saveLlmSettings: async (values) => {
+				const base = await resolveBaseLlmSettings();
+				const defaultSystemPrompt =
+					base.systemPrompt?.trim() || DEFAULT_ASSISTANT_SYSTEM_PROMPT;
+				const current = await resolveAssistantLlmSettings();
+				const normalizedValues = {
+					...values,
+					systemPrompt:
+						values.systemPrompt.trim() === defaultSystemPrompt
+							? ""
+							: values.systemPrompt,
+				};
+				llmSettingsStorage.save(
+					toStoredSettings(normalizedValues, current.apiKey),
+				);
+				await get().loadLlmStatus();
+			},
+
+			clearLlmSettings: async () => {
+				llmSettingsStorage.clear();
+				const base = await resolveBaseLlmSettings();
+				llmSettingsStorage.save(createDefaultStoredSettings(base));
+				await get().loadLlmStatus();
+			},
+
+			testLlmSettings: async (values) => {
+				const current = await resolveAssistantLlmSettings();
+				const stored = toStoredSettings(values, current.apiKey);
+				if (!stored.apiKey && !isLocalLlmBaseUrl(stored.baseUrl)) {
+					return {
+						ok: false,
+						error: "API key is required for remote LLM providers.",
+					};
+				}
+				return testLlmConnection({
+					baseUrl: stored.baseUrl,
+					apiKey: stored.apiKey,
+					model: stored.model,
+				});
+			},
+
+			llmSettingsHasOverrides: async () => {
+				await ensureLlmSettingsStored();
+				const base = await resolveBaseLlmSettings();
+				const stored = llmSettingsStorage.load(base);
+				if (!stored) return false;
+				return storedSettingsHaveOverrides(stored, base);
+			},
+
+			setSelectedModel: (model) => {
+				const trimmed = model.trim();
+				if (!trimmed) return;
+				const { llmEnabled, llmModels } = get();
+				const models = llmModels.includes(trimmed)
+					? llmModels
+					: [trimmed, ...llmModels];
+				persistStoredModelSelection(llmSettingsKey, trimmed);
+				set((state) => ({
+					selectedModel: trimmed,
+					llmModels: models,
+					messages: patchWelcomeMessage(
+						state.messages,
+						deps.welcomeMessage,
+						trimmed,
+						llmEnabled,
+					),
+				}));
+			},
+
+			clearChatHistory: () => {
+				if (get().chatLoading) return;
+				const { llmEnabled, selectedModel } = get();
+				history.clear();
+				set({
+					messages: [deps.welcomeMessage({ llmEnabled, model: selectedModel })],
+				});
+			},
+
+			stopChat: () => {
+				chatAbortController?.abort();
+				rejectAllInteractiveToolWaiters(
+					new DOMException("Aborted", "AbortError"),
+				);
+				set((state) => ({
+					messages: finalizeStoppedMessages(state.messages),
+					chatLoading: false,
+				}));
+			},
+
+			submitInteractiveToolResult: (callId, result) => {
+				resolveInteractiveToolResult(callId, result);
+			},
+
+			cancelInteractiveToolResult: (callId) => {
+				resolveInteractiveToolResult(callId, {
+					cancelled: true,
+					confirmed: false,
+					selected: [],
+				});
+			},
+
+			sendChat: async (message) => {
+				const userMsg: AssistantMessage = {
+					id: crypto.randomUUID(),
+					role: "user",
+					content: message,
+					timestamp: Date.now(),
+				};
+				chatAbortController?.abort();
+				chatAbortController = new AbortController();
+				set((state) => ({
+					messages: [...clearReplySuggestions(state.messages), userMsg],
+					chatLoading: true,
+				}));
+
+				try {
+					if (!get().llmEnabled) {
+						set((state) => ({
+							messages: [
+								...state.messages,
+								{
+									id: crypto.randomUUID(),
+									role: "assistant",
+									content: LLM_UNAVAILABLE_MESSAGE,
+									llmSetupRequired: true,
+									timestamp: Date.now(),
+								},
+							],
+							chatLoading: false,
+						}));
+						return;
+					}
+					await runLlmChatTurn(message);
+				} catch (error) {
+					if (
+						error instanceof ChatAbortedError ||
+						(error instanceof DOMException && error.name === "AbortError") ||
+						chatAbortController?.signal.aborted
+					) {
+						set((state) => ({
+							messages: finalizeStoppedMessages(state.messages),
+							chatLoading: false,
+						}));
+						return;
+					}
+					set((state) => ({
+						messages: finalizeErroredMessages(
+							state.messages,
+							`Chat failed: ${error instanceof Error ? error.message : String(error)}`,
+						),
+						chatLoading: false,
+					}));
+				} finally {
+					chatAbortController = null;
+				}
+			},
+
+			retryLastChat: async () => {
+				if (get().chatLoading) return;
+
+				const { messages } = get();
+				let errorIndex = -1;
+				for (let i = messages.length - 1; i >= 0; i--) {
+					const message = messages[i];
+					if (message?.role === "assistant" && message.isError) {
+						errorIndex = i;
+						break;
+					}
+				}
+				if (errorIndex < 0) return;
+
+				let userContent: string | null = null;
+				for (let i = errorIndex - 1; i >= 0; i--) {
+					const message = messages[i];
+					if (message?.role === "user") {
+						userContent = message.content;
+						break;
+					}
+				}
+				if (!userContent) return;
+
+				chatAbortController?.abort();
+				chatAbortController = new AbortController();
+				set((state) => ({
+					messages: state.messages.filter((_, index) => index !== errorIndex),
+					chatLoading: true,
+				}));
+
+				try {
+					if (!get().llmEnabled) {
+						set((state) => ({
+							messages: [
+								...state.messages,
+								{
+									id: crypto.randomUUID(),
+									role: "assistant",
+									content: LLM_UNAVAILABLE_MESSAGE,
+									llmSetupRequired: true,
+									timestamp: Date.now(),
+								},
+							],
+							chatLoading: false,
+						}));
+						return;
+					}
+					await runLlmChatTurn(userContent);
+				} catch (error) {
+					if (
+						error instanceof ChatAbortedError ||
+						(error instanceof DOMException && error.name === "AbortError") ||
+						chatAbortController?.signal.aborted
+					) {
+						set((state) => ({
+							messages: finalizeStoppedMessages(state.messages),
+							chatLoading: false,
+						}));
+						return;
+					}
+					set((state) => ({
+						messages: finalizeErroredMessages(
+							state.messages,
+							`Chat failed: ${error instanceof Error ? error.message : String(error)}`,
+						),
+						chatLoading: false,
+					}));
+				} finally {
+					chatAbortController = null;
+				}
+			},
+		};
+	});
+
+	store.subscribe((state, previousState) => {
+		if (state.messages === previousState.messages) return;
+		history.persist(state.messages);
+	});
+
+	return store;
+}
+
+export type AssistantStore = ReturnType<typeof createAssistantStore>;

package/src/core/fetch-suggested-prompts.ts

@@ -0,0 +1,53 @@
+export interface SuggestedPromptsResponse {
+	prompts: Array<{
+		id: string;
+		label: string;
+		description?: string;
+		prompt: string;
+		icon?: string;
+	}>;
+}
+
+export function parseSuggestedPromptsResponse(
+	data: unknown,
+): SuggestedPromptsResponse["prompts"] {
+	if (!data || typeof data !== "object") return [];
+	const root = data as Record<string, unknown>;
+	const raw = Array.isArray(root.prompts)
+		? root.prompts
+		: Array.isArray(root.suggestions)
+			? root.suggestions
+			: [];
+
+	const prompts: SuggestedPromptsResponse["prompts"] = [];
+	for (const [index, entry] of raw.entries()) {
+		if (!entry || typeof entry !== "object") continue;
+		const item = entry as Record<string, unknown>;
+		const label = typeof item.label === "string" ? item.label.trim() : "";
+		const prompt =
+			typeof item.prompt === "string"
+				? item.prompt.trim()
+				: typeof item.message === "string"
+					? item.message.trim()
+					: "";
+		if (!label || !prompt) continue;
+
+		prompts.push({
+			id:
+				typeof item.id === "string" && item.id.trim()
+					? item.id.trim()
+					: `prompt-${index + 1}`,
+			label,
+			description:
+				typeof item.description === "string"
+					? item.description.trim()
+					: typeof item.hint === "string"
+						? item.hint.trim()
+						: undefined,
+			prompt,
+			icon: typeof item.icon === "string" ? item.icon.trim() : undefined,
+		});
+	}
+
+	return prompts.slice(0, 6);
+}