Merge branch 'main' into feat/openid-custom-data

2026-01-29 05:36:13 +01:00 · 2025-04-10 19:13:03 +02:00 · 2025-04-10 19:13:03 +02:00 · f0a42d20a2
commit f0a42d20a2
parent 1cfb9f1b3a e16a6190a5
296 changed files with 9736 additions and 4122 deletions
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@ -51,6 +51,7 @@ export const excludedKeys = new Set([
  'tools',
  'model',
  'files',
+  'spec',
 ]);

 export enum SettingsViews {
@ -236,6 +237,7 @@ export const agentsEndpointSChema = baseEndpointSchema.merge(
    recursionLimit: z.number().optional(),
    disableBuilder: z.boolean().optional(),
    maxRecursionLimit: z.number().optional(),
+    allowedProviders: z.array(z.union([z.string(), eModelEndpointSchema])).optional(),
    capabilities: z
      .array(z.nativeEnum(AgentCapabilities))
      .optional()
@ -862,6 +864,8 @@ export const visionModels = [
  'gemini-exp',
  'gemini-1.5',
  'gemini-2.0',
+  'gemini-2.5',
+  'gemini-3',
  'moondream',
  'llama3.2-vision',
  'llama-3.2-11b-vision',
@ -1005,6 +1009,10 @@ export enum CacheKeys {
   * Key for in-progress flow states.
   */
  FLOWS = 'flows',
+  /**
+   * Key for s3 check intervals per user
+   */
+  S3_EXPIRY_INTERVAL = 'S3_EXPIRY_INTERVAL',
 }

 /**
@ -1097,6 +1105,10 @@ export enum ErrorTypes {
   * Google provider returned an error
   */
  GOOGLE_ERROR = 'google_error',
+  /**
+   * Invalid Agent Provider (excluded by Admin)
+   */
+  INVALID_AGENT_PROVIDER = 'invalid_agent_provider',
 }

 /**
@ -1209,7 +1221,7 @@ export enum Constants {
  /** Key for the app's version. */
  VERSION = 'v0.7.7',
  /** Key for the Custom Config's version (librechat.yaml). */
-  CONFIG_VERSION = '1.2.3',
+  CONFIG_VERSION = '1.2.4',
  /** Standard value for the first message's `parentMessageId` value, to indicate no parent exists. */
  NO_PARENT = '00000000-0000-0000-0000-000000000000',
  /** Standard value for the initial conversationId before a request is sent */
@ -1234,6 +1246,8 @@ export enum Constants {
  GLOBAL_PROJECT_NAME = 'instance',
  /** Delimiter for MCP tools */
  mcp_delimiter = '_mcp_',
+  /** Placeholder Agent ID for Ephemeral Agents */
+  EPHEMERAL_AGENT_ID = 'ephemeral',
 }

 export enum LocalStorageKeys {
@ -1269,6 +1283,10 @@ export enum LocalStorageKeys {
  ENABLE_USER_MSG_MARKDOWN = 'enableUserMsgMarkdown',
  /** Key for displaying analysis tool code input */
  SHOW_ANALYSIS_CODE = 'showAnalysisCode',
+  /** Last selected MCP values per conversation ID */
+  LAST_MCP_ = 'LAST_MCP_',
+  /** Last checked toggle for Code Interpreter API per conversation ID */
+  LAST_CODE_TOGGLE_ = 'LAST_CODE_TOGGLE_',
 }

 export enum ForkOptions {
--- a/packages/data-provider/src/createPayload.ts
+++ b/packages/data-provider/src/createPayload.ts
@ -3,8 +3,15 @@ import { EndpointURLs } from './config';
 import * as s from './schemas';

 export default function createPayload(submission: t.TSubmission) {
-  const { conversation, userMessage, endpointOption, isEdited, isContinued, isTemporary } =
-    submission;
+  const {
+    conversation,
+    userMessage,
+    endpointOption,
+    isEdited,
+    isContinued,
+    isTemporary,
+    ephemeralAgent,
+  } = submission;
  const { conversationId } = s.tConvoUpdateSchema.parse(conversation);
  const { endpoint, endpointType } = endpointOption as {
    endpoint: s.EModelEndpoint;
@ -12,16 +19,20 @@ export default function createPayload(submission: t.TSubmission) {
  };

  let server = EndpointURLs[endpointType ?? endpoint];
+  const isEphemeral = s.isEphemeralAgent(endpoint, ephemeralAgent);

  if (isEdited && s.isAssistantsEndpoint(endpoint)) {
    server += '/modify';
  } else if (isEdited) {
    server = server.replace('/ask/', '/edit/');
+  } else if (isEphemeral) {
+    server = `${EndpointURLs[s.EModelEndpoint.agents]}/${endpoint}`;
  }

  const payload: t.TPayload = {
    ...userMessage,
    ...endpointOption,
+    ephemeralAgent: isEphemeral ? ephemeralAgent : undefined,
    isContinued: !!(isEdited && isContinued),
    conversationId,
    isTemporary,
--- a/packages/data-provider/src/file-config.ts
+++ b/packages/data-provider/src/file-config.ts
@ -112,7 +112,7 @@ export const excelMimeTypes =
  /^application\/(vnd\.ms-excel|msexcel|x-msexcel|x-ms-excel|x-excel|x-dos_ms_excel|xls|x-xls|vnd\.openxmlformats-officedocument\.spreadsheetml\.sheet)$/;

 export const textMimeTypes =
-  /^(text\/(x-c|x-csharp|x-c\+\+|x-java|html|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|css|vtt|javascript|csv))$/;
+  /^(text\/(x-c|x-csharp|tab-separated-values|x-c\+\+|x-java|html|markdown|x-php|x-python|x-script\.python|x-ruby|x-tex|plain|css|vtt|javascript|csv))$/;

 export const applicationMimeTypes =
  /^(application\/(epub\+zip|csv|json|pdf|x-tar|typescript|vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation|spreadsheetml\.sheet)|xml|zip))$/;
@ -152,6 +152,7 @@ export const codeTypeMapping: { [key: string]: string } = {
  yml: 'application/x-yaml',
  yaml: 'application/x-yaml',
  log: 'text/plain',
+  tsv: 'text/tab-separated-values',
 };

 export const retrievalMimeTypes = [
@ -230,7 +231,7 @@ export const convertStringsToRegex = (patterns: string[]): RegExp[] =>
      const regex = new RegExp(pattern);
      acc.push(regex);
    } catch (error) {
-      console.error(`Invalid regex pattern "${pattern}" skipped.`);
+      console.error(`Invalid regex pattern "${pattern}" skipped.`, error);
    }
    return acc;
  }, []);
--- a/packages/data-provider/src/index.ts
+++ b/packages/data-provider/src/index.ts
@ -15,6 +15,7 @@ export * from './models';
 /* mcp */
 export * from './mcp';
 /* RBAC */
+export * from './permissions';
 export * from './roles';
 /* types (exports schemas from `./types` as they contain needed in other defs) */
 export * from './types';
--- a/packages/data-provider/src/mcp.ts
+++ b/packages/data-provider/src/mcp.ts
@ -65,6 +65,7 @@ export const WebSocketOptionsSchema = BaseOptionsSchema.extend({

 export const SSEOptionsSchema = BaseOptionsSchema.extend({
  type: z.literal('sse').optional(),
+  headers: z.record(z.string(), z.string()).optional(),
  url: z
    .string()
    .url()
@ -92,9 +93,10 @@ export type MCPOptions = z.infer<typeof MCPOptionsSchema>;
 /**
 * Recursively processes an object to replace environment variables in string values
 * @param {MCPOptions} obj - The object to process
+ * @param {string} [userId] - The user ID
 * @returns {MCPOptions} - The processed object with environment variables replaced
 */
-export function processMCPEnv(obj: MCPOptions): MCPOptions {
+export function processMCPEnv(obj: MCPOptions, userId?: string): MCPOptions {
  if (obj === null || obj === undefined) {
    return obj;
  }
@ -105,6 +107,16 @@ export function processMCPEnv(obj: MCPOptions): MCPOptions {
      processedEnv[key] = extractEnvVariable(value);
    }
    obj.env = processedEnv;
+  } else if ('headers' in obj && obj.headers) {
+    const processedHeaders: Record<string, string> = {};
+    for (const [key, value] of Object.entries(obj.headers)) {
+      if (value === '{{LIBRECHAT_USER_ID}}' && userId != null && userId) {
+        processedHeaders[key] = userId;
+        continue;
+      }
+      processedHeaders[key] = extractEnvVariable(value);
+    }
+    obj.headers = processedHeaders;
  }

  return obj;
--- a/packages/data-provider/src/models.ts
+++ b/packages/data-provider/src/models.ts
@ -38,6 +38,7 @@ export const specsConfigSchema = z.object({
  enforce: z.boolean().default(false),
  prioritize: z.boolean().default(true),
  list: z.array(tModelSpecSchema).min(1),
+  addedEndpoints: z.array(z.union([z.string(), eModelEndpointSchema])).optional(),
 });

 export type TSpecsConfig = z.infer<typeof specsConfigSchema>;
--- a/packages/data-provider/src/parsers.ts
+++ b/packages/data-provider/src/parsers.ts
@ -13,8 +13,6 @@ import {
  // agentsSchema,
  compactAgentsSchema,
  compactGoogleSchema,
-  compactChatGPTSchema,
-  chatGPTBrowserSchema,
  compactPluginsSchema,
  compactAssistantSchema,
 } from './schemas';
@ -26,19 +24,19 @@ type EndpointSchema =
  | typeof openAISchema
  | typeof googleSchema
  | typeof anthropicSchema
-  | typeof chatGPTBrowserSchema
  | typeof gptPluginsSchema
  | typeof assistantSchema
  | typeof compactAgentsSchema
  | typeof bedrockInputSchema;

-const endpointSchemas: Record<EModelEndpoint, EndpointSchema> = {
+type EndpointSchemaKey = Exclude<EModelEndpoint, EModelEndpoint.chatGPTBrowser>;
+
+const endpointSchemas: Record<EndpointSchemaKey, EndpointSchema> = {
  [EModelEndpoint.openAI]: openAISchema,
  [EModelEndpoint.azureOpenAI]: openAISchema,
  [EModelEndpoint.custom]: openAISchema,
  [EModelEndpoint.google]: googleSchema,
  [EModelEndpoint.anthropic]: anthropicSchema,
-  [EModelEndpoint.chatGPTBrowser]: chatGPTBrowserSchema,
  [EModelEndpoint.gptPlugins]: gptPluginsSchema,
  [EModelEndpoint.assistants]: assistantSchema,
  [EModelEndpoint.azureAssistants]: assistantSchema,
@ -167,8 +165,8 @@ export const parseConvo = ({
  conversation,
  possibleValues,
 }: {
-  endpoint: EModelEndpoint;
-  endpointType?: EModelEndpoint | null;
+  endpoint: EndpointSchemaKey;
+  endpointType?: EndpointSchemaKey | null;
  conversation: Partial<s.TConversation | s.TPreset> | null;
  possibleValues?: TPossibleValues;
  // TODO: POC for default schema
@ -252,7 +250,7 @@ export const getResponseSender = (endpointOption: t.TEndpointOption): string =>
      return modelLabel;
    } else if (model && extractOmniVersion(model)) {
      return extractOmniVersion(model);
-    } else if (model && model.includes('mistral')) {
+    } else if (model && (model.includes('mistral') || model.includes('codestral'))) {
      return 'Mistral';
    } else if (model && model.includes('gpt-')) {
      const gptVersion = extractGPTVersion(model);
@ -288,7 +286,7 @@ export const getResponseSender = (endpointOption: t.TEndpointOption): string =>
      return chatGptLabel;
    } else if (model && extractOmniVersion(model)) {
      return extractOmniVersion(model);
-    } else if (model && model.includes('mistral')) {
+    } else if (model && (model.includes('mistral') || model.includes('codestral'))) {
      return 'Mistral';
    } else if (model && model.includes('gpt-')) {
      const gptVersion = extractGPTVersion(model);
@ -309,11 +307,10 @@ type CompactEndpointSchema =
  | typeof compactAgentsSchema
  | typeof compactGoogleSchema
  | typeof anthropicSchema
-  | typeof compactChatGPTSchema
  | typeof bedrockInputSchema
  | typeof compactPluginsSchema;

-const compactEndpointSchemas: Record<string, CompactEndpointSchema> = {
+const compactEndpointSchemas: Record<EndpointSchemaKey, CompactEndpointSchema> = {
  [EModelEndpoint.openAI]: openAISchema,
  [EModelEndpoint.azureOpenAI]: openAISchema,
  [EModelEndpoint.custom]: openAISchema,
@ -323,7 +320,6 @@ const compactEndpointSchemas: Record<string, CompactEndpointSchema> = {
  [EModelEndpoint.google]: compactGoogleSchema,
  [EModelEndpoint.bedrock]: bedrockInputSchema,
  [EModelEndpoint.anthropic]: anthropicSchema,
-  [EModelEndpoint.chatGPTBrowser]: compactChatGPTSchema,
  [EModelEndpoint.gptPlugins]: compactPluginsSchema,
 };

@ -333,8 +329,8 @@ export const parseCompactConvo = ({
  conversation,
  possibleValues,
 }: {
-  endpoint?: EModelEndpoint;
-  endpointType?: EModelEndpoint | null;
+  endpoint?: EndpointSchemaKey;
+  endpointType?: EndpointSchemaKey | null;
  conversation: Partial<s.TConversation | s.TPreset>;
  possibleValues?: TPossibleValues;
  // TODO: POC for default schema
@ -371,13 +367,30 @@ export const parseCompactConvo = ({
  return convo;
 };

-export function parseTextParts(contentParts: a.TMessageContentParts[]): string {
+export function parseTextParts(
+  contentParts: a.TMessageContentParts[],
+  skipReasoning: boolean = false,
+): string {
  let result = '';

  for (const part of contentParts) {
+    if (!part.type) {
+      continue;
+    }
    if (part.type === ContentTypes.TEXT) {
      const textValue = typeof part.text === 'string' ? part.text : part.text.value;

+      if (
+        result.length > 0 &&
+        textValue.length > 0 &&
+        result[result.length - 1] !== ' ' &&
+        textValue[0] !== ' '
+      ) {
+        result += ' ';
+      }
+      result += textValue;
+    } else if (part.type === ContentTypes.THINK && !skipReasoning) {
+      const textValue = typeof part.think === 'string' ? part.think : '';
      if (
        result.length > 0 &&
        textValue.length > 0 &&
--- a/packages/data-provider/src/permissions.ts
+++ b/packages/data-provider/src/permissions.ts
@ -0,0 +1,90 @@
+import { z } from 'zod';
+
+/**
+ * Enum for Permission Types
+ */
+export enum PermissionTypes {
+  /**
+   * Type for Prompt Permissions
+   */
+  PROMPTS = 'PROMPTS',
+  /**
+   * Type for Bookmark Permissions
+   */
+  BOOKMARKS = 'BOOKMARKS',
+  /**
+   * Type for Agent Permissions
+   */
+  AGENTS = 'AGENTS',
+  /**
+   * Type for Multi-Conversation Permissions
+   */
+  MULTI_CONVO = 'MULTI_CONVO',
+  /**
+   * Type for Temporary Chat
+   */
+  TEMPORARY_CHAT = 'TEMPORARY_CHAT',
+  /**
+   * Type for using the "Run Code" LC Code Interpreter API feature
+   */
+  RUN_CODE = 'RUN_CODE',
+}
+
+/**
+ * Enum for Role-Based Access Control Constants
+ */
+export enum Permissions {
+  SHARED_GLOBAL = 'SHARED_GLOBAL',
+  USE = 'USE',
+  CREATE = 'CREATE',
+  UPDATE = 'UPDATE',
+  READ = 'READ',
+  READ_AUTHOR = 'READ_AUTHOR',
+  SHARE = 'SHARE',
+}
+
+export const promptPermissionsSchema = z.object({
+  [Permissions.SHARED_GLOBAL]: z.boolean().default(false),
+  [Permissions.USE]: z.boolean().default(true),
+  [Permissions.CREATE]: z.boolean().default(true),
+  // [Permissions.SHARE]: z.boolean().default(false),
+});
+export type TPromptPermissions = z.infer<typeof promptPermissionsSchema>;
+
+export const bookmarkPermissionsSchema = z.object({
+  [Permissions.USE]: z.boolean().default(true),
+});
+export type TBookmarkPermissions = z.infer<typeof bookmarkPermissionsSchema>;
+
+export const agentPermissionsSchema = z.object({
+  [Permissions.SHARED_GLOBAL]: z.boolean().default(false),
+  [Permissions.USE]: z.boolean().default(true),
+  [Permissions.CREATE]: z.boolean().default(true),
+  // [Permissions.SHARE]: z.boolean().default(false),
+});
+export type TAgentPermissions = z.infer<typeof agentPermissionsSchema>;
+
+export const multiConvoPermissionsSchema = z.object({
+  [Permissions.USE]: z.boolean().default(true),
+});
+export type TMultiConvoPermissions = z.infer<typeof multiConvoPermissionsSchema>;
+
+export const temporaryChatPermissionsSchema = z.object({
+  [Permissions.USE]: z.boolean().default(true),
+});
+export type TTemporaryChatPermissions = z.infer<typeof temporaryChatPermissionsSchema>;
+
+export const runCodePermissionsSchema = z.object({
+  [Permissions.USE]: z.boolean().default(true),
+});
+export type TRunCodePermissions = z.infer<typeof runCodePermissionsSchema>;
+
+// Define a single permissions schema that holds all permission types.
+export const permissionsSchema = z.object({
+  [PermissionTypes.PROMPTS]: promptPermissionsSchema,
+  [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
+  [PermissionTypes.AGENTS]: agentPermissionsSchema,
+  [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
+  [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
+  [PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
+});
--- a/packages/data-provider/src/roles.ts
+++ b/packages/data-provider/src/roles.ts
@ -1,4 +1,15 @@
 import { z } from 'zod';
+import {
+  Permissions,
+  PermissionTypes,
+  permissionsSchema,
+  agentPermissionsSchema,
+  promptPermissionsSchema,
+  runCodePermissionsSchema,
+  bookmarkPermissionsSchema,
+  multiConvoPermissionsSchema,
+  temporaryChatPermissionsSchema,
+} from './permissions';

 /**
 * Enum for System Defined Roles
@ -14,153 +25,88 @@ export enum SystemRoles {
  USER = 'USER',
 }

-/**
- * Enum for Permission Types
- */
-export enum PermissionTypes {
-  /**
-   * Type for Prompt Permissions
-   */
-  PROMPTS = 'PROMPTS',
-  /**
-   * Type for Bookmark Permissions
-   */
-  BOOKMARKS = 'BOOKMARKS',
-  /**
-   * Type for Agent Permissions
-   */
-  AGENTS = 'AGENTS',
-  /**
-   * Type for Multi-Conversation Permissions
-   */
-  MULTI_CONVO = 'MULTI_CONVO',
-  /**
-   * Type for Temporary Chat
-   */
-  TEMPORARY_CHAT = 'TEMPORARY_CHAT',
-  /**
-   * Type for using the "Run Code" LC Code Interpreter API feature
-   */
-  RUN_CODE = 'RUN_CODE',
-}
-
-/**
- * Enum for Role-Based Access Control Constants
- */
-export enum Permissions {
-  SHARED_GLOBAL = 'SHARED_GLOBAL',
-  USE = 'USE',
-  CREATE = 'CREATE',
-  UPDATE = 'UPDATE',
-  READ = 'READ',
-  READ_AUTHOR = 'READ_AUTHOR',
-  SHARE = 'SHARE',
-}
-
-export const promptPermissionsSchema = z.object({
-  [Permissions.SHARED_GLOBAL]: z.boolean().default(false),
-  [Permissions.USE]: z.boolean().default(true),
-  [Permissions.CREATE]: z.boolean().default(true),
-  // [Permissions.SHARE]: z.boolean().default(false),
-});
-
-export const bookmarkPermissionsSchema = z.object({
-  [Permissions.USE]: z.boolean().default(true),
-});
-
-export const agentPermissionsSchema = z.object({
-  [Permissions.SHARED_GLOBAL]: z.boolean().default(false),
-  [Permissions.USE]: z.boolean().default(true),
-  [Permissions.CREATE]: z.boolean().default(true),
-  // [Permissions.SHARE]: z.boolean().default(false),
-});
-
-export const multiConvoPermissionsSchema = z.object({
-  [Permissions.USE]: z.boolean().default(true),
-});
-
-export const temporaryChatPermissionsSchema = z.object({
-  [Permissions.USE]: z.boolean().default(true),
-});
-
-export const runCodePermissionsSchema = z.object({
-  [Permissions.USE]: z.boolean().default(true),
-});
-
+// The role schema now only needs to reference the permissions schema.
 export const roleSchema = z.object({
  name: z.string(),
-  [PermissionTypes.PROMPTS]: promptPermissionsSchema,
-  [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
-  [PermissionTypes.AGENTS]: agentPermissionsSchema,
-  [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
-  [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
-  [PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
+  permissions: permissionsSchema,
 });

 export type TRole = z.infer<typeof roleSchema>;
-export type TAgentPermissions = z.infer<typeof agentPermissionsSchema>;
-export type TPromptPermissions = z.infer<typeof promptPermissionsSchema>;
-export type TBookmarkPermissions = z.infer<typeof bookmarkPermissionsSchema>;
-export type TMultiConvoPermissions = z.infer<typeof multiConvoPermissionsSchema>;
-export type TTemporaryChatPermissions = z.infer<typeof temporaryChatPermissionsSchema>;
-export type TRunCodePermissions = z.infer<typeof runCodePermissionsSchema>;

+// Define default roles using the new structure.
 const defaultRolesSchema = z.object({
  [SystemRoles.ADMIN]: roleSchema.extend({
    name: z.literal(SystemRoles.ADMIN),
-    [PermissionTypes.PROMPTS]: promptPermissionsSchema.extend({
-      [Permissions.SHARED_GLOBAL]: z.boolean().default(true),
-      [Permissions.USE]: z.boolean().default(true),
-      [Permissions.CREATE]: z.boolean().default(true),
-      // [Permissions.SHARE]: z.boolean().default(true),
-    }),
-    [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema.extend({
-      [Permissions.USE]: z.boolean().default(true),
-    }),
-    [PermissionTypes.AGENTS]: agentPermissionsSchema.extend({
-      [Permissions.SHARED_GLOBAL]: z.boolean().default(true),
-      [Permissions.USE]: z.boolean().default(true),
-      [Permissions.CREATE]: z.boolean().default(true),
-      // [Permissions.SHARE]: z.boolean().default(true),
-    }),
-    [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema.extend({
-      [Permissions.USE]: z.boolean().default(true),
-    }),
-    [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema.extend({
-      [Permissions.USE]: z.boolean().default(true),
-    }),
-    [PermissionTypes.RUN_CODE]: runCodePermissionsSchema.extend({
-      [Permissions.USE]: z.boolean().default(true),
+    permissions: permissionsSchema.extend({
+      [PermissionTypes.PROMPTS]: promptPermissionsSchema.extend({
+        [Permissions.SHARED_GLOBAL]: z.boolean().default(true),
+        [Permissions.USE]: z.boolean().default(true),
+        [Permissions.CREATE]: z.boolean().default(true),
+        // [Permissions.SHARE]: z.boolean().default(true),
+      }),
+      [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema.extend({
+        [Permissions.USE]: z.boolean().default(true),
+      }),
+      [PermissionTypes.AGENTS]: agentPermissionsSchema.extend({
+        [Permissions.SHARED_GLOBAL]: z.boolean().default(true),
+        [Permissions.USE]: z.boolean().default(true),
+        [Permissions.CREATE]: z.boolean().default(true),
+        // [Permissions.SHARE]: z.boolean().default(true),
+      }),
+      [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema.extend({
+        [Permissions.USE]: z.boolean().default(true),
+      }),
+      [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema.extend({
+        [Permissions.USE]: z.boolean().default(true),
+      }),
+      [PermissionTypes.RUN_CODE]: runCodePermissionsSchema.extend({
+        [Permissions.USE]: z.boolean().default(true),
+      }),
    }),
  }),
  [SystemRoles.USER]: roleSchema.extend({
    name: z.literal(SystemRoles.USER),
-    [PermissionTypes.PROMPTS]: promptPermissionsSchema,
-    [PermissionTypes.BOOKMARKS]: bookmarkPermissionsSchema,
-    [PermissionTypes.AGENTS]: agentPermissionsSchema,
-    [PermissionTypes.MULTI_CONVO]: multiConvoPermissionsSchema,
-    [PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
-    [PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
+    permissions: permissionsSchema,
  }),
 });

 export const roleDefaults = defaultRolesSchema.parse({
  [SystemRoles.ADMIN]: {
    name: SystemRoles.ADMIN,
-    [PermissionTypes.PROMPTS]: {},
-    [PermissionTypes.BOOKMARKS]: {},
-    [PermissionTypes.AGENTS]: {},
-    [PermissionTypes.MULTI_CONVO]: {},
-    [PermissionTypes.TEMPORARY_CHAT]: {},
-    [PermissionTypes.RUN_CODE]: {},
+    permissions: {
+      [PermissionTypes.PROMPTS]: {
+        [Permissions.SHARED_GLOBAL]: true,
+        [Permissions.USE]: true,
+        [Permissions.CREATE]: true,
+      },
+      [PermissionTypes.BOOKMARKS]: {
+        [Permissions.USE]: true,
+      },
+      [PermissionTypes.AGENTS]: {
+        [Permissions.SHARED_GLOBAL]: true,
+        [Permissions.USE]: true,
+        [Permissions.CREATE]: true,
+      },
+      [PermissionTypes.MULTI_CONVO]: {
+        [Permissions.USE]: true,
+      },
+      [PermissionTypes.TEMPORARY_CHAT]: {
+        [Permissions.USE]: true,
+      },
+      [PermissionTypes.RUN_CODE]: {
+        [Permissions.USE]: true,
+      },
+    },
  },
  [SystemRoles.USER]: {
    name: SystemRoles.USER,
-    [PermissionTypes.PROMPTS]: {},
-    [PermissionTypes.BOOKMARKS]: {},
-    [PermissionTypes.AGENTS]: {},
-    [PermissionTypes.MULTI_CONVO]: {},
-    [PermissionTypes.TEMPORARY_CHAT]: {},
-    [PermissionTypes.RUN_CODE]: {},
+    permissions: {
+      [PermissionTypes.PROMPTS]: {},
+      [PermissionTypes.BOOKMARKS]: {},
+      [PermissionTypes.AGENTS]: {},
+      [PermissionTypes.MULTI_CONVO]: {},
+      [PermissionTypes.TEMPORARY_CHAT]: {},
+      [PermissionTypes.RUN_CODE]: {},
+    },
  },
 });
--- a/packages/data-provider/src/schemas.ts
+++ b/packages/data-provider/src/schemas.ts
@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Tools } from './types/assistants';
 import type { TMessageContentParts, FunctionTool, FunctionToolCall } from './types/assistants';
+import type { TEphemeralAgent } from './types';
 import type { TFile } from './types/files';

 export const isUUID = z.string().uuid();
@ -88,6 +89,21 @@ export const isAgentsEndpoint = (_endpoint?: EModelEndpoint.agents | null | stri
  return endpoint === EModelEndpoint.agents;
 };

+export const isEphemeralAgent = (
+  endpoint?: EModelEndpoint.agents | null | string,
+  ephemeralAgent?: TEphemeralAgent | null,
+) => {
+  if (!ephemeralAgent) {
+    return false;
+  }
+  if (isAgentsEndpoint(endpoint)) {
+    return false;
+  }
+  const hasMCPSelected = (ephemeralAgent?.mcp?.length ?? 0) > 0;
+  const hasCodeSelected = (ephemeralAgent?.execute_code ?? false) === true;
+  return hasMCPSelected || hasCodeSelected;
+};
+
 export const isParamEndpoint = (
  endpoint: EModelEndpoint | string,
  endpointType?: EModelEndpoint | string,
@ -230,7 +246,7 @@ export const googleSettings = {
  },
  maxOutputTokens: {
    min: 1 as const,
-    max: 8192 as const,
+    max: 64000 as const,
    step: 1 as const,
    default: 8192 as const,
  },
@ -645,6 +661,8 @@ export const tConvoUpdateSchema = tConversationSchema.merge(
 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,
    /**
@ -750,22 +768,23 @@ export const tConversationTagSchema = z.object({
 });
 export type TConversationTag = z.infer<typeof tConversationTagSchema>;

-export const googleSchema = tConversationSchema
-  .pick({
-    model: true,
-    modelLabel: true,
-    promptPrefix: true,
-    examples: true,
-    temperature: true,
-    maxOutputTokens: true,
-    artifacts: true,
-    topP: true,
-    topK: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    maxContextTokens: true,
-  })
+export const googleBaseSchema = tConversationSchema.pick({
+  model: true,
+  modelLabel: true,
+  promptPrefix: true,
+  examples: true,
+  temperature: true,
+  maxOutputTokens: true,
+  artifacts: true,
+  topP: true,
+  topK: true,
+  iconURL: true,
+  greeting: true,
+  spec: true,
+  maxContextTokens: true,
+});
+
+export const googleSchema = googleBaseSchema
  .transform((obj: Partial<TConversation>) => removeNullishValues(obj))
  .catch(() => ({}));

@ -788,36 +807,25 @@ export const googleGenConfigSchema = z
  .strip()
  .optional();

-export const chatGPTBrowserSchema = tConversationSchema
-  .pick({
-    model: true,
-  })
-  .transform((obj) => ({
-    ...obj,
-    model: obj.model ?? 'text-davinci-002-render-sha',
-  }))
-  .catch(() => ({
-    model: 'text-davinci-002-render-sha',
-  }));
+const gptPluginsBaseSchema = tConversationSchema.pick({
+  model: true,
+  modelLabel: true,
+  chatGptLabel: true,
+  promptPrefix: true,
+  temperature: true,
+  artifacts: true,
+  top_p: true,
+  presence_penalty: true,
+  frequency_penalty: true,
+  tools: true,
+  agentOptions: true,
+  iconURL: true,
+  greeting: true,
+  spec: true,
+  maxContextTokens: true,
+});

-export const gptPluginsSchema = tConversationSchema
-  .pick({
-    model: true,
-    modelLabel: true,
-    chatGptLabel: true,
-    promptPrefix: true,
-    temperature: true,
-    artifacts: true,
-    top_p: true,
-    presence_penalty: true,
-    frequency_penalty: true,
-    tools: true,
-    agentOptions: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    maxContextTokens: true,
-  })
+export const gptPluginsSchema = gptPluginsBaseSchema
  .transform((obj) => {
    const result = {
      ...obj,
@ -887,18 +895,19 @@ export function removeNullishValues<T extends Record<string, unknown>>(
  return newObj;
 }

-export const assistantSchema = tConversationSchema
-  .pick({
-    model: true,
-    assistant_id: true,
-    instructions: true,
-    artifacts: true,
-    promptPrefix: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    append_current_datetime: true,
-  })
+const assistantBaseSchema = tConversationSchema.pick({
+  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,
@ -921,37 +930,39 @@ export const assistantSchema = tConversationSchema
    append_current_datetime: false,
  }));

-export const compactAssistantSchema = tConversationSchema
-  .pick({
-    model: true,
-    assistant_id: true,
-    instructions: true,
-    promptPrefix: true,
-    artifacts: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-  })
+const compactAssistantBaseSchema = tConversationSchema.pick({
+  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 agentsSchema = tConversationSchema
-  .pick({
-    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 agentsBaseSchema = tConversationSchema.pick({
+  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,
@ -987,46 +998,32 @@ export const agentsSchema = tConversationSchema
    maxContextTokens: undefined,
  }));

-export const openAISchema = tConversationSchema
-  .pick({
-    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,
-  })
+export const openAIBaseSchema = tConversationSchema.pick({
+  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,
+});
+
+export const openAISchema = openAIBaseSchema
  .transform((obj: Partial<TConversation>) => removeNullishValues(obj))
  .catch(() => ({}));

-export const compactGoogleSchema = tConversationSchema
-  .pick({
-    model: true,
-    modelLabel: true,
-    promptPrefix: true,
-    examples: true,
-    temperature: true,
-    maxOutputTokens: true,
-    artifacts: true,
-    topP: true,
-    topK: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    maxContextTokens: true,
-  })
+export const compactGoogleSchema = googleBaseSchema
  .transform((obj) => {
    const newObj: Partial<TConversation> = { ...obj };
    if (newObj.temperature === google.temperature.default) {
@ -1046,55 +1043,30 @@ export const compactGoogleSchema = tConversationSchema
  })
  .catch(() => ({}));

-export const anthropicSchema = tConversationSchema
-  .pick({
-    model: true,
-    modelLabel: true,
-    promptPrefix: true,
-    temperature: true,
-    maxOutputTokens: true,
-    topP: true,
-    topK: true,
-    resendFiles: true,
-    promptCache: true,
-    thinking: true,
-    thinkingBudget: true,
-    artifacts: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    maxContextTokens: true,
-  })
+export const anthropicBaseSchema = tConversationSchema.pick({
+  model: true,
+  modelLabel: true,
+  promptPrefix: true,
+  temperature: true,
+  maxOutputTokens: true,
+  topP: true,
+  topK: true,
+  resendFiles: true,
+  promptCache: true,
+  thinking: true,
+  thinkingBudget: true,
+  artifacts: true,
+  iconURL: true,
+  greeting: true,
+  spec: true,
+  maxContextTokens: true,
+});
+
+export const anthropicSchema = anthropicBaseSchema
  .transform((obj) => removeNullishValues(obj))
  .catch(() => ({}));

-export const compactChatGPTSchema = tConversationSchema
-  .pick({
-    model: true,
-  })
-  .transform((obj) => {
-    const newObj: Partial<TConversation> = { ...obj };
-    return removeNullishValues(newObj);
-  })
-  .catch(() => ({}));
-
-export const compactPluginsSchema = tConversationSchema
-  .pick({
-    model: true,
-    modelLabel: true,
-    chatGptLabel: true,
-    promptPrefix: true,
-    temperature: true,
-    top_p: true,
-    presence_penalty: true,
-    frequency_penalty: true,
-    tools: true,
-    agentOptions: true,
-    iconURL: true,
-    greeting: true,
-    spec: true,
-    maxContextTokens: true,
-  })
+export const compactPluginsSchema = gptPluginsBaseSchema
  .transform((obj) => {
    const newObj: Partial<TConversation> = { ...obj };
    if (newObj.modelLabel === null) {
@ -1147,15 +1119,16 @@ export const tBannerSchema = z.object({
 });
 export type TBanner = z.infer<typeof tBannerSchema>;

-export const compactAgentsSchema = tConversationSchema
-  .pick({
-    spec: true,
-    // model: true,
-    iconURL: true,
-    greeting: true,
-    agent_id: true,
-    instructions: true,
-    additional_instructions: true,
-  })
+export const compactAgentsBaseSchema = tConversationSchema.pick({
+  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(() => ({}));
--- a/packages/data-provider/src/types.ts
+++ b/packages/data-provider/src/types.ts
@ -18,6 +18,8 @@ export type TMessages = TMessage[];

 /* TODO: Cleanup EndpointOption types */
 export type TEndpointOption = {
+  spec?: string | null;
+  iconURL?: string | null;
  endpoint: EModelEndpoint;
  endpointType?: EModelEndpoint;
  modelDisplayLabel?: string;
@ -39,12 +41,18 @@ export type TEndpointOption = {
  overrideUserMessageId?: string;
 };

+export type TEphemeralAgent = {
+  mcp?: string[];
+  execute_code?: boolean;
+};
+
 export type TPayload = Partial<TMessage> &
  Partial<TEndpointOption> & {
    isContinued: boolean;
    conversationId: string | null;
    messages?: TMessages;
    isTemporary: boolean;
+    ephemeralAgent?: TEphemeralAgent | null;
  };

 export type TSubmission = {
@ -57,11 +65,11 @@ export type TSubmission = {
  isTemporary: boolean;
  messages: TMessage[];
  isRegenerate?: boolean;
-  conversationId?: string;
  initialResponse?: TMessage;
  conversation: Partial<TConversation>;
  endpointOption: TEndpointOption;
  clientTimestamp?: string;
+  ephemeralAgent?: TEphemeralAgent | null;
 };

 export type EventSubmission = Omit<TSubmission, 'initialResponse'> & { initialResponse: TMessage };
--- a/packages/data-provider/src/types/assistants.ts
+++ b/packages/data-provider/src/types/assistants.ts
@ -448,7 +448,7 @@ export type ContentPart = (
  PartMetadata;

 export type TMessageContentParts =
-  | { type: ContentTypes.ERROR; text: Text & PartMetadata }
+  | { type: ContentTypes.ERROR; text?: string | (Text & PartMetadata); error?: string }
  | { type: ContentTypes.THINK; think: string | (Text & PartMetadata) }
  | { type: ContentTypes.TEXT; text: string | (Text & PartMetadata); tool_call_ids?: string[] }
  | {
--- a/packages/data-provider/src/types/files.ts
+++ b/packages/data-provider/src/types/files.ts
@ -4,6 +4,7 @@ export enum FileSources {
  local = 'local',
  firebase = 'firebase',
  azure = 'azure',
+  azure_blob = 'azure_blob',
  openai = 'openai',
  s3 = 's3',
  vectordb = 'vectordb',
--- a/packages/data-provider/src/types/mutations.ts
+++ b/packages/data-provider/src/types/mutations.ts
@ -1,5 +1,6 @@
 import * as types from '../types';
 import * as r from '../roles';
+import * as p from '../permissions';
 import {
  Tools,
  Assistant,
@ -251,9 +252,9 @@ export type UpdatePermVars<T> = {
  updates: Partial<T>;
 };

-export type UpdatePromptPermVars = UpdatePermVars<r.TPromptPermissions>;
+export type UpdatePromptPermVars = UpdatePermVars<p.TPromptPermissions>;

-export type UpdateAgentPermVars = UpdatePermVars<r.TAgentPermissions>;
+export type UpdateAgentPermVars = UpdatePermVars<p.TAgentPermissions>;

 export type UpdatePermResponse = r.TRole;

--- a/packages/data-provider/src/zod.spec.ts
+++ b/packages/data-provider/src/zod.spec.ts
@ -1,4 +1,3 @@
-/* eslint-disable jest/no-conditional-expect */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // zod.spec.ts
 import { z } from 'zod';
@ -468,6 +467,156 @@ describe('convertJsonSchemaToZod', () => {
    });
  });

+  describe('additionalProperties handling', () => {
+    it('should allow any additional properties when additionalProperties is true', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+        },
+        additionalProperties: true,
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Should accept the defined property
+      expect(zodSchema?.parse({ name: 'John' })).toEqual({ name: 'John' });
+
+      // Should also accept additional properties of any type
+      expect(zodSchema?.parse({ name: 'John', age: 30 })).toEqual({ name: 'John', age: 30 });
+      expect(zodSchema?.parse({ name: 'John', isActive: true })).toEqual({
+        name: 'John',
+        isActive: true,
+      });
+      expect(zodSchema?.parse({ name: 'John', tags: ['tag1', 'tag2'] })).toEqual({
+        name: 'John',
+        tags: ['tag1', 'tag2'],
+      });
+    });
+
+    it('should validate additional properties according to schema when additionalProperties is an object', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+        },
+        additionalProperties: { type: 'number' },
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Should accept the defined property
+      expect(zodSchema?.parse({ name: 'John' })).toEqual({ name: 'John' });
+
+      // Should accept additional properties that match the additionalProperties schema
+      expect(zodSchema?.parse({ name: 'John', age: 30, score: 100 })).toEqual({
+        name: 'John',
+        age: 30,
+        score: 100,
+      });
+
+      // Should reject additional properties that don't match the additionalProperties schema
+      expect(() => zodSchema?.parse({ name: 'John', isActive: true })).toThrow();
+      expect(() => zodSchema?.parse({ name: 'John', tags: ['tag1', 'tag2'] })).toThrow();
+    });
+
+    it('should strip additional properties when additionalProperties is false or not specified', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+        additionalProperties: false,
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      // Should accept the defined properties
+      expect(zodSchema?.parse({ name: 'John', age: 30 })).toEqual({ name: 'John', age: 30 });
+
+      // Current implementation strips additional properties when additionalProperties is false
+      const objWithExtra = { name: 'John', age: 30, isActive: true };
+      expect(zodSchema?.parse(objWithExtra)).toEqual({ name: 'John', age: 30 });
+
+      // Test with additionalProperties not specified (should behave the same)
+      const schemaWithoutAdditionalProps: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'number' },
+        },
+      };
+      const zodSchemaWithoutAdditionalProps = convertJsonSchemaToZod(schemaWithoutAdditionalProps);
+
+      expect(zodSchemaWithoutAdditionalProps?.parse({ name: 'John', age: 30 })).toEqual({
+        name: 'John',
+        age: 30,
+      });
+
+      // Current implementation strips additional properties when additionalProperties is not specified
+      const objWithExtra2 = { name: 'John', age: 30, isActive: true };
+      expect(zodSchemaWithoutAdditionalProps?.parse(objWithExtra2)).toEqual({
+        name: 'John',
+        age: 30,
+      });
+    });
+
+    it('should handle complex nested objects with additionalProperties', () => {
+      const schema: JsonSchemaType = {
+        type: 'object',
+        properties: {
+          user: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              profile: {
+                type: 'object',
+                properties: {
+                  bio: { type: 'string' },
+                },
+                additionalProperties: true,
+              },
+            },
+            additionalProperties: { type: 'string' },
+          },
+        },
+        additionalProperties: false,
+      };
+      const zodSchema = convertJsonSchemaToZod(schema);
+
+      const validData = {
+        user: {
+          name: 'John',
+          profile: {
+            bio: 'Developer',
+            location: 'New York', // Additional property allowed in profile
+            website: 'https://example.com', // Additional property allowed in profile
+          },
+          role: 'admin', // Additional property of type string allowed in user
+          level: 'senior', // Additional property of type string allowed in user
+        },
+      };
+
+      expect(zodSchema?.parse(validData)).toEqual(validData);
+
+      // Current implementation strips additional properties at the top level
+      // when additionalProperties is false
+      const dataWithExtraTopLevel = {
+        user: { name: 'John' },
+        extraField: 'not allowed', // This should be stripped
+      };
+      expect(zodSchema?.parse(dataWithExtraTopLevel)).toEqual({ user: { name: 'John' } });
+
+      // Should reject additional properties in user that don't match the string type
+      expect(() =>
+        zodSchema?.parse({
+          user: {
+            name: 'John',
+            age: 30, // Not a string
+          },
+        }),
+      ).toThrow();
+    });
+  });
+
  describe('empty object handling', () => {
    it('should return undefined for empty object schemas when allowEmptyObject is false', () => {
      const emptyObjectSchemas = [
--- a/packages/data-provider/src/zod.ts
+++ b/packages/data-provider/src/zod.ts
@ -7,6 +7,7 @@ export type JsonSchemaType = {
  properties?: Record<string, JsonSchemaType>;
  required?: string[];
  description?: string;
+  additionalProperties?: boolean | JsonSchemaType;
 };

 function isEmptyObjectSchema(jsonSchema?: JsonSchemaType): boolean {
@ -72,7 +73,20 @@ export function convertJsonSchemaToZod(
    } else {
      objectSchema = objectSchema.partial();
    }
-    zodSchema = objectSchema;
+
+    // Handle additionalProperties for open-ended objects
+    if (schema.additionalProperties === true) {
+      // This allows any additional properties with any type
+      zodSchema = objectSchema.passthrough();
+    } else if (typeof schema.additionalProperties === 'object') {
+      // For specific additional property types
+      const additionalSchema = convertJsonSchemaToZod(
+        schema.additionalProperties as JsonSchemaType,
+      );
+      zodSchema = objectSchema.catchall(additionalSchema as z.ZodType);
+    } else {
+      zodSchema = objectSchema;
+    }
  } else {
    zodSchema = z.unknown();
  }