@librechat/agents 3.0.776 → 3.1.1

package/src/tools/ToolNode.ts

@@ -145,9 +145,9 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
       /**
        * Inject session context for code execution tools when available.
+       * Each file uses its own session_id (supporting multi-session file tracking).
        * Both session_id and _injected_files are injected directly to invokeParams
        * (not inside args) so they bypass Zod schema validation and reach config.toolCall.
-       * This avoids /files endpoint race conditions.
        */
       if (
         call.name === Constants.EXECUTE_CODE ||
@@ -156,14 +156,18 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         const codeSession = this.sessions?.get(Constants.EXECUTE_CODE) as
           | t.CodeSessionContext
           | undefined;
-        if (codeSession?.session_id != null && codeSession.files.length > 0) {
-          /** Convert tracked files to CodeEnvFile format for the API */
+        if (codeSession?.files != null && codeSession.files.length > 0) {
+          /**
+           * Convert tracked files to CodeEnvFile format for the API.
+           * Each file uses its own session_id (set when file was created).
+           * This supports files from multiple parallel/sequential executions.
+           */
           const fileRefs: t.CodeEnvFile[] = codeSession.files.map((file) => ({
-            session_id: codeSession.session_id,
+            session_id: file.session_id ?? codeSession.session_id,
             id: file.id,
             name: file.name,
           }));
-          /** Inject session_id and files directly - bypasses Zod, reaches config.toolCall */
+          /** Inject latest session_id and files - bypasses Zod, reaches config.toolCall */
           invokeParams = {
             ...invokeParams,
             session_id: codeSession.session_id,

package/src/tools/ToolSearch.ts

@@ -1,5 +1,4 @@
 // src/tools/ToolSearch.ts
-import { z } from 'zod';
 import * as okapibm25Module from 'okapibm25';
 import { config } from 'dotenv';
 
@@ -40,20 +39,25 @@ const MAX_REGEX_COMPLEXITY = 5;
 /** Default search timeout in milliseconds */
 const SEARCH_TIMEOUT = 5000;
 
-/** Zod schema type for tool search parameters */
-type ToolSearchSchema = z.ZodObject<{
-  query: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-  fields: z.ZodDefault<
-    z.ZodOptional<z.ZodArray<z.ZodEnum<['name', 'description', 'parameters']>>>
-  >;
-  max_results: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-  mcp_server: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
-}>;
+/** JSON schema type for tool search parameters */
+interface ToolSearchSchema {
+  type: 'object';
+  properties: Record<string, unknown>;
+  required: string[];
+}
+
+/** Input params type for tool search */
+interface ToolSearchParams {
+  query?: string;
+  fields?: ('name' | 'description' | 'parameters')[];
+  max_results?: number;
+  mcp_server?: string | string[];
+}
 
 /**
- * Creates the Zod schema with dynamic query description based on mode.
+ * Creates the JSON schema with dynamic query description based on mode.
  * @param mode - The search mode determining query interpretation
- * @returns Zod schema for tool search parameters
+ * @returns JSON schema for tool search parameters
  */
 function createToolSearchSchema(mode: t.ToolSearchMode): ToolSearchSchema {
   const queryDescription =
@@ -61,33 +65,39 @@ function createToolSearchSchema(mode: t.ToolSearchMode): ToolSearchSchema {
       ? 'Search term to find in tool names and descriptions. Case-insensitive substring matching. Optional if mcp_server is provided.'
       : 'Regex pattern to search tool names and descriptions. Optional if mcp_server is provided.';
 
-  return z.object({
-    query: z
-      .string()
-      .max(MAX_PATTERN_LENGTH)
-      .optional()
-      .default('')
-      .describe(queryDescription),
-    fields: z
-      .array(z.enum(['name', 'description', 'parameters']))
-      .optional()
-      .default(['name', 'description'])
-      .describe('Which fields to search. Default: name and description'),
-    max_results: z
-      .number()
-      .int()
-      .min(1)
-      .max(50)
-      .optional()
-      .default(10)
-      .describe('Maximum number of matching tools to return'),
-    mcp_server: z
-      .union([z.string(), z.array(z.string())])
-      .optional()
-      .describe(
-        'Filter to tools from specific MCP server(s). Can be a single server name or array of names. If provided without a query, lists all tools from those servers.'
-      ),
-  });
+  return {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        maxLength: MAX_PATTERN_LENGTH,
+        default: '',
+        description: queryDescription,
+      },
+      fields: {
+        type: 'array',
+        items: { type: 'string', enum: ['name', 'description', 'parameters'] },
+        default: ['name', 'description'],
+        description: 'Which fields to search. Default: name and description',
+      },
+      max_results: {
+        type: 'integer',
+        minimum: 1,
+        maximum: 50,
+        default: 10,
+        description: 'Maximum number of matching tools to return',
+      },
+      mcp_server: {
+        oneOf: [
+          { type: 'string' },
+          { type: 'array', items: { type: 'string' } },
+        ],
+        description:
+          'Filter to tools from specific MCP server(s). Can be a single server name or array of names. If provided without a query, lists all tools from those servers.',
+      },
+    },
+    required: [],
+  };
 }
 
 /**
@@ -748,7 +758,7 @@ function formatServerListing(
  */
 function createToolSearch(
   initParams: t.ToolSearchParams = {}
-): DynamicStructuredTool<ReturnType<typeof createToolSearchSchema>> {
+): DynamicStructuredTool {
   const mode: t.ToolSearchMode = initParams.mode ?? 'code_interpreter';
   const defaultOnlyDeferred = initParams.onlyDeferred ?? true;
   const schema = createToolSearchSchema(mode);
@@ -802,10 +812,11 @@ Searches deferred tools by regex pattern.
 ${mcpNote}${toolsListSection}
 `.trim();
 
-  return tool<typeof schema>(
-    async (params, config) => {
+  return tool(
+    async (rawParams, config) => {
+      const params = rawParams as ToolSearchParams;
       const {
-        query,
+        query = '',
         fields = ['name', 'description'],
         max_results = 10,
         mcp_server,

package/src/tools/search/schema.ts

@@ -1,5 +1,3 @@
-import { z } from 'zod';
-
 export enum DATE_RANGE {
   PAST_HOUR = 'h',
   PAST_24_HOURS = 'd',
@@ -38,26 +36,33 @@ Examples:
 - "in" for India
 `.trim();
 
-export const querySchema = z.string().describe(DEFAULT_QUERY_DESCRIPTION);
-export const dateSchema = z
-  .nativeEnum(DATE_RANGE)
-  .optional()
-  .describe('Date range for search results.');
-export const countrySchema = z
-  .string()
-  .optional()
-  .describe(DEFAULT_COUNTRY_DESCRIPTION);
-export const imagesSchema = z
-  .boolean()
-  .optional()
-  .describe('Whether to also run an image search.');
-
-export const videosSchema = z
-  .boolean()
-  .optional()
-  .describe('Whether to also run a video search.');
-
-export const newsSchema = z
-  .boolean()
-  .optional()
-  .describe('Whether to also run a news search.');
+export const querySchema = {
+  type: 'string',
+  description: DEFAULT_QUERY_DESCRIPTION,
+} as const;
+
+export const dateSchema = {
+  type: 'string',
+  enum: Object.values(DATE_RANGE),
+  description: 'Date range for search results.',
+} as const;
+
+export const countrySchema = {
+  type: 'string',
+  description: DEFAULT_COUNTRY_DESCRIPTION,
+} as const;
+
+export const imagesSchema = {
+  type: 'boolean',
+  description: 'Whether to also run an image search.',
+} as const;
+
+export const videosSchema = {
+  type: 'boolean',
+  description: 'Whether to also run a video search.',
+} as const;
+
+export const newsSchema = {
+  type: 'boolean',
+  description: 'Whether to also run a news search.',
+} as const;

package/src/tools/search/tool.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from './types';
@@ -269,12 +268,13 @@ function createTool({
   search,
   onSearchResults: _onSearchResults,
 }: {
-  schema: t.SearchToolSchema;
+  schema: Record<string, unknown>;
   search: ReturnType<typeof createSearchProcessor>;
   onSearchResults: t.SearchToolConfig['onSearchResults'];
-}): DynamicStructuredTool<typeof schema> {
-  return tool<typeof schema>(
-    async (params, runnableConfig) => {
+}): DynamicStructuredTool {
+  return tool(
+    async (rawParams, runnableConfig) => {
+      const params = rawParams as SearchToolParams;
       const { query, date, country: _c, images, videos, news } = params;
       const country = typeof _c === 'string' && _c ? _c : undefined;
       const searchResult = await search({
@@ -353,9 +353,19 @@ Use anchor marker(s) immediately after the statement:
  * @param config - The search tool configuration
  * @returns A DynamicStructuredTool with a schema that depends on the searchProvider
  */
+/** Input params type for search tool */
+interface SearchToolParams {
+  query: string;
+  date?: DATE_RANGE;
+  country?: string;
+  images?: boolean;
+  videos?: boolean;
+  news?: boolean;
+}
+
 export const createSearchTool = (
   config: t.SearchToolConfig = {}
-): DynamicStructuredTool<typeof toolSchema> => {
+): DynamicStructuredTool => {
   const {
     searchProvider = 'serper',
     serperApiKey,
@@ -382,14 +392,7 @@ export const createSearchTool = (
 
   const logger = config.logger || createDefaultLogger();
 
-  const schemaObject: {
-    query: z.ZodString;
-    date: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
-    country?: z.ZodOptional<z.ZodString>;
-    images: z.ZodOptional<z.ZodBoolean>;
-    videos: z.ZodOptional<z.ZodBoolean>;
-    news: z.ZodOptional<z.ZodBoolean>;
-  } = {
+  const schemaProperties: Record<string, unknown> = {
     query: querySchema,
     date: dateSchema,
     images: imagesSchema,
@@ -398,10 +401,14 @@ export const createSearchTool = (
   };
 
   if (searchProvider === 'serper') {
-    schemaObject.country = countrySchema;
+    schemaProperties.country = countrySchema;
   }
 
-  const toolSchema = z.object(schemaObject);
+  const toolSchema = {
+    type: 'object',
+    properties: schemaProperties,
+    required: ['query'],
+  };
 
   const searchAPI = createSearchAPI({
     searchProvider,

package/src/tools/search/types.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import type { Logger as WinstonLogger } from 'winston';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
@@ -657,31 +656,8 @@ export type ProcessSourcesFields = {
   onGetHighlights: SearchToolConfig['onGetHighlights'];
 };
 
-export type SearchToolSchema = z.ZodObject<
-  {
-    query: z.ZodString;
-    date: z.ZodOptional<z.ZodNativeEnum<typeof DATE_RANGE>>;
-    country?: z.ZodOptional<z.ZodString>;
-    images: z.ZodOptional<z.ZodBoolean>;
-    videos: z.ZodOptional<z.ZodBoolean>;
-    news: z.ZodOptional<z.ZodBoolean>;
-  },
-  'strip',
-  z.ZodTypeAny,
-  {
-    query: string;
-    date?: DATE_RANGE;
-    country?: unknown;
-    images?: boolean;
-    videos?: boolean;
-    news?: boolean;
-  },
-  {
-    query: string;
-    date?: DATE_RANGE;
-    country?: unknown;
-    images?: boolean;
-    videos?: boolean;
-    news?: boolean;
-  }
->;
+export interface SearchToolSchema {
+  type: 'object';
+  properties: Record<string, unknown>;
+  required: string[];
+}

package/src/types/tools.ts

@@ -74,6 +74,8 @@ export type FileRef = {
   id: string;
   name: string;
   path?: string;
+  /** Session ID this file belongs to (for multi-session file tracking) */
+  session_id?: string;
 };
 
 export type FileRefs = FileRef[];

package/src/utils/index.ts

@@ -4,3 +4,4 @@ export * from './misc';
 export * from './handlers';
 export * from './run';
 export * from './tokens';
+export * from './schema';

package/src/utils/schema.ts

@@ -0,0 +1,35 @@
+// src/utils/schema.ts
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import type { ZodTypeAny } from 'zod';
+
+/** Checks if a schema is a Zod schema by looking for the _def property */
+export function isZodSchema(schema: unknown): schema is ZodTypeAny {
+  return (
+    schema != null && typeof schema === 'object' && '_def' in (schema as object)
+  );
+}
+
+/**
+ * Converts a schema to JSON schema format.
+ * Handles both Zod schemas (converts) and JSON schemas (passthrough).
+ */
+export function toJsonSchema(
+  schema: unknown,
+  name?: string,
+  description?: string
+): Record<string, unknown> {
+  if (isZodSchema(schema)) {
+    const zodSchema = schema as ZodTypeAny & {
+      describe: (desc: string) => ZodTypeAny;
+    };
+    const described =
+      description != null && description !== ''
+        ? zodSchema.describe(description)
+        : schema;
+    return zodToJsonSchema(
+      described as Parameters<typeof zodToJsonSchema>[0],
+      name ?? ''
+    );
+  }
+  return schema as Record<string, unknown>;
+}

package/src/utils/title.ts

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import { ChatPromptTemplate } from '@langchain/core/prompts';
 import { RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
 import type { Runnable, RunnableConfig } from '@langchain/core/runnables';
@@ -12,22 +11,33 @@ const defaultTitlePrompt = `Analyze this conversation and provide:
 
 {convo}`;
 
-const titleSchema = z.object({
-  title: z
-    .string()
-    .describe(
-      'A concise title for the conversation in 5 words or less, without punctuation or quotation'
-    ),
-});
-
-const combinedSchema = z.object({
-  language: z.string().describe('The detected language of the conversation'),
-  title: z
-    .string()
-    .describe(
-      'A concise title for the conversation in 5 words or less, without punctuation or quotation'
-    ),
-});
+const titleSchema = {
+  type: 'object',
+  properties: {
+    title: {
+      type: 'string',
+      description:
+        'A concise title for the conversation in 5 words or less, without punctuation or quotation',
+    },
+  },
+  required: ['title'],
+} as const;
+
+const combinedSchema = {
+  type: 'object',
+  properties: {
+    language: {
+      type: 'string',
+      description: 'The detected language of the conversation',
+    },
+    title: {
+      type: 'string',
+      description:
+        'A concise title for the conversation in 5 words or less, without punctuation or quotation',
+    },
+  },
+  required: ['language', 'title'],
+} as const;
 
 export const createTitleRunnable = async (
   model: t.ChatModelInstance,
@@ -54,7 +64,8 @@ export const createTitleRunnable = async (
       input: { convo: string },
       config?: Partial<RunnableConfig>
     ): Promise<{ title: string }> => {
-      return await titleOnlyInnerChain.invoke(input, config);
+      const result = await titleOnlyInnerChain.invoke(input, config);
+      return result as { title: string };
     },
   }).withConfig({ runName: 'TitleOnlyChain' });
 
@@ -64,7 +75,8 @@ export const createTitleRunnable = async (
       input: { convo: string },
       config?: Partial<RunnableConfig>
     ): Promise<{ language: string; title: string }> => {
-      return await combinedInnerChain.invoke(input, config);
+      const result = await combinedInnerChain.invoke(input, config);
+      return result as { language: string; title: string };
     },
   }).withConfig({ runName: 'TitleLanguageChain' });