@librechat/agents 2.4.62 → 2.4.64

package/src/run.ts

@@ -10,10 +10,13 @@ import type {
 import type { ClientCallbacks, SystemCallbacks } from '@/graphs/Graph';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { GraphEvents, Providers, Callback } from '@/common';
+import { GraphEvents, Providers, Callback, TitleMethod } from '@/common';
 import { manualToolStreamProviders } from '@/llm/providers';
 import { shiftIndexTokenCountMap } from '@/messages/format';
-import { createTitleRunnable } from '@/utils/title';
+import {
+  createTitleRunnable,
+  createCompletionTitleRunnable,
+} from '@/utils/title';
 import { createTokenCounter } from '@/utils/tokens';
 import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
@@ -259,9 +262,11 @@ export class Run<T extends t.BaseGraphState> {
     chainOptions,
     skipLanguage,
     omitOptions = defaultOmitOptions,
-  }: t.RunTitleOptions): Promise<{ language: string; title: string }> {
+    titleMethod = TitleMethod.COMPLETION,
+    convoPromptTemplate,
+  }: t.RunTitleOptions): Promise<{ language?: string; title?: string }> {
     const convoTemplate = PromptTemplate.fromTemplate(
-      'User: {input}\nAI: {output}'
+      convoPromptTemplate ?? 'User: {input}\nAI: {output}'
     );
     const response = contentParts
       .map((part) => {
@@ -297,10 +302,13 @@ export class Run<T extends t.BaseGraphState> {
       model.n = (clientOptions as t.OpenAIClientOptions | undefined)
         ?.n as number;
     }
-    const chain = await createTitleRunnable(model, titlePrompt);
+    const chain =
+      titleMethod === TitleMethod.COMPLETION
+        ? await createCompletionTitleRunnable(model, titlePrompt)
+        : await createTitleRunnable(model, titlePrompt);
     return (await chain.invoke(
       { convo, inputText, skipLanguage },
       chainOptions
-    )) as { language: string; title: string };
+    )) as { language?: string; title?: string };
   }
 }

package/src/scripts/simple.ts

@@ -14,9 +14,9 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+import { GraphEvents, Providers, TitleMethod } from '@/common';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
-import { GraphEvents, Providers } from '@/common';
 import { Run } from '@/run';
 
 const conversationHistory: BaseMessage[] = [];

package/src/specs/anthropic.simple.test.ts

@@ -16,8 +16,8 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ContentTypes, GraphEvents, Providers } from '@/common';
 import { capitalizeFirstLetter } from './spec.utils';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
@@ -175,6 +175,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     const titleResult = await run.generateTitle({
       provider,
       inputText: userMessage,
+      titleMethod: TitleMethod.STRUCTURED,
       contentParts,
       chainOptions: {
         callbacks: [
@@ -191,6 +192,62 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     expect(collected).toBeDefined();
   });
 
+  test(`${capitalizeFirstLetter(provider)}: should generate title using completion method`, async () => {
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id-completion',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions:
+          'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    const userMessage =
+      'Can you help me calculate the area of a circle with radius 5?';
+    conversationHistory = [];
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+
+    const { handleLLMEnd, collected } = createMetadataAggregator();
+    const titleResult = await run.generateTitle({
+      provider,
+      inputText: userMessage,
+      titleMethod: TitleMethod.COMPLETION, // Using completion method
+      contentParts,
+      chainOptions: {
+        callbacks: [
+          {
+            handleLLMEnd,
+          },
+        ],
+      },
+    });
+
+    expect(titleResult).toBeDefined();
+    expect(titleResult.title).toBeDefined();
+    expect(titleResult.title).not.toBe('');
+    expect(titleResult.title).not.toBe('Untitled Conversation');
+    // Completion method doesn't return language
+    expect(titleResult.language).toBeUndefined();
+    expect(collected).toBeDefined();
+    console.log(`Completion method generated title: "${titleResult.title}"`);
+  });
+
   test(`${capitalizeFirstLetter(provider)}: should follow-up`, async () => {
     console.log('Previous conversation length:', runningHistory.length);
     console.log(

package/src/specs/openai.simple.test.ts

@@ -16,8 +16,8 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
 import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ContentTypes, GraphEvents, Providers } from '@/common';
 import { capitalizeFirstLetter } from './spec.utils';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';
@@ -175,6 +175,7 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     const titleResult = await run.generateTitle({
       provider,
       inputText: userMessage,
+      titleMethod: TitleMethod.STRUCTURED,
       contentParts,
       chainOptions: {
         callbacks: [
@@ -191,6 +192,61 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     expect(collected).toBeDefined();
   });
 
+  test(`${capitalizeFirstLetter(provider)}: should generate title using completion method`, async () => {
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id-completion',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions:
+          'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    const userMessage = 'What is the weather like today?';
+    conversationHistory = [];
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+
+    const { handleLLMEnd, collected } = createMetadataAggregator();
+    const titleResult = await run.generateTitle({
+      provider,
+      inputText: userMessage,
+      titleMethod: TitleMethod.COMPLETION, // Using completion method
+      contentParts,
+      chainOptions: {
+        callbacks: [
+          {
+            handleLLMEnd,
+          },
+        ],
+      },
+    });
+
+    expect(titleResult).toBeDefined();
+    expect(titleResult.title).toBeDefined();
+    expect(titleResult.title).not.toBe('');
+    expect(titleResult.title).not.toBe('Untitled Conversation');
+    // Completion method doesn't return language
+    expect(titleResult.language).toBeUndefined();
+    expect(collected).toBeDefined();
+    console.log(`Completion method generated title: "${titleResult.title}"`);
+  });
+
   test(`${capitalizeFirstLetter(provider)}: should follow-up`, async () => {
     console.log('Previous conversation length:', runningHistory.length);
     console.log(

package/src/tools/search/firecrawl.ts

@@ -13,6 +13,21 @@ export class FirecrawlScraper {
   private defaultFormats: string[];
   private timeout: number;
   private logger: t.Logger;
+  private includeTags?: string[];
+  private excludeTags?: string[];
+  private waitFor?: number;
+  private maxAge?: number;
+  private mobile?: boolean;
+  private skipTlsVerification?: boolean;
+  private blockAds?: boolean;
+  private removeBase64Images?: boolean;
+  private parsePDF?: boolean;
+  private storeInCache?: boolean;
+  private zeroDataRetention?: boolean;
+  private headers?: Record<string, string>;
+  private location?: { country?: string; languages?: string[] };
+  private onlyMainContent?: boolean;
+  private changeTrackingOptions?: object;
 
   constructor(config: t.FirecrawlScraperConfig = {}) {
     this.apiKey = config.apiKey ?? process.env.FIRECRAWL_API_KEY ?? '';
@@ -23,11 +38,27 @@ export class FirecrawlScraper {
       'https://api.firecrawl.dev';
     this.apiUrl = `${baseUrl.replace(/\/+$/, '')}/v1/scrape`;
 
-    this.defaultFormats = config.formats ?? ['markdown', 'html'];
+    this.defaultFormats = config.formats ?? ['markdown', 'rawHtml'];
     this.timeout = config.timeout ?? 7500;
 
     this.logger = config.logger || createDefaultLogger();
 
+    this.includeTags = config.includeTags;
+    this.excludeTags = config.excludeTags;
+    this.waitFor = config.waitFor;
+    this.maxAge = config.maxAge;
+    this.mobile = config.mobile;
+    this.skipTlsVerification = config.skipTlsVerification;
+    this.blockAds = config.blockAds;
+    this.removeBase64Images = config.removeBase64Images;
+    this.parsePDF = config.parsePDF;
+    this.storeInCache = config.storeInCache;
+    this.zeroDataRetention = config.zeroDataRetention;
+    this.headers = config.headers;
+    this.location = config.location;
+    this.onlyMainContent = config.onlyMainContent;
+    this.changeTrackingOptions = config.changeTrackingOptions;
+
     if (!this.apiKey) {
       this.logger.warn('FIRECRAWL_API_KEY is not set. Scraping will not work.');
     }
@@ -58,25 +89,36 @@ export class FirecrawlScraper {
     }
 
     try {
-      const response = await axios.post(
-        this.apiUrl,
-        {
-          url,
-          formats: options.formats || this.defaultFormats,
-          includeTags: options.includeTags,
-          excludeTags: options.excludeTags,
-          headers: options.headers,
-          waitFor: options.waitFor,
-          timeout: options.timeout ?? this.timeout,
+      const payload = omitUndefined({
+        url,
+        formats: options.formats ?? this.defaultFormats,
+        includeTags: options.includeTags ?? this.includeTags,
+        excludeTags: options.excludeTags ?? this.excludeTags,
+        headers: options.headers ?? this.headers,
+        waitFor: options.waitFor ?? this.waitFor,
+        timeout: options.timeout ?? this.timeout,
+        onlyMainContent: options.onlyMainContent ?? this.onlyMainContent,
+        maxAge: options.maxAge ?? this.maxAge,
+        mobile: options.mobile ?? this.mobile,
+        skipTlsVerification:
+          options.skipTlsVerification ?? this.skipTlsVerification,
+        parsePDF: options.parsePDF ?? this.parsePDF,
+        location: options.location ?? this.location,
+        removeBase64Images:
+          options.removeBase64Images ?? this.removeBase64Images,
+        blockAds: options.blockAds ?? this.blockAds,
+        storeInCache: options.storeInCache ?? this.storeInCache,
+        zeroDataRetention: options.zeroDataRetention ?? this.zeroDataRetention,
+        changeTrackingOptions:
+          options.changeTrackingOptions ?? this.changeTrackingOptions,
+      });
+      const response = await axios.post(this.apiUrl, payload, {
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
         },
-        {
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${this.apiKey}`,
-          },
-          timeout: this.timeout,
-        }
-      );
+        timeout: this.timeout,
+      });
 
       return [url, response.data];
     } catch (error) {
@@ -156,3 +198,10 @@ export const createFirecrawlScraper = (
 ): FirecrawlScraper => {
   return new FirecrawlScraper(config);
 };
+
+// Helper function to clean up payload for firecrawl
+function omitUndefined<T extends object>(obj: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== undefined)
+  ) as Partial<T>;
+}

package/src/tools/search/tool.ts

@@ -346,7 +346,7 @@ export const createSearchTool = (
     safeSearch = 1,
     firecrawlApiKey,
     firecrawlApiUrl,
-    firecrawlFormats = ['markdown', 'html'],
+    firecrawlOptions,
     scraperTimeout,
     jinaApiKey,
     cohereApiKey,
@@ -385,10 +385,11 @@ export const createSearchTool = (
   });
 
   const firecrawlScraper = createFirecrawlScraper({
+    ...firecrawlOptions,
     apiKey: firecrawlApiKey ?? process.env.FIRECRAWL_API_KEY,
     apiUrl: firecrawlApiUrl,
-    timeout: scraperTimeout,
-    formats: firecrawlFormats,
+    timeout: scraperTimeout ?? firecrawlOptions?.timeout,
+    formats: firecrawlOptions?.formats ?? ['markdown', 'rawHtml'],
   });
 
   const selectedReranker = createReranker({

package/src/tools/search/types.ts

@@ -94,7 +94,7 @@ export interface ProcessSourcesConfig {
 export interface FirecrawlConfig {
   firecrawlApiKey?: string;
   firecrawlApiUrl?: string;
-  firecrawlFormats?: string[];
+  firecrawlOptions?: FirecrawlScraperConfig;
 }
 
 export interface ScraperContentResult {
@@ -170,15 +170,10 @@ export type UsedReferences = {
 }[];
 
 /** Firecrawl */
-
-export interface FirecrawlScrapeOptions {
-  formats?: string[];
-  includeTags?: string[];
-  excludeTags?: string[];
-  headers?: Record<string, string>;
-  waitFor?: number;
-  timeout?: number;
-}
+export type FirecrawlScrapeOptions = Omit<
+  FirecrawlScraperConfig,
+  'apiKey' | 'apiUrl' | 'logger'
+>;
 
 export interface ScrapeMetadata {
   // Core source information
@@ -261,6 +256,21 @@ export interface FirecrawlScraperConfig {
   formats?: string[];
   timeout?: number;
   logger?: Logger;
+  includeTags?: string[];
+  excludeTags?: string[];
+  waitFor?: number;
+  maxAge?: number;
+  mobile?: boolean;
+  skipTlsVerification?: boolean;
+  blockAds?: boolean;
+  removeBase64Images?: boolean;
+  parsePDF?: boolean;
+  storeInCache?: boolean;
+  zeroDataRetention?: boolean;
+  headers?: Record<string, string>;
+  location?: { country?: string; languages?: string[] };
+  onlyMainContent?: boolean;
+  changeTrackingOptions?: object;
 }
 
 export type GetSourcesParams = {

package/src/types/run.ts

@@ -33,6 +33,8 @@ export type RunTitleOptions = {
   clientOptions?: l.ClientOptions;
   chainOptions?: Partial<RunnableConfig> | undefined;
   omitOptions?: Set<string>;
+  titleMethod?: e.TitleMethod;
+  convoPromptTemplate?: string;
 };
 
 export interface AgentStateChannels {

package/src/utils/title.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { ChatPromptTemplate } from '@langchain/core/prompts';
 import { RunnableLambda } from '@langchain/core/runnables';
+import { ChatPromptTemplate } from '@langchain/core/prompts';
 import type { Runnable } from '@langchain/core/runnables';
-import * as t from '@/types';
+import type * as t from '@/types';
+import { ContentTypes } from '@/common';
 
 const defaultTitlePrompt = `Analyze this conversation and provide:
 1. The detected language of the conversation
@@ -66,3 +67,47 @@ export const createTitleRunnable = async (
     },
   });
 };
+
+const defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using its same language, with no punctuation. Apply title case conventions appropriate for the language. Never directly mention the language name or the word "title" and only return the title itself.
+
+Conversation:
+{convo}`;
+
+export const createCompletionTitleRunnable = async (
+  model: t.ChatModelInstance,
+  titlePrompt?: string
+): Promise<Runnable> => {
+  const completionPrompt = ChatPromptTemplate.fromTemplate(
+    titlePrompt ?? defaultCompletionPrompt
+  );
+
+  return new RunnableLambda({
+    func: async (input: {
+      convo: string;
+      inputText: string;
+      skipLanguage: boolean;
+    }): Promise<{ title: string }> => {
+      const promptOutput = await completionPrompt.invoke({
+        convo: input.convo,
+      });
+
+      const response = await model.invoke(promptOutput);
+      let content = '';
+      if (typeof response.content === 'string') {
+        content = response.content;
+      } else if (Array.isArray(response.content)) {
+        content = response.content
+          .filter(
+            (part): part is { type: ContentTypes.TEXT; text: string } =>
+              part.type === ContentTypes.TEXT
+          )
+          .map((part) => part.text)
+          .join('');
+      }
+      const title = content.trim();
+      return {
+        title: title || 'Untitled Conversation',
+      };
+    },
+  });
+};