FilesExpand file tree

main

/

chat.schema.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

122 lines (106 loc) · 4.4 KB

main

/

chat.schema.ts

Copy path

Top

File metadata and controls

• Code
• Blame

122 lines (106 loc) · 4.4 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import { type Static, Type } from '@sinclair/typebox';

import { CHAT_PREVIEW_KEYS, type Chat, type ChatList, type ChatPreview } from '#shared/chat/chat.model';

import type { AreTypesFullyCompatible, ChangePropertyType } from '#shared/typeUtils';

import { CallSettingsSchema, GenerateTextOptionsSchema, LlmMessagesSchema, type LlmMessagesSchemaModel, UserContentSchema } from '../llm/llm.schema';

//#region == Chat database model schemas ====

export const ChatModelSchema = Type.Object(

{

id: Type.String(),

userId: Type.String(),

shareable: Type.Boolean(),

title: Type.String(),

updatedAt: Type.Number(),

parentId: Type.Optional(Type.String()),

rootId: Type.Optional(Type.String()),

messages: Type.Array(Type.Any()), // Do not change this for now,

},

{ $id: 'Chat' },

);

// DO NOT CHANGE THIS PART ----

// LlmMessageSchema doesn't exactly map to LlmMessage, but let's assume it does for now

type ChatHack = ChangePropertyType<Chat, 'messages', LlmMessagesSchemaModel>;

const _ChatCheck: AreTypesFullyCompatible<ChatHack, Static<typeof ChatModelSchema>> = true;

// -----

//#endregion - Chat database model schema

//#region == Derived model schemas ====

export const ChatPreviewSchema = Type.Pick(ChatModelSchema, CHAT_PREVIEW_KEYS, { $id: 'ChatPreview' });

const _ChatPreviewCheck: AreTypesFullyCompatible<ChatPreview, Static<typeof ChatPreviewSchema>> = true;

//#endregion - Derived model schemas

//#region == Chat API schemas ====

export const ChatListSchema = Type.Object(

{

chats: Type.Array(ChatPreviewSchema),

hasMore: Type.Boolean(),

},

{ $id: 'ChatList' },

);

const _ChatListCheck: AreTypesFullyCompatible<ChatList, Static<typeof ChatListSchema>> = true;

// Parameters for routes like /api/chat/:chatId

export const ChatParamsSchema = Type.Object(

{

chatId: Type.String(),

},

{ $id: 'ChatParams' },

);

export type ChatParams = Static<typeof ChatParamsSchema>;

// Request body for POST /api/chat/new and POST /api/chat/:chatId/send

export const ChatMessageSendSchema = Type.Object(

{

llmId: Type.String(),

userContent: UserContentSchema, // UserContentSchema from llm.schema.ts (represents UserContentExt)

options: Type.Optional(

Type.Intersect([

GenerateTextOptionsSchema,

Type.Object({

serviceTier: Type.Optional(Type.Union([Type.Literal('default'), Type.Literal('flex'), Type.Literal('priority')])),

}),

]),

),

autoReformat: Type.Optional(Type.Boolean()),

},

{ $id: 'ChatMessageSend' },

);

export type ChatMessagePayload = Static<typeof ChatMessageSendSchema>;

// Schema for the request body of PATCH /api/chat/:chatId/details

const ChatUpdatableDetailsKeys = ['title', 'shareable'] as const;

export const ChatUpdateDetailsSchema = Type.Partial(Type.Pick(ChatModelSchema, ChatUpdatableDetailsKeys), { $id: 'ChatUpdateDetails' });

export type ChatUpdateDetailsPayload = Static<typeof ChatUpdateDetailsSchema>;

// Schema for the request body of POST /api/chat/:chatId/regenerate

export const RegenerateMessageSchema = Type.Object(

{

userContent: UserContentSchema, // Renamed 'text' to 'userContent' for consistency

llmId: Type.String(),

historyTruncateIndex: Type.Number(),

options: Type.Optional(CallSettingsSchema),

},

{ $id: 'RegenerateMessage' },

);

export type RegenerateMessagePayload = Static<typeof RegenerateMessageSchema>;

// Schema for the request body of POST /api/chat/from-llm-call

export const CreateChatFromLlmCallSchema = Type.Object(

{

llmCallId: Type.String(),

},

{ $id: 'CreateChatFromLlmCall' },

);

export type CreateChatFromLlmCallPayload = Static<typeof CreateChatFromLlmCallSchema>;

// DeleteChatSuccessResponseSchema is not strictly needed if using 204 with ApiNullResponseSchema

// Export Static types for use in frontend/backend

export type ChatListSchemaModel = Static<typeof ChatListSchema>;

export type ChatSchemaModel = Static<typeof ChatModelSchema>;

// Request body for POST /api/chat/markdown

export const ChatMarkdownRequestSchema = Type.Object(

{

text: Type.String({ description: 'The text content to be formatted as Markdown.' }),

},

{ $id: 'ChatMarkdownRequest' },

);

export type ChatMarkdownRequestPayload = Static<typeof ChatMarkdownRequestSchema>;

// Response body for POST /api/chat/markdown

export const ChatMarkdownResponseSchema = Type.Object(

{

markdownText: Type.String({ description: 'The Markdown formatted text.' }),

},

{ $id: 'ChatMarkdownResponse' },

);

export type ChatMarkdownResponseModel = Static<typeof ChatMarkdownResponseSchema>;