@4djs/assistant 0.0.0 → 0.1.0

package/src/core/index.ts

@@ -1,125 +0,0 @@
-export type { ChatActivityStep } from "./chat-activity.ts";
-export {
-	chatActivityStepLabel,
-	formatJsonIfLarge,
-	summarizeActivityResult,
-} from "./chat-activity.ts";
-export type {
-	AssistantCommandDeps,
-	ChatCommandRunResult,
-	ChatCommandSuggestion,
-	ChatCommandSurface,
-} from "./chat-commands.ts";
-export {
-	filterChatCommands,
-	getChatCommandSuggestions,
-	isChatCommandInput,
-	listChatCommands,
-	parseChatCommand,
-	runAssistantChatCommand,
-	shouldShowChatCommandMenu,
-} from "./chat-commands.ts";
-export { createChatHistoryHelpers } from "./chat-history.ts";
-export {
-	type AssistantState,
-	createAssistantStore,
-} from "./create-assistant-store.ts";
-export {
-	parseSuggestedPromptsResponse,
-	type SuggestedPromptsResponse,
-} from "./fetch-suggested-prompts.ts";
-export {
-	CHOICES_TOOL,
-	type ChoiceOption,
-	type ChoicesToolArgs,
-	CONFIRMATION_TOOL,
-	type ConfirmationToolArgs,
-	type ReplySuggestions,
-	rejectAllInteractiveToolWaiters,
-	resolveInteractiveToolResult,
-	SUGGEST_REPLIES_TOOL,
-} from "./interactive-tools/index.ts";
-export type {
-	AgentStepResult,
-	LlmChatStatus,
-	StreamHandlers,
-	ToolHandlers,
-} from "./llm-chat.ts";
-export {
-	buildLlmHistory,
-	ChatAbortedError,
-	fetchLlmStatus,
-	LlmNotConfiguredError,
-	LlmUpstreamError,
-	requestLlmCompletion,
-	runLlmAgent,
-	sanitizeLlmMessages,
-} from "./llm-chat.ts";
-export {
-	buildCompletionsUrl,
-	buildLlmRequestHeaders,
-	buildModelsUrl,
-	DEFAULT_LLM_BASE_URL,
-	DEFAULT_LLM_MODEL,
-	getFallbackModels,
-	isLlmConfigured,
-	isLlmUnavailableMessage,
-	isLocalLlmBaseUrl,
-	LLM_UNAVAILABLE_MESSAGE,
-} from "./llm-config.ts";
-export {
-	clearProviderModelCache,
-	fetchProviderModels,
-} from "./llm-models.ts";
-export {
-	configureAssistantLlm,
-	resetAssistantLlm,
-	resolveAssistantLlmSettings,
-	testLlmConnection,
-} from "./llm-provider.ts";
-export type {
-	LlmSettingsFormState,
-	LlmSettingsFormValues,
-	StoredLlmUserSettings,
-} from "./llm-settings-storage.ts";
-export {
-	assistantToStored,
-	buildDefaultLlmSettings,
-	createDefaultStoredSettings,
-	createLlmSettingsFormState,
-	createLlmSettingsFormStateFromStored,
-	createLlmSettingsStorage,
-	DEFAULT_LLM_SETTINGS_STORAGE_KEY,
-	formatModelsText,
-	isLlmSettingsFormDirty,
-	mergeLlmSettings,
-	migrateLegacyModelStorage,
-	normalizeStoredSettings,
-	normalizeStoredSystemPrompt,
-	parseModelsText,
-	peekStoredModel,
-	persistStoredModelSelection,
-	resolveSelectedModel,
-	storedSettingsHaveOverrides,
-	storedToAssistant,
-	toStoredSettings,
-} from "./llm-settings-storage.ts";
-export type {
-	ClientToolDefinition,
-	LlmChatMessage,
-	OpenAiToolCall,
-} from "./llm-types.ts";
-export { childrenToText } from "./markdown-utils.ts";
-export type {
-	AssistantLlmConfig,
-	AssistantLlmSettings,
-	AssistantMessage,
-	AssistantStorageKeys,
-	AssistantStoreDependencies,
-	AssistantSuggestedPrompt,
-	AssistantToolContent,
-	AssistantToolDefinition,
-	AssistantToolResult,
-	AssistantWelcomeContext,
-	JsonSchema,
-} from "./types.ts";

package/src/core/interactive-tools/choices.ts

@@ -1,155 +0,0 @@
-import type { ClientToolDefinition } from "../llm-types.ts";
-
-export const REQUEST_CHOICES_TOOL = "request_choices";
-
-export type ChoiceOption = {
-	id: string;
-	label: string;
-	description?: string;
-};
-
-export type ChoicesToolArgs = {
-	message: string;
-	options: ChoiceOption[];
-	allowMultiple: boolean;
-	minSelections: number;
-	maxSelections?: number;
-	submitLabel: string;
-};
-
-export type ChoicesToolResult = {
-	selected: string[];
-	cancelled?: boolean;
-};
-
-export const CHOICES_TOOL: ClientToolDefinition = {
-	name: REQUEST_CHOICES_TOOL,
-	description:
-		"Present options when multiple valid paths exist and you need the user to choose before continuing. Supports single-select and multi-select.",
-	inputSchema: {
-		type: "object",
-		properties: {
-			message: {
-				type: "string",
-				description: "Prompt explaining what the user should choose.",
-			},
-			options: {
-				type: "array",
-				minItems: 2,
-				items: {
-					type: "object",
-					properties: {
-						id: {
-							type: "string",
-							description: "Stable option id returned in the tool result.",
-						},
-						label: {
-							type: "string",
-							description: "User-visible option label.",
-						},
-						description: {
-							type: "string",
-							description: "Optional longer description for the option.",
-						},
-					},
-					required: ["id", "label"],
-					additionalProperties: false,
-				},
-			},
-			allowMultiple: {
-				type: "boolean",
-				description: "If true, the user may select multiple options.",
-			},
-			minSelections: {
-				type: "integer",
-				description:
-					"Minimum number of selections when allowMultiple is true. Default: 1.",
-			},
-			maxSelections: {
-				type: "integer",
-				description: "Maximum number of selections when allowMultiple is true.",
-			},
-			submitLabel: {
-				type: "string",
-				description: "Submit button label. Default: Continue.",
-			},
-		},
-		required: ["message", "options"],
-		additionalProperties: false,
-	},
-};
-
-export function parseChoicesArgs(
-	args: Record<string, unknown>,
-): ChoicesToolArgs {
-	const message = String(args.message ?? "").trim();
-	if (!message) {
-		throw new Error("request_choices requires a non-empty message");
-	}
-
-	if (!Array.isArray(args.options) || args.options.length < 2) {
-		throw new Error("request_choices requires at least two options");
-	}
-
-	const options: ChoiceOption[] = [];
-	const seenIds = new Set<string>();
-
-	for (const entry of args.options) {
-		if (!entry || typeof entry !== "object") {
-			throw new Error("Each choice option must be an object with id and label");
-		}
-
-		const option = entry as Record<string, unknown>;
-		const id = String(option.id ?? "").trim();
-		const label = String(option.label ?? "").trim();
-
-		if (!id || !label) {
-			throw new Error("Each choice option requires a non-empty id and label");
-		}
-
-		if (seenIds.has(id)) {
-			throw new Error(`Duplicate choice option id: ${id}`);
-		}
-
-		seenIds.add(id);
-		options.push({
-			id,
-			label,
-			description:
-				option.description !== undefined
-					? String(option.description).trim()
-					: undefined,
-		});
-	}
-
-	const allowMultiple = Boolean(args.allowMultiple);
-	const minSelections =
-		typeof args.minSelections === "number" && args.minSelections > 0
-			? Math.floor(args.minSelections)
-			: 1;
-	const maxSelections =
-		typeof args.maxSelections === "number" && args.maxSelections > 0
-			? Math.floor(args.maxSelections)
-			: undefined;
-
-	if (
-		allowMultiple &&
-		maxSelections !== undefined &&
-		maxSelections < minSelections
-	) {
-		throw new Error(
-			"maxSelections must be greater than or equal to minSelections",
-		);
-	}
-
-	return {
-		message,
-		options,
-		allowMultiple,
-		minSelections: allowMultiple ? minSelections : 1,
-		maxSelections: allowMultiple ? maxSelections : 1,
-		submitLabel: args.submitLabel
-			? String(args.submitLabel).trim()
-			: "Continue",
-	};
-}

package/src/core/interactive-tools/confirmation.ts

@@ -1,63 +0,0 @@
-import type { ClientToolDefinition } from "../llm-types.ts";
-
-export const REQUEST_CONFIRMATION_TOOL = "request_confirmation";
-
-export type ConfirmationToolArgs = {
-	message: string;
-	action?: string;
-	confirmLabel: string;
-	cancelLabel: string;
-};
-
-export type ConfirmationToolResult = {
-	confirmed: boolean;
-	cancelled?: boolean;
-};
-
-export const CONFIRMATION_TOOL: ClientToolDefinition = {
-	name: REQUEST_CONFIRMATION_TOOL,
-	description:
-		"Ask the user to confirm before proceeding with an important or irreversible action. Execution pauses until the user confirms or cancels.",
-	inputSchema: {
-		type: "object",
-		properties: {
-			message: {
-				type: "string",
-				description: "Explanation or question shown to the user.",
-			},
-			action: {
-				type: "string",
-				description:
-					"Short summary of what happens if confirmed, e.g. 'Delete 3 User records'.",
-			},
-			confirmLabel: {
-				type: "string",
-				description: "Confirm button label. Default: Proceed.",
-			},
-			cancelLabel: {
-				type: "string",
-				description: "Cancel button label. Default: Cancel.",
-			},
-		},
-		required: ["message"],
-		additionalProperties: false,
-	},
-};
-
-export function parseConfirmationArgs(
-	args: Record<string, unknown>,
-): ConfirmationToolArgs {
-	const message = String(args.message ?? "").trim();
-	if (!message) {
-		throw new Error("request_confirmation requires a non-empty message");
-	}
-
-	return {
-		message,
-		action: args.action !== undefined ? String(args.action).trim() : undefined,
-		confirmLabel: args.confirmLabel
-			? String(args.confirmLabel).trim()
-			: "Proceed",
-		cancelLabel: args.cancelLabel ? String(args.cancelLabel).trim() : "Cancel",
-	};
-}

package/src/core/interactive-tools/constants.ts

@@ -1,22 +0,0 @@
-import { REQUEST_CHOICES_TOOL } from "./choices.ts";
-import { REQUEST_CONFIRMATION_TOOL } from "./confirmation.ts";
-import { SUGGEST_REPLIES_TOOL } from "./suggestions.ts";
-
-export const INTERACTIVE_CHAT_TOOL_NAMES = new Set([
-	REQUEST_CONFIRMATION_TOOL,
-	REQUEST_CHOICES_TOOL,
-]);
-
-export const POST_RESPONSE_CHAT_TOOL_NAMES = new Set([SUGGEST_REPLIES_TOOL]);
-
-export function isInteractiveChatTool(name: string): boolean {
-	return INTERACTIVE_CHAT_TOOL_NAMES.has(name);
-}
-
-export function isPostResponseChatTool(name: string): boolean {
-	return POST_RESPONSE_CHAT_TOOL_NAMES.has(name);
-}
-
-export function isChatUiTool(name: string): boolean {
-	return isInteractiveChatTool(name) || isPostResponseChatTool(name);
-}

package/src/core/interactive-tools/execute.ts

@@ -1,70 +0,0 @@
-import type { ClientToolDefinition } from "../llm-types.ts";
-import {
-	CHOICES_TOOL,
-	type ChoicesToolResult,
-	parseChoicesArgs,
-	REQUEST_CHOICES_TOOL,
-} from "./choices.ts";
-import {
-	CONFIRMATION_TOOL,
-	type ConfirmationToolResult,
-	parseConfirmationArgs,
-	REQUEST_CONFIRMATION_TOOL,
-} from "./confirmation.ts";
-import { isPostResponseChatTool } from "./constants.ts";
-import {
-	parseSuggestRepliesArgs,
-	type ReplySuggestions,
-	SUGGEST_REPLIES_TOOL,
-	SUGGEST_REPLIES_TOOL_DEFINITION,
-} from "./suggestions.ts";
-import { waitForInteractiveToolResult } from "./waiters.ts";
-
-export type ChatInteractiveToolResult = {
-	content: string;
-	postResponse?: ReplySuggestions;
-	isError?: boolean;
-};
-
-export function getChatInteractiveTools(): ClientToolDefinition[] {
-	return [CONFIRMATION_TOOL, CHOICES_TOOL, SUGGEST_REPLIES_TOOL_DEFINITION];
-}
-
-export async function executeChatInteractiveTool(
-	name: string,
-	args: Record<string, unknown>,
-	callId: string,
-	signal?: AbortSignal,
-): Promise<ChatInteractiveToolResult> {
-	if (name === REQUEST_CONFIRMATION_TOOL) {
-		parseConfirmationArgs(args);
-		const result = await waitForInteractiveToolResult<ConfirmationToolResult>(
-			callId,
-			signal,
-		);
-		return { content: JSON.stringify(result) };
-	}
-
-	if (name === REQUEST_CHOICES_TOOL) {
-		parseChoicesArgs(args);
-		const result = await waitForInteractiveToolResult<ChoicesToolResult>(
-			callId,
-			signal,
-		);
-		return { content: JSON.stringify(result) };
-	}
-
-	if (name === SUGGEST_REPLIES_TOOL) {
-		const suggestions = parseSuggestRepliesArgs(args);
-		return {
-			content: JSON.stringify({ displayed: true }),
-			postResponse: suggestions,
-		};
-	}
-
-	throw new Error(`Unknown chat UI tool: ${name}`);
-}
-
-export function shouldTerminateTurnAfterTool(name: string): boolean {
-	return isPostResponseChatTool(name);
-}

package/src/core/interactive-tools/index.ts

@@ -1,41 +0,0 @@
-export {
-	CHOICES_TOOL,
-	type ChoiceOption,
-	type ChoicesToolArgs,
-	type ChoicesToolResult,
-	parseChoicesArgs,
-	REQUEST_CHOICES_TOOL,
-} from "./choices.ts";
-export {
-	CONFIRMATION_TOOL,
-	type ConfirmationToolArgs,
-	type ConfirmationToolResult,
-	parseConfirmationArgs,
-	REQUEST_CONFIRMATION_TOOL,
-} from "./confirmation.ts";
-export {
-	INTERACTIVE_CHAT_TOOL_NAMES,
-	isChatUiTool,
-	isInteractiveChatTool,
-	isPostResponseChatTool,
-	POST_RESPONSE_CHAT_TOOL_NAMES,
-} from "./constants.ts";
-export {
-	type ChatInteractiveToolResult,
-	executeChatInteractiveTool,
-	getChatInteractiveTools,
-	shouldTerminateTurnAfterTool,
-} from "./execute.ts";
-export {
-	isValidReplySuggestions,
-	parseSuggestRepliesArgs,
-	type ReplySuggestions,
-	SUGGEST_REPLIES_TOOL,
-	SUGGEST_REPLIES_TOOL_DEFINITION,
-	type SuggestRepliesToolResult,
-} from "./suggestions.ts";
-export {
-	rejectAllInteractiveToolWaiters,
-	resolveInteractiveToolResult,
-	waitForInteractiveToolResult,
-} from "./waiters.ts";

package/src/core/interactive-tools/suggestions.ts

@@ -1,87 +0,0 @@
-import type { ClientToolDefinition } from "../llm-types.ts";
-
-export const SUGGEST_REPLIES_TOOL = "suggest_replies";
-
-export type ReplySuggestions = {
-	question: string;
-	suggestions: string[];
-};
-
-export type SuggestRepliesToolResult = {
-	displayed: true;
-};
-
-export const SUGGEST_REPLIES_TOOL_DEFINITION: ClientToolDefinition = {
-	name: SUGGEST_REPLIES_TOOL,
-	description:
-		"Required when your message asks the user a question and you can suggest 2–6 short example answers. Call as the ONLY tool in the turn, after writing the question in your message. Use for yes/no, dataclass picks, filter examples, or next-step options. The user can tap a suggestion or type their own reply.",
-	inputSchema: {
-		type: "object",
-		properties: {
-			question: {
-				type: "string",
-				description:
-					"The question from your message, e.g. Which dataclass should I query?",
-			},
-			suggestions: {
-				type: "array",
-				minItems: 2,
-				maxItems: 8,
-				items: {
-					type: "string",
-					description: "A short tap-to-send answer.",
-				},
-			},
-		},
-		required: ["question", "suggestions"],
-		additionalProperties: false,
-	},
-};
-
-export function parseSuggestRepliesArgs(
-	args: Record<string, unknown>,
-): ReplySuggestions {
-	const question = String(args.question ?? "").trim();
-	if (!question) {
-		throw new Error("suggest_replies requires a non-empty question");
-	}
-
-	if (!Array.isArray(args.suggestions) || args.suggestions.length < 2) {
-		throw new Error("suggest_replies requires at least two suggestions");
-	}
-
-	const suggestions = args.suggestions
-		.map((entry) => String(entry ?? "").trim())
-		.filter((entry) => entry.length > 0);
-
-	if (suggestions.length < 2) {
-		throw new Error(
-			"suggest_replies requires at least two non-empty suggestions",
-		);
-	}
-
-	if (suggestions.length > 8) {
-		throw new Error("suggest_replies allows at most 8 suggestions");
-	}
-
-	return { question, suggestions };
-}
-
-export function isValidReplySuggestions(
-	value: unknown,
-): value is ReplySuggestions {
-	if (!value || typeof value !== "object") return false;
-
-	const entry = value as ReplySuggestions;
-	if (typeof entry.question !== "string" || !entry.question.trim()) {
-		return false;
-	}
-
-	if (!Array.isArray(entry.suggestions) || entry.suggestions.length < 2) {
-		return false;
-	}
-
-	return entry.suggestions.every(
-		(suggestion) => typeof suggestion === "string" && suggestion.trim(),
-	);
-}

package/src/core/interactive-tools/waiters.ts

@@ -1,55 +0,0 @@
-type InteractiveWaiter = {
-	resolve: (value: unknown) => void;
-	reject: (error: Error) => void;
-};
-
-const waiters = new Map<string, InteractiveWaiter>();
-
-export function waitForInteractiveToolResult<T>(
-	callId: string,
-	signal?: AbortSignal,
-): Promise<T> {
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(new DOMException("Aborted", "AbortError"));
-			return;
-		}
-
-		const onAbort = () => {
-			waiters.delete(callId);
-			reject(new DOMException("Aborted", "AbortError"));
-		};
-
-		signal?.addEventListener("abort", onAbort, { once: true });
-
-		waiters.set(callId, {
-			resolve: (value) => {
-				signal?.removeEventListener("abort", onAbort);
-				resolve(value as T);
-			},
-			reject: (error) => {
-				signal?.removeEventListener("abort", onAbort);
-				reject(error);
-			},
-		});
-	});
-}
-
-export function resolveInteractiveToolResult(
-	callId: string,
-	value: unknown,
-): boolean {
-	const waiter = waiters.get(callId);
-	if (!waiter) return false;
-
-	waiter.resolve(value);
-	waiters.delete(callId);
-	return true;
-}
-
-export function rejectAllInteractiveToolWaiters(error: Error): void {
-	for (const [callId, waiter] of waiters.entries()) {
-		waiter.reject(error);
-		waiters.delete(callId);
-	}
-}