@theia/ai-chat 1.66.0-next.44 → 1.66.0-next.73

package/src/browser/chat-session-store-impl.ts

@@ -0,0 +1,326 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { StorageService } from '@theia/core/lib/browser';
+import { URI } from '@theia/core';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { ChatModel } from '../common/chat-model';
+import { ChatSessionIndex, ChatSessionStore, ChatModelWithMetadata, ChatSessionMetadata } from '../common/chat-session-store';
+import { SerializedChatData, CHAT_DATA_VERSION } from '../common/chat-model-serialization';
+
+const MAX_SESSIONS = 25;
+const INDEX_FILE = 'index.json';
+
+@injectable()
+export class ChatSessionStoreImpl implements ChatSessionStore {
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    @inject(EnvVariablesServer)
+    protected readonly envServer: EnvVariablesServer;
+
+    @inject(StorageService)
+    protected readonly storageService: StorageService;
+
+    @inject(ILogger) @named('ChatSessionStore')
+    protected readonly logger: ILogger;
+
+    protected storageRoot?: URI;
+    protected indexCache?: ChatSessionIndex;
+    protected storePromise: Promise<void> = Promise.resolve();
+
+    async storeSessions(...sessions: Array<ChatModel | ChatModelWithMetadata>): Promise<void> {
+        this.storePromise = this.storePromise.then(async () => {
+            const root = await this.getStorageRoot();
+            this.logger.debug('Starting to store sessions', { totalSessions: sessions.length, storageRoot: root.toString() });
+
+            // Normalize to SessionWithTitle and filter empty sessions
+            const nonEmptySessions = sessions
+                .map(s => this.isChatModelWithMetadata(s) ? { ...s, saveDate: Date.now() } : { model: s, saveDate: Date.now() })
+                .filter(s => !s.model.isEmpty());
+            this.logger.debug('Filtered empty sessions', { nonEmptySessions: nonEmptySessions.length });
+
+            // Write each session as JSON file
+            for (const session of nonEmptySessions) {
+                const sessionFile = root.resolve(`${session.model.id}.json`);
+                const modelData = session.model.toSerializable();
+                // Wrap model data with persistence metadata
+                const data: SerializedChatData = {
+                    version: CHAT_DATA_VERSION,
+                    title: session.title,
+                    pinnedAgentId: session.pinnedAgentId,
+                    saveDate: session.saveDate,
+                    model: modelData
+                };
+                this.logger.debug('Writing session to file', {
+                    sessionId: session.model.id,
+                    title: data.title,
+                    filePath: sessionFile.toString(),
+                    requestCount: modelData.requests.length,
+                    responseCount: modelData.responses.length,
+                    pinnedAgentId: data.pinnedAgentId,
+                    version: data.version
+                });
+                await this.fileService.writeFile(
+                    sessionFile,
+                    BinaryBuffer.fromString(JSON.stringify(data, undefined, 2))
+                );
+            }
+
+            // Update index with metadata
+            await this.updateIndex(nonEmptySessions);
+
+            // Trim to max sessions
+            await this.trimSessions();
+            this.logger.debug('Finished storing sessions');
+        });
+        return this.storePromise;
+    }
+
+    private isChatModelWithMetadata(session: ChatModel | ChatModelWithMetadata): session is ChatModelWithMetadata {
+        return 'model' in session;
+    }
+
+    async readSession(sessionId: string): Promise<SerializedChatData | undefined> {
+        const root = await this.getStorageRoot();
+        const sessionFile = root.resolve(`${sessionId}.json`);
+        this.logger.debug('Reading session from file', { sessionId, filePath: sessionFile.toString() });
+
+        try {
+            const content = await this.fileService.readFile(sessionFile);
+            const parsedData = JSON.parse(content.value.toString());
+            const data = this.migrateData(parsedData);
+            this.logger.debug('Successfully read session', {
+                sessionId,
+                requestCount: data.model.requests.length,
+                responseCount: data.model.responses.length,
+                version: data.version
+            });
+            return data;
+        } catch (e) {
+            this.logger.debug('Failed to read session', { sessionId, error: e });
+            return undefined;
+        }
+    }
+
+    async deleteSession(sessionId: string): Promise<void> {
+        this.storePromise = this.storePromise.then(async () => {
+            const root = await this.getStorageRoot();
+            const sessionFile = root.resolve(`${sessionId}.json`);
+            this.logger.debug('Deleting session', { sessionId, filePath: sessionFile.toString() });
+
+            try {
+                await this.fileService.delete(sessionFile);
+                this.logger.debug('Session file deleted', { sessionId });
+            } catch (e) {
+                this.logger.debug('Failed to delete session file (may not exist)', { sessionId, error: e });
+            }
+
+            // Update index
+            const index = await this.loadIndex();
+            delete index[sessionId];
+            await this.saveIndex(index);
+            this.logger.debug('Session removed from index', { sessionId });
+        });
+        return this.storePromise;
+    }
+
+    async clearAllSessions(): Promise<void> {
+        this.storePromise = this.storePromise.then(async () => {
+            const root = await this.getStorageRoot();
+
+            try {
+                await this.fileService.delete(root, { recursive: true });
+                await this.fileService.createFolder(root);
+            } catch (e) {
+                // Ignore errors
+            }
+
+            this.indexCache = {};
+            await this.saveIndex({});
+        });
+        return this.storePromise;
+    }
+
+    async getSessionIndex(): Promise<ChatSessionIndex> {
+        const index = await this.loadIndex();
+        this.logger.debug('Retrieved session index', { sessionCount: Object.keys(index).length });
+        return index;
+    }
+
+    async setSessionTitle(sessionId: string, title: string): Promise<void> {
+        this.storePromise = this.storePromise.then(async () => {
+            const index = await this.loadIndex();
+            if (index[sessionId]) {
+                index[sessionId].title = title;
+                await this.saveIndex(index);
+            }
+        });
+        return this.storePromise;
+    }
+
+    protected async getStorageRoot(): Promise<URI> {
+        if (this.storageRoot) {
+            return this.storageRoot;
+        }
+
+        const configDir = await this.envServer.getConfigDirUri();
+        this.storageRoot = new URI(configDir).resolve('chatSessions');
+
+        try {
+            await this.fileService.createFolder(this.storageRoot);
+        } catch (e) {
+            // Folder may already exist
+        }
+
+        return this.storageRoot;
+    }
+
+    protected async updateIndex(sessions: ((ChatModelWithMetadata & { saveDate: number })[])): Promise<void> {
+        const index = await this.loadIndex();
+
+        for (const session of sessions) {
+            const data = session.model.toSerializable();
+            const { model, ...metadata } = session;
+            const previousData = index[model.id];
+            index[model.id] = {
+                ...previousData,
+                sessionId: model.id,
+                location: data.location,
+                ...metadata
+            };
+        }
+
+        await this.saveIndex(index);
+    }
+
+    protected async trimSessions(): Promise<void> {
+        const index = await this.loadIndex();
+        const sessions = Object.values(index);
+
+        if (sessions.length <= MAX_SESSIONS) {
+            return;
+        }
+
+        this.logger.debug('Trimming sessions', { currentCount: sessions.length, maxSessions: MAX_SESSIONS });
+
+        // Sort by save date
+        sessions.sort((a, b) => a.saveDate - b.saveDate);
+
+        // Delete oldest sessions
+        const sessionsToDelete = sessions.slice(0, sessions.length - MAX_SESSIONS);
+        this.logger.debug('Deleting oldest sessions', { deleteCount: sessionsToDelete.length, sessionIds: sessionsToDelete.map(s => s.sessionId) });
+        for (const session of sessionsToDelete) {
+            await this.deleteSession(session.sessionId);
+        }
+    }
+
+    protected async loadIndex(): Promise<ChatSessionIndex> {
+        if (this.indexCache) {
+            return this.indexCache;
+        }
+
+        const root = await this.getStorageRoot();
+        const indexFile = root.resolve(INDEX_FILE);
+
+        try {
+            const content = await this.fileService.readFile(indexFile);
+            const rawIndex = JSON.parse(content.value.toString());
+
+            // Validate and clean up index entries
+            const validatedIndex: ChatSessionIndex = {};
+            let hasInvalidEntries = false;
+
+            for (const [sessionId, metadata] of Object.entries(rawIndex)) {
+                // Check if entry has required fields and valid values
+                if (this.isValidMetadata(metadata)) {
+                    validatedIndex[sessionId] = metadata as ChatSessionMetadata;
+                } else {
+                    hasInvalidEntries = true;
+                    this.logger.warn('Removing invalid session metadata from index', {
+                        sessionId,
+                        metadata
+                    });
+                }
+            }
+
+            // If we removed any entries, persist the cleaned index
+            if (hasInvalidEntries) {
+                this.logger.info('Index cleaned up, removing invalid entries');
+                await this.fileService.writeFile(
+                    indexFile,
+                    BinaryBuffer.fromString(JSON.stringify(validatedIndex, undefined, 2))
+                );
+            }
+
+            this.indexCache = validatedIndex;
+            return this.indexCache;
+        } catch (e) {
+            this.indexCache = {};
+            return this.indexCache;
+        }
+    }
+
+    protected isValidMetadata(metadata: unknown): metadata is ChatSessionMetadata {
+        if (!metadata || typeof metadata !== 'object') {
+            return false;
+        }
+
+        const m = metadata as Record<string, unknown>;
+
+        // Check required fields exist and have correct types
+        return typeof m.sessionId === 'string' &&
+            typeof m.title === 'string' &&
+            typeof m.saveDate === 'number' &&
+            typeof m.location === 'string' &&
+            // Ensure saveDate is a valid timestamp
+            !isNaN(m.saveDate) &&
+            m.saveDate > 0;
+    }
+
+    protected async saveIndex(index: ChatSessionIndex): Promise<void> {
+        this.indexCache = index;
+        const root = await this.getStorageRoot();
+        const indexFile = root.resolve(INDEX_FILE);
+
+        await this.fileService.writeFile(
+            indexFile,
+            BinaryBuffer.fromString(JSON.stringify(index, undefined, 2))
+        );
+    }
+
+    protected migrateData(data: unknown): SerializedChatData {
+        const parsed = data as SerializedChatData;
+
+        // Defensive check for unexpected future versions
+        if (parsed.version && parsed.version > CHAT_DATA_VERSION) {
+            this.logger.warn(
+                `Session data version ${parsed.version} is newer than supported ${CHAT_DATA_VERSION}. ` +
+                'Data may not load correctly.'
+            );
+        }
+
+        return parsed;
+    }
+}

package/src/browser/file-chat-variable-contribution.ts

@@ -17,7 +17,7 @@
 import { AIVariableContext, AIVariableResolutionRequest, PromptText } from '@theia/ai-core';
 import { AIVariableCompletionContext, AIVariableDropResult, FrontendVariableContribution, FrontendVariableService } from '@theia/ai-core/lib/browser';
 import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
-import { CancellationToken, ILogger, QuickInputService, URI } from '@theia/core';
+import { CancellationToken, ILogger, nls, QuickInputService, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import * as monaco from '@theia/monaco-editor-core';
 import { FileQuickPickItem, QuickFileSelectService } from '@theia/file-search/lib/browser/quick-file-select-service';
@@ -76,7 +76,7 @@ export class FileChatVariableContribution implements FrontendVariableContributio
 
     protected async imageArgumentPicker(): Promise<string | undefined> {
         const quickPick = this.quickInputService.createQuickPick();
-        quickPick.title = 'Select an image file';
+        quickPick.title = nls.localize('theia/ai/chat/selectImageFile', 'Select an image file');
 
         // Get all files and filter only image files
         const allPicks = await this.quickFileSelectService.getPicks();

package/src/browser/image-context-variable-contribution.ts

@@ -148,6 +148,6 @@ export class ImageContextVariableContribution implements AIVariableContribution,
 
     getDetails(element: ImageContextVariableRequest): string | undefined {
         const path = ImageContextVariable.parseArg(element.arg).wsRelativePath;
-        return path ? this.labelProvider.getDetails(new URI(path)) : '[pasted]';
+        return path ? this.labelProvider.getDetails(new URI(path)) : undefined;
     }
 }

package/src/browser/task-context-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { MaybePromise, ProgressService, URI, generateUuid, Event, EOL } from '@theia/core';
+import { MaybePromise, ProgressService, URI, generateUuid, Event, EOL, nls } from '@theia/core';
 import { ChatAgent, ChatAgentLocation, ChatService, ChatSession, MutableChatModel, MutableChatRequestModel, ParsedChatRequestTextPart } from '../common';
 import { PreferenceService } from '@theia/core/lib/common';
 import { ChatSessionSummaryAgent } from '../common/chat-session-summary-agent';
@@ -90,7 +90,10 @@ export class TaskContextService {
         if (existing && !override) { return existing.id; }
         const summaryId = generateUuid();
         const summaryDeferred = new Deferred<Summary>();
-        const progress = await this.progressService.showProgress({ text: `Summarize: ${session.title || session.id}`, options: { location: 'ai-chat' } });
+        const progress = await this.progressService.showProgress({
+            text: nls.localize('theia/ai/chat/taskContextService/summarizeProgressMessage', 'Summarize: {0}', session.title || session.id),
+            options: { location: 'ai-chat' }
+        });
         this.pendingSummaries.set(session.id, summaryDeferred.promise);
         try {
             const prompt = await this.getSystemPrompt(session, promptId);
@@ -127,7 +130,10 @@ export class TaskContextService {
             return this.summarize(session, promptId, agent, override);
         }
 
-        const progress = await this.progressService.showProgress({ text: `Updating: ${session.title || session.id}`, options: { location: 'ai-chat' } });
+        const progress = await this.progressService.showProgress({
+            text: nls.localize('theia/ai/chat/taskContextService/updatingProgressMessage', 'Updating: {0}', session.title || session.id),
+            options: { location: 'ai-chat' }
+        });
         try {
             const prompt = await this.getSystemPrompt(session, promptId);
             if (!prompt) {

package/src/browser/task-context-variable.ts

@@ -15,14 +15,19 @@
 // *****************************************************************************
 
 import { AIVariable } from '@theia/ai-core';
+import { nls } from '@theia/core';
 import { codiconArray } from '@theia/core/lib/browser';
 
 export const TASK_CONTEXT_VARIABLE: AIVariable = {
     id: 'taskContext',
-    description: 'Provides context information for a task, e.g. the plan for completing a task or a summary of a previous sessions',
+    description: nls.localize('theia/chat/taskContextVariable/description',
+        'Provides context information for a task, e.g. the plan for completing a task or a summary of a previous sessions'),
     name: 'taskContext',
-    label: 'Task Context',
+    label: nls.localize('theia/chat/taskContextVariable/label', 'Task Context'),
     iconClasses: codiconArray('clippy'),
     isContextVariable: true,
-    args: [{ name: 'context-id', description: 'The ID of the task context to retrieve, or a chat session to summarize.' }]
+    args: [{
+        name: 'context-id',
+        description: nls.localize('theia/chat/taskContextVariable/args/contextId/description', 'The ID of the task context to retrieve, or a chat session to summarize.')
+    }]
 };

package/src/common/change-set-element-deserializer.ts

@@ -0,0 +1,90 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import { ContributionProvider, MaybePromise, URI } from '@theia/core';
+import { ChangeSetElement } from './change-set';
+import { SerializableChangeSetElement } from './chat-model-serialization';
+
+export const ChangeSetElementDeserializer = Symbol('ChangeSetElementDeserializer');
+
+export interface ChangeSetElementDeserializer<T = unknown> {
+    readonly kind: string;
+    deserialize(serialized: SerializableChangeSetElement, context: ChangeSetDeserializationContext): ChangeSetElement | Promise<ChangeSetElement>;
+}
+
+export interface ChangeSetDeserializationContext {
+    chatSessionId: string;
+    requestId: string;
+}
+
+export interface ChangeSetElementDeserializerContribution {
+    registerDeserializers(registry: ChangeSetElementDeserializerRegistry): void;
+}
+export const ChangeSetElementDeserializerContribution = Symbol('ChangeSetElementDeserializerContribution');
+export interface ChangeSetElementDeserializerRegistry {
+    register(deserializer: ChangeSetElementDeserializer): void;
+    deserialize(serialized: SerializableChangeSetElement, context: ChangeSetDeserializationContext): MaybePromise<ChangeSetElement>;
+}
+export const ChangeSetElementDeserializerRegistry = Symbol('ChangeSetElementDeserializerRegistry');
+
+@injectable()
+export class ChangeSetElementDeserializerRegistryImpl implements ChangeSetElementDeserializerRegistry {
+    protected deserializers = new Map<string, ChangeSetElementDeserializer>();
+
+    @inject(ContributionProvider) @named(ChangeSetElementDeserializerContribution)
+    protected readonly changeSetElementDeserializerContributions: ContributionProvider<ChangeSetElementDeserializerContribution>;
+
+    @postConstruct() init(): void {
+        for (const contribution of this.changeSetElementDeserializerContributions.getContributions()) {
+            contribution.registerDeserializers(this);
+        }
+    }
+
+    register(deserializer: ChangeSetElementDeserializer): void {
+        this.deserializers.set(deserializer.kind, deserializer);
+    }
+
+    deserialize(serialized: SerializableChangeSetElement, context: ChangeSetDeserializationContext): MaybePromise<ChangeSetElement> {
+        const deserializer = this.deserializers.get(serialized.kind || 'generic');
+        if (!deserializer) {
+            return this.createFallbackElement(serialized);
+        }
+        return deserializer.deserialize(serialized, context);
+    }
+
+    private createFallbackElement(serialized: SerializableChangeSetElement): ChangeSetElement {
+        return {
+            uri: new URI(serialized.uri),
+            name: serialized.name,
+            icon: serialized.icon,
+            additionalInfo: serialized.additionalInfo,
+            state: serialized.state,
+            type: serialized.type,
+            data: serialized.data,
+            toSerializable: (): SerializableChangeSetElement => ({
+                kind: serialized.kind || 'generic',
+                uri: serialized.uri,
+                name: serialized.name,
+                icon: serialized.icon,
+                additionalInfo: serialized.additionalInfo,
+                state: serialized.state,
+                type: serialized.type,
+                data: serialized.data
+            })
+        };
+    }
+}

package/src/common/change-set.ts

@@ -14,7 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ArrayUtils, Disposable, Emitter, Event, URI } from '@theia/core';
+import { ArrayUtils, Disposable, Emitter, Event, nls, URI } from '@theia/core';
+import { SerializableChangeSetElement } from './chat-model-serialization';
 
 export interface ChangeSetElement {
     readonly uri: URI;
@@ -37,6 +38,13 @@ export interface ChangeSetElement {
     apply?(): Promise<void>;
     revert?(): Promise<void>;
     dispose?(): void;
+
+    /**
+     * Serializes this element to a format suitable for persistence.
+     * Each element type is responsible for serializing its own data.
+     * Optional - elements without this method will be excluded from serialization.
+     */
+    toSerializable?(): SerializableChangeSetElement;
 }
 
 export interface ChatUpdateChangeSetEvent {
@@ -95,7 +103,7 @@ export class ChangeSetImpl implements ChangeSet {
 
     protected hasBeenSet = false;
     protected _elements = new Map<string, ChangeSetElement | undefined>();
-    protected _title = 'Suggested Changes';
+    protected _title = nls.localize('theia/ai/chat/changeSetDefaultTitle', 'Suggested Changes');
     get title(): string {
         return this._title;
     }

package/src/common/chat-agents-variable-contribution.ts

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { MaybePromise } from '@theia/core';
+import { MaybePromise, nls } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import {
     AIVariable,
@@ -29,7 +29,7 @@ import { ChatAgentService } from './chat-agent-service';
 export const CHAT_AGENTS_VARIABLE: AIVariable = {
     id: 'chatAgents',
     name: 'chatAgents',
-    description: 'Returns the list of chat agents available in the system'
+    description: nls.localize('theia/ai/chat/chatAgentsVariable/description', 'Returns the list of chat agents available in the system')
 };
 
 export interface ChatAgentDescriptor {

package/src/common/chat-agents.ts

@@ -49,7 +49,7 @@ import {
     LanguageModelRegistry,
     LanguageModelStreamResponsePart
 } from '@theia/ai-core/lib/common';
-import { ContributionProvider, ILogger, isArray } from '@theia/core';
+import { ContributionProvider, ILogger, isArray, nls } from '@theia/core';
 import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
 import { ChatAgentService } from './chat-agent-service';
 import {
@@ -155,7 +155,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
     readonly abstract languageModelRequirements: LanguageModelRequirement[];
     iconClass: string = 'codicon codicon-copilot';
     locations: ChatAgentLocation[] = ChatAgentLocation.ALL;
-    tags: string[] = ['Chat'];
+    tags: string[] = [nls.localizeByDefault('Chat')];
     description: string = '';
     variables: string[] = [];
     prompts: PromptVariantSet[] = [];
@@ -180,7 +180,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
         try {
             const languageModel = await this.getLanguageModel(this.defaultLanguageModelPurpose);
             if (!languageModel) {
-                throw new Error('Couldn\'t find a matching language model. Please check your setup!');
+                throw new Error(nls.localize('theia/ai/chat/couldNotFindMatchingLM', 'Couldn\'t find a matching language model. Please check your setup!'));
             }
             const systemMessageDescription = await this.getSystemMessageDescription({ model: request.session, request } satisfies ChatSessionContext);
             const messages = await this.getMessages(request.session);
@@ -237,7 +237,7 @@ export abstract class AbstractChatAgent implements ChatAgent {
     protected async selectLanguageModel(selector: LanguageModelRequirement): Promise<LanguageModel> {
         const languageModel = await this.languageModelRegistry.selectLanguageModel({ agent: this.id, ...selector });
         if (!languageModel) {
-            throw new Error(`Couldn\'t find a ready language model for agent ${this.id}. Please check your setup!`);
+            throw new Error(nls.localize('theia/ai/chat/couldNotFindReadyLMforAgent', 'Couldn\'t find a ready language model for agent {0}. Please check your setup!', this.id));
         }
         return languageModel;
     }