@librechat/agents 3.2.57 → 3.2.59

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/tools.ts

@@ -292,6 +292,15 @@ export type CodeExecutionToolParams =
       files?: CodeEnvFile[];
       /** Optional host-supplied Code API auth headers. */
       authHeaders?: CodeApiAuthHeaders;
+      /**
+       * Advertise best-effort stateful sessions in the tool description
+       * (variables/files may persist between calls, may reset). Prompt text
+       * only, and it must be set here because the description is bound to the
+       * LLM at construction time. Pair it with the run-scoped
+       * `toolExecution.sandbox.statefulSessions` gate, which drives the wire
+       * hint — set both from one flag so the prompt and the backend agree.
+       */
+      statefulSessions?: boolean;
     };
 
 export type CodeApiAuthHeaderMap = Record<string, string>;
@@ -347,6 +356,13 @@ export type ExecuteResult = {
   stdout: string;
   stderr: string;
   files?: FileRefs;
+  /**
+   * Durable runtime session id echoed by a stateful Code API backend
+   * (hash of tenant+user+hint). Additive; absent on stateless servers.
+   */
+  runtime_session_id?: string;
+  /** Whether this execution reused a warm runtime session or started fresh. */
+  runtime_status?: 'new' | 'reused';
 };
 
 /** JSON Schema type definition for tool parameters */
@@ -413,6 +429,12 @@ export type ToolCallRequest = {
     session_id: string;
     files?: CodeEnvFile[];
   };
+  /**
+   * Stable runtime session hint for stateful sandbox sessions. Orthogonal to
+   * `codeSessionContext` (which threads the transient exec-session for file
+   * continuity): the hint identifies the durable server-side runtime session.
+   */
+  runtimeSessionHint?: string;
 };
 
 /** Batch request containing ALL tool calls for a graph step */
@@ -969,6 +991,32 @@ export type CloudflareSandboxExecutionConfig = {
   postEditSyntaxCheck?: LocalExecutionConfig['postEditSyntaxCheck'];
 };
 
+export type SandboxExecutionConfig = {
+  /**
+   * Opt into best-effort stateful runtime sessions on the remote Code API
+   * (its warm per-session MicroVM backend). This gate is run-scoped: it only
+   * controls the wire behavior (ToolNode injecting the session hint on
+   * execute_code/bash calls). The transport is otherwise unchanged.
+   *
+   * It does NOT change the model-facing tool description. Tool descriptions are
+   * bound to the LLM at construction time (`createCodeExecutionTool` /
+   * `createBashExecutionTool`), before this run config is applied inside the
+   * graph, so they can only be adjusted via the tools' own `statefulSessions`
+   * factory param. Set BOTH from one flag (as LibreChat does): with this on but
+   * the factory param off, the backend runs statefully while the model is still
+   * told the environment is stateless (non-corrupting — the model just won't
+   * exploit persistence).
+   */
+  statefulSessions?: boolean;
+  /**
+   * Stable identity for the runtime session (e.g. the conversation id). The
+   * server derives the real session id as hash(tenant, user, hint), so this
+   * is never a security boundary. Falls back to `configurable.thread_id` when
+   * omitted.
+   */
+  runtimeSessionHint?: string;
+};
+
 export type ToolExecutionConfig = {
   /** `sandbox` preserves the remote Code API behavior and is the default. */
   engine?: ToolExecutionEngine;
@@ -976,6 +1024,8 @@ export type ToolExecutionConfig = {
   local?: LocalExecutionConfig;
   /** Cloudflare Sandbox execution settings used when `engine` is `cloudflare-sandbox`. */
   cloudflare?: CloudflareSandboxExecutionConfig;
+  /** Remote sandbox settings; applies when `engine` is `sandbox` or omitted. */
+  sandbox?: SandboxExecutionConfig;
 };
 
 export type ProgrammaticCache = {
@@ -1099,6 +1149,10 @@ export type ProgrammaticExecutionResponse = {
   stderr?: string;
   files?: FileRefs;
 
+  /** Durable runtime session echo from a stateful backend (additive). */
+  runtime_session_id?: string;
+  runtime_status?: 'new' | 'reused';
+
   /** Present when status='error' */
   error?: string;
 };
@@ -1110,6 +1164,9 @@ export type ProgrammaticExecutionArtifact = {
   /** Execution session — see `CodeSessionContext.session_id`. */
   session_id?: string;
   files?: FileRefs;
+  /** Durable runtime session echo from a stateful backend (additive). */
+  runtime_session_id?: string;
+  runtime_status?: 'new' | 'reused';
 };
 
 /** Parameters for creating a bash execution tool (same API as CodeExecutor, bash-only) */
@@ -1134,6 +1191,11 @@ export type ProgrammaticToolCallingParams = {
   debug?: boolean;
   /** Optional host-supplied Code API auth headers. */
   authHeaders?: CodeApiAuthHeaders;
+  /* No `statefulSessions` here: PTC is stateless in v1. The initial
+   * /exec/programmatic request still forwards a ToolNode-injected
+   * `_runtime_session_hint` when present, but there is no factory-level opt-in
+   * to advertise (it would be a no-op). Re-add with real behavior when PTC
+   * stateful prompting lands. */
 };
 
 // ============================================================================
@@ -1166,6 +1228,9 @@ export type CodeExecutionArtifact = {
   /** Execution session — see `CodeSessionContext.session_id`. */
   session_id?: string;
   files?: FileRefs;
+  /** Durable runtime session echo from a stateful backend (additive). */
+  runtime_session_id?: string;
+  runtime_status?: 'new' | 'reused';
 };
 
 /**

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' });
 };