feat: added support for custom JINA_API_URL (#15)

* added jinaApiUrl / JINA_API_URL

* test: improve jina-reranker test reliability and type safety

- Fix TypeScript linting errors in jina-reranker.test.ts
- Improve type casting for private property access
- Fix environment variable handling in tests
- Replace require import with ES6 import
- Add proper null checks for createReranker return value

* Revert "test: improve jina-reranker test reliability and type safety"

This reverts commit 4ee8448.

Author: dan-and

src/tools/search/jina-reranker.test.ts

@@ -0,0 +1,126 @@
+import { JinaReranker } from './rerankers';
+import { createDefaultLogger } from './utils';
+
+describe('JinaReranker', () => {
+  const mockLogger = createDefaultLogger();
+  
+  describe('constructor', () => {
+    it('should use default API URL when no apiUrl is provided', () => {
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        logger: mockLogger,
+      });
+      
+      // Access private property for testing
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
+    });
+
+    it('should use custom API URL when provided', () => {
+      const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe(customUrl);
+    });
+
+    it('should use environment variable JINA_API_URL when available', () => {
+      const originalEnv = process.env.JINA_API_URL;
+      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
+      
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe('https://env-jina-endpoint.com/v1/rerank');
+      
+      // Restore original environment
+      if (originalEnv) {
+        process.env.JINA_API_URL = originalEnv;
+      } else {
+        delete process.env.JINA_API_URL;
+      }
+    });
+
+    it('should prioritize explicit apiUrl over environment variable', () => {
+      const originalEnv = process.env.JINA_API_URL;
+      process.env.JINA_API_URL = 'https://env-jina-endpoint.com/v1/rerank';
+      
+      const customUrl = 'https://explicit-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const apiUrl = (reranker as any).apiUrl;
+      expect(apiUrl).toBe(customUrl);
+      
+      // Restore original environment
+      if (originalEnv) {
+        process.env.JINA_API_URL = originalEnv;
+      } else {
+        delete process.env.JINA_API_URL;
+      }
+    });
+  });
+
+  describe('rerank method', () => {
+    it('should log the API URL being used', async () => {
+      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      
+      const logSpy = jest.spyOn(mockLogger, 'debug');
+      
+      try {
+        await reranker.rerank('test query', ['document1', 'document2'], 2);
+      } catch (error) {
+        // Expected to fail due to missing API key, but we can check the log
+      }
+      
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(`Reranking 2 chunks with Jina using API URL: ${customUrl}`)
+      );
+      
+      logSpy.mockRestore();
+    });
+  });
+});
+
+describe('createReranker', () => {
+  const { createReranker } = require('./rerankers');
+  
+  it('should create JinaReranker with jinaApiUrl when provided', () => {
+    const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
+    const reranker = createReranker({
+      rerankerType: 'jina',
+      jinaApiKey: 'test-key',
+      jinaApiUrl: customUrl,
+    });
+    
+    expect(reranker).toBeInstanceOf(JinaReranker);
+    const apiUrl = (reranker as any).apiUrl;
+    expect(apiUrl).toBe(customUrl);
+  });
+
+  it('should create JinaReranker with default URL when jinaApiUrl is not provided', () => {
+    const reranker = createReranker({
+      rerankerType: 'jina',
+      jinaApiKey: 'test-key',
+    });
+    
+    expect(reranker).toBeInstanceOf(JinaReranker);
+    const apiUrl = (reranker as any).apiUrl;
+    expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
+  });
+});

src/tools/search/rerankers.ts

@@ -28,23 +28,28 @@ export abstract class BaseReranker {
 }
 
 export class JinaReranker extends BaseReranker {
+  private apiUrl: string;
+
   constructor({
     apiKey = process.env.JINA_API_KEY,
+    apiUrl = process.env.JINA_API_URL || 'https://api.jina.ai/v1/rerank',
     logger,
   }: {
     apiKey?: string;
+    apiUrl?: string;
     logger?: t.Logger;
   }) {
     super(logger);
     this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
   }
 
   async rerank(
     query: string,
     documents: string[],
     topK: number = 5
   ): Promise<t.Highlight[]> {
-    this.logger.debug(`Reranking ${documents.length} chunks with Jina`);
+    this.logger.debug(`Reranking ${documents.length} chunks with Jina using API URL: ${this.apiUrl}`);
 
     try {
       if (this.apiKey == null || this.apiKey === '') {
@@ -61,7 +66,7 @@ export class JinaReranker extends BaseReranker {
       };
 
       const response = await axios.post<t.JinaRerankerResponse | undefined>(
-        'https://api.jina.ai/v1/rerank',
+        this.apiUrl,
         requestData,
         {
           headers: {
@@ -201,17 +206,18 @@ export class InfinityReranker extends BaseReranker {
 export const createReranker = (config: {
   rerankerType: t.RerankerType;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   logger?: t.Logger;
 }): BaseReranker | undefined => {
-  const { rerankerType, jinaApiKey, cohereApiKey, logger } = config;
+  const { rerankerType, jinaApiKey, jinaApiUrl, cohereApiKey, logger } = config;
 
   // Create a default logger if none is provided
   const defaultLogger = logger || createDefaultLogger();
 
   switch (rerankerType.toLowerCase()) {
   case 'jina':
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   case 'cohere':
     return new CohereReranker({
       apiKey: cohereApiKey,
@@ -226,7 +232,7 @@ export const createReranker = (config: {
     defaultLogger.warn(
       `Unknown reranker type: ${rerankerType}. Defaulting to InfinityReranker.`
     );
-    return new JinaReranker({ apiKey: jinaApiKey, logger: defaultLogger });
+    return new JinaReranker({ apiKey: jinaApiKey, apiUrl: jinaApiUrl, logger: defaultLogger });
   }
 };
 

src/tools/search/tool.ts

@@ -349,6 +349,7 @@ export const createSearchTool = (
     firecrawlOptions,
     scraperTimeout,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     onSearchResults: _onSearchResults,
     onGetHighlights,
@@ -395,6 +396,7 @@ export const createSearchTool = (
   const selectedReranker = createReranker({
     rerankerType,
     jinaApiKey,
+    jinaApiUrl,
     cohereApiKey,
     logger,
   });

src/tools/search/types.ts

@@ -148,6 +148,7 @@ export interface SearchToolConfig
   logger?: Logger;
   safeSearch?: SafeSearchLevel;
   jinaApiKey?: string;
+  jinaApiUrl?: string;
   cohereApiKey?: string;
   rerankerType?: RerankerType;
   scraperTimeout?: number;