@librechat/agents 3.2.56 → 3.2.58

package/src/tools/search/rerankers.ts

@@ -4,6 +4,11 @@ import { createDefaultLogger, formatErrorForLog } from './utils';
 
 const DEFAULT_JINA_API_URL = 'https://api.jina.ai/v1/rerank';
 
+/** Every other network call in the search pipeline is bounded (scrapers,
+ * search providers); rerank requests must be too, or a hung rerank API
+ * stalls the whole tool. */
+const DEFAULT_RERANKER_TIMEOUT = 10000;
+
 const getDefaultJinaApiUrl = (): string =>
   process.env.JINA_API_URL != null && process.env.JINA_API_URL !== ''
     ? process.env.JINA_API_URL
@@ -36,19 +41,23 @@ export abstract class BaseReranker {
 
 export class JinaReranker extends BaseReranker {
   private apiUrl: string;
+  private timeout: number;
 
   constructor({
     apiKey = process.env.JINA_API_KEY,
     apiUrl = getDefaultJinaApiUrl(),
+    timeout = DEFAULT_RERANKER_TIMEOUT,
     logger,
   }: {
     apiKey?: string;
     apiUrl?: string;
+    timeout?: number;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
     this.apiUrl = apiUrl;
+    this.timeout = timeout;
   }
 
   async rerank(
@@ -56,7 +65,9 @@ export class JinaReranker extends BaseReranker {
     documents: string[],
     topK: number = 5
   ): Promise<t.Highlight[]> {
-    this.logger.debug(`Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`);
+    this.logger.debug(
+      `Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`
+    );
 
     try {
       if (this.apiKey == null || this.apiKey === '') {
@@ -80,6 +91,7 @@ export class JinaReranker extends BaseReranker {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${this.apiKey}`,
           },
+          timeout: this.timeout,
         }
       );
 
@@ -122,15 +134,20 @@ export class JinaReranker extends BaseReranker {
 }
 
 export class CohereReranker extends BaseReranker {
+  private timeout: number;
+
   constructor({
     apiKey = process.env.COHERE_API_KEY,
+    timeout = DEFAULT_RERANKER_TIMEOUT,
     logger,
   }: {
     apiKey?: string;
+    timeout?: number;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
+    this.timeout = timeout;
   }
 
   async rerank(
@@ -161,6 +178,7 @@ export class CohereReranker extends BaseReranker {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${this.apiKey}`,
           },
+          timeout: this.timeout,
         }
       );
 
@@ -218,19 +236,33 @@ export const createReranker = (config: {
   jinaApiKey?: string;
   jinaApiUrl?: string;
   cohereApiKey?: string;
+  rerankerTimeout?: number;
   logger?: t.Logger;
 }): BaseReranker | undefined => {
-  const { rerankerType, jinaApiKey, jinaApiUrl, cohereApiKey, logger } = config;
+  const {
+    rerankerType,
+    jinaApiKey,
+    jinaApiUrl,
+    cohereApiKey,
+    rerankerTimeout,
+    logger,
+  } = config;
 
   // Create a default logger if none is provided
   const defaultLogger = logger || createDefaultLogger();
 
   switch (rerankerType.toLowerCase()) {
   case 'jina':
-    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
+    return new JinaReranker({
+      apiKey: jinaApiKey,
+      apiUrl: jinaApiUrl,
+      timeout: rerankerTimeout,
+      logger: defaultLogger,
+    });
   case 'cohere':
     return new CohereReranker({
       apiKey: cohereApiKey,
+      timeout: rerankerTimeout,
       logger: defaultLogger,
     });
   case 'infinity':
@@ -242,7 +274,12 @@ export const createReranker = (config: {
     defaultLogger.warn(
       `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
     );
-    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
+    return new JinaReranker({
+      apiKey: jinaApiKey,
+      apiUrl: jinaApiUrl,
+      timeout: rerankerTimeout,
+      logger: defaultLogger,
+    });
   }
 };
 

package/src/tools/search/search.ts

@@ -2,6 +2,7 @@ import axios from 'axios';
 import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 import type * as t from './types';
 import { getAttribution, createDefaultLogger } from './utils';
+import { createKeenableAPI } from './keenable-search';
 import { createTavilyAPI } from './tavily-search';
 import { BaseReranker } from './rerankers';
 
@@ -67,6 +68,43 @@ const chunker = {
 };
 
 const DEFAULT_MAX_CONTENT_LENGTH = 50000;
+const DEFAULT_CHUNK_SIZE = 150;
+const DEFAULT_CHUNK_OVERLAP = 50;
+
+/** Resolves reranker chunking from config, the `SEARCH_CHUNK_SIZE` /
+ * `SEARCH_CHUNK_OVERLAP` env vars, or the defaults (150 / 50 chars). The
+ * overlap is clamped below the chunk size — `RecursiveCharacterTextSplitter`
+ * throws when overlap >= size. */
+function resolveChunkOptions(
+  chunkSize?: number,
+  chunkOverlap?: number
+): { chunkSize: number; chunkOverlap: number } {
+  const resolve = (
+    configValue: number | undefined,
+    envVar: string,
+    fallback: number
+  ): number => {
+    if (configValue != null && configValue > 0) {
+      return configValue;
+    }
+    const envValue = Number(process.env[envVar]);
+    if (Number.isFinite(envValue) && envValue > 0) {
+      return envValue;
+    }
+    return fallback;
+  };
+
+  const size = resolve(chunkSize, 'SEARCH_CHUNK_SIZE', DEFAULT_CHUNK_SIZE);
+  let overlap = resolve(
+    chunkOverlap,
+    'SEARCH_CHUNK_OVERLAP',
+    DEFAULT_CHUNK_OVERLAP
+  );
+  if (overlap >= size) {
+    overlap = Math.floor(size / 3);
+  }
+  return { chunkSize: size, chunkOverlap: overlap };
+}
 
 /** Resolves the per-source scraped content cap from config, the
  * `SEARCH_MAX_CONTENT_LENGTH` env var, or the default (50,000 chars) */
@@ -103,6 +141,7 @@ const getHighlights = async ({
   reranker,
   topResults = 5,
   maxContentLength = DEFAULT_MAX_CONTENT_LENGTH,
+  chunkOptions,
   logger,
 }: {
   content: string;
@@ -110,6 +149,7 @@ const getHighlights = async ({
   reranker?: BaseReranker;
   topResults?: number;
   maxContentLength?: number;
+  chunkOptions?: { chunkSize: number; chunkOverlap: number };
   logger?: t.Logger;
 }): Promise<t.Highlight[] | undefined> => {
   const logger_ = logger || createDefaultLogger();
@@ -125,7 +165,8 @@ const getHighlights = async ({
 
   try {
     const documents = await chunker.splitText(
-      truncateContent(content, maxContentLength)
+      truncateContent(content, maxContentLength),
+      chunkOptions
     );
     if (Array.isArray(documents)) {
       return await reranker.rerank(query, documents, topResults);
@@ -445,6 +486,9 @@ export const createSearchAPI = (
     tavilyApiKey,
     tavilySearchUrl,
     tavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
   } = config;
 
   if (searchProvider.toLowerCase() === 'serper') {
@@ -453,9 +497,15 @@ export const createSearchAPI = (
     return createSearXNGAPI(searxngInstanceUrl, searxngApiKey);
   } else if (searchProvider.toLowerCase() === 'tavily') {
     return createTavilyAPI(tavilyApiKey, tavilySearchUrl, tavilySearchOptions);
+  } else if (searchProvider.toLowerCase() === 'keenable') {
+    return createKeenableAPI(
+      keenableApiKey,
+      keenableApiUrl,
+      keenableSearchOptions
+    );
   } else {
     throw new Error(
-      `Invalid search provider: ${searchProvider}. Must be 'serper', 'searxng', or 'tavily'`
+      `Invalid search provider: ${searchProvider}. Must be 'serper', 'searxng', 'tavily', or 'keenable'`
     );
   }
 };
@@ -481,6 +531,10 @@ export const createSourceProcessor = (
   } = config;
 
   const maxContentLength = resolveMaxContentLength(config.maxContentLength);
+  const chunkOptions = resolveChunkOptions(
+    config.chunkSize,
+    config.chunkOverlap
+  );
   const logger_ = logger || createDefaultLogger();
   const scraper = scraperInstance;
 
@@ -521,8 +575,10 @@ export const createSourceProcessor = (
       const highlights = await getHighlights({
         query,
         reranker,
+        topResults,
         content: result.content,
         maxContentLength,
+        chunkOptions,
         logger: logger_,
       });
       if (onGetHighlights) {

package/src/tools/search/source-processing.test.ts

@@ -14,6 +14,7 @@ const silentLogger = {
 
 class RecordingReranker extends BaseReranker {
   public rerankCalls: string[][] = [];
+  public topKCalls: number[] = [];
 
   constructor() {
     super(silentLogger);
@@ -25,6 +26,7 @@ class RecordingReranker extends BaseReranker {
     topK: number = 5
   ): Promise<t.Highlight[]> {
     this.rerankCalls.push(documents);
+    this.topKCalls.push(topK);
     return this.getDefaultRanking(documents, topK);
   }
 }
@@ -212,6 +214,90 @@ describe('createSourceProcessor content capping', () => {
 
     expect(data.organic?.[0].content?.length).toBe(50000);
   });
+
+  test('passes configured topResults through to the reranker', async () => {
+    const reranker = new RecordingReranker();
+    const scraper = createFakeScraper({ [link]: makeLongContent(3000) });
+    const processor = createSourceProcessor(
+      { reranker, topResults: 2, logger: silentLogger },
+      scraper
+    );
+
+    await processor.processSources({
+      ...baseFields,
+      news: false,
+      numElements: 5,
+      result: { success: true, data: { organic: [makeOrganic(link)] } },
+    });
+
+    expect(reranker.topKCalls).toEqual([2]);
+  });
+});
+
+describe('createSourceProcessor reranker chunking', () => {
+  const link = 'https://a.com';
+  const baseFields = {
+    query: 'test query',
+    proMode: true,
+    onGetHighlights: undefined,
+  };
+
+  const runWithConfig = async (
+    config: Partial<t.ProcessSourcesConfig>
+  ): Promise<string[]> => {
+    const reranker = new RecordingReranker();
+    const scraper = createFakeScraper({ [link]: makeLongContent(10000) });
+    const processor = createSourceProcessor(
+      { reranker, logger: silentLogger, ...config },
+      scraper
+    );
+
+    await processor.processSources({
+      ...baseFields,
+      news: false,
+      numElements: 5,
+      result: { success: true, data: { organic: [makeOrganic(link)] } },
+    });
+
+    return reranker.rerankCalls[0] ?? [];
+  };
+
+  test('configured chunkSize produces fewer, larger chunks', async () => {
+    const defaultDocs = await runWithConfig({});
+    const largeDocs = await runWithConfig({
+      chunkSize: 500,
+      chunkOverlap: 100,
+    });
+
+    expect(defaultDocs.length).toBeGreaterThan(0);
+    expect(largeDocs.length).toBeGreaterThan(0);
+    expect(largeDocs.length).toBeLessThan(defaultDocs.length);
+    expect(Math.max(...defaultDocs.map((d) => d.length))).toBeLessThanOrEqual(
+      150
+    );
+    expect(Math.max(...largeDocs.map((d) => d.length))).toBeLessThanOrEqual(
+      500
+    );
+  });
+
+  test('respects SEARCH_CHUNK_SIZE env vars when config is not set', async () => {
+    process.env.SEARCH_CHUNK_SIZE = '500';
+    process.env.SEARCH_CHUNK_OVERLAP = '100';
+    try {
+      const docs = await runWithConfig({});
+      expect(docs.length).toBeGreaterThan(0);
+      expect(Math.max(...docs.map((d) => d.length))).toBeLessThanOrEqual(500);
+    } finally {
+      delete process.env.SEARCH_CHUNK_SIZE;
+      delete process.env.SEARCH_CHUNK_OVERLAP;
+    }
+  });
+
+  test('clamps overlap below chunk size instead of throwing', async () => {
+    const docs = await runWithConfig({ chunkSize: 200, chunkOverlap: 300 });
+    expect(docs.length).toBeGreaterThan(0);
+    expect(Math.max(...docs.map((d) => d.length))).toBeLessThanOrEqual(200);
+  });
 });
 
 describe('createSourceProcessor topStories capping', () => {

package/src/tools/search/tool.ts

@@ -197,13 +197,17 @@ export async function executeParallelSearches({
 function createSearchProcessor({
   searchAPI,
   safeSearch,
+  supportsImages,
   supportsVideos,
+  supportsNews,
   sourceProcessor,
   onGetHighlights,
   logger,
 }: {
   safeSearch: t.SearchToolConfig['safeSearch'];
+  supportsImages: boolean;
   supportsVideos: boolean;
+  supportsNews: boolean;
   searchAPI: ReturnType<typeof createSearchAPI>;
   sourceProcessor: ReturnType<typeof createSourceProcessor>;
   onGetHighlights: t.SearchToolConfig['onGetHighlights'];
@@ -238,9 +242,9 @@ function createSearchProcessor({
         date,
         country,
         safeSearch,
-        images,
+        images: supportsImages && images,
         videos: supportsVideos && videos,
-        news,
+        news: supportsNews && news,
         logger,
       });
 
@@ -315,7 +319,11 @@ function createTool({
         }),
       });
       const turn = runnableConfig.toolCall?.turn ?? 0;
-      const { output, references } = formatResultsForLLM(turn, searchResult, maxOutputChars);
+      const { output, references } = formatResultsForLLM(
+        turn,
+        searchResult,
+        maxOutputChars
+      );
       const data: t.SearchResultData = { turn, ...searchResult, references };
       return [output, { [Constants.WEB_SEARCH]: data }];
     },
@@ -358,9 +366,15 @@ export const createSearchTool = (
     tavilySearchUrl,
     tavilyExtractUrl,
     tavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
     rerankerType = 'cohere',
+    rerankerTimeout,
     topResults = 5,
     maxContentLength,
+    chunkSize,
+    chunkOverlap,
     maxOutputChars,
     strategies = ['no_extraction'],
     filterContent = true,
@@ -415,6 +429,9 @@ export const createSearchTool = (
     tavilyApiKey,
     tavilySearchUrl,
     tavilySearchOptions: effectiveTavilySearchOptions,
+    keenableApiKey,
+    keenableApiUrl,
+    keenableSearchOptions,
   });
 
   /** Create scraper based on scraperProvider */
@@ -455,6 +472,7 @@ export const createSearchTool = (
     jinaApiKey,
     jinaApiUrl,
     cohereApiKey,
+    rerankerTimeout,
     logger,
   });
 
@@ -467,6 +485,8 @@ export const createSearchTool = (
       reranker: selectedReranker,
       topResults,
       maxContentLength,
+      chunkSize,
+      chunkOverlap,
       strategies,
       filterContent,
       logger,
@@ -477,7 +497,12 @@ export const createSearchTool = (
   const search = createSearchProcessor({
     searchAPI,
     safeSearch,
-    supportsVideos: searchProvider !== 'tavily',
+    // Keenable is organic-only: its API ignores `type`, so image/news
+    // sub-searches would spend rate limit and merge nothing.
+    supportsImages: searchProvider !== 'keenable',
+    supportsVideos:
+      searchProvider !== 'tavily' && searchProvider !== 'keenable',
+    supportsNews: searchProvider !== 'keenable',
     sourceProcessor,
     onGetHighlights,
     logger,

package/src/tools/search/types.ts

@@ -3,7 +3,7 @@ import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 
-export type SearchProvider = 'serper' | 'searxng' | 'tavily';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable';
 export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 
@@ -115,6 +115,36 @@ export interface SearchConfig {
   tavilySearchUrl?: string;
   tavilyExtractUrl?: string;
   tavilySearchOptions?: TavilySearchOptions;
+  keenableApiKey?: string;
+  keenableApiUrl?: string;
+  keenableSearchOptions?: KeenableSearchOptions;
+}
+
+export interface KeenableSearchOptions {
+  maxResults?: number;
+  /** Restrict results to a single domain, e.g. "github.com". */
+  site?: string;
+  /** Sent as the X-Keenable-Title attribution header. Defaults to "LibreChat". */
+  attributionTitle?: string;
+  timeout?: number;
+}
+
+export interface KeenableSearchPayload {
+  query: string;
+  site?: string;
+  published_after?: string;
+}
+
+export interface KeenableSearchResult {
+  title?: string;
+  url?: string;
+  description?: string;
+  snippet?: string;
+  published_at?: string;
+}
+
+export interface KeenableSearchResponse {
+  results?: KeenableSearchResult[];
 }
 
 export type References = {
@@ -137,6 +167,15 @@ export interface ProcessSourcesConfig {
    * chunker/reranker. Defaults to 50,000; also configurable via the
    * `SEARCH_MAX_CONTENT_LENGTH` env var. */
   maxContentLength?: number;
+  /** Chunk size (chars) for splitting scraped content before reranking.
+   * Defaults to 150; also configurable via the `SEARCH_CHUNK_SIZE` env var.
+   * Larger chunks send fewer documents to the reranker (lower cost/latency);
+   * highlights are expanded ±300-450 chars around each hit either way. */
+  chunkSize?: number;
+  /** Overlap (chars) between adjacent chunks. Defaults to 50; also
+   * configurable via the `SEARCH_CHUNK_OVERLAP` env var. Clamped below
+   * `chunkSize`. */
+  chunkOverlap?: number;
   strategies?: string[];
   filterContent?: boolean;
   reranker?: BaseReranker;
@@ -231,6 +270,8 @@ export interface SearchToolConfig
   jinaApiUrl?: string;
   cohereApiKey?: string;
   rerankerType?: RerankerType;
+  /** Timeout (ms) for rerank API requests. Defaults to 10,000. */
+  rerankerTimeout?: number;
   scraperProvider?: ScraperProvider;
   scraperTimeout?: number;
   serperScraperOptions?: SerperScraperConfig;

package/src/tools/subagent/SubagentExecutor.ts

@@ -1422,6 +1422,17 @@ export function buildChildInputs(
      */
     initialSummary: undefined,
     discoveredTools: undefined,
+    /**
+     * Host-supplied direct tools are scrubbed from INHERITED configs only.
+     * A self-spawn config's `agentInputs` is a shallow spread of the parent's
+     * `_sourceInputs`, so without this a parent-scoped graph tool (e.g. an
+     * interrupt-raising ask_user_question, which needs the parent's
+     * checkpointer — child graphs compile without one) would silently leak
+     * into the child and deterministically throw `No checkpointer set`. An
+     * EXPLICIT child config that lists its own `graphTools` is a deliberate
+     * host choice and keeps them (Codex #289 P2).
+     */
+    graphTools: config.self === true ? undefined : agentInputs.graphTools,
   };
 
   if (config.allowNested === true) {

package/src/types/graph.ts

@@ -610,6 +610,28 @@ export interface AgentInputs {
   subagentConfigs?: SubagentConfig[];
   /** Maximum subagent nesting depth. Default 1 means top-level agents can spawn subagents but subagents cannot nest further. */
   maxSubagentDepth?: number;
+  /**
+   * Host-supplied tool instances that must execute IN-PROCESS inside the graph's
+   * ToolNode even when the run is event-driven (`toolDefinitions` non-empty). Each
+   * instance is bound to the model alongside the schema-only event tools and its
+   * name is marked direct, so calls bypass ON_TOOL_EXECUTE dispatch and run inside
+   * the Pregel task frame. This is the only execution mode where a tool body may
+   * raise a LangGraph `interrupt()` (e.g. a tool built on `askUserQuestion()`) —
+   * the host-side event handler runs outside the graph task, where `interrupt()`
+   * throws. Do NOT also list these tools in `toolDefinitions` (they would be bound
+   * twice). NOT inherited by SELF-SPAWNED subagent children (their config is a
+   * shallow spread of the parent's inputs, and child graphs compile without a
+   * checkpointer, so an interrupt-capable tool could never pause there) —
+   * `buildChildInputs` scrubs the inherited copy; an EXPLICIT child config that
+   * lists its own `graphTools` keeps them.
+   *
+   * Deliberately `GenericTool[]`, not `GraphTools`: the wider union admits
+   * schema-only shapes (OpenAI `BindToolsInput`, Google tool objects) that
+   * `initializeTools` cannot register in the ToolNode direct map — the model
+   * would bind a tool the SDK advertised as in-process but cannot execute.
+   * Every entry must be a real executable tool instance with a `name`.
+   */
+  graphTools?: GenericTool[];
 }
 
 export interface ContextPruningConfig {

package/src/types/run.ts

@@ -184,6 +184,15 @@ export type RunConfig = {
    * eager dispatch unsafe.
    */
   eagerEventToolExecution?: EagerEventToolExecutionConfig;
+  /**
+   * Names of host tools that write to the code-execution sandbox but are not
+   * built-in `CODE_EXECUTION_TOOLS` (e.g. LibreChat's create_file/edit_file).
+   * Their successful results fold the returned exec `session_id` into the
+   * shared code session, so a file such a tool writes is visible to later
+   * bash_tool/execute_code calls running in the same sandbox. Host-declared so
+   * the SDK stays name-agnostic.
+   */
+  codeSessionToolNames?: string[];
   /**
    * Selects the execution backend for built-in code tools. Omit this to keep
    * the remote LibreChat Code API sandbox. Set `{ engine: 'local' }` to run

package/src/types/tools.ts

@@ -110,6 +110,12 @@ export type ToolNodeOptions = {
   directToolNames?: Set<string>;
   /** Opt-in eager execution for event-driven tool calls. */
   eagerEventToolExecution?: EagerEventToolExecutionConfig;
+  /**
+   * Host tool names that write to the code-execution sandbox but are not
+   * built-in `CODE_EXECUTION_TOOLS`. Their exec `session_id` is folded into the
+   * shared code session so later bash_tool/execute_code calls see written files.
+   */
+  codeSessionToolNames?: string[];
   /** Shared per-run eager execution registry populated by the stream handler. */
   eagerEventToolExecutions?: Map<string, EagerEventToolExecution>;
   /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */

package/src/utils/title.ts

@@ -53,7 +53,7 @@ export const createTitleRunnable = async (
 
   const titlePrompt = ChatPromptTemplate.fromTemplate(
     _titlePrompt ?? defaultTitlePrompt
-  ).withConfig({ runName: 'TitlePrompt' });
+  ).withConfig({ runName: 'BuildTitlePrompt' });
 
   const titleOnlyInnerChain = RunnableSequence.from([titlePrompt, titleLLM]);
   const combinedInnerChain = RunnableSequence.from([titlePrompt, combinedLLM]);
@@ -67,7 +67,7 @@ export const createTitleRunnable = async (
       const result = await titleOnlyInnerChain.invoke(input, config);
       return result as { title: string };
     },
-  }).withConfig({ runName: 'TitleOnlyChain' });
+  }).withConfig({ runName: 'GenerateTitleOnly' });
 
   /** Wrap combinedChain in RunnableLambda to create parent span */
   const combinedChain = new RunnableLambda({
@@ -78,7 +78,7 @@ export const createTitleRunnable = async (
       const result = await combinedInnerChain.invoke(input, config);
       return result as { language: string; title: string };
     },
-  }).withConfig({ runName: 'TitleLanguageChain' });
+  }).withConfig({ runName: 'GenerateTitleAndDetectLanguage' });
 
   /** Runnable to add default values if needed */
   const addDefaults = new RunnableLambda({
@@ -88,7 +88,7 @@ export const createTitleRunnable = async (
       language: result?.language ?? 'English',
       title: result?.title ?? '',
     }),
-  }).withConfig({ runName: 'AddDefaults' });
+  }).withConfig({ runName: 'ApplyTitleDefaults' });
 
   const combinedChainInner = RunnableSequence.from([
     combinedChain,
@@ -103,7 +103,7 @@ export const createTitleRunnable = async (
     ): Promise<{ language: string; title: string }> => {
       return await combinedChainInner.invoke(input, config);
     },
-  }).withConfig({ runName: 'CombinedChainWithDefaults' });
+  }).withConfig({ runName: 'GenerateTitleAndDetectLanguageWithDefaults' });
 
   return new RunnableLambda({
     func: async (
@@ -124,7 +124,7 @@ export const createTitleRunnable = async (
 
       return await combinedChainWithDefaults.invoke(invokeInput, config);
     },
-  }).withConfig({ runName: 'TitleGenerator' });
+  }).withConfig({ runName: 'GenerateTitle' });
 };
 
 const defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using title case conventions. Only return the title itself.
@@ -138,7 +138,7 @@ export const createCompletionTitleRunnable = async (
 ): Promise<Runnable> => {
   const completionPrompt = ChatPromptTemplate.fromTemplate(
     titlePrompt ?? defaultCompletionPrompt
-  ).withConfig({ runName: 'CompletionTitlePrompt' });
+  ).withConfig({ runName: 'BuildTitlePrompt' });
 
   /** Runnable to extract content from model response */
   const extractContent = new RunnableLambda({
@@ -157,7 +157,7 @@ export const createCompletionTitleRunnable = async (
       }
       return { title: content.trim() };
     },
-  }).withConfig({ runName: 'ExtractTitle' });
+  }).withConfig({ runName: 'ParseTitleFromResponse' });
 
   const innerChain = RunnableSequence.from([
     completionPrompt,
@@ -173,5 +173,5 @@ export const createCompletionTitleRunnable = async (
     ): Promise<{ title: string }> => {
       return await innerChain.invoke(input, config);
     },
-  }).withConfig({ runName: 'CompletionTitleChain' });
+  }).withConfig({ runName: 'GenerateTitle' });
 };