webui: restore OpenAI-Compatible model source of truth and unify metadata capture

This change re-establishes a single, reliable source of truth for the active model:
fully aligned with the OpenAI-Compat API behavior

It introduces a unified metadata flow that captures the model field from both
streaming and non-streaming responses, wiring a new onModel callback through ChatService
The model name is now resolved directly from the API payload rather than relying on
server /props or UI assumptions

ChatStore records and persists the resolved model for each assistant message during
streaming, ensuring consistency across the UI and database
Type definitions for API and settings were also extended to include model metadata
and the onModel callback, completing the alignment with OpenAI-Compat semantics

Author: ServeurpersoCom

tools/server/webui/src/lib/services/chat.ts

@@ -52,6 +52,8 @@ export class ChatService {
 			onChunk,
 			onComplete,
 			onError,
+			onReasoningChunk,
+			onModel,
 			// Generation parameters
 			temperature,
 			max_tokens,
@@ -195,13 +197,14 @@ export class ChatService {
 					onChunk,
 					onComplete,
 					onError,
-					options.onReasoningChunk,
+					onReasoningChunk,
+					onModel,
 					conversationId,
 					abortController.signal
 				);
 				return;
 			} else {
-				return this.handleNonStreamResponse(response, onComplete, onError);
+				return this.handleNonStreamResponse(response, onComplete, onError, onModel);
 			}
 		} catch (error) {
 			if (error instanceof Error && error.name === 'AbortError') {
@@ -261,6 +264,7 @@ export class ChatService {
 		) => void,
 		onError?: (error: Error) => void,
 		onReasoningChunk?: (chunk: string) => void,
+		onModel?: (model: string) => void,
 		conversationId?: string,
 		abortSignal?: AbortSignal
 	): Promise<void> {
@@ -276,6 +280,7 @@ export class ChatService {
 		let hasReceivedData = false;
 		let lastTimings: ChatMessageTimings | undefined;
 		let streamFinished = false;
+		let modelEmitted = false;
 
 		try {
 			let chunk = '';
@@ -304,6 +309,12 @@ export class ChatService {
 						try {
 							const parsed: ApiChatCompletionStreamChunk = JSON.parse(data);
 
+							const chunkModel = this.extractModelName(parsed);
+							if (chunkModel && !modelEmitted) {
+								modelEmitted = true;
+								onModel?.(chunkModel);
+							}
+
 							const content = parsed.choices[0]?.delta?.content;
 							const reasoningContent = parsed.choices[0]?.delta?.reasoning_content;
 							const timings = parsed.timings;
@@ -378,7 +389,8 @@ export class ChatService {
 			reasoningContent?: string,
 			timings?: ChatMessageTimings
 		) => void,
-		onError?: (error: Error) => void
+		onError?: (error: Error) => void,
+		onModel?: (model: string) => void
 	): Promise<string> {
 		try {
 			const responseText = await response.text();
@@ -389,6 +401,11 @@ export class ChatService {
 			}
 
 			const data: ApiChatCompletionResponse = JSON.parse(responseText);
+			const responseModel = this.extractModelName(data);
+			if (responseModel) {
+				onModel?.(responseModel);
+			}
+
 			const content = data.choices[0]?.message?.content || '';
 			const reasoningContent = data.choices[0]?.message?.reasoning_content;
 
@@ -631,6 +648,69 @@ export class ChatService {
 		}
 	}
 
+	private extractModelName(data: unknown): string | undefined {
+		if (!data || typeof data !== 'object') {
+			return undefined;
+		}
+
+		const record = data as Record<string, unknown>;
+		const normalize = (value: unknown): string | undefined => {
+			if (typeof value !== 'string') {
+				return undefined;
+			}
+
+			const trimmed = value.trim();
+
+			return trimmed.length > 0 ? trimmed : undefined;
+		};
+
+		const rootModel = normalize(record['model']);
+		if (rootModel) {
+			return rootModel;
+		}
+
+		const choices = record['choices'];
+		if (!Array.isArray(choices) || choices.length === 0) {
+			return undefined;
+		}
+
+		const firstChoice = choices[0] as Record<string, unknown> | undefined;
+		if (!firstChoice) {
+			return undefined;
+		}
+
+		const choiceModel = normalize(firstChoice['model']);
+		if (choiceModel) {
+			return choiceModel;
+		}
+
+		const delta = firstChoice['delta'] as Record<string, unknown> | undefined;
+		if (delta) {
+			const deltaModel = normalize(delta['model']);
+			if (deltaModel) {
+				return deltaModel;
+			}
+		}
+
+		const message = firstChoice['message'] as Record<string, unknown> | undefined;
+		if (message) {
+			const messageModel = normalize(message['model']);
+			if (messageModel) {
+				return messageModel;
+			}
+		}
+
+		const metadata = firstChoice['metadata'] as Record<string, unknown> | undefined;
+		if (metadata) {
+			const metadataModel = normalize(metadata['model']);
+			if (metadataModel) {
+				return metadataModel;
+			}
+		}
+
+		return undefined;
+	}
+
 	private updateProcessingState(
 		timings?: ChatMessageTimings,
 		promptProgress?: ChatMessagePromptProgress,

tools/server/webui/src/lib/types/api.d.ts

@@ -186,10 +186,14 @@ export interface ApiChatCompletionRequest {
 }
 
 export interface ApiChatCompletionStreamChunk {
+	model?: string;
 	choices: Array<{
+		model?: string;
+		metadata?: { model?: string };
 		delta: {
 			content?: string;
 			reasoning_content?: string;
+			model?: string;
 		};
 	}>;
 	timings?: {
@@ -203,10 +207,14 @@ export interface ApiChatCompletionStreamChunk {
 }
 
 export interface ApiChatCompletionResponse {
+	model?: string;
 	choices: Array<{
+		model?: string;
+		metadata?: { model?: string };
 		message: {
 			content: string;
 			reasoning_content?: string;
+			model?: string;
 		};
 	}>;
 }

tools/server/webui/src/lib/types/settings.d.ts

@@ -41,6 +41,7 @@ export interface SettingsChatServiceOptions {
 	// Callbacks
 	onChunk?: (chunk: string) => void;
 	onReasoningChunk?: (chunk: string) => void;
+	onModel?: (model: string) => void;
 	onComplete?: (response: string, reasoningContent?: string, timings?: ChatMessageTimings) => void;
 	onError?: (error: Error) => void;
 }