File size: 6,006 Bytes
9853396 | 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 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | import { z } from 'zod';
import { pageInfoSchema } from '@/gql/pagination';
export const modelTypeSchema = z.enum(['chat', 'embedding', 'rerank']);
export type ModelType = z.infer<typeof modelTypeSchema>;
export const modelStatusSchema = z.enum(['enabled', 'disabled', 'archived']);
export type ModelStatus = z.infer<typeof modelStatusSchema>;
export const modelReasoningSchema = z.object({
supported: z.boolean(),
default: z.boolean(),
});
export type ModelReasoning = z.infer<typeof modelReasoningSchema>;
export const modelModalitiesSchema = z.object({
input: z.array(z.string()),
output: z.array(z.string()),
});
export type ModelModalities = z.infer<typeof modelModalitiesSchema>;
export const modelCostSchema = z.object({
input: z.number(),
output: z.number(),
cacheRead: z.number().optional(),
cacheWrite: z.number().optional(),
});
export type ModelCost = z.infer<typeof modelCostSchema>;
export const modelLimitSchema = z.object({
context: z.number(),
output: z.number(),
});
export type ModelLimit = z.infer<typeof modelLimitSchema>;
export const modelCardSchema = z.object({
reasoning: modelReasoningSchema.optional(),
toolCall: z.boolean().optional(),
temperature: z.boolean().optional(),
modalities: modelModalitiesSchema.optional(),
vision: z.boolean().optional(),
cost: modelCostSchema.optional(),
limit: modelLimitSchema.optional(),
knowledge: z.string().optional(),
releaseDate: z.string().optional(),
lastUpdated: z.string().optional(),
});
export type ModelCard = z.infer<typeof modelCardSchema>;
export const channelModelAssociationSchema = z.object({
channelId: z.number(),
modelId: z.string(),
});
export type ChannelModelAssociation = z.infer<typeof channelModelAssociationSchema>;
export const channelRegexAssociationSchema = z.object({
channelId: z.number(),
pattern: z.string(),
});
export type ChannelRegexAssociation = z.infer<typeof channelRegexAssociationSchema>;
export const excludeAssociationSchema = z.object({
channelNamePattern: z.string().optional().nullable(),
channelIds: z.array(z.number()).optional().nullable(),
channelTags: z.array(z.string()).optional().nullable(),
});
export type ExcludeAssociation = z.infer<typeof excludeAssociationSchema>;
export const regexAssociationSchema = z.object({
pattern: z.string(),
exclude: z.array(excludeAssociationSchema).optional().nullable(),
});
export type RegexAssociation = z.infer<typeof regexAssociationSchema>;
export const modelIDAssociationSchema = z.object({
modelId: z.string(),
exclude: z.array(excludeAssociationSchema).optional().nullable(),
});
export type ModelIDAssociation = z.infer<typeof modelIDAssociationSchema>;
export const channelTagsModelAssociationSchema = z.object({
channelTags: z.array(z.string()),
modelId: z.string(),
});
export type ChannelTagsModelAssociation = z.infer<typeof channelTagsModelAssociationSchema>;
export const channelTagsRegexAssociationSchema = z.object({
channelTags: z.array(z.string()),
pattern: z.string(),
});
export type ChannelTagsRegexAssociation = z.infer<typeof channelTagsRegexAssociationSchema>;
export const modelAssociationSchema = z.object({
type: z.enum(['channel_model', 'channel_regex', 'model', 'regex', 'channel_tags_model', 'channel_tags_regex']),
priority: z.number().min(0).max(100).optional().default(0),
disabled: z.boolean().optional().default(false),
channelModel: channelModelAssociationSchema.optional().nullable(),
channelRegex: channelRegexAssociationSchema.optional().nullable(),
regex: regexAssociationSchema.optional().nullable(),
modelId: modelIDAssociationSchema.optional().nullable(),
channelTagsModel: channelTagsModelAssociationSchema.optional().nullable(),
channelTagsRegex: channelTagsRegexAssociationSchema.optional().nullable(),
});
export type ModelAssociation = z.infer<typeof modelAssociationSchema>;
export const modelSettingsSchema = z.object({
associations: z.array(modelAssociationSchema).optional().default([]),
});
export type ModelSettings = z.infer<typeof modelSettingsSchema>;
export const modelSchema = z.object({
id: z.string(),
createdAt: z.coerce.date(),
updatedAt: z.coerce.date(),
developer: z.string(),
modelID: z.string(),
type: modelTypeSchema,
name: z.string(),
icon: z.string(),
group: z.string(),
modelCard: modelCardSchema,
settings: modelSettingsSchema,
status: modelStatusSchema,
remark: z.string().optional().nullable(),
associatedChannelCount: z.number(),
});
export type Model = z.infer<typeof modelSchema>;
export const createModelInputSchema = z.object({
developer: z.string().min(1, 'Developer is required'),
modelID: z.string().min(1, 'Model ID is required'),
type: modelTypeSchema,
name: z.string().min(1, 'Name is required'),
icon: z.string().min(1, 'Icon is required'),
group: z.string().min(1, 'Group is required'),
modelCard: modelCardSchema,
settings: modelSettingsSchema.optional(),
status: modelStatusSchema.optional(),
remark: z.string().optional(),
});
export type CreateModelInput = z.infer<typeof createModelInputSchema>;
export const updateModelInputSchema = z.object({
name: z.string().min(1, 'Name is required').optional(),
icon: z.string().min(1, 'Icon is required').optional(),
group: z.string().min(1, 'Group is required').optional(),
modelCard: modelCardSchema.optional(),
settings: modelSettingsSchema.optional(),
status: modelStatusSchema.optional(),
remark: z.string().optional().nullable(),
});
export type UpdateModelInput = z.infer<typeof updateModelInputSchema>;
export const modelConnectionSchema = z.object({
edges: z.array(
z.object({
node: modelSchema,
cursor: z.string(),
})
),
pageInfo: pageInfoSchema,
totalCount: z.number(),
});
export type ModelConnection = z.infer<typeof modelConnectionSchema>;
|