Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { z } from 'zod';
import type { TMessageContentParts } from './types/content';
import type { AgentSubagentGraph } from './types/agents';
import type { SearchResultData } from './types/web';
import type { FunctionTool } from './types/tools';
import type { TFile } from './types/files';
import {
CODE_ENVIRONMENT_MODES,
CODE_WORKSPACE_ID_PATTERN,
CODE_WORKSPACE_CHECKOUT_MODES,
MAX_AGENT_CODE_ENVIRONMENT_CHOICES,
} from './code/workspace';
import { userSubmittedMessageFieldPathSchema } from './filters';
import { TFeedback, feedbackSchema } from './feedback';
import { CODE_APPROVAL_MODES } from './code/approval';
import { Tools } from './types/tools';
export const isUUID = z.guid();
export enum AuthType {
OVERRIDE_AUTH = 'override_auth',
USER_PROVIDED = 'user_provided',
SYSTEM_DEFINED = 'system_defined',
}
export const authTypeSchema = z.nativeEnum(AuthType);
export enum EModelEndpoint {
azureOpenAI = 'azureOpenAI',
openAI = 'openAI',
google = 'google',
anthropic = 'anthropic',
assistants = 'assistants',
azureAssistants = 'azureAssistants',
agents = 'agents',
custom = 'custom',
bedrock = 'bedrock',
}
/** Mirrors `@librechat/agents` providers */
export enum Providers {
OPENAI = 'openAI',
ANTHROPIC = 'anthropic',
AZURE = 'azureOpenAI',
GOOGLE = 'google',
VERTEXAI = 'vertexai',
BEDROCK = 'bedrock',
MISTRALAI = 'mistralai',
MISTRAL = 'mistral',
DEEPSEEK = 'deepseek',
MOONSHOT = 'moonshot',
OPENROUTER = 'openrouter',
XAI = 'xai',
}
/**
* Endpoints that support direct PDF processing in the agent system
*/
export const documentSupportedProviders = new Set<string>([
EModelEndpoint.anthropic,
EModelEndpoint.openAI,
EModelEndpoint.bedrock,
EModelEndpoint.custom,
// handled in AttachFileMenu and DragDropModal since azureOpenAI only supports documents with Use Responses API set to true
// EModelEndpoint.azureOpenAI,
EModelEndpoint.google,
Providers.VERTEXAI,
Providers.MISTRALAI,
Providers.MISTRAL,
Providers.DEEPSEEK,
Providers.MOONSHOT,
Providers.OPENROUTER,
Providers.XAI,
]);
const openAILikeProviders = new Set<string>([
Providers.OPENAI,
Providers.AZURE,
EModelEndpoint.custom,
Providers.MISTRALAI,
Providers.MISTRAL,
Providers.DEEPSEEK,
Providers.MOONSHOT,
Providers.OPENROUTER,
Providers.XAI,
]);
export const isOpenAILikeProvider = (provider?: string | null): boolean => {
return openAILikeProviders.has(provider ?? '');
};
/**
* Providers whose `usage_metadata.input_tokens` ALREADY INCLUDES cached tokens
* (`input_token_details.cache_*` is a subset, not an additional charge):
* Google/Vertex (`promptTokenCount`), OpenAI/Azure (`prompt_tokens`), and the
* OpenAI-compatible family. `@librechat/agents`' `getAnthropicUsageMetadata`
* folds `cache_creation` + `cache_read` into `input_tokens`, so Anthropic is a
* subset provider too; without this the cache portion is billed twice. Bedrock
* stays additive — its Converse path passes AWS `inputTokens` through unmodified.
* Single source of truth shared by the backend billing path
* (`packages/api/src/agents/usage.ts`) and the client usage normalization.
*/
export const cacheSubsetProviders = new Set<string>([
Providers.OPENAI,
Providers.AZURE,
Providers.GOOGLE,
Providers.VERTEXAI,
Providers.XAI,
Providers.DEEPSEEK,
Providers.OPENROUTER,
Providers.MOONSHOT,
Providers.ANTHROPIC,
]);
export const inputTokensIncludesCache = (provider?: string | null): boolean => {
return cacheSubsetProviders.has(provider ?? '');
};
export const isDocumentSupportedProvider = (provider?: string | null): boolean => {
const normalized = provider?.toLowerCase() ?? '';
return Array.from(documentSupportedProviders).some(
(candidate) => candidate.toLowerCase() === normalized,
);
};
/**
* Endpoints whose encoders actually build native audio/video payloads. Narrower than
* `documentSupportedProviders`: a provider can accept PDFs and still emit nothing for
* media, in which case the upload has to fall back to text/STT.
*/
export const mediaSupportedProviders = new Set<string>([
EModelEndpoint.google,
Providers.VERTEXAI,
Providers.OPENROUTER,
]);
export const isMediaSupportedProvider = (provider?: string | null): boolean => {
return mediaSupportedProviders.has(provider?.toLowerCase() ?? '');
};
/**
* Built-in endpoint and provider identifiers. A name outside this set is a custom
* endpoint whose real provider is resolved at request time, so its capabilities
* cannot be judged from the name alone.
*/
const knownProviderIdentifiers = new Set<string>([
...Object.values(EModelEndpoint),
...Object.values(Providers),
...Object.values(EModelEndpoint).map((provider) => provider.toLowerCase()),
...Object.values(Providers).map((provider) => provider.toLowerCase()),
]);
export const isKnownProviderIdentifier = (provider?: string | null): boolean => {
return knownProviderIdentifiers.has(provider?.toLowerCase() ?? '');
};
export const paramEndpoints = new Set<EModelEndpoint | string>([
EModelEndpoint.agents,
EModelEndpoint.openAI,
EModelEndpoint.bedrock,
EModelEndpoint.azureOpenAI,
EModelEndpoint.anthropic,
EModelEndpoint.custom,
EModelEndpoint.google,
]);
export enum BedrockProviders {
AI21 = 'ai21',
Amazon = 'amazon',
Anthropic = 'anthropic',
Cohere = 'cohere',
DeepSeek = 'deepseek',
Meta = 'meta',
MistralAI = 'mistral',
Moonshot = 'moonshot',
MoonshotAI = 'moonshotai',
OpenAI = 'openai',
StabilityAI = 'stability',
ZAI = 'zai',
}
export const getModelKey = (endpoint: EModelEndpoint | string, model: string) => {
if (endpoint === EModelEndpoint.bedrock) {
const parts = model.split('.');
const provider = [parts[0], parts[1]].find((part) =>
Object.values(BedrockProviders).includes(part as BedrockProviders),
);
return (provider ?? parts[0]) as BedrockProviders;
}
return model;
};
export const getSettingsKeys = (endpoint: EModelEndpoint | string, model: string) => {
const endpointKey = endpoint;
const modelKey = getModelKey(endpointKey, model);
const combinedKey = `${endpointKey}-${modelKey}`;
return [combinedKey, endpointKey];
};
export type AssistantsEndpoint = EModelEndpoint.assistants | EModelEndpoint.azureAssistants;
export const isAssistantsEndpoint = (_endpoint?: AssistantsEndpoint | null | string): boolean => {
const endpoint = _endpoint ?? '';
if (!endpoint) {
return false;
}
return endpoint.toLowerCase().endsWith(EModelEndpoint.assistants);
};
export type AgentProvider = Exclude<keyof typeof EModelEndpoint, EModelEndpoint.agents> | string;
export const isAgentsEndpoint = (_endpoint?: EModelEndpoint.agents | null | string): boolean => {
const endpoint = _endpoint ?? '';
if (!endpoint) {
return false;
}
return endpoint === EModelEndpoint.agents;
};
export const isParamEndpoint = (
endpoint: EModelEndpoint | string,
endpointType?: EModelEndpoint | string,
): boolean => {
if (paramEndpoints.has(endpoint)) {
return true;
}
if (endpointType != null) {
return paramEndpoints.has(endpointType);
}
return false;
};
export enum ImageDetail {
low = 'low',
auto = 'auto',
high = 'high',
}
export enum ReasoningEffort {
unset = '',
none = 'none',
minimal = 'minimal',
low = 'low',
medium = 'medium',
high = 'high',
xhigh = 'xhigh',
max = 'max',
}
export enum ReasoningParameterFormat {
disabled = 'disabled',
reasoningEffort = 'reasoning_effort',
reasoningObject = 'reasoning_object',
}
export enum ReasoningResponseKey {
reasoning = 'reasoning',
reasoningContent = 'reasoning_content',
}
export enum AnthropicEffort {
unset = '',
low = 'low',
medium = 'medium',
high = 'high',
xhigh = 'xhigh',
max = 'max',
}
/**
* Controls whether the model's reasoning content is returned in responses.
*
* - `'auto'` - LibreChat decides: opt in to `'summarized'` for models that
* omit by default (Opus 4.7+), leave the field off for older models.
* - `'summarized'` - always request a post-hoc summary of the reasoning.
* - `'omitted'` - always suppress reasoning content. Slightly lower latency.
* - `'updates'` - return only the progress notes Claude writes between tool
* calls (mid-thinking display updates); reasoning blocks stay empty. Needs
* the `thinking-display-updates-2026-08-18` beta header.
*
* See https://platform.claude.com/docs/en/about-claude/models/whats-new-claude-4-7#thinking-content-omitted-by-default
*/
export enum ThinkingDisplay {
auto = 'auto',
summarized = 'summarized',
omitted = 'omitted',
updates = 'updates',
}
/**
* Wire-level values accepted by the Anthropic Messages API `thinking.display`
* field. Excludes the LibreChat-only `'auto'` sentinel.
*/
export type ThinkingDisplayWireValue = Exclude<ThinkingDisplay, ThinkingDisplay.auto>;
export enum BedrockReasoningConfig {
low = 'low',
medium = 'medium',
high = 'high',
}
export enum ReasoningSummary {
none = '',
auto = 'auto',
concise = 'concise',
detailed = 'detailed',
}
export enum Verbosity {
none = '',
low = 'low',
medium = 'medium',
high = 'high',
}
export enum ThinkingLevel {
unset = '',
minimal = 'minimal',
low = 'low',
medium = 'medium',
high = 'high',
}
/** OpenAI Responses API `reasoning.mode` (GPT-5.6+). */
export enum ReasoningMode {
unset = '',
standard = 'standard',
pro = 'pro',
}
/** OpenAI Responses API `reasoning.context` (GPT-5.6+). */
export enum ReasoningContext {
unset = '',
auto = 'auto',
current_turn = 'current_turn',
all_turns = 'all_turns',
}
export const imageDetailNumeric = {
[ImageDetail.low]: 0,
[ImageDetail.auto]: 1,
[ImageDetail.high]: 2,
};
export const imageDetailValue = {
0: ImageDetail.low,
1: ImageDetail.auto,
2: ImageDetail.high,
};
export const eImageDetailSchema = z.nativeEnum(ImageDetail);
export const eReasoningEffortSchema = z.nativeEnum(ReasoningEffort);
export const eReasoningParameterFormatSchema = z.nativeEnum(ReasoningParameterFormat);
export const eReasoningResponseKeySchema = z.nativeEnum(ReasoningResponseKey);
export const eAnthropicEffortSchema = z.nativeEnum(AnthropicEffort);
export const eThinkingDisplaySchema = z.nativeEnum(ThinkingDisplay);
export const eReasoningSummarySchema = z.nativeEnum(ReasoningSummary);
export const eVerbositySchema = z.nativeEnum(Verbosity);
export const eThinkingLevelSchema = z.nativeEnum(ThinkingLevel);
export const eReasoningModeSchema = z.nativeEnum(ReasoningMode);
export const eReasoningContextSchema = z.nativeEnum(ReasoningContext);
export const reasoningOverrideSchema = z.discriminatedUnion('key', [
z
.object({
key: z.literal('reasoning_effort'),
value: eReasoningEffortSchema,
})
.strict(),
z
.object({
key: z.literal('effort'),
value: eAnthropicEffortSchema,
})
.strict(),
z
.object({
key: z.literal('thinkingLevel'),
value: eThinkingLevelSchema,
})
.strict(),
z
.object({
key: z.literal('thinkingBudget'),
/* No fixed ceiling: an operator's paramDefinitions may widen the range,
and the request is checked against the resolved range server-side. */
value: z.number().int().min(-1).max(Number.MAX_SAFE_INTEGER),
})
.strict(),
]);
export type TReasoningOverride = z.infer<typeof reasoningOverrideSchema>;
export const defaultAssistantFormValues = {
assistant: '',
id: '',
name: '',
description: '',
instructions: '',
conversation_starters: [],
model: '',
functions: [],
code_interpreter: false,
image_vision: false,
retrieval: false,
append_current_datetime: false,
};
export const defaultAgentFormValues = {
agent: {},
id: '',
name: '',
description: '',
instructions: '',
model: '',
model_parameters: {},
tools: [],
tool_options: {},
provider: {},
edges: [],
artifacts: '',
recursion_limit: undefined,
[Tools.execute_code]: false,
[Tools.file_search]: false,
[Tools.web_search]: false,
[Tools.memory]: false,
stateful_code_environment: 'user' as const,
code_environment_id: undefined as string | null | undefined,
code_environment_ids: [] as string[],
code_workspace_id: undefined as string | undefined,
repositoryInstructions: undefined as 'prefer' | 'defer' | 'off' | undefined,
category: 'general',
support_contact: {
name: '',
email: '',
},
conversation_starters: [] as string[],
/** Optional allowlist. Only applies when `skills_enabled === true`.
* Empty/undefined + enabled = full catalog; non-empty + enabled = narrow to ids. */
skills: undefined as string[] | undefined,
/** Master toggle for skill use on this agent. `true` activates skills
* (full catalog unless `skills` narrows it). Anything else = inactive. */
skills_enabled: undefined as boolean | undefined,
/** Enables runtime skill creation without exposing an existing skill catalog. */
skill_authoring_enabled: undefined as boolean | undefined,
/** Explicit catalog scope. Missing preserves the legacy enabled + empty = all behavior. */
skills_scope: undefined as SkillsScope | undefined,
/** `undefined` = feature disabled by default (no subagent tool injected). */
subagents: undefined as
| {
enabled?: boolean;
allowSelf?: boolean;
agent_ids?: string[];
graphs?: AgentSubagentGraph[];
}
| undefined,
/** Memory partition: 'agent' isolates memories per (user, agent); default shared pool */
memory_scope: undefined as MemoryScope | undefined,
};
export const ImageVisionTool: FunctionTool = {
type: Tools.function,
[Tools.function]: {
name: 'image_vision',
description: 'Get detailed text descriptions for all current image attachments.',
parameters: {
type: 'object',
properties: {},
required: [],
},
},
};
/** Structural on purpose: accepts assistants tools/tool calls and agents function tool
* calls alike — the check only ever reads `type` and `function.name`. */
export const isImageVisionTool = (tool: { type?: string; function?: { name?: string } }) =>
tool.type === 'function' && tool.function?.name === ImageVisionTool.function?.name;
export const openAISettings = {
model: {
default: 'gpt-4o-mini' as const,
},
temperature: {
min: 0 as const,
max: 2 as const,
step: 0.01 as const,
default: 1 as const,
},
top_p: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 1 as const,
},
presence_penalty: {
min: -2 as const,
max: 2 as const,
step: 0.01 as const,
default: 0 as const,
},
frequency_penalty: {
min: -2 as const,
max: 2 as const,
step: 0.01 as const,
default: 0 as const,
},
resendFiles: {
default: true as const,
},
maxContextTokens: {
default: undefined,
},
max_tokens: {
default: undefined,
},
imageDetail: {
default: ImageDetail.auto as const,
min: 0 as const,
max: 2 as const,
step: 1 as const,
},
};
/**
* `65535` (not 65536) is the value valid on both Google AI Studio and Vertex AI:
* Vertex caps current Gemini text models at 65,535 output tokens, so defaulting to
* 65,536 would make otherwise-default Vertex requests fail validation.
*/
const GOOGLE_MAX_OUTPUT = 65535 as const;
const GOOGLE_IMAGE_MAX_OUTPUT = 32768 as const;
const GOOGLE_LEGACY_MAX_OUTPUT = 8192 as const;
/**
* Resolves the documented max output-token limit for a Google/Gemini model.
* Current Gemini text models (2.5 and 3+) support 64K output tokens; their image
* variants (e.g. `gemini-2.5-flash-image`) cap at 32K; legacy/deprecated models
* (2.0 and earlier, including legacy image models) and Gemma retain the 8K limit.
*/
const getGoogleMaxOutputTokens = (modelName: string): number => {
if (/gemini-(?:2\.5|[3-9]|\d{2,})/i.test(modelName)) {
if (/image/i.test(modelName)) {
return GOOGLE_IMAGE_MAX_OUTPUT;
}
return GOOGLE_MAX_OUTPUT;
}
return GOOGLE_LEGACY_MAX_OUTPUT;
};
/**
* Per-model thinking budget bounds, documented in
* `com_endpoint_google_thinking_budget`: Gemini 2.5 Pro accepts 128-32,768,
* Flash accepts 0-24,576, and Flash Lite accepts 512-24,576. The generic
* 32,000 in the shared definition both under-limits Pro and lets invalid
* Flash values through.
*
* `-1` remains the "decide automatically" sentinel and is not part of these
* floors. Callers must keep `range.min` at -1 and apply `min` only to
* non-negative values.
*/
const GOOGLE_THINKING_BUDGET_PRO_MAX = 32768 as const;
const GOOGLE_THINKING_BUDGET_FLASH_MAX = 24576 as const;
const GOOGLE_THINKING_BUDGET_PRO_MIN = 128 as const;
const GOOGLE_THINKING_BUDGET_FLASH_MIN = 0 as const;
const GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN = 512 as const;
export type GoogleThinkingBudgetBounds = { min: number; max: number };
export const getGoogleThinkingBudgetBounds = (
modelName: string,
): GoogleThinkingBudgetBounds | undefined => {
if (!/gemini-2\.5/i.test(modelName)) {
return undefined;
}
if (/flash[-_.]?lite/i.test(modelName)) {
return { min: GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN, max: GOOGLE_THINKING_BUDGET_FLASH_MAX };
}
if (/flash/i.test(modelName)) {
return { min: GOOGLE_THINKING_BUDGET_FLASH_MIN, max: GOOGLE_THINKING_BUDGET_FLASH_MAX };
}
if (/pro/i.test(modelName)) {
return { min: GOOGLE_THINKING_BUDGET_PRO_MIN, max: GOOGLE_THINKING_BUDGET_PRO_MAX };
}
return undefined;
};
export const googleSettings = {
model: {
default: 'gemini-1.5-flash-latest' as const,
},
maxContextTokens: {
min: 10 as const,
max: 2000000 as const,
step: 1000 as const,
},
maxOutputTokens: {
min: 1 as const,
max: GOOGLE_MAX_OUTPUT,
step: 1 as const,
default: GOOGLE_LEGACY_MAX_OUTPUT,
reset: (modelName: string): number => getGoogleMaxOutputTokens(modelName),
set: (value: number, modelName: string): number => {
const max = getGoogleMaxOutputTokens(modelName);
return value > max ? max : value;
},
},
temperature: {
min: 0 as const,
max: 2 as const,
step: 0.01 as const,
default: 1 as const,
},
topP: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 0.95 as const,
},
topK: {
min: 1 as const,
max: 40 as const,
step: 1 as const,
default: 40 as const,
},
thinking: {
default: true as const,
},
thinkingBudget: {
min: -1 as const,
max: 32000 as const,
step: 1 as const,
/** `-1` = Dynamic Thinking, meaning the model will adjust
* the budget based on the complexity of the request.
*/
default: -1 as const,
},
thinkingLevel: {
default: ThinkingLevel.unset as const,
},
};
const ANTHROPIC_MAX_OUTPUT = 128000 as const;
const CLAUDE_4_64K_MAX_OUTPUT = 64000 as const;
const CLAUDE_32K_MAX_OUTPUT = 32000 as const;
const DEFAULT_MAX_OUTPUT = 8192 as const;
const LEGACY_ANTHROPIC_MAX_OUTPUT = 4096 as const;
const CLAUDE_SONNET_128K_OUTPUT_PATTERN =
/claude-sonnet[-.]?(?:4[-.]?(?:[6-9]|\d{2})|[5-9]|\d{2,})(?=$|[^0-9])/;
const CLAUDE_HAIKU_128K_OUTPUT_PATTERN =
/claude-haiku[-.]?(?:5[-.]?(?:[5-9]|\d{2})|[6-9]|\d{2,})(?=$|[^0-9])/;
/**
* Claude "Mythos-class" model families — new top-level classes (peers of
* `opus`/`sonnet`/`haiku`) that ship with the post-Opus-4.7 modern profile:
* adaptive thinking always on, raw thinking omitted by default (summarized
* opt-in), sampling parameters rejected, and a 1M context window. The tier
* word is the class name itself, so the `opus`/`sonnet` version parsers don't
* cover them.
*
* Single source of truth: add a future sibling class name here and every
* Mythos-class gate (adaptive thinking, sampling omission, prompt caching, 1M
* context, 128K output) picks it up.
*/
export const MYTHOS_CLASS_FAMILIES = ['fable', 'mythos'] as const;
const MYTHOS_CLASS_PATTERN = new RegExp(`claude-(?:${MYTHOS_CLASS_FAMILIES.join('|')})[-.]?\\d`);
/** Whether the model is a Claude Mythos-class model (e.g. `claude-fable-5`). */
export function isMythosClassModel(model: string): boolean {
return MYTHOS_CLASS_PATTERN.test(model);
}
export const anthropicSettings = {
model: {
default: 'claude-3-5-sonnet-latest' as const,
},
temperature: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 1 as const,
},
promptCache: {
default: true as const,
},
promptCacheTtl: {
default: undefined,
},
thinking: {
default: true as const,
},
thinkingBudget: {
min: 1024 as const,
step: 100 as const,
max: 200000 as const,
default: 2000 as const,
},
maxOutputTokens: {
min: 1 as const,
max: ANTHROPIC_MAX_OUTPUT,
step: 1 as const,
default: DEFAULT_MAX_OUTPUT,
reset: (modelName: string) => {
if (isMythosClassModel(modelName)) {
return ANTHROPIC_MAX_OUTPUT;
}
if (/claude-opus[-.]?(?:4[-.]?(?:[6-9]|\d{2,})|[5-9]|\d{2,})/.test(modelName)) {
return ANTHROPIC_MAX_OUTPUT;
}
if (
CLAUDE_SONNET_128K_OUTPUT_PATTERN.test(modelName) ||
CLAUDE_HAIKU_128K_OUTPUT_PATTERN.test(modelName)
) {
return ANTHROPIC_MAX_OUTPUT;
}
if (/claude-(?:sonnet|haiku)[-.]?[4-9]/.test(modelName)) {
return CLAUDE_4_64K_MAX_OUTPUT;
}
if (/claude-opus[-.]?(?:[5-9]|4[-.]?([5-9]|\d{2,}))/.test(modelName)) {
return CLAUDE_4_64K_MAX_OUTPUT;
}
if (/claude-opus[-.]?[4-9]/.test(modelName)) {
return CLAUDE_32K_MAX_OUTPUT;
}
return DEFAULT_MAX_OUTPUT;
},
set: (value: number, modelName: string) => {
if (isMythosClassModel(modelName)) {
if (value > ANTHROPIC_MAX_OUTPUT) {
return ANTHROPIC_MAX_OUTPUT;
}
return value;
}
if (/claude-opus[-.]?(?:4[-.]?(?:[6-9]|\d{2,})|[5-9]|\d{2,})/.test(modelName)) {
if (value > ANTHROPIC_MAX_OUTPUT) {
return ANTHROPIC_MAX_OUTPUT;
}
return value;
}
if (
CLAUDE_SONNET_128K_OUTPUT_PATTERN.test(modelName) ||
CLAUDE_HAIKU_128K_OUTPUT_PATTERN.test(modelName)
) {
if (value > ANTHROPIC_MAX_OUTPUT) {
return ANTHROPIC_MAX_OUTPUT;
}
return value;
}
if (/claude-(?:sonnet|haiku)[-.]?[4-9]/.test(modelName) && value > CLAUDE_4_64K_MAX_OUTPUT) {
return CLAUDE_4_64K_MAX_OUTPUT;
}
if (/claude-opus[-.]?(?:[5-9]|4[-.]?([5-9]|\d{2,}))/.test(modelName)) {
if (value > CLAUDE_4_64K_MAX_OUTPUT) {
return CLAUDE_4_64K_MAX_OUTPUT;
}
return value;
}
if (/claude-opus[-.]?[4-9]/.test(modelName) && value > CLAUDE_32K_MAX_OUTPUT) {
return CLAUDE_32K_MAX_OUTPUT;
}
if (value > ANTHROPIC_MAX_OUTPUT) {
return ANTHROPIC_MAX_OUTPUT;
}
return value;
},
},
topP: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 0.7 as const,
},
topK: {
min: 1 as const,
max: 40 as const,
step: 1 as const,
default: 5 as const,
},
resendFiles: {
default: true as const,
},
maxContextTokens: {
default: undefined,
},
legacy: {
maxOutputTokens: {
min: 1 as const,
max: LEGACY_ANTHROPIC_MAX_OUTPUT,
step: 1 as const,
default: LEGACY_ANTHROPIC_MAX_OUTPUT,
},
},
effort: {
default: AnthropicEffort.unset,
options: [
AnthropicEffort.unset,
AnthropicEffort.low,
AnthropicEffort.medium,
AnthropicEffort.high,
AnthropicEffort.xhigh,
AnthropicEffort.max,
],
},
thinkingDisplay: {
default: ThinkingDisplay.auto,
options: [
ThinkingDisplay.auto,
ThinkingDisplay.summarized,
ThinkingDisplay.omitted,
ThinkingDisplay.updates,
],
},
web_search: {
default: false as const,
},
};
export const agentsSettings = {
model: {
default: 'gpt-3.5-turbo-test' as const,
},
temperature: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 1 as const,
},
top_p: {
min: 0 as const,
max: 1 as const,
step: 0.01 as const,
default: 1 as const,
},
presence_penalty: {
min: -2 as const,
max: 2 as const,
step: 0.01 as const,
default: 0 as const,
},
frequency_penalty: {
min: -2 as const,
max: 2 as const,
step: 0.01 as const,
default: 0 as const,
},
resendFiles: {
default: true as const,
},
maxContextTokens: {
default: undefined,
},
max_tokens: {
default: undefined,
},
imageDetail: {
default: ImageDetail.auto as const,
},
};
export const endpointSettings = {
[EModelEndpoint.openAI]: openAISettings,
[EModelEndpoint.google]: googleSettings,
[EModelEndpoint.anthropic]: anthropicSettings,
[EModelEndpoint.agents]: agentsSettings,
[EModelEndpoint.bedrock]: agentsSettings,
};
const google = endpointSettings[EModelEndpoint.google];
export const eModelEndpointSchema = z.nativeEnum(EModelEndpoint);
export const extendedModelEndpointSchema = z.union([eModelEndpointSchema, z.string()]);
export const tPluginAuthConfigSchema = z.object({
authField: z.string(),
label: z.string(),
description: z.string(),
optional: z.boolean().optional(),
/** Whether the field holds a secret and should be masked in the UI (defaults to masked when omitted). */
sensitive: z.boolean().optional(),
});
export type TPluginAuthConfig = z.infer<typeof tPluginAuthConfigSchema>;
export const tPluginSchema = z.object({
name: z.string(),
pluginKey: z.string(),
description: z.string().optional(),
icon: z.string().optional(),
authConfig: z.array(tPluginAuthConfigSchema).optional(),
authenticated: z.boolean().optional(),
chatMenu: z.boolean().optional(),
isButton: z.boolean().optional(),
toolkit: z.boolean().optional(),
/** Raw upstream tool name when the model-facing key stripped a redundant
* server-name prefix — proves upstream identity for legacy id migration. */
serverToolName: z.string().optional(),
});
export type TPlugin = z.infer<typeof tPluginSchema>;
export type TInput = {
inputStr: string;
};
export const tExampleSchema = z.object({
input: z.object({
content: z.string(),
}),
output: z.object({
content: z.string(),
}),
});
export type TExample = z.infer<typeof tExampleSchema>;
/** Compact context-fading tier persisted beside a message's calibration ratio. */
const agentFadingTierSchema = z.object({
v: z.union([z.literal(1), z.literal(2)]),
budgetTokens: z.number().positive(),
masked: z.boolean(),
});
export const tMessageSchema = z.object({
messageId: z.string(),
endpoint: z.string().optional(),
clientId: z.string().nullable().optional(),
conversationId: z.string().nullable(),
parentMessageId: z.string().nullable(),
responseMessageId: z.string().nullable().optional(),
overrideParentMessageId: z.string().nullable().optional(),
bg: z.string().nullable().optional(),
model: z.string().nullable().optional(),
title: z.string().nullable().or(z.literal('New Chat')).default('New Chat'),
sender: z.string().optional(),
text: z.string(),
/** @deprecated */
generation: z.string().nullable().optional(),
isCreatedByUser: z.boolean(),
/** Opaque revision of the separately authorized owner display. */
privacyRevision: z.string().optional(),
/** True when the complete stored row came from outside the model. */
isUserSubmitted: z.boolean().optional(),
/** JSON pointers to caller-authored fields in an otherwise mixed model response. */
userSubmittedPaths: z.array(z.string().startsWith('/')).optional(),
/** Exact HITL message-field identity for caller-authored values stored in mixed responses. */
userSubmittedMessageFieldPaths: z.array(userSubmittedMessageFieldPathSchema).optional(),
isTemporary: z.boolean().optional(),
expiredAt: z.string().nullable().optional(),
error: z.boolean().optional(),
clientTimestamp: z.string().optional(),
createdAt: z
.string()
.optional()
.default(() => new Date().toISOString()),
updatedAt: z
.string()
.optional()
.default(() => new Date().toISOString()),
current: z.boolean().optional(),
unfinished: z.boolean().optional(),
searchResult: z.boolean().optional(),
finish_reason: z.string().optional(),
/* assistant */
thread_id: z.string().optional(),
/* frontend components */
iconURL: z.string().nullable().optional(),
feedback: feedbackSchema.optional(),
/** metadata */
metadata: z.record(z.string(), z.unknown()).optional(),
/** Output tokens for assistant messages, calibrated prompt-side estimate for user messages */
tokenCount: z.number().optional(),
contextMeta: z
.object({
calibrationRatio: z
.number()
.optional()
.describe(
'EMA ratio of provider-reported vs local token estimates; seeds the pruner on subsequent runs',
),
encoding: z
.string()
.optional()
.describe(
'Tokenizer encoding used when this ratio was computed (e.g. "claude", "o200k_base")',
),
fading: agentFadingTierSchema
.optional()
.describe(
'Latched context-fading tier of the default agent; seeds the next run so the provider projection of history keeps the same bytes',
),
fadingTiers: z
.array(agentFadingTierSchema.extend({ agentId: z.string().min(1) }))
.optional()
.describe('Latched context-fading tiers keyed by agent ID, stored as entries'),
})
.optional(),
/**
* Skill names the user invoked manually via the `$` popover on this turn.
* Purely UI metadata — `SkillPills` renders these above the message
* bubble so users can see which skills they asked for in history and on
* reload. Runtime resolution uses the top-level payload field with the
* same name. Empty / absent for model-invoked skills (shown as tool_call
* content parts on the assistant message instead).
*/
manualSkills: z.array(z.string()).optional(),
/**
* Skill names auto-primed on this turn because their `always-apply`
* frontmatter flag is set. Persisted at turn time so the pinned-variant
* pills on the user bubble survive reload and stay stable across later
* edits to the skill's `alwaysApply` flag (the user bubble reflects
* what actually ran, not the current catalog).
*/
alwaysAppliedSkills: z.array(z.string()).optional(),
/**
* Verbatim excerpts the user quoted (via the "Add to chat" selection
* popup) to reference on this turn. UI metadata that `MessageQuotes`
* renders above the user bubble so the references persist on reload. The
* excerpts are merged into the user message text sent to the model at
* request time and counted in the user message token count.
*/
quotes: z.array(z.string()).optional(),
/** Request-scoped reasoning selection that produced this user turn. */
reasoningOverride: reasoningOverrideSchema.optional(),
});
/**
* Which memory partition an agent reads/writes.
* `user` = the shared personal pool (default); `agent` = a partition
* isolated per (user, agent) so the agent only sees its own memories.
*/
export enum MemoryScope {
user = 'user',
agent = 'agent',
}
/** Catalog exposure for a persisted agent with skills enabled. */
export enum SkillsScope {
all = 'all',
selected = 'selected',
none = 'none',
}
/** Resolves explicit and legacy persisted-agent skill catalog states. */
export function resolveAgentSkillsScope(
skills: readonly string[] | undefined,
enabled: boolean | undefined,
scope: SkillsScope | undefined,
): SkillsScope {
if (enabled !== true) {
return SkillsScope.none;
}
if (scope !== undefined) {
return scope;
}
return (skills ?? []).length > 0 ? SkillsScope.selected : SkillsScope.all;
}
export type MemoryArtifact = {
key: string;
value?: string;
tokenCount?: number;
type: 'update' | 'delete' | 'error';
/** Agent partition the write targeted; absent = shared personal pool */
agentId?: string;
};
export type UIResource = {
resourceId: string;
uri: string;
name?: string;
mimeType?: string;
text?: string;
serverName?: string;
toolName?: string;
/** Opaque server-issued binding required for executable MCP App callbacks. */
serverBinding?: string;
structuredContent?: Record<string, unknown>;
content?: unknown[];
csp?: {
connectDomains?: string[];
resourceDomains?: string[];
frameDomains?: string[];
baseUriDomains?: string[];
};
permissions?: {
camera?: Record<string, never>;
microphone?: Record<string, never>;
geolocation?: Record<string, never>;
clipboardWrite?: Record<string, never>;
};
toolArgs?: Record<string, unknown>;
isError?: boolean;
resultMeta?: Record<string, unknown>;
[key: string]: unknown;
};
export type WorkspaceChange = {
profile: 'stateful';
operation: 'created' | 'updated';
path: string;
};
export type TAttachmentMetadata = {
type?: Tools;
messageId: string;
toolCallId: string;
/** Saved-agent owner when provider tool-call ids repeat across handoffs. */
agentId?: string;
/** Host run-step owner when one agent repeats a provider tool-call id. */
stepId?: string;
workspaceChange?: WorkspaceChange;
[Tools.memory]?: MemoryArtifact;
[Tools.ui_resources]?: UIResource[];
[Tools.web_search]?: SearchResultData;
[Tools.file_search]?: SearchResultData;
};
export type TAttachment =
| (TFile & TAttachmentMetadata)
| (Pick<TFile, 'filename' | 'filepath' | 'conversationId'> & {
expiresAt: number;
} & TAttachmentMetadata)
| (Partial<Pick<TFile, 'filename' | 'filepath'>> &
Pick<TFile, 'conversationId'> &
TAttachmentMetadata);
export type TMessage = z.input<typeof tMessageSchema> & {
children?: TMessage[];
content?: TMessageContentParts[];
files?: Partial<TFile>[];
depth?: number;
siblingIndex?: number;
attachments?: TAttachment[];
clientTimestamp?: string;
/** Client-only durable branch anchor while this message is an optimistic response. */
clientQueueParentMessageId?: string;
feedback?: TFeedback;
};
export const coerceNumber = z.union([z.number(), z.string()]).transform((val) => {
if (typeof val === 'string') {
return val.trim() === '' ? undefined : parseFloat(val);
}
return val;
});
type DocumentTypeValue =
| null
| boolean
| number
| string
| DocumentTypeValue[]
| { [key: string]: DocumentTypeValue };
const DocumentType: z.ZodType<DocumentTypeValue> = z.lazy(() =>
z.union([
z.null(),
z.boolean(),
z.number(),
z.string(),
z.array(z.lazy(() => DocumentType)),
z.record(
z.string(),
z.lazy(() => DocumentType),
),
]),
);
export const subagentThreadLineageSchema = z.object({
rootConversationId: z.string().min(1),
parentConversationId: z.string().min(1),
parentMessageId: z.string().min(1),
parentToolCallId: z.string().min(1),
parentAgentId: z.string().min(1).optional(),
subagentType: z.string().min(1),
subagentKind: z.enum(['agent', 'graph']),
depth: z.number().int().positive(),
});
export type TSubagentThreadLineage = z.infer<typeof subagentThreadLineageSchema>;
export const tConversationSchema = z.object({
conversationId: z.string().nullable(),
endpoint: eModelEndpointSchema.nullable(),
endpointType: eModelEndpointSchema.nullable().optional(),
isArchived: z.boolean().optional(),
/** When the chat was archived; absent on chats archived before this was recorded. */
archivedAt: z.string().nullable().optional(),
pinned: z.boolean().optional(),
/** Server-derived: an active shared link exists for this conversation. Not persisted. */
isShared: z.boolean().optional(),
/** Server-derived on list rows: the listing replica returned the code decision. Not persisted. */
codeDecisionListed: z.boolean().optional(),
codeApprovalMode: z.enum(CODE_APPROVAL_MODES).optional(),
codeEnvironmentMode: z.enum(CODE_ENVIRONMENT_MODES).optional(),
codeWorkspaces: z
.array(
z
.object({
environmentId: z.string().regex(CODE_WORKSPACE_ID_PATTERN),
workspaceId: z.string().regex(CODE_WORKSPACE_ID_PATTERN),
checkout: z.enum(CODE_WORKSPACE_CHECKOUT_MODES).optional(),
agentIds: z
.array(z.string().regex(CODE_WORKSPACE_ID_PATTERN))
.min(1)
.max(MAX_AGENT_CODE_ENVIRONMENT_CHOICES)
.optional(),
})
.strict(),
)
.optional(),
title: z.string().nullable().or(z.literal('New Chat')).default('New Chat'),
/** Server-owned title authority; ordinary chat saves cannot set or clear it. */
titleSetByUser: z.boolean().optional(),
titleRevision: z.number().int().nonnegative().optional(),
user: z.string().optional(),
messages: z.array(z.string()).optional(),
tools: z.union([z.array(tPluginSchema), z.array(z.string())]).optional(),
modelLabel: z.string().nullable().optional(),
userLabel: z.string().optional(),
model: z.string().nullable().optional(),
promptPrefix: z.string().nullable().optional(),
temperature: z.number().nullable().optional(),
topP: z.number().optional(),
topK: z.number().optional(),
top_p: z.number().optional(),
frequency_penalty: z.number().optional(),
presence_penalty: z.number().optional(),
parentMessageId: z.string().optional(),
maxOutputTokens: coerceNumber.nullable().optional(),
maxContextTokens: coerceNumber.optional(),
max_tokens: coerceNumber.optional(),
/* Anthropic */
promptCache: z.boolean().optional(),
promptCacheTtl: z.enum(['5m', '1h']).optional(),
system: z.string().optional(),
thinking: z.boolean().optional(),
thinkingBudget: coerceNumber.optional(),
thinkingLevel: eThinkingLevelSchema.optional(),
stream: z.boolean().optional(),
/* artifacts */
artifacts: z.string().optional(),
/* google */
context: z.string().nullable().optional(),
examples: z.array(tExampleSchema).optional(),
/* DB */
tags: z.array(z.string()).optional(),
chatProjectId: z.string().nullable().optional(),
createdAt: z.string(),
updatedAt: z.string(),
/** Set only when an assistant message is persisted; drives the unseen-reply indicator. */
lastResponseAt: z.string().optional(),
/** Durable messageId of the assistant reply named by `lastResponseAt`. */
lastResponseMessageId: z.string().optional(),
/** True only while `lastResponseAt` is the synthetic marker from "mark unread". */
lastResponseIsManual: z.boolean().optional(),
/** True: manual reminder; false: real reply; absent: legacy/unknown intent. */
isMarkedUnread: z.boolean().optional(),
/** Read acknowledgement; epoch is the explicit unseen-reply watermark. */
lastSeenAt: z.string().optional(),
/* Files */
resendFiles: z.boolean().optional(),
file_ids: z.array(z.string()).optional(),
/* vision */
imageDetail: eImageDetailSchema.optional(),
/* OpenAI: Reasoning models only */
reasoning_effort: eReasoningEffortSchema.optional().nullable(),
reasoning_summary: eReasoningSummarySchema.optional().nullable(),
/* OpenAI Responses API: reasoning mode (standard/pro) + context */
reasoning_mode: eReasoningModeSchema.optional().nullable(),
reasoning_context: eReasoningContextSchema.optional().nullable(),
/* OpenAI: Verbosity control */
verbosity: eVerbositySchema.optional().nullable(),
/* OpenAI: use Responses API */
useResponsesApi: z.boolean().optional(),
/* Anthropic: Effort control */
effort: eAnthropicEffortSchema.optional().nullable(),
/* Anthropic: Thinking visibility (Opus 4.7+ opt-in) */
thinkingDisplay: eThinkingDisplaySchema.optional().nullable(),
/* OpenAI Responses API / Anthropic API / Google API */
web_search: z.boolean().optional(),
/* Google API: URL Context tool (+ native YouTube video understanding) */
url_context: z.boolean().optional(),
/* disable streaming */
disableStreaming: z.boolean().optional(),
/* assistant */
assistant_id: z.string().optional(),
/* agents */
agent_id: z.string().optional(),
/** Durable parent/child navigation for a subagent thread. */
subagentThread: subagentThreadLineageSchema.optional(),
/* AWS Bedrock */
region: z.string().optional(),
maxTokens: coerceNumber.optional(),
additionalModelRequestFields: DocumentType.optional(),
/* assistants */
instructions: z.string().optional(),
additional_instructions: z.string().optional(),
append_current_datetime: z.boolean().optional(),
/** Used to overwrite active conversation settings when saving a Preset */
presetOverride: z.record(z.string(), z.unknown()).optional(),
stop: z.array(z.string()).optional(),
/* frontend components */
greeting: z.string().optional(),
spec: z.string().nullable().optional(),
iconURL: z.string().nullable().optional(),
/* temporary chat */
expiredAt: z.string().nullable().optional(),
isTemporary: z.boolean().optional(),
/* file token limits */
fileTokenLimit: coerceNumber.optional(),
/** @deprecated */
resendImages: z.boolean().optional(),
/** @deprecated Prefer `modelLabel` over `chatGptLabel` */
chatGptLabel: z.string().nullable().optional(),
});
export const tPresetSchema = tConversationSchema
.omit({
conversationId: true,
chatProjectId: true,
createdAt: true,
updatedAt: true,
title: true,
titleSetByUser: true,
titleRevision: true,
/* Runtime unseen-reply state must not ride into presets: applying one would stamp
stale timestamps back onto conversations. */
lastResponseAt: true,
lastResponseMessageId: true,
lastResponseIsManual: true,
isMarkedUnread: true,
lastSeenAt: true,
})
.merge(
z.object({
conversationId: z.string().nullable().optional(),
presetId: z.string().nullable().optional(),
title: z.string().nullable().optional(),
defaultPreset: z.boolean().optional(),
order: z.number().optional(),
endpoint: extendedModelEndpointSchema.nullable(),
}),
);
export const tConvoUpdateSchema = tConversationSchema.merge(
z.object({
endpoint: extendedModelEndpointSchema.nullable(),
createdAt: z.string().optional(),
updatedAt: z.string().optional(),
}),
);
export const tQueryParamsSchema = tConversationSchema
.pick({
// librechat settings
/** The model spec to be used */
spec: true,
/** The AI context window, overrides the system-defined window as determined by `model` value */
maxContextTokens: true,
/**
* Whether or not to re-submit files from previous messages on subsequent messages
* */
resendFiles: true,
/**
* @endpoints openAI, custom, azureOpenAI
*
* System parameter that only affects the above endpoints.
* Image detail for re-sizing according to OpenAI spec, defaults to `auto`
* */
imageDetail: true,
/**
* AKA Custom Instructions, dynamically added to chat history as a system message;
* for `bedrock` endpoint, this is used as the `system` model param if the provider uses it;
* for `assistants` endpoint, this is used as the `additional_instructions` model param:
* https://platform.openai.com/docs/api-reference/runs/createRun#runs-createrun-additional_instructions
* ; otherwise, a message with `system` role is added to the chat history
*/
promptPrefix: true,
// Model parameters
/** @endpoints openAI, custom, azureOpenAI, google, anthropic, assistants, azureAssistants, bedrock */
model: true,
/** @endpoints openAI, custom, azureOpenAI, google, anthropic, bedrock */
temperature: true,
/** @endpoints openAI, custom, azureOpenAI */
presence_penalty: true,
/** @endpoints openAI, custom, azureOpenAI */
frequency_penalty: true,
/** @endpoints openAI, custom, azureOpenAI */
stop: true,
/** @endpoints openAI, custom, azureOpenAI */
top_p: true,
/** @endpoints openAI, custom, azureOpenAI */
max_tokens: true,
/** @endpoints openAI, custom, azureOpenAI */
reasoning_effort: true,
/** @endpoints openAI, custom, azureOpenAI */
reasoning_summary: true,
/** @endpoints openAI, custom, azureOpenAI */
reasoning_mode: true,
/** @endpoints openAI, custom, azureOpenAI */
reasoning_context: true,
/** @endpoints openAI, custom, azureOpenAI */
verbosity: true,
/** @endpoints openAI, custom, azureOpenAI */
useResponsesApi: true,
/** @endpoints openAI, anthropic, google */
web_search: true,
/** @endpoints google */
url_context: true,
/** @endpoints openAI, custom, azureOpenAI */
disableStreaming: true,
/** @endpoints google, anthropic, bedrock */
topP: true,
/** @endpoints google, anthropic */
topK: true,
/** @endpoints google, anthropic */
maxOutputTokens: true,
/** @endpoints anthropic */
promptCache: true,
promptCacheTtl: true,
thinking: true,
thinkingBudget: true,
thinkingLevel: true,
effort: true,
thinkingDisplay: true,
/** @endpoints bedrock */
region: true,
/** @endpoints bedrock */
maxTokens: true,
/** @endpoints agents */
agent_id: true,
/** @endpoints assistants, azureAssistants */
assistant_id: true,
/** @endpoints assistants, azureAssistants */
append_current_datetime: true,
/**
* @endpoints assistants, azureAssistants
*
* Overrides existing assistant instructions, only used for the current run:
* https://platform.openai.com/docs/api-reference/runs/createRun#runs-createrun-instructions
* */
instructions: true,
/** @endpoints openAI, google, anthropic */
fileTokenLimit: true,
})
.merge(
z.object({
/** @endpoints openAI, custom, azureOpenAI, google, anthropic, assistants, azureAssistants, bedrock, agents */
endpoint: extendedModelEndpointSchema.nullable(),
}),
);
/** Narrowed preset schema for use in model specs — omits system/DB/deprecated fields.
*
* `greeting` and `iconURL` are admin-configurable display fields on a model spec's
* preset (landing greeting, preset-level icon fallback) and must be preserved.
* `spec` is set by the client from `modelSpec.name` via `getModelSpecPreset` and is
* omitted to avoid duplicate configuration surface.
*/
export const tModelSpecPresetSchema = tPresetSchema
.omit({
conversationId: true,
presetId: true,
title: true,
defaultPreset: true,
order: true,
isArchived: true,
user: true,
messages: true,
tags: true,
file_ids: true,
expiredAt: true,
parentMessageId: true,
resendImages: true,
chatGptLabel: true,
presetOverride: true,
spec: true,
})
.merge(
z.object({
/**
* Optional here, unlike `tPresetSchema`, where the key is required (though
* nullable). A preset naming an `agent_id` has an unambiguous endpoint, so
* config may omit it and `resolveModelSpecEndpoint` infers `agents` when
* specs are materialized at config load.
*/
endpoint: extendedModelEndpointSchema.nullish(),
}),
)
.superRefine((preset, ctx) => {
/**
* Omission is only legal when the endpoint is inferable, which requires a
* NON-EMPTY `agent_id` — form-backed writers persist untouched fields as
* `''`, which names no agent. An explicit `endpoint: null` stays accepted:
* it validated before the key became optional, so rejecting it now would
* break previously valid configs.
*/
if (preset.endpoint === undefined && !preset.agent_id) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
path: ['endpoint'],
message:
'endpoint is required unless the preset names a non-empty agent_id (the agents endpoint is then inferred)',
});
}
});
export type TModelSpecPreset = z.infer<typeof tModelSpecPresetSchema>;
export type TPreset = z.infer<typeof tPresetSchema>;
export type TSetOption = (
param: number | string,
) => (newValue: number | string | boolean | string[] | Partial<TPreset>) => void;
export type TConversation = z.infer<typeof tConversationSchema> & {
presetOverride?: Partial<TPreset>;
disableParams?: boolean;
};
export const tSharedLinkSchema = z.object({
conversationId: z.string(),
shareId: z.string(),
targetMessageId: z.string().optional(),
messages: z.array(z.string()),
title: z.string(),
createdAt: z.string(),
updatedAt: z.string(),
});
export type TSharedLink = z.infer<typeof tSharedLinkSchema>;
export const tConversationTagSchema = z.object({
_id: z.string(),
user: z.string(),
tag: z.string(),
description: z.string().optional(),
createdAt: z.string(),
updatedAt: z.string(),
count: z.number(),
position: z.number(),
});
export type TConversationTag = z.infer<typeof tConversationTagSchema>;
export const googleBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
modelLabel: true,
promptPrefix: true,
examples: true,
temperature: true,
maxOutputTokens: true,
resendFiles: true,
artifacts: true,
topP: true,
topK: true,
thinking: true,
thinkingBudget: true,
thinkingLevel: true,
web_search: true,
url_context: true,
fileTokenLimit: true,
iconURL: true,
greeting: true,
spec: true,
maxContextTokens: true,
});
export const googleSchema = googleBaseSchema
.transform((obj: Partial<TConversation>) => removeNullishValues(obj, true))
.catch(() => ({}));
export function removeNullishValues<T extends Record<string, unknown>>(
obj: T,
removeEmptyStrings?: boolean,
): Partial<T> {
const newObj: Partial<T> = { ...obj };
(Object.keys(newObj) as Array<keyof T>).forEach((key) => {
const value = newObj[key];
if (value === undefined || value === null) {
delete newObj[key];
}
if (removeEmptyStrings && typeof value === 'string' && value === '') {
delete newObj[key];
}
});
return newObj;
}
const assistantBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
assistant_id: true,
instructions: true,
artifacts: true,
promptPrefix: true,
iconURL: true,
greeting: true,
spec: true,
append_current_datetime: true,
});
export const assistantSchema = assistantBaseSchema
.transform((obj) => ({
...obj,
model: obj.model ?? openAISettings.model.default,
assistant_id: obj.assistant_id ?? undefined,
instructions: obj.instructions ?? undefined,
promptPrefix: obj.promptPrefix ?? null,
iconURL: obj.iconURL ?? undefined,
greeting: obj.greeting ?? undefined,
spec: obj.spec ?? undefined,
append_current_datetime: obj.append_current_datetime ?? false,
}))
.catch(() => ({
model: openAISettings.model.default,
assistant_id: undefined,
instructions: undefined,
promptPrefix: null,
iconURL: undefined,
greeting: undefined,
spec: undefined,
append_current_datetime: false,
}));
const compactAssistantBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
assistant_id: true,
instructions: true,
promptPrefix: true,
artifacts: true,
iconURL: true,
greeting: true,
spec: true,
});
export const compactAssistantSchema = compactAssistantBaseSchema
.transform((obj) => removeNullishValues(obj))
.catch(() => ({}));
export const agentsBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
modelLabel: true,
temperature: true,
top_p: true,
presence_penalty: true,
frequency_penalty: true,
resendFiles: true,
imageDetail: true,
agent_id: true,
instructions: true,
promptPrefix: true,
iconURL: true,
greeting: true,
maxContextTokens: true,
});
export const agentsSchema = agentsBaseSchema
.transform((obj) => ({
...obj,
model: obj.model ?? agentsSettings.model.default,
modelLabel: obj.modelLabel ?? null,
temperature: obj.temperature ?? 1,
top_p: obj.top_p ?? 1,
presence_penalty: obj.presence_penalty ?? 0,
frequency_penalty: obj.frequency_penalty ?? 0,
resendFiles:
typeof obj.resendFiles === 'boolean' ? obj.resendFiles : agentsSettings.resendFiles.default,
imageDetail: obj.imageDetail ?? ImageDetail.auto,
agent_id: obj.agent_id ?? undefined,
instructions: obj.instructions ?? undefined,
promptPrefix: obj.promptPrefix ?? null,
iconURL: obj.iconURL ?? undefined,
greeting: obj.greeting ?? undefined,
maxContextTokens: obj.maxContextTokens ?? undefined,
}))
.catch(() => ({
model: agentsSettings.model.default,
modelLabel: null,
temperature: 1,
top_p: 1,
presence_penalty: 0,
frequency_penalty: 0,
resendFiles: agentsSettings.resendFiles.default,
imageDetail: ImageDetail.auto,
agent_id: undefined,
instructions: undefined,
promptPrefix: null,
iconURL: undefined,
greeting: undefined,
maxContextTokens: undefined,
}));
export const openAIBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
modelLabel: true,
chatGptLabel: true,
promptPrefix: true,
temperature: true,
top_p: true,
presence_penalty: true,
frequency_penalty: true,
resendFiles: true,
artifacts: true,
imageDetail: true,
stop: true,
iconURL: true,
greeting: true,
spec: true,
maxContextTokens: true,
max_tokens: true,
reasoning_effort: true,
reasoning_summary: true,
reasoning_mode: true,
reasoning_context: true,
verbosity: true,
useResponsesApi: true,
web_search: true,
disableStreaming: true,
fileTokenLimit: true,
});
export const openAISchema = openAIBaseSchema
.transform((obj: Partial<TConversation>) => removeNullishValues(obj, true))
.catch(() => ({}));
export const openRouterSchema = openAIBaseSchema
.merge(tConversationSchema.pick({ promptCache: true, promptCacheTtl: true }))
.transform((obj: Partial<TConversation>) => removeNullishValues(obj, true))
.catch(() => ({}));
export const compactGoogleSchema = googleBaseSchema
.transform((obj) => {
const newObj: Partial<TConversation> = { ...obj };
if (newObj.temperature === google.temperature.default) {
delete newObj.temperature;
}
if (newObj.maxOutputTokens === google.maxOutputTokens.reset(newObj.model ?? '')) {
delete newObj.maxOutputTokens;
}
if (newObj.topP === google.topP.default) {
delete newObj.topP;
}
if (newObj.topK === google.topK.default) {
delete newObj.topK;
}
return removeNullishValues(newObj, true);
})
.catch(() => ({}));
export const anthropicBaseSchema = tConversationSchema.pick({
chatProjectId: true,
model: true,
modelLabel: true,
promptPrefix: true,
temperature: true,
maxOutputTokens: true,
topP: true,
topK: true,
resendFiles: true,
promptCache: true,
promptCacheTtl: true,
thinking: true,
thinkingBudget: true,
effort: true,
thinkingDisplay: true,
artifacts: true,
iconURL: true,
greeting: true,
spec: true,
maxContextTokens: true,
web_search: true,
fileTokenLimit: true,
stop: true,
stream: true,
});
export const anthropicSchema = anthropicBaseSchema
.transform((obj) => removeNullishValues(obj))
.catch(() => ({}));
export const tBannerSchema = z.object({
bannerId: z.string(),
message: z.string(),
displayFrom: z.string(),
displayTo: z.string(),
createdAt: z.string(),
updatedAt: z.string(),
isPublic: z.boolean(),
persistable: z.boolean().default(false),
});
export type TBanner = z.infer<typeof tBannerSchema>;
export const compactAgentsBaseSchema = tConversationSchema.pick({
chatProjectId: true,
spec: true,
// model: true,
iconURL: true,
greeting: true,
agent_id: true,
instructions: true,
additional_instructions: true,
});
export const compactAgentsSchema = compactAgentsBaseSchema
.transform((obj) => removeNullishValues(obj))
.catch(() => ({}));