@4djs/assistant 0.0.0 → 0.0.1

package/src/core/llm-chat.ts

@@ -1,686 +0,0 @@
-import type { ReplySuggestions } from "./interactive-tools/index.ts";
-import {
-	executeChatInteractiveTool,
-	getChatInteractiveTools,
-	isChatUiTool,
-	shouldTerminateTurnAfterTool,
-} from "./interactive-tools/index.ts";
-import {
-	buildCompletionsUrl,
-	buildLlmRequestHeaders,
-	isLlmConfigured,
-	type ResolvedLlmSettings,
-	resolveRequestModel,
-} from "./llm-config.ts";
-import { fetchProviderModels } from "./llm-models.ts";
-import { resolveAssistantLlmSettings } from "./llm-provider.ts";
-import { readSseStream } from "./llm-sse.ts";
-import type {
-	ClientToolDefinition,
-	LlmChatMessage,
-	OpenAiToolCall,
-} from "./llm-types.ts";
-import type { AssistantToolDefinition, AssistantToolResult } from "./types.ts";
-
-const MAX_AGENT_STEPS = 8;
-
-const DEFAULT_SYSTEM_PROMPT =
-	"You are a helpful assistant with access to tools. Use tools when they help answer the user.";
-
-export class LlmNotConfiguredError extends Error {
-	readonly code = "LLM_DISABLED";
-
-	constructor(
-		message = "LLM is not configured. Provide llm settings with a valid apiKey.",
-	) {
-		super(message);
-		this.name = "LlmNotConfiguredError";
-	}
-}
-
-export class LlmUpstreamError extends Error {
-	readonly status: number;
-	readonly code: string;
-
-	constructor(message: string, status: number, code = "LLM_UPSTREAM_ERROR") {
-		super(message);
-		this.name = "LlmUpstreamError";
-		this.status = status;
-		this.code = code;
-	}
-}
-
-export interface LlmChatStatus {
-	enabled: boolean;
-	model: string | null;
-	models: string[];
-}
-
-export class ChatAbortedError extends Error {
-	constructor() {
-		super("Chat aborted");
-		this.name = "ChatAbortedError";
-	}
-}
-
-export interface StreamHandlers {
-	turnId: string;
-	onUpdate: (content: string) => void;
-}
-
-export interface ToolHandlers {
-	onStart: (step: {
-		id: string;
-		name: string;
-		args: Record<string, unknown>;
-		callId: string;
-	}) => void;
-	onFinish: (
-		stepId: string,
-		update: {
-			status: "done" | "error";
-			result?: unknown;
-			error?: string;
-		},
-	) => void;
-}
-
-export interface AgentStepResult {
-	assistantMessages: Array<{
-		id?: string;
-		content: string;
-		toolCall?: { name: string; args: Record<string, unknown> };
-		isError?: boolean;
-		streaming?: boolean;
-	}>;
-	apiMessages: LlmChatMessage[];
-	lastToolResult?: AssistantToolResult;
-}
-
-export async function fetchLlmStatus(): Promise<LlmChatStatus> {
-	try {
-		const config = await resolveAssistantLlmSettings();
-		if (!isLlmConfigured(config)) {
-			return { enabled: false, model: null, models: [] };
-		}
-
-		const models = config.models?.length
-			? config.models
-			: await fetchProviderModels(config);
-		return {
-			enabled: true,
-			model: config.model,
-			models,
-		};
-	} catch {
-		return { enabled: false, model: null, models: [] };
-	}
-}
-
-export async function requestLlmCompletion(input: {
-	messages: LlmChatMessage[];
-	tools?: ClientToolDefinition[];
-	model?: string;
-	systemPrompt?: string;
-	responseFormat?: { type: "json_object" };
-	stream?: StreamHandlers;
-	signal?: AbortSignal;
-}): Promise<{
-	content: string | null;
-	toolCalls: OpenAiToolCall[];
-	model: string;
-}> {
-	if (input.stream) {
-		return requestLlmCompletionStream(input, input.stream);
-	}
-
-	const settings = await requireLlmSettings();
-	const payload = buildChatPayload(input, settings);
-
-	const res = await fetch(buildCompletionsUrl(settings.baseUrl), {
-		method: "POST",
-		headers: buildLlmRequestHeaders(settings.apiKey),
-		body: JSON.stringify(payload),
-		signal: input.signal,
-	});
-
-	const raw = await res.text();
-	let data: Record<string, unknown> = {};
-	try {
-		data = raw ? (JSON.parse(raw) as Record<string, unknown>) : {};
-	} catch {
-		throw new LlmUpstreamError(
-			`LLM returned non-JSON response (${res.status})`,
-			502,
-			"LLM_BAD_RESPONSE",
-		);
-	}
-
-	if (!res.ok) {
-		throw upstreamError(data, res.status);
-	}
-
-	const choice = (
-		data.choices as Array<Record<string, unknown>> | undefined
-	)?.[0];
-	const message = choice?.message as Record<string, unknown> | undefined;
-	if (!message) {
-		throw new LlmUpstreamError(
-			"LLM response missing message",
-			502,
-			"LLM_BAD_RESPONSE",
-		);
-	}
-
-	return {
-		content: (message.content as string | null) ?? null,
-		toolCalls: (message.tool_calls as OpenAiToolCall[] | undefined) ?? [],
-		model: typeof data.model === "string" ? data.model : settings.model,
-	};
-}
-
-async function requestLlmCompletionStream(
-	input: {
-		messages: LlmChatMessage[];
-		tools?: ClientToolDefinition[];
-		model?: string;
-		systemPrompt?: string;
-		responseFormat?: { type: "json_object" };
-		signal?: AbortSignal;
-	},
-	handlers: StreamHandlers,
-): Promise<{
-	content: string | null;
-	toolCalls: OpenAiToolCall[];
-	model: string;
-}> {
-	const settings = await requireLlmSettings();
-	const payload = buildChatPayload(input, settings);
-
-	try {
-		const res = await fetch(buildCompletionsUrl(settings.baseUrl), {
-			method: "POST",
-			headers: buildLlmRequestHeaders(settings.apiKey),
-			body: JSON.stringify({ ...payload, stream: true }),
-			signal: input.signal,
-		});
-
-		if (!res.ok) {
-			const raw = await res.text();
-			let data: Record<string, unknown> = {};
-			try {
-				data = raw ? (JSON.parse(raw) as Record<string, unknown>) : {};
-			} catch {
-				// ignore
-			}
-			throw upstreamError(data, res.status);
-		}
-
-		if (!res.body) {
-			throw new LlmUpstreamError(
-				"LLM stream missing body",
-				502,
-				"LLM_BAD_RESPONSE",
-			);
-		}
-
-		const final = await readSseStream(
-			res.body,
-			(chunk) => {
-				if (chunk.contentDelta) {
-					handlers.onUpdate(chunk.content);
-				}
-			},
-			input.signal,
-		);
-
-		return {
-			content: final.content || null,
-			toolCalls: final.toolCalls,
-			model: final.model ?? settings.model,
-		};
-	} catch (error) {
-		if (
-			input.signal?.aborted ||
-			(error instanceof DOMException && error.name === "AbortError")
-		) {
-			throw new ChatAbortedError();
-		}
-		throw error;
-	}
-}
-
-export async function runLlmAgent(input: {
-	userMessage: string;
-	history: LlmChatMessage[];
-	tools: AssistantToolDefinition[];
-	model?: string;
-	signal?: AbortSignal;
-	stream?: StreamHandlers;
-	toolHandlers?: ToolHandlers;
-	invokeTool: (
-		name: string,
-		args: Record<string, unknown>,
-	) => Promise<AssistantToolResult>;
-	onPostResponseTool?: (suggestions: ReplySuggestions) => void;
-}): Promise<AgentStepResult> {
-	const apiMessages: LlmChatMessage[] = [
-		...input.history,
-		{ role: "user", content: input.userMessage },
-	];
-
-	let lastToolResult: AssistantToolResult | undefined;
-	const clientTools = [
-		...input.tools.map(toClientTool),
-		...getChatInteractiveTools(),
-	];
-	let finalContent = "";
-	let endedWithPostResponseTool = false;
-
-	for (let step = 0; step < MAX_AGENT_STEPS; step++) {
-		if (input.signal?.aborted) {
-			throw new ChatAbortedError();
-		}
-
-		const completion = await requestLlmCompletion({
-			messages: apiMessages,
-			tools: clientTools,
-			model: input.model,
-			signal: input.signal,
-			stream: input.stream
-				? {
-						turnId: input.stream.turnId,
-						onUpdate: (content) => {
-							finalContent = content;
-							input.stream?.onUpdate(content);
-						},
-					}
-				: undefined,
-		});
-
-		if (completion.toolCalls.length === 0) {
-			finalContent =
-				completion.content?.trim() ||
-				"I couldn't produce a response. Try rephrasing your request.";
-			input.stream?.onUpdate(finalContent);
-			apiMessages.push({
-				role: "assistant",
-				content: completion.content,
-			});
-			break;
-		}
-
-		apiMessages.push({
-			role: "assistant",
-			content: completion.content,
-			tool_calls: completion.toolCalls,
-		});
-
-		let terminatesTurn = false;
-
-		for (const call of completion.toolCalls) {
-			const args = parseToolArguments(call.function.arguments);
-			const stepId = crypto.randomUUID();
-			input.toolHandlers?.onStart({
-				id: stepId,
-				name: call.function.name,
-				args,
-				callId: call.id,
-			});
-
-			let toolContent: string;
-			let finishUpdate: {
-				status: "done" | "error";
-				result?: unknown;
-				error?: string;
-			};
-
-			if (isChatUiTool(call.function.name)) {
-				try {
-					const interactiveResult = await executeChatInteractiveTool(
-						call.function.name,
-						args,
-						call.id,
-						input.signal,
-					);
-					toolContent = interactiveResult.content;
-					finishUpdate = {
-						status: interactiveResult.isError ? "error" : "done",
-						result: JSON.parse(interactiveResult.content),
-					};
-					if (interactiveResult.postResponse) {
-						input.onPostResponseTool?.(interactiveResult.postResponse);
-						terminatesTurn = true;
-					}
-				} catch (error) {
-					if (
-						input.signal?.aborted ||
-						(error instanceof DOMException && error.name === "AbortError")
-					) {
-						throw new ChatAbortedError();
-					}
-					const message =
-						error instanceof Error ? error.message : String(error);
-					toolContent = message;
-					finishUpdate = { status: "error", error: message };
-				}
-			} else {
-				const result = await input.invokeTool(call.function.name, args);
-				lastToolResult = result;
-				toolContent = formatToolResult(result);
-				finishUpdate = {
-					status: result.isError ? "error" : "done",
-					result: result.structuredContent ?? result,
-					error: result.isError ? result.content[0]?.text : undefined,
-				};
-			}
-
-			input.toolHandlers?.onFinish(stepId, finishUpdate);
-
-			apiMessages.push({
-				role: "tool",
-				tool_call_id: call.id,
-				content: toolContent,
-			});
-
-			if (shouldTerminateTurnAfterTool(call.function.name)) {
-				terminatesTurn = true;
-			}
-		}
-
-		if (terminatesTurn) {
-			finalContent =
-				completion.content?.trim() ||
-				finalContent.trim() ||
-				"Choose an option below or type your reply.";
-			input.stream?.onUpdate(finalContent);
-			endedWithPostResponseTool = true;
-			break;
-		}
-	}
-
-	if (!endedWithPostResponseTool && apiMessages.at(-1)?.role === "tool") {
-		const completion = await requestLlmCompletion({
-			messages: apiMessages,
-			tools: clientTools,
-			model: input.model,
-			signal: input.signal,
-			stream: input.stream
-				? {
-						turnId: input.stream.turnId,
-						onUpdate: (content) => {
-							finalContent = content;
-							input.stream?.onUpdate(content);
-						},
-					}
-				: undefined,
-		});
-		finalContent =
-			completion.content?.trim() || "Done — see the trace below for details.";
-		input.stream?.onUpdate(finalContent);
-		apiMessages.push({
-			role: "assistant",
-			content: completion.content,
-		});
-	}
-
-	return {
-		assistantMessages: finalContent
-			? [{ id: input.stream?.turnId, content: finalContent }]
-			: [],
-		apiMessages,
-		lastToolResult,
-	};
-}
-
-function resolveAssistantContentForApi(message: {
-	content: string;
-	replySuggestions?: ReplySuggestions;
-}): string {
-	const content = message.content.trim();
-	if (content) return message.content;
-	if (message.replySuggestions?.question.trim()) {
-		return message.replySuggestions.question;
-	}
-	return message.content;
-}
-
-/** Keep recent turns at UI-message boundaries so tool-call groups stay intact. */
-const MAX_HISTORY_USER_TURNS = 12;
-
-function trimMessagesForHistory<T extends { role: string }>(
-	messages: T[],
-	maxUserTurns: number,
-): T[] {
-	if (messages.length === 0 || maxUserTurns <= 0) return messages;
-
-	let userCount = 0;
-	let start = 0;
-	for (let i = messages.length - 1; i >= 0; i--) {
-		if (messages[i]?.role === "user") {
-			userCount++;
-			if (userCount >= maxUserTurns) {
-				start = i;
-				break;
-			}
-		}
-	}
-	return messages.slice(start);
-}
-
-/** Drop tool messages that are not preceded by a matching assistant tool_calls entry. */
-export function sanitizeLlmMessages(
-	messages: LlmChatMessage[],
-): LlmChatMessage[] {
-	const out: LlmChatMessage[] = [];
-	let pendingToolCallIds: Set<string> | null = null;
-
-	for (const msg of messages) {
-		if (msg.role === "assistant" && msg.tool_calls?.length) {
-			out.push(msg);
-			pendingToolCallIds = new Set(
-				msg.tool_calls.map((toolCall) => toolCall.id),
-			);
-			continue;
-		}
-
-		if (msg.role === "tool") {
-			const callId = msg.tool_call_id;
-			if (callId && pendingToolCallIds?.has(callId)) {
-				out.push(msg);
-				pendingToolCallIds.delete(callId);
-				if (pendingToolCallIds.size === 0) {
-					pendingToolCallIds = null;
-				}
-			}
-			continue;
-		}
-
-		pendingToolCallIds = null;
-		out.push(msg);
-	}
-
-	while (out[0]?.role === "tool") {
-		out.shift();
-	}
-
-	return out;
-}
-
-export function buildLlmHistory(
-	messages: Array<{
-		role: string;
-		content: string;
-		replySuggestions?: ReplySuggestions;
-		activity?: Array<{
-			name: string;
-			args: Record<string, unknown>;
-			error?: string;
-			result?: unknown;
-		}>;
-		toolCall?: { name: string; args: Record<string, unknown> };
-	}>,
-): LlmChatMessage[] {
-	const history: LlmChatMessage[] = [];
-
-	for (const msg of trimMessagesForHistory(messages, MAX_HISTORY_USER_TURNS)) {
-		if (msg.role === "user") {
-			history.push({ role: "user", content: msg.content });
-			continue;
-		}
-		if (msg.role !== "assistant") continue;
-
-		if (msg.activity?.length) {
-			const baseId = history.length;
-			const toolCalls = msg.activity.map((step, index) => ({
-				id: `call_${baseId}_${index}`,
-				type: "function" as const,
-				function: {
-					name: step.name,
-					arguments: JSON.stringify(step.args),
-				},
-			}));
-			history.push({
-				role: "assistant",
-				content: resolveAssistantContentForApi(msg) || null,
-				tool_calls: toolCalls,
-			});
-			for (const [index, step] of msg.activity.entries()) {
-				history.push({
-					role: "tool",
-					tool_call_id: `call_${baseId}_${index}`,
-					content:
-						step.error ??
-						(typeof step.result === "string"
-							? step.result
-							: JSON.stringify(step.result ?? "Result shown in UI.")),
-				});
-			}
-			continue;
-		}
-
-		if (msg.toolCall) {
-			const id = `call_${history.length}`;
-			history.push({
-				role: "assistant",
-				content: msg.content || null,
-				tool_calls: [
-					{
-						id,
-						type: "function",
-						function: {
-							name: msg.toolCall.name,
-							arguments: JSON.stringify(msg.toolCall.args),
-						},
-					},
-				],
-			});
-			history.push({
-				role: "tool",
-				tool_call_id: id,
-				content: "Result shown in UI.",
-			});
-			continue;
-		}
-
-		history.push({
-			role: "assistant",
-			content: resolveAssistantContentForApi(msg),
-		});
-	}
-
-	return sanitizeLlmMessages(history);
-}
-
-async function requireLlmSettings(): Promise<ResolvedLlmSettings> {
-	const settings = await resolveAssistantLlmSettings();
-	if (!isLlmConfigured(settings)) {
-		throw new LlmNotConfiguredError();
-	}
-	return settings;
-}
-
-function buildChatPayload(
-	body: {
-		messages: LlmChatMessage[];
-		tools?: ClientToolDefinition[];
-		model?: string;
-		systemPrompt?: string;
-		responseFormat?: { type: "json_object" };
-	},
-	settings: ResolvedLlmSettings,
-) {
-	const messages: LlmChatMessage[] = [
-		{
-			role: "system",
-			content:
-				body.systemPrompt ?? settings.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
-		},
-		...body.messages.filter((message) => message.role !== "system"),
-	];
-
-	const payload: Record<string, unknown> = {
-		model: resolveRequestModel(body.model, settings),
-		messages,
-	};
-
-	if (body.responseFormat) {
-		payload.response_format = body.responseFormat;
-	}
-
-	if (body.tools?.length) {
-		payload.tools = body.tools.map((tool) => ({
-			type: "function",
-			function: {
-				name: tool.name,
-				description: tool.description,
-				parameters: tool.inputSchema,
-			},
-		}));
-		payload.tool_choice = "auto";
-	}
-
-	return payload;
-}
-
-function upstreamError(body: Record<string, unknown>, status: number): Error {
-	const errorRecord = body.error as Record<string, unknown> | undefined;
-	const message =
-		(typeof errorRecord?.message === "string" && errorRecord.message) ||
-		(typeof body.message === "string" && body.message) ||
-		(typeof body.error === "string" && body.error) ||
-		`LLM request failed (${status})`;
-	const code =
-		(typeof body.code === "string" && body.code) || "LLM_UPSTREAM_ERROR";
-	return new LlmUpstreamError(message, status, code);
-}
-
-function toClientTool(tool: AssistantToolDefinition): ClientToolDefinition {
-	return {
-		name: tool.name,
-		description: tool.description,
-		inputSchema: tool.inputSchema,
-	};
-}
-
-function parseToolArguments(raw: string): Record<string, unknown> {
-	try {
-		const parsed = JSON.parse(raw) as unknown;
-		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-			return parsed as Record<string, unknown>;
-		}
-		return { params: parsed };
-	} catch {
-		return { params: [raw] };
-	}
-}
-
-function formatToolResult(result: AssistantToolResult): string {
-	if (result.isError) {
-		return result.content.map((c) => c.text).join("\n");
-	}
-	if (result.structuredContent !== undefined) {
-		return JSON.stringify(result.structuredContent);
-	}
-	return result.content.map((c) => c.text).join("\n");
-}