@resolveio/server-lib 22.3.220 → 22.3.221

package/src/services/openai-client.ts

@@ -0,0 +1,265 @@
+import { setTimeout as sleepTimeout } from 'timers/promises';
+import { round } from '../util/common';
+
+export type OpenAIResponseFormat = 'text' | 'json' | 'json_object' | { type: string; [key: string]: any };
+
+export interface OpenAIConfig {
+	apiKey: string;
+	baseUrl?: string;
+	model?: string;
+	fallbackModel?: string;
+	temperature?: number;
+	maxRetries?: number;
+	retryDelayMs?: number;
+	maxTokens?: number;
+	responseFormat?: OpenAIResponseFormat;
+}
+
+export interface OpenAIChatOptions {
+	timeoutMs?: number;
+	responseFormat?: OpenAIResponseFormat;
+}
+
+export interface OpenAIUsageSummary {
+	inputTokens: number;
+	outputTokens: number;
+	totalTokens: number;
+}
+
+export interface OpenAIChatResult {
+	content: string;
+	usage?: OpenAIUsageSummary;
+	model?: string;
+	requestId?: string;
+}
+
+export class OpenAIClient {
+	private readonly config: OpenAIConfig;
+
+	constructor(config: OpenAIConfig) {
+		this.config = config;
+		if (!this.config.apiKey) {
+			throw new Error('AI API key is required for AI client');
+		}
+	}
+
+	async chat(
+		messages: Array<{role: 'system' | 'user' | 'assistant'; content: any}>,
+		options?: OpenAIChatOptions
+	): Promise<OpenAIChatResult> {
+		const baseUrl = (this.config.baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
+		const primaryModel = this.config.model || 'gpt-5.1';
+		const fallbackModel = (this.config.fallbackModel || '').trim();
+		const maxRetries = this.normalizeRetryCount(this.config.maxRetries);
+		const retryDelayMs = this.normalizeRetryDelay(this.config.retryDelayMs);
+		const payload: any = {
+			model: primaryModel,
+			messages,
+			temperature: this.config.temperature ?? 0.2
+		};
+		const responseFormat = options?.responseFormat ?? this.config.responseFormat;
+		if (responseFormat) {
+			const normalized = typeof responseFormat === 'string' ? responseFormat.toLowerCase() : '';
+			if (normalized === 'json' || normalized === 'json_object') {
+				payload.response_format = { type: 'json_object' };
+			}
+			else if (typeof responseFormat === 'object') {
+				payload.response_format = responseFormat;
+			}
+			else if (normalized && normalized !== 'text') {
+				payload.response_format = { type: normalized };
+			}
+		}
+		if (Number.isFinite(this.config.maxTokens)) {
+			payload.max_completion_tokens = this.normalizeTokenCount(this.config.maxTokens);
+		}
+
+		const runRequest = async (model: string): Promise<OpenAIChatResult & { responseText: string }> => {
+			const timeoutMs = options?.timeoutMs;
+			const controller = timeoutMs ? new AbortController() : null;
+			const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+			let response: Response;
+			let requestId = '';
+			try {
+				response = await fetch(`${baseUrl}/chat/completions`, {
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						Authorization: `Bearer ${this.config.apiKey}`
+					},
+					body: JSON.stringify({ ...payload, model }),
+					signal: controller?.signal
+				});
+				requestId = response.headers.get('x-request-id') || '';
+			}
+			catch (error) {
+				if (controller?.signal?.aborted) {
+					throw new Error('AI request timed out.');
+				}
+				throw error;
+			}
+			finally {
+				if (timeoutId) {
+					clearTimeout(timeoutId);
+				}
+			}
+
+			const responseText = await response.text();
+			if (!response.ok) {
+				const requestError = new Error(`AI request failed (${response.status}).`);
+				(requestError as any).status = response.status;
+				(requestError as any).raw = responseText;
+				throw requestError;
+			}
+
+			const data = responseText ? JSON.parse(responseText) : {};
+			const message = data?.choices?.[0]?.message || {};
+			const content = this.extractContent(message);
+			if (!content) {
+				const refusal = message?.refusal ? ` Refusal: ${message.refusal}` : '';
+				throw new Error(`AI returned no completion content.${refusal}`);
+			}
+
+			const usage = this.extractUsage(data?.usage);
+			return {
+				content,
+				usage,
+				model: data?.model || model,
+				requestId: data?.id || requestId,
+				responseText
+			};
+		};
+
+		const runWithRetry = async (model: string): Promise<OpenAIChatResult & { responseText: string }> => {
+			let attempt = 0;
+			let lastError: unknown = null;
+			while (attempt <= maxRetries) {
+				try {
+					return await runRequest(model);
+				}
+				catch (error) {
+					lastError = error;
+					if (attempt >= maxRetries || !this.isRetryableError(error)) {
+						break;
+					}
+					const delay = retryDelayMs * Math.pow(2, attempt);
+					await this.sleep(delay);
+					attempt += 1;
+				}
+			}
+			throw lastError;
+		};
+
+		try {
+			const result = await runWithRetry(primaryModel);
+			return {
+				content: result.content,
+				usage: result.usage,
+				model: result.model,
+				requestId: result.requestId
+			};
+		}
+		catch (error) {
+			if (!fallbackModel || fallbackModel === primaryModel) {
+				throw error;
+			}
+			const result = await runWithRetry(fallbackModel);
+			return {
+				content: result.content,
+				usage: result.usage,
+				model: result.model,
+				requestId: result.requestId
+			};
+		}
+	}
+
+	private extractContent(message: any): string {
+		if (!message) {
+			return '';
+		}
+		const content = message.content;
+		if (typeof content === 'string') {
+			return content.trim();
+		}
+		if (Array.isArray(content)) {
+			return content
+				.map((part) => {
+					if (!part) {
+						return '';
+					}
+					if (typeof part === 'string') {
+						return part;
+					}
+					if (typeof part?.text === 'string') {
+						return part.text;
+					}
+					if (typeof part?.content === 'string') {
+						return part.content;
+					}
+					return '';
+				})
+				.join('')
+				.trim();
+		}
+		return '';
+	}
+
+	private extractUsage(usage: any): OpenAIUsageSummary | undefined {
+		if (!usage) {
+			return undefined;
+		}
+		const inputTokens = this.normalizeTokenValue(usage.prompt_tokens ?? usage.input_tokens);
+		const outputTokens = this.normalizeTokenValue(usage.completion_tokens ?? usage.output_tokens);
+		const totalTokens = this.normalizeTokenValue(usage.total_tokens ?? (inputTokens + outputTokens));
+		if (!totalTokens && !inputTokens && !outputTokens) {
+			return undefined;
+		}
+		return {
+			inputTokens,
+			outputTokens,
+			totalTokens
+		};
+	}
+
+	private normalizeTokenValue(value: any): number {
+		const parsed = Number(value);
+		if (!Number.isFinite(parsed) || parsed < 0) {
+			return 0;
+		}
+		return round(parsed);
+	}
+
+	private normalizeTokenCount(value?: number): number {
+		if (!Number.isFinite(value)) {
+			return 0;
+		}
+		const rounded = round(value || 0);
+		return rounded < 0 ? 0 : rounded;
+	}
+
+	private normalizeRetryCount(value?: number): number {
+		if (!Number.isFinite(value)) {
+			return 0;
+		}
+		return Math.max(0, round(value || 0));
+	}
+
+	private normalizeRetryDelay(value?: number): number {
+		if (!Number.isFinite(value)) {
+			return 750;
+		}
+		return Math.max(250, round(value || 0));
+	}
+
+	private isRetryableError(error: any): boolean {
+		const message = error instanceof Error ? error.message.toLowerCase() : String(error || '').toLowerCase();
+		return message.includes('timeout') || message.includes('429') || message.includes('rate limit');
+	}
+
+	private async sleep(ms: number): Promise<void> {
+		if (!ms) {
+			return;
+		}
+		await sleepTimeout(ms);
+	}
+}

package/src/types/error-report.ts

@@ -0,0 +1,26 @@
+export interface ErrorReportAttachment {
+	name?: string;
+	url?: string;
+	contentType?: string;
+	size?: number;
+}
+
+export interface ErrorReportPayload {
+	clientId?: string;
+	clientName?: string;
+	clientRepo?: string;
+	clientEmail?: string;
+	clientSlug?: string;
+	sourceApp: string;
+	environment?: string;
+	severity?: string;
+	message: string;
+	stack?: string;
+	context?: Record<string, any>;
+	metadata?: Record<string, any>;
+	attachments?: ErrorReportAttachment[];
+	fingerprint?: string;
+	idempotencyKey?: string;
+	reportedBy?: string;
+	reportedAt?: Date;
+}

package/src/types/js-tiktoken.d.ts

@@ -0,0 +1,11 @@
+/* eslint-disable no-unused-vars -- Type declarations require parameter names. */
+declare module 'js-tiktoken' {
+	export type Tiktoken = {
+		encode: (text: string) => number[];
+		free: () => void;
+	};
+
+	export function encodingForModel(model: string): Tiktoken;
+	export function getEncoding(encoding: string): Tiktoken;
+}
+/* eslint-enable no-unused-vars */

package/src/types/slow-query-report.ts

@@ -0,0 +1,28 @@
+export type SlowQueryLogStatus = 'new' | 'investigating' | 'queued' | 'optimized' | 'ignored';
+export const slowQueryLogStatuses: SlowQueryLogStatus[] = ['new', 'investigating', 'queued', 'optimized', 'ignored'];
+
+export interface SlowQueryReportPayload {
+	queryHash: string;
+	collection: string;
+	filter?: Record<string, any>;
+	options?: Record<string, any>;
+	durationMs: number;
+	maxDurationMs?: number;
+	thresholdMs?: number;
+	explainPlan?: Record<string, any>;
+	explainExecutionStats?: Record<string, any>;
+	explainGeneratedAt?: Date | string;
+	clientSlug?: string;
+	clientName?: string;
+	environment?: string;
+	sourceApp?: string;
+	nodeHostname?: string;
+	status?: SlowQueryLogStatus;
+	ignored?: boolean;
+	notes?: string;
+	pipeline?: Record<string, any>[];
+	server_url?: string;
+	publication?: string;
+	subscription_data?: any[];
+	userId?: string;
+}