@4djs/assistant 0.0.0 → 0.0.1

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

@@ -1,639 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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);
-}