@librechat/agents 3.1.0 → 3.1.2

package/src/tools/ProgrammaticToolCalling.ts

@@ -1,5 +1,4 @@
 // src/tools/ProgrammaticToolCalling.ts
-import { z } from 'zod';
 import { config } from 'dotenv';
 import fetch, { RequestInit } from 'node-fetch';
 import { HttpsProxyAgent } from 'https-proxy-agent';
@@ -33,12 +32,13 @@ const DEFAULT_TIMEOUT = 60000;
 // Schema
 // ============================================================================
 
-const ProgrammaticToolCallingSchema = z.object({
-  code: z
-    .string()
-    .min(1)
-    .describe(
-      `Python code that calls tools programmatically. Tools are available as async functions.
+const ProgrammaticToolCallingSchema = {
+  type: 'object',
+  properties: {
+    code: {
+      type: 'string',
+      minLength: 1,
+      description: `Python code that calls tools programmatically. Tools are available as async functions.
 
 CRITICAL - STATELESS EXECUTION:
 Each call is a fresh Python interpreter. Variables, imports, and data do NOT persist between calls.
@@ -66,19 +66,19 @@ Rules:
 - Just write code with await—auto-wrapped in async context
 - DO NOT define async def main() or call asyncio.run()
 - Tools are pre-defined—DO NOT write function definitions
-- Only print() output returns to the model`
-    ),
-  timeout: z
-    .number()
-    .int()
-    .min(1000)
-    .max(300000)
-    .optional()
-    .default(DEFAULT_TIMEOUT)
-    .describe(
-      'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.'
-    ),
-});
+- Only print() output returns to the model`,
+    },
+    timeout: {
+      type: 'integer',
+      minimum: 1000,
+      maximum: 300000,
+      default: DEFAULT_TIMEOUT,
+      description:
+        'Maximum execution time in milliseconds. Default: 60 seconds. Max: 5 minutes.',
+    },
+  },
+  required: ['code'],
+} as const;
 
 // ============================================================================
 // Helper Functions
@@ -576,7 +576,7 @@ export function formatCompletedResponse(
  */
 export function createProgrammaticToolCallingTool(
   initParams: t.ProgrammaticToolCallingParams = {}
-): DynamicStructuredTool<typeof ProgrammaticToolCallingSchema> {
+): DynamicStructuredTool {
   const apiKey =
     (initParams[EnvVar.CODE_API_KEY] as string | undefined) ??
     initParams.apiKey ??
@@ -616,8 +616,9 @@ Example (complete pipeline):
   data = await query_db(sql="..."); df = process(data); await save_to_sheet(data=df); print("Done")
 `.trim();
 
-  return tool<typeof ProgrammaticToolCallingSchema>(
-    async (params, config) => {
+  return tool(
+    async (rawParams, config) => {
+      const params = rawParams as { code: string; timeout?: number };
       const { code, timeout = DEFAULT_TIMEOUT } = params;
 
       // Extra params injected by ToolNode (follows web_search pattern)

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/__tests__/ProgrammaticToolCalling.integration.test.ts

@@ -4,6 +4,9 @@
  * These tests hit the LIVE Code API and verify end-to-end functionality.
  *
  * Run with: npm test -- ProgrammaticToolCalling.integration.test.ts
+ *
+ * Requires LIBRECHAT_CODE_API_KEY environment variable.
+ * Tests are skipped when the API key is not available.
  */
 import { config as dotenvConfig } from 'dotenv';
 dotenvConfig();
@@ -19,19 +22,17 @@ import {
   createProgrammaticToolRegistry,
 } from '@/test/mockTools';
 
-describe('ProgrammaticToolCalling - Live API Integration', () => {
+const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
+const shouldSkip = apiKey == null || apiKey === '';
+
+const describeIfApiKey = shouldSkip ? describe.skip : describe;
+
+describeIfApiKey('ProgrammaticToolCalling - Live API Integration', () => {
   let ptcTool: ReturnType<typeof createProgrammaticToolCallingTool>;
   let toolMap: t.ToolMap;
   let toolDefinitions: t.LCTool[];
 
   beforeAll(() => {
-    const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
-    if (apiKey == null || apiKey === '') {
-      throw new Error(
-        'LIBRECHAT_CODE_API_KEY not set. Required for integration tests.'
-      );
-    }
-
     const tools = [
       createGetTeamMembersTool(),
       createGetExpensesTool(),
@@ -42,7 +43,7 @@ describe('ProgrammaticToolCalling - Live API Integration', () => {
     toolMap = new Map(tools.map((t) => [t.name, t]));
     toolDefinitions = Array.from(createProgrammaticToolRegistry().values());
 
-    ptcTool = createProgrammaticToolCallingTool({ apiKey });
+    ptcTool = createProgrammaticToolCallingTool({ apiKey: apiKey! });
   });
 
   it('executes simple single tool call', async () => {

package/src/tools/__tests__/ToolSearch.integration.test.ts

@@ -4,6 +4,9 @@
  * These tests hit the LIVE Code API and verify end-to-end search functionality.
  *
  * Run with: npm test -- ToolSearch.integration.test.ts
+ *
+ * Requires LIBRECHAT_CODE_API_KEY environment variable.
+ * Tests are skipped when the API key is not available.
  */
 import { config as dotenvConfig } from 'dotenv';
 dotenvConfig();
@@ -12,19 +15,17 @@ import { describe, it, expect, beforeAll } from '@jest/globals';
 import { createToolSearch } from '../ToolSearch';
 import { createToolSearchToolRegistry } from '@/test/mockTools';
 
-describe('ToolSearch - Live API Integration', () => {
+const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
+const shouldSkip = apiKey == null || apiKey === '';
+
+const describeIfApiKey = shouldSkip ? describe.skip : describe;
+
+describeIfApiKey('ToolSearch - Live API Integration', () => {
   let searchTool: ReturnType<typeof createToolSearch>;
   const toolRegistry = createToolSearchToolRegistry();
 
   beforeAll(() => {
-    const apiKey = process.env.LIBRECHAT_CODE_API_KEY;
-    if (apiKey == null || apiKey === '') {
-      throw new Error(
-        'LIBRECHAT_CODE_API_KEY not set. Required for integration tests.'
-      );
-    }
-
-    searchTool = createToolSearch({ apiKey, toolRegistry });
+    searchTool = createToolSearch({ apiKey: apiKey!, toolRegistry });
   });
 
   it('searches for expense-related tools', async () => {

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