@lobehub/chat 1.39.3 → 1.40.1

package/src/server/services/changelog/index.test.ts

@@ -0,0 +1,310 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ChangelogIndexItem } from '@/types/changelog';
+
+import { ChangelogService } from './index';
+
+// Mock external dependencies
+vi.mock('dayjs', () => ({
+  default: (date: string) => ({
+    format: vi.fn().mockReturnValue(date),
+  }),
+}));
+
+vi.mock('gray-matter', () => ({
+  default: vi.fn().mockImplementation((text) => ({
+    data: { date: '2023-01-01' },
+    content: text,
+  })),
+}));
+
+vi.mock('markdown-to-txt', () => ({
+  markdownToTxt: vi.fn().mockImplementation((text) => text),
+}));
+
+vi.mock('semver', async (importOriginal) => {
+  const actual: any = await importOriginal();
+  return {
+    ...actual,
+    rcompare: vi.fn().mockImplementation((a, b) => b.localeCompare(a)),
+    lt: vi.fn().mockImplementation((a, b) => a < b),
+    gt: vi.fn().mockImplementation((a, b) => a > b),
+    parse: vi.fn().mockImplementation((v) => ({ toString: () => v })),
+  };
+});
+
+vi.mock('url-join', () => ({
+  default: vi.fn((...args) => args.join('/')),
+}));
+
+// 模拟 process.env
+const originalEnv = process.env;
+
+beforeEach(() => {
+  vi.resetModules();
+  process.env = { ...originalEnv };
+});
+
+afterEach(() => {
+  process.env = originalEnv;
+});
+
+describe('ChangelogService', () => {
+  let service: ChangelogService;
+
+  beforeEach(() => {
+    service = new ChangelogService();
+    // Mock fetch globally
+    global.fetch = vi.fn();
+  });
+
+  describe('getLatestChangelogId', () => {
+    it('should return the id of the first changelog item', async () => {
+      const mockIndex = [{ id: 'latest' }, { id: 'older' }];
+      vi.spyOn(service, 'getChangelogIndex').mockResolvedValue(mockIndex as ChangelogIndexItem[]);
+
+      const result = await service.getLatestChangelogId();
+      expect(result).toBe('latest');
+    });
+
+    it('should return undefined if the index is empty', async () => {
+      vi.spyOn(service, 'getChangelogIndex').mockResolvedValue([]);
+
+      const result = await service.getLatestChangelogId();
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getChangelogIndex', () => {
+    it('should fetch and merge changelog data', async () => {
+      const mockResponse = {
+        json: vi.fn().mockResolvedValue({
+          cloud: [{ id: 'cloud1', date: '2023-01-01', versionRange: ['1.0.0'] }],
+          community: [{ id: 'community1', date: '2023-01-02', versionRange: ['1.1.0'] }],
+        }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await service.getChangelogIndex();
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe('community1');
+      expect(result[1].id).toBe('cloud1');
+    });
+
+    it('should handle fetch errors', async () => {
+      (global.fetch as any).mockRejectedValue(new Error('Fetch failed'));
+
+      const result = await service.getChangelogIndex();
+      expect(result).toBe(false);
+    });
+
+    it('should return only community items when config type is community', async () => {
+      service.config.type = 'community';
+      const mockResponse = {
+        json: vi.fn().mockResolvedValue({
+          cloud: [{ id: 'cloud1', date: '2023-01-01', versionRange: ['1.0.0'] }],
+          community: [{ id: 'community1', date: '2023-01-02', versionRange: ['1.1.0'] }],
+        }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await service.getChangelogIndex();
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('community1');
+    });
+  });
+
+  describe('getIndexItemById', () => {
+    it('should return the correct item by id', async () => {
+      const mockIndex = [
+        { id: 'item1', date: '2023-01-01', versionRange: ['1.0.0'] },
+        { id: 'item2', date: '2023-01-02', versionRange: ['1.1.0'] },
+      ];
+      vi.spyOn(service, 'getChangelogIndex').mockResolvedValue(mockIndex as ChangelogIndexItem[]);
+
+      const result = await service.getIndexItemById('item2');
+      expect(result).toEqual({ id: 'item2', date: '2023-01-02', versionRange: ['1.1.0'] });
+    });
+
+    it('should return undefined for non-existent id', async () => {
+      vi.spyOn(service, 'getChangelogIndex').mockResolvedValue([]);
+
+      const result = await service.getIndexItemById('nonexistent');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getPostById', () => {
+    it('should fetch and parse post content', async () => {
+      vi.spyOn(service, 'getIndexItemById').mockResolvedValue({
+        id: 'post1',
+        date: '2023-01-01',
+        versionRange: ['1.0.0'],
+      } as ChangelogIndexItem);
+
+      const mockResponse = {
+        text: vi.fn().mockResolvedValue('# Post Title\nPost content'),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await service.getPostById('post1');
+      expect(result).toMatchObject({
+        content: 'Post content',
+        date: expect.any(String), // 改为期望字符串而不是 Date 对象
+        description: 'Post content',
+        image: undefined,
+        rawTitle: 'Post Title',
+        tags: ['changelog'],
+        title: 'Post Title',
+      });
+
+      // 额外检查日期格式
+      expect(result.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    });
+
+    it('should handle fetch errors', async () => {
+      vi.spyOn(service, 'getIndexItemById').mockResolvedValue({} as ChangelogIndexItem);
+      (global.fetch as any).mockRejectedValue(new Error('Fetch failed'));
+
+      const result = await service.getPostById('error');
+      expect(result).toBe(false);
+    });
+
+    it('should use the correct locale for fetching content', async () => {
+      vi.spyOn(service, 'getIndexItemById').mockResolvedValue({
+        id: 'post1',
+        date: '2023-01-01',
+        versionRange: ['1.0.0'],
+      } as ChangelogIndexItem);
+
+      const mockResponse = {
+        text: vi.fn().mockResolvedValue('# Chinese Title\n中文内容'),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await service.getPostById('post1', { locale: 'zh-CN' });
+      expect(result).toEqual({
+        content: '中文内容',
+        date: '2023-01-01',
+        description: '中文内容',
+        image: undefined,
+        rawTitle: 'Chinese Title',
+        tags: ['changelog'],
+        title: 'Chinese Title',
+      });
+    });
+  });
+
+  describe('private methods', () => {
+    describe('mergeChangelogs', () => {
+      it('should merge and sort changelogs correctly', () => {
+        const cloud = [{ id: 'cloud1', date: '2023-01-01', versionRange: ['1.0.0'] }];
+        const community = [{ id: 'community1', date: '2023-01-02', versionRange: ['1.1.0'] }];
+
+        // @ts-ignore - accessing private method for testing
+        const result = service.mergeChangelogs(cloud, community);
+        expect(result).toHaveLength(2);
+        expect(result[0].id).toBe('community1');
+        expect(result[1].id).toBe('cloud1');
+      });
+
+      it('should override community items with cloud items when ids match', () => {
+        const cloud = [{ id: 'item1', date: '2023-01-01', versionRange: ['1.0.0'], type: 'cloud' }];
+        const community = [
+          { id: 'item1', date: '2023-01-01', versionRange: ['1.0.0'], type: 'community' },
+        ];
+
+        // @ts-ignore - accessing private method for testing
+        const result = service.mergeChangelogs(cloud, community);
+        expect(result).toHaveLength(1);
+        // @ts-ignore
+        expect(result[0].type).toBe('cloud');
+      });
+    });
+
+    describe('formatVersionRange', () => {
+      it('should format version range correctly', () => {
+        // @ts-ignore - accessing private method for testing
+        const result = service.formatVersionRange(['1.0.0', '1.1.0']);
+        expect(result).toEqual(['1.1.0', '1.0.0']);
+      });
+
+      it('should return single version as is', () => {
+        // @ts-ignore - accessing private method for testing
+        const result = service.formatVersionRange(['1.0.0']);
+        expect(result).toEqual(['1.0.0']);
+      });
+    });
+
+    describe('genUrl', () => {
+      it('should generate correct URL', () => {
+        // @ts-ignore - accessing private method for testing
+        const result = service.genUrl('test/path');
+        expect(result).toBe('https://raw.githubusercontent.com/lobehub/lobe-chat/main/test/path');
+      });
+    });
+
+    describe('extractHttpsLinks', () => {
+      it('should extract HTTPS links from text', () => {
+        const text = 'Text with https://example.com and https://test.com/image.jpg links';
+        // @ts-ignore - accessing private method for testing
+        const result = service.extractHttpsLinks(text);
+        expect(result).toEqual(['https://example.com', 'https://test.com/image.jpg']);
+      });
+    });
+
+    describe('cdnInit', () => {
+      it('should initialize CDN URLs if docCdnPrefix is set', async () => {
+        // 设置环境变量
+        process.env.DOC_S3_PUBLIC_DOMAIN = 'https://cdn.example.com';
+
+        // 重新导入模块以确保环境变量生效
+        const { ChangelogService } = await import('./index');
+        const service = new ChangelogService();
+
+        const mockData = { 'https://example.com/image.jpg': 'image-hash.jpg' };
+        const mockResponse = {
+          json: vi.fn().mockResolvedValue(mockData),
+        };
+        global.fetch = vi.fn().mockResolvedValue(mockResponse);
+
+        // @ts-ignore - accessing private method for testing
+        await service.cdnInit();
+
+        expect(service.cdnUrls).toEqual(mockData);
+      });
+    });
+
+    describe('replaceCdnUrl', () => {
+      it('should replace URL with CDN URL if available', async () => {
+        // 设置环境变量
+        process.env.DOC_S3_PUBLIC_DOMAIN = 'https://cdn.example.com';
+
+        // 重新导入模块以确保环境变量生效
+        const { ChangelogService } = await import('./index');
+        const service = new ChangelogService();
+
+        service.cdnUrls = { 'https://example.com/image.jpg': 'image-hash.jpg' };
+
+        // @ts-ignore - accessing private method for testing
+        const result = service.replaceCdnUrl('https://example.com/image.jpg');
+
+        expect(result).toBe('https://cdn.example.com/image-hash.jpg');
+      });
+
+      it('should return original URL if CDN URL is not available', () => {
+        const originalDocCdnPrefix = process.env.DOC_S3_PUBLIC_DOMAIN;
+        process.env.DOC_S3_PUBLIC_DOMAIN = 'https://cdn.example.com';
+        service.cdnUrls = {};
+
+        // @ts-ignore - accessing private method for testing
+        const result = service.replaceCdnUrl('https://example.com/image.jpg');
+        expect(result).toBe('https://example.com/image.jpg');
+
+        // Restore original value
+        process.env.DOC_S3_PUBLIC_DOMAIN = originalDocCdnPrefix;
+      });
+    });
+  });
+});

package/src/server/services/changelog/index.ts

@@ -0,0 +1,196 @@
+import dayjs from 'dayjs';
+import matter from 'gray-matter';
+import { markdownToTxt } from 'markdown-to-txt';
+import semver from 'semver';
+import urlJoin from 'url-join';
+
+import { Locales } from '@/locales/resources';
+import { ChangelogIndexItem } from '@/types/changelog';
+
+const BASE_URL = 'https://raw.githubusercontent.com';
+const LAST_MODIFIED = new Date().toISOString();
+
+const docCdnPrefix = process.env.DOC_S3_PUBLIC_DOMAIN || '';
+
+export interface ChangelogConfig {
+  branch: string;
+  cdnPath: string;
+  changelogPath: string;
+  docsPath: string;
+  majorVersion: number;
+  repo: string;
+  type: 'cloud' | 'community';
+  user: string;
+}
+
+export class ChangelogService {
+  cdnUrls: {
+    [key: string]: string;
+  } = {};
+  config: ChangelogConfig = {
+    branch: process.env.DOCS_BRANCH || 'main',
+    cdnPath: 'docs/.cdn.cache.json',
+    changelogPath: 'changelog',
+    docsPath: 'docs/changelog',
+    majorVersion: 1,
+    repo: 'lobe-chat',
+    type: 'cloud',
+    user: 'lobehub',
+  };
+
+  async getLatestChangelogId() {
+    const index = await this.getChangelogIndex();
+    return index[0]?.id;
+  }
+
+  async getChangelogIndex(): Promise<ChangelogIndexItem[]> {
+    try {
+      const url = this.genUrl(urlJoin(this.config.docsPath, 'index.json'));
+
+      const res = await fetch(url);
+
+      const data = await res.json();
+
+      return this.mergeChangelogs(data.cloud, data.community).slice(0, 5);
+    } catch (e) {
+      console.error('Error getting changelog lists:', e);
+      return false as any;
+    }
+  }
+
+  async getIndexItemById(id: string) {
+    const index = await this.getChangelogIndex();
+    return index.find((item) => item.id === id);
+  }
+
+  async getPostById(id: string, options?: { locale?: Locales }) {
+    await this.cdnInit();
+    try {
+      const post = await this.getIndexItemById(id);
+
+      const filename = options?.locale === 'en-US' ? `${id}.mdx` : `${id}.zh-CN.mdx`;
+      const url = this.genUrl(urlJoin(this.config.docsPath, filename));
+
+      const response = await fetch(url);
+      const text = await response.text();
+      const { data, content } = matter(text);
+
+      const regex = /^#\s(.+)/;
+      const match = regex.exec(content.trim());
+      const matches = content.trim().split(regex);
+
+      let description: string;
+
+      if (matches[2]) {
+        description = matches[2] ? matches[2].trim() : '';
+      } else {
+        description = matches[1] ? matches[1].trim() : '';
+      }
+
+      if (docCdnPrefix) {
+        const images = this.extractHttpsLinks(content);
+        for (const url of images) {
+          const cdnUrl = this.replaceCdnUrl(url);
+          if (cdnUrl && url !== cdnUrl) {
+            description = description.replaceAll(url, cdnUrl);
+          }
+        }
+      }
+
+      return {
+        date: post?.date
+          ? new Date(post.date)
+          : data?.date
+            ? new Date(data.date)
+            : new Date(LAST_MODIFIED),
+        description: markdownToTxt(description.replaceAll('\n', '').replaceAll('  ', ' ')).slice(
+          0,
+          160,
+        ),
+        image: post?.image ? this.replaceCdnUrl(post.image) : undefined,
+        tags: ['changelog'],
+        title: match ? match[1] : '',
+        ...data,
+        content: description,
+        rawTitle: match ? match[1] : '',
+      };
+    } catch {
+      console.error('Error getting changlog post by id', id);
+      return false as any;
+    }
+  }
+
+  private mergeChangelogs(
+    cloud: ChangelogIndexItem[],
+    community: ChangelogIndexItem[],
+  ): ChangelogIndexItem[] {
+    if (this.config.type === 'community') {
+      return community;
+    }
+
+    const merged = [...community];
+
+    for (const cloudItem of cloud) {
+      const index = merged.findIndex((item) => item.id === cloudItem.id);
+      if (index !== -1) {
+        merged[index] = cloudItem;
+      } else {
+        merged.push(cloudItem);
+      }
+    }
+
+    return merged
+      .map((item) => ({
+        ...item,
+        date: dayjs(item.date).format('YYYY-MM-DD'),
+        versionRange: this.formatVersionRange(item.versionRange),
+      }))
+      .sort((a, b) => semver.rcompare(a.versionRange[0], b.versionRange[0]));
+  }
+
+  private formatVersionRange(range: string[]): string[] {
+    if (range.length === 1) {
+      return range;
+    }
+
+    const [v1, v2]: any = range.map((v) => semver.parse(v)?.toString());
+
+    const minVersion = semver.lt(v1, v2) ? v1 : v2;
+    const maxVersion = semver.gt(v1, v2) ? v1 : v2;
+
+    return [maxVersion, minVersion];
+  }
+
+  private genUrl(path: string) {
+    return urlJoin(BASE_URL, this.config.user, this.config.repo, this.config.branch, path);
+  }
+
+  private extractHttpsLinks(text: string) {
+    const regex = /https:\/\/[^\s"')>]+/g;
+    const links = text.match(regex);
+    return links || [];
+  }
+
+  private async cdnInit() {
+    if (!docCdnPrefix) return;
+    if (Object.keys(this.cdnUrls).length === 0) {
+      try {
+        const url = this.genUrl(this.config.cdnPath);
+        const res = await fetch(url);
+        const data = await res.json();
+        if (data) {
+          this.cdnUrls = data;
+        }
+      } catch (error) {
+        console.error('Error getting changelog cdn cache:', error);
+      }
+    }
+  }
+
+  private replaceCdnUrl(url: string) {
+    if (!docCdnPrefix || !this.cdnUrls?.[url]) {
+      return url;
+    }
+    return urlJoin(docCdnPrefix, this.cdnUrls[url]);
+  }
+}

package/src/server/services/discover/index.test.ts

@@ -1,7 +1,6 @@
 // @vitest-environment node
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { DEFAULT_LANG } from '@/const/locale';
 import { AssistantCategory, PluginCategory } from '@/types/discover';
 
 import { DiscoverService } from './index';

package/src/server/sitemap.ts

@@ -3,6 +3,7 @@ import { MetadataRoute } from 'next';
 import qs from 'query-string';
 import urlJoin from 'url-join';
 
+import { serverFeatureFlags } from '@/config/featureFlags';
 import { DEFAULT_LANG } from '@/const/locale';
 import { SITEMAP_BASE_URL } from '@/const/url';
 import { Locales, locales as allLocales } from '@/locales/resources';
@@ -195,12 +196,14 @@ export class Sitemap {
   }
 
   async getPage(): Promise<MetadataRoute.Sitemap> {
+    const hideDocs = serverFeatureFlags().hideDocs;
     const assistantsCategory = Object.values(AssistantCategory);
     const pluginCategory = Object.values(PluginCategory);
     const modelCategory = await this.discoverService.getProviderList(DEFAULT_LANG);
     return [
       ...this._genSitemap('/', { noLocales: true }),
       ...this._genSitemap('/chat', { noLocales: true }),
+      ...(!hideDocs ? this._genSitemap('/changelog', { noLocales: true }) : []),
       /* ↓ cloud slot ↓ */
 
       /* ↑ cloud slot ↑ */
@@ -227,7 +230,7 @@ export class Sitemap {
         }),
       ),
       ...this._genSitemap('/discover/providers', { changeFrequency: 'daily', priority: 0.7 }),
-    ];
+    ].filter(Boolean);
   }
   getRobots() {
     return [

package/src/services/__tests__/chat.test.ts

@@ -904,7 +904,7 @@ describe('ChatService', () => {
  * initialization of AgentRuntime with different providers
  */
 vi.mock('../_auth', async (importOriginal) => {
-  return await importOriginal();
+  return importOriginal();
 });
 describe('AgentRuntimeOnClient', () => {
   describe('initializeWithClientStore', () => {

package/src/services/__tests__/global.test.ts

@@ -18,6 +18,9 @@ vi.mock('@/libs/trpc/client', () => {
         getGlobalConfig: { query: vi.fn() },
         getDefaultAgentConfig: { query: vi.fn() },
       },
+      appStatus: {
+        getLatestChangelogId: { query: vi.fn() },
+      },
     },
   };
 });
@@ -28,14 +31,14 @@ describe('GlobalService', () => {
       // Arrange
       const mockVersion = '1.0.0';
       (fetch as Mock).mockResolvedValue({
-        json: () => Promise.resolve({ 'dist-tags': { latest: mockVersion } }),
+        json: () => Promise.resolve({ version: mockVersion }),
       });
 
       // Act
       const version = await globalService.getLatestVersion();
 
       // Assert
-      expect(fetch).toHaveBeenCalledWith('https://registry.npmmirror.com/@lobehub/chat');
+      expect(fetch).toHaveBeenCalledWith('https://registry.npmmirror.com/@lobehub/chat/latest');
       expect(version).toBe(mockVersion);
     });
 

package/src/services/_auth.ts

@@ -78,7 +78,7 @@ const createAuthTokenWithPayload = async (payload = {}) => {
   const accessCode = keyVaultsConfigSelectors.password(useUserStore.getState());
   const userId = userProfileSelectors.userId(useUserStore.getState());
 
-  return await createJWT<JWTPayload>({ accessCode, userId, ...payload });
+  return createJWT<JWTPayload>({ accessCode, userId, ...payload });
 };
 
 interface AuthParams {

package/src/services/agent.ts

@@ -1,45 +1,49 @@
 import { lambdaClient } from '@/libs/trpc/client';
 
 class AgentService {
-  async createAgentKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
-    return await lambdaClient.agent.createAgentKnowledgeBase.mutate({
+  createAgentKnowledgeBase = async (
+    agentId: string,
+    knowledgeBaseId: string,
+    enabled?: boolean,
+  ) => {
+    return lambdaClient.agent.createAgentKnowledgeBase.mutate({
       agentId,
       enabled,
       knowledgeBaseId,
     });
-  }
+  };
 
-  async deleteAgentKnowledgeBase(agentId: string, knowledgeBaseId: string) {
-    return await lambdaClient.agent.deleteAgentKnowledgeBase.mutate({ agentId, knowledgeBaseId });
-  }
+  deleteAgentKnowledgeBase = async (agentId: string, knowledgeBaseId: string) => {
+    return lambdaClient.agent.deleteAgentKnowledgeBase.mutate({ agentId, knowledgeBaseId });
+  };
 
-  async toggleKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
-    return await lambdaClient.agent.toggleKnowledgeBase.mutate({
+  toggleKnowledgeBase = async (agentId: string, knowledgeBaseId: string, enabled?: boolean) => {
+    return lambdaClient.agent.toggleKnowledgeBase.mutate({
       agentId,
       enabled,
       knowledgeBaseId,
     });
-  }
+  };
 
-  async createAgentFiles(agentId: string, fileIds: string[], enabled?: boolean) {
-    return await lambdaClient.agent.createAgentFiles.mutate({ agentId, enabled, fileIds });
-  }
+  createAgentFiles = async (agentId: string, fileIds: string[], enabled?: boolean) => {
+    return lambdaClient.agent.createAgentFiles.mutate({ agentId, enabled, fileIds });
+  };
 
-  async deleteAgentFile(agentId: string, fileId: string) {
-    return await lambdaClient.agent.deleteAgentFile.mutate({ agentId, fileId });
-  }
+  deleteAgentFile = async (agentId: string, fileId: string) => {
+    return lambdaClient.agent.deleteAgentFile.mutate({ agentId, fileId });
+  };
 
-  async toggleFile(agentId: string, fileId: string, enabled?: boolean) {
-    return await lambdaClient.agent.toggleFile.mutate({
+  toggleFile = async (agentId: string, fileId: string, enabled?: boolean) => {
+    return lambdaClient.agent.toggleFile.mutate({
       agentId,
       enabled,
       fileId,
     });
-  }
+  };
 
-  async getFilesAndKnowledgeBases(agentId: string) {
-    return await lambdaClient.agent.getKnowledgeBasesAndFiles.query({ agentId });
-  }
+  getFilesAndKnowledgeBases = async (agentId: string) => {
+    return lambdaClient.agent.getKnowledgeBasesAndFiles.query({ agentId });
+  };
 }
 
 export const agentService = new AgentService();

package/src/services/chat.ts

@@ -499,7 +499,7 @@ class ChatService {
     return this.reorderToolMessages(postMessages);
   };
 
-  private mapTrace(trace?: TracePayload, tag?: TraceTagMap): TracePayload {
+  private mapTrace = (trace?: TracePayload, tag?: TraceTagMap): TracePayload => {
     const tags = sessionMetaSelectors.currentAgentMeta(useSessionStore.getState()).tags || [];
 
     const enabled = preferenceSelectors.userAllowTrace(useUserStore.getState());
@@ -512,7 +512,7 @@ class ChatService {
       tags: [tag, ...(trace?.tags || []), ...tags].filter(Boolean) as string[],
       userId: userProfileSelectors.userId(useUserStore.getState()),
     };
-  }
+  };
 
   /**
    * Fetch chat completion on the client side.