librechat-data-provider 0.7.87 → 0.7.89

package/src/schemas.ts

@@ -3,7 +3,6 @@ import { Tools } from './types/assistants';
 import type { TMessageContentParts, FunctionTool, FunctionToolCall } from './types/assistants';
 import { TFeedback, feedbackSchema } from './feedback';
 import type { SearchResultData } from './types/web';
-import type { TEphemeralAgent } from './types';
 import type { TFile } from './types/files';
 
 export const isUUID = z.string().uuid();
@@ -91,22 +90,6 @@ 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;
-  const hasSearchSelected = (ephemeralAgent?.web_search ?? false) === true;
-  return hasMCPSelected || hasCodeSelected || hasSearchSelected;
-};
-
 export const isParamEndpoint = (
   endpoint: EModelEndpoint | string,
   endpointType?: EModelEndpoint | string,
@@ -272,6 +255,18 @@ export const googleSettings = {
     step: 1 as const,
     default: 40 as const,
   },
+  thinking: {
+    default: true as const,
+  },
+  thinkingBudget: {
+    min: -1 as const,
+    max: 32768 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,
+  },
 };
 
 const ANTHROPIC_MAX_OUTPUT = 128000 as const;
@@ -417,7 +412,7 @@ export type TPluginAuthConfig = z.infer<typeof tPluginAuthConfigSchema>;
 export const tPluginSchema = z.object({
   name: z.string(),
   pluginKey: z.string(),
-  description: z.string(),
+  description: z.string().optional(),
   icon: z.string().optional(),
   authConfig: z.array(tPluginAuthConfigSchema).optional(),
   authenticated: z.boolean().optional(),
@@ -802,6 +797,8 @@ export const googleBaseSchema = tConversationSchema.pick({
   artifacts: true,
   topP: true,
   topK: true,
+  thinking: true,
+  thinkingBudget: true,
   iconURL: true,
   greeting: true,
   spec: true,
@@ -827,6 +824,12 @@ export const googleGenConfigSchema = z
     presencePenalty: coerceNumber.optional(),
     frequencyPenalty: coerceNumber.optional(),
     stopSequences: z.array(z.string()).optional(),
+    thinkingConfig: z
+      .object({
+        includeThoughts: z.boolean().optional(),
+        thinkingBudget: coerceNumber.optional(),
+      })
+      .optional(),
   })
   .strip()
   .optional();

package/src/types/agents.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 import { StepTypes, ContentTypes, ToolCallTypes } from './runs';
+import type { TAttachment, TPlugin } from 'src/schemas';
 import type { FunctionToolCall } from './assistants';
-import type { TAttachment } from 'src/schemas';
 
 export namespace Agents {
   export type MessageType = 'human' | 'ai' | 'generic' | 'system' | 'function' | 'tool' | 'remove';
@@ -279,3 +279,79 @@ export type ToolCallResult = {
   conversationId: string;
   attachments?: TAttachment[];
 };
+
+export enum AuthTypeEnum {
+  ServiceHttp = 'service_http',
+  OAuth = 'oauth',
+  None = 'none',
+}
+
+export enum AuthorizationTypeEnum {
+  Bearer = 'bearer',
+  Basic = 'basic',
+  Custom = 'custom',
+}
+
+export enum TokenExchangeMethodEnum {
+  DefaultPost = 'default_post',
+  BasicAuthHeader = 'basic_auth_header',
+}
+
+export type Action = {
+  action_id: string;
+  type?: string;
+  settings?: Record<string, unknown>;
+  metadata: ActionMetadata;
+  version: number | string;
+} & ({ assistant_id: string; agent_id?: never } | { assistant_id?: never; agent_id: string });
+
+export type ActionMetadata = {
+  api_key?: string;
+  auth?: ActionAuth;
+  domain?: string;
+  privacy_policy_url?: string;
+  raw_spec?: string;
+  oauth_client_id?: string;
+  oauth_client_secret?: string;
+};
+
+export type ActionAuth = {
+  authorization_type?: AuthorizationTypeEnum;
+  custom_auth_header?: string;
+  type?: AuthTypeEnum;
+  authorization_content_type?: string;
+  authorization_url?: string;
+  client_url?: string;
+  scope?: string;
+  token_exchange_method?: TokenExchangeMethodEnum;
+};
+
+export type ActionMetadataRuntime = ActionMetadata & {
+  oauth_access_token?: string;
+  oauth_refresh_token?: string;
+  oauth_token_expires_at?: Date;
+};
+
+export type MCP = {
+  mcp_id: string;
+  metadata: MCPMetadata;
+} & ({ assistant_id: string; agent_id?: never } | { assistant_id?: never; agent_id: string });
+
+export type MCPMetadata = Omit<ActionMetadata, 'auth'> & {
+  name?: string;
+  description?: string;
+  url?: string;
+  tools?: string[];
+  auth?: MCPAuth;
+  icon?: string;
+  trust?: boolean;
+};
+
+export type MCPAuth = ActionAuth;
+
+export type AgentToolType = {
+  tool_id: string;
+  metadata: ToolMetadata;
+} & ({ assistant_id: string; agent_id?: never } | { assistant_id?: never; agent_id: string });
+
+export type ToolMetadata = TPlugin;

package/src/types/assistants.ts

@@ -487,60 +487,6 @@ export const actionDomainSeparator = '---';
 export const hostImageIdSuffix = '_host_copy';
 export const hostImageNamePrefix = 'host_copy_';
 
-export enum AuthTypeEnum {
-  ServiceHttp = 'service_http',
-  OAuth = 'oauth',
-  None = 'none',
-}
-
-export enum AuthorizationTypeEnum {
-  Bearer = 'bearer',
-  Basic = 'basic',
-  Custom = 'custom',
-}
-
-export enum TokenExchangeMethodEnum {
-  DefaultPost = 'default_post',
-  BasicAuthHeader = 'basic_auth_header',
-}
-
-export type ActionAuth = {
-  authorization_type?: AuthorizationTypeEnum;
-  custom_auth_header?: string;
-  type?: AuthTypeEnum;
-  authorization_content_type?: string;
-  authorization_url?: string;
-  client_url?: string;
-  scope?: string;
-  token_exchange_method?: TokenExchangeMethodEnum;
-};
-
-export type ActionMetadata = {
-  api_key?: string;
-  auth?: ActionAuth;
-  domain?: string;
-  privacy_policy_url?: string;
-  raw_spec?: string;
-  oauth_client_id?: string;
-  oauth_client_secret?: string;
-};
-
-export type ActionMetadataRuntime = ActionMetadata & {
-  oauth_access_token?: string;
-  oauth_refresh_token?: string;
-  oauth_token_expires_at?: Date;
-};
-
-/* Assistant types */
-
-export type Action = {
-  action_id: string;
-  type?: string;
-  settings?: Record<string, unknown>;
-  metadata: ActionMetadata;
-  version: number | string;
-} & ({ assistant_id: string; agent_id?: never } | { assistant_id?: never; agent_id: string });
-
 export type AssistantAvatar = {
   filepath: string;
   source: string;

package/src/types/files.ts

@@ -10,6 +10,7 @@ export enum FileSources {
   vectordb = 'vectordb',
   execute_code = 'execute_code',
   mistral_ocr = 'mistral_ocr',
+  azure_mistral_ocr = 'azure_mistral_ocr',
   text = 'text',
 }
 
@@ -47,6 +48,12 @@ export type FileConfig = {
   };
   serverFileSizeLimit?: number;
   avatarSizeLimit?: number;
+  clientImageResize?: {
+    enabled?: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+    quality?: number;
+  };
   checkType?: (fileType: string, supportedTypes: RegExp[]) => boolean;
 };
 

package/src/types/mutations.ts

@@ -6,14 +6,13 @@ import {
   Assistant,
   AssistantCreateParams,
   AssistantUpdateParams,
-  ActionMetadata,
   FunctionTool,
   AssistantDocument,
-  Action,
   Agent,
   AgentCreateParams,
   AgentUpdateParams,
 } from './assistants';
+import { Action, ActionMetadata } from './agents';
 
 export type MutationOptions<
   Response,

package/src/types.ts

@@ -98,6 +98,7 @@ export type TEndpointOption = Pick<
 export type TEphemeralAgent = {
   mcp?: string[];
   web_search?: boolean;
+  file_search?: boolean;
   execute_code?: boolean;
 };
 
@@ -133,7 +134,7 @@ export type EventSubmission = Omit<TSubmission, 'initialResponse'> & { initialRe
 export type TPluginAction = {
   pluginKey: string;
   action: 'install' | 'uninstall';
-  auth?: Partial<Record<string, string>>;
+  auth?: Partial<Record<string, string>> | null;
   isEntityTool?: boolean;
 };
 
@@ -143,7 +144,7 @@ export type TUpdateUserPlugins = {
   isEntityTool?: boolean;
   pluginKey: string;
   action: string;
-  auth?: Partial<Record<string, string | null>>;
+  auth?: Partial<Record<string, string | null>> | null;
 };
 
 // TODO `label` needs to be changed to the proper `TranslationKeys`

package/specs/mcp.spec.ts

@@ -1,277 +0,0 @@
-import { StdioOptionsSchema, StreamableHTTPOptionsSchema, processMCPEnv, MCPOptions } from '../src/mcp';
-
-describe('Environment Variable Extraction (MCP)', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    process.env = {
-      ...originalEnv,
-      TEST_API_KEY: 'test-api-key-value',
-      ANOTHER_SECRET: 'another-secret-value',
-    };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  describe('StdioOptionsSchema', () => {
-    it('should transform environment variables in the env field', () => {
-      const options = {
-        command: 'node',
-        args: ['server.js'],
-        env: {
-          API_KEY: '${TEST_API_KEY}',
-          ANOTHER_KEY: '${ANOTHER_SECRET}',
-          PLAIN_VALUE: 'plain-value',
-          NON_EXISTENT: '${NON_EXISTENT_VAR}',
-        },
-      };
-
-      const result = StdioOptionsSchema.parse(options);
-
-      expect(result.env).toEqual({
-        API_KEY: 'test-api-key-value',
-        ANOTHER_KEY: 'another-secret-value',
-        PLAIN_VALUE: 'plain-value',
-        NON_EXISTENT: '${NON_EXISTENT_VAR}',
-      });
-    });
-
-    it('should handle undefined env field', () => {
-      const options = {
-        command: 'node',
-        args: ['server.js'],
-      };
-
-      const result = StdioOptionsSchema.parse(options);
-
-      expect(result.env).toBeUndefined();
-    });
-  });
-
-  describe('StreamableHTTPOptionsSchema', () => {
-    it('should validate a valid streamable-http configuration', () => {
-      const options = {
-        type: 'streamable-http',
-        url: 'https://example.com/api',
-        headers: {
-          Authorization: 'Bearer token',
-          'Content-Type': 'application/json',
-        },
-      };
-
-      const result = StreamableHTTPOptionsSchema.parse(options);
-
-      expect(result).toEqual(options);
-    });
-
-    it('should reject websocket URLs', () => {
-      const options = {
-        type: 'streamable-http',
-        url: 'ws://example.com/socket',
-      };
-
-      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
-    });
-
-    it('should reject secure websocket URLs', () => {
-      const options = {
-        type: 'streamable-http',
-        url: 'wss://example.com/socket',
-      };
-
-      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
-    });
-
-    it('should require type field to be set explicitly', () => {
-      const options = {
-        url: 'https://example.com/api',
-      };
-
-      // Type is now required, so parsing should fail
-      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
-      
-      // With type provided, it should pass
-      const validOptions = {
-        type: 'streamable-http' as const,
-        url: 'https://example.com/api',
-      };
-      
-      const result = StreamableHTTPOptionsSchema.parse(validOptions);
-      expect(result.type).toBe('streamable-http');
-    });
-
-    it('should validate headers as record of strings', () => {
-      const options = {
-        type: 'streamable-http',
-        url: 'https://example.com/api',
-        headers: {
-          'X-API-Key': '123456',
-          'User-Agent': 'MCP Client',
-        },
-      };
-
-      const result = StreamableHTTPOptionsSchema.parse(options);
-      
-      expect(result.headers).toEqual(options.headers);
-    });
-  });
-
-  describe('processMCPEnv', () => {
-    it('should create a deep clone of the input object', () => {
-      const originalObj: MCPOptions = {
-        command: 'node',
-        args: ['server.js'],
-        env: {
-          API_KEY: '${TEST_API_KEY}',
-          PLAIN_VALUE: 'plain-value',
-        },
-      };
-
-      const result = processMCPEnv(originalObj);
-
-      // Verify it's not the same object reference
-      expect(result).not.toBe(originalObj);
-
-      // Modify the result and ensure original is unchanged
-      if ('env' in result && result.env) {
-        result.env.API_KEY = 'modified-value';
-      }
-
-      expect(originalObj.env?.API_KEY).toBe('${TEST_API_KEY}');
-    });
-
-    it('should process environment variables in env field', () => {
-      const obj: MCPOptions = {
-        command: 'node',
-        args: ['server.js'],
-        env: {
-          API_KEY: '${TEST_API_KEY}',
-          ANOTHER_KEY: '${ANOTHER_SECRET}',
-          PLAIN_VALUE: 'plain-value',
-          NON_EXISTENT: '${NON_EXISTENT_VAR}',
-        },
-      };
-
-      const result = processMCPEnv(obj);
-
-      expect('env' in result && result.env).toEqual({
-        API_KEY: 'test-api-key-value',
-        ANOTHER_KEY: 'another-secret-value',
-        PLAIN_VALUE: 'plain-value',
-        NON_EXISTENT: '${NON_EXISTENT_VAR}',
-      });
-    });
-
-    it('should process user ID in headers field', () => {
-      const userId = 'test-user-123';
-      const obj: MCPOptions = {
-        type: 'sse',
-        url: 'https://example.com',
-        headers: {
-          Authorization: '${TEST_API_KEY}',
-          'User-Id': '{{LIBRECHAT_USER_ID}}',
-          'Content-Type': 'application/json',
-        },
-      };
-
-      const result = processMCPEnv(obj, userId);
-
-      expect('headers' in result && result.headers).toEqual({
-        Authorization: 'test-api-key-value',
-        'User-Id': 'test-user-123',
-        'Content-Type': 'application/json',
-      });
-    });
-
-    it('should handle null or undefined input', () => {
-      // @ts-ignore - Testing null/undefined handling
-      expect(processMCPEnv(null)).toBeNull();
-      // @ts-ignore - Testing null/undefined handling
-      expect(processMCPEnv(undefined)).toBeUndefined();
-    });
-
-    it('should not modify objects without env or headers', () => {
-      const obj: MCPOptions = {
-        command: 'node',
-        args: ['server.js'],
-        timeout: 5000,
-      };
-
-      const result = processMCPEnv(obj);
-
-      expect(result).toEqual(obj);
-      expect(result).not.toBe(obj); // Still a different object (deep clone)
-    });
-
-    it('should ensure different users with same starting config get separate values', () => {
-      // Create a single base configuration
-      const baseConfig: MCPOptions = {
-        type: 'sse',
-        url: 'https://example.com',
-        headers: {
-          'User-Id': '{{LIBRECHAT_USER_ID}}',
-          'API-Key': '${TEST_API_KEY}',
-        },
-      };
-
-      // Process for two different users
-      const user1Id = 'user-123';
-      const user2Id = 'user-456';
-
-      const resultUser1 = processMCPEnv(baseConfig, user1Id);
-      const resultUser2 = processMCPEnv(baseConfig, user2Id);
-
-      // Verify each has the correct user ID
-      expect('headers' in resultUser1 && resultUser1.headers?.['User-Id']).toBe(user1Id);
-      expect('headers' in resultUser2 && resultUser2.headers?.['User-Id']).toBe(user2Id);
-
-      // Verify they're different objects
-      expect(resultUser1).not.toBe(resultUser2);
-
-      // Modify one result and ensure it doesn't affect the other
-      if ('headers' in resultUser1 && resultUser1.headers) {
-        resultUser1.headers['User-Id'] = 'modified-user';
-      }
-
-      // Original config should be unchanged
-      expect(baseConfig.headers?.['User-Id']).toBe('{{LIBRECHAT_USER_ID}}');
-
-      // Second user's config should be unchanged
-      expect('headers' in resultUser2 && resultUser2.headers?.['User-Id']).toBe(user2Id);
-    });
-
-    it('should process headers in streamable-http options', () => {
-      const userId = 'test-user-123';
-      const obj: MCPOptions = {
-        type: 'streamable-http',
-        url: 'https://example.com',
-        headers: {
-          Authorization: '${TEST_API_KEY}',
-          'User-Id': '{{LIBRECHAT_USER_ID}}',
-          'Content-Type': 'application/json',
-        },
-      };
-
-      const result = processMCPEnv(obj, userId);
-
-      expect('headers' in result && result.headers).toEqual({
-        Authorization: 'test-api-key-value',
-        'User-Id': 'test-user-123',
-        'Content-Type': 'application/json',
-      });
-    });
-    
-    it('should maintain streamable-http type in processed options', () => {
-      const obj: MCPOptions = {
-        type: 'streamable-http',
-        url: 'https://example.com/api',
-      };
-
-      const result = processMCPEnv(obj);
-
-      expect(result.type).toBe('streamable-http');
-    });
-  });
-});