@librechat/agents 3.2.56 → 3.2.58

package/src/tools/__tests__/SubagentExecutor.test.ts

@@ -292,6 +292,50 @@ describe('buildChildInputs', () => {
     expect(result.toolDefinitions).toBeUndefined();
   });
 
+  it('scrubs INHERITED graphTools on self-spawn (parent-spread config) but keeps an explicit child config’s own', () => {
+    const askLikeTool = { name: 'ask_user_question' } as unknown as NonNullable<
+      AgentInputs['graphTools']
+    >[number];
+    const inputsWithGraphTools: AgentInputs = {
+      ...parentAgentInputs,
+      graphTools: [askLikeTool],
+    };
+
+    /**
+     * Self-spawn: `resolveSubagentConfigs` fills `agentInputs` as a shallow
+     * spread of the parent's `_sourceInputs`, so the parent-scoped direct
+     * tool would leak into a checkpointer-less child graph and fail with
+     * `No checkpointer set` — must be scrubbed.
+     */
+    const selfConfig: ResolvedSubagentConfig = {
+      type: 'self',
+      name: 'Self',
+      description: 'd',
+      self: true,
+      agentInputs: { ...inputsWithGraphTools },
+    };
+    expect(
+      buildChildInputs(selfConfig, 'child-self', 3).graphTools
+    ).toBeUndefined();
+
+    /**
+     * Explicit child config: a host that deliberately attaches its own
+     * in-process direct tools to a child keeps them (Codex #289 P2 —
+     * interrupt-capable tools still fail in children, but non-interrupting
+     * direct tools are legitimate there).
+     */
+    const explicitConfig: ResolvedSubagentConfig = {
+      type: 'researcher',
+      name: 'R',
+      description: 'd',
+      agentInputs: inputsWithGraphTools,
+    };
+    expect(
+      buildChildInputs(explicitConfig, 'child-explicit', 3).graphTools
+    ).toEqual([askLikeTool]);
+    expect(inputsWithGraphTools.graphTools).toHaveLength(1); // parent untouched
+  });
+
   it('strips parent-run-scoped initialSummary and discoveredTools from child inputs', () => {
     /**
      * Codex P1: a child inheriting `initialSummary` or `discoveredTools` from

package/src/tools/__tests__/ToolNode.session.test.ts

@@ -140,6 +140,52 @@ describe('ToolNode code execution session management', () => {
       expect(capturedConfigs[0]._injected_files).toBeUndefined();
     });
 
+    it('injects the existing session into declared host tools on the direct path', async () => {
+      const capturedConfigs: Record<string, unknown>[] = [];
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: 'host-session',
+        files: [
+          { id: 'g1', name: 'gen.png', storage_session_id: 'host-session' },
+        ],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      const cfTool = tool(
+        async (_input, config) => {
+          capturedConfigs.push({ ...(config.toolCall ?? {}) });
+          return 'Created /mnt/data/x.py';
+        },
+        {
+          name: 'create_file',
+          description: 'write a file',
+          schema: z.object({ path: z.string(), content: z.string() }),
+        }
+      ) as unknown as StructuredToolInterface;
+
+      const toolNode = new ToolNode({
+        tools: [cfTool],
+        sessions,
+        codeSessionToolNames: ['create_file', 'edit_file'],
+      });
+
+      const aiMsg = new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_cf',
+            name: 'create_file',
+            args: { path: '/mnt/data/x.py', content: 'print(1)' },
+          },
+        ],
+      });
+      await toolNode.invoke({ messages: [aiMsg] });
+
+      // Declared host tool writes into the current sandbox, not a fresh one.
+      expect(capturedConfigs).toHaveLength(1);
+      expect(capturedConfigs[0].session_id).toBe('host-session');
+    });
+
     it('preserves per-file storage_session_id for multi-session files', async () => {
       const capturedConfigs: Record<string, unknown>[] = [];
       const sessions: t.ToolSessionMap = new Map();
@@ -774,6 +820,78 @@ describe('ToolNode code execution session management', () => {
       expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
     });
 
+    it('stores the exec session for host tools declared in codeSessionToolNames', () => {
+      const sessions: t.ToolSessionMap = new Map();
+      const toolNode = new ToolNode({
+        tools: [createMockCodeTool({ capturedConfigs: [] })],
+        sessions,
+        eventDrivenMode: true,
+        codeSessionToolNames: ['create_file', 'edit_file'],
+      });
+
+      const storeMethod = (
+        toolNode as unknown as {
+          storeCodeSessionFromResults: (
+            results: t.ToolExecuteResult[],
+            requestMap: Map<string, t.ToolCallRequest>
+          ) => void;
+        }
+      ).storeCodeSessionFromResults.bind(toolNode);
+
+      storeMethod(
+        [
+          {
+            toolCallId: 'tc-cf',
+            content: 'Created /mnt/data/x.py (10 chars).',
+            artifact: { session_id: 'authoring-session' },
+            status: 'success',
+          },
+        ],
+        new Map([['tc-cf', { id: 'tc-cf', name: 'create_file', args: {} }]])
+      );
+
+      // create_file's exec session is folded into the shared code session, so a
+      // later bash_tool/execute_code call reuses the same sandbox.
+      const stored = sessions.get(Constants.EXECUTE_CODE) as
+        | t.CodeSessionContext
+        | undefined;
+      expect(stored?.session_id).toBe('authoring-session');
+    });
+
+    it('does not store a host authoring tool session when not declared', () => {
+      const sessions: t.ToolSessionMap = new Map();
+      const toolNode = new ToolNode({
+        tools: [createMockCodeTool({ capturedConfigs: [] })],
+        sessions,
+        eventDrivenMode: true,
+        // codeSessionToolNames omitted — create_file must NOT be treated as a
+        // code-session participant.
+      });
+
+      const storeMethod = (
+        toolNode as unknown as {
+          storeCodeSessionFromResults: (
+            results: t.ToolExecuteResult[],
+            requestMap: Map<string, t.ToolCallRequest>
+          ) => void;
+        }
+      ).storeCodeSessionFromResults.bind(toolNode);
+
+      storeMethod(
+        [
+          {
+            toolCallId: 'tc-cf2',
+            content: 'Created /mnt/data/x.py (10 chars).',
+            artifact: { session_id: 'authoring-session' },
+            status: 'success',
+          },
+        ],
+        new Map([['tc-cf2', { id: 'tc-cf2', name: 'create_file', args: {} }]])
+      );
+
+      expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
+    });
+
     it('ignores error results', () => {
       const sessions: t.ToolSessionMap = new Map();
 
@@ -1102,5 +1220,47 @@ describe('ToolNode code execution session management', () => {
       expect(capturedRequests[0].name).toBe('web_search');
       expect(capturedRequests[0].codeSessionContext).toBeUndefined();
     });
+
+    it('attaches codeSessionContext to declared host tools so they write into the current sandbox', async () => {
+      const sessions: t.ToolSessionMap = new Map();
+      sessions.set(Constants.EXECUTE_CODE, {
+        session_id: 'cf-session',
+        files: [
+          { id: 'g1', name: 'gen.png', storage_session_id: 'cf-session' },
+        ],
+        lastUpdated: Date.now(),
+      } satisfies t.CodeSessionContext);
+
+      const { capturedRequests } = captureBatchRequests();
+
+      const toolNode = new ToolNode({
+        tools: [createDummyTool('create_file')],
+        sessions,
+        eventDrivenMode: true,
+        codeSessionToolNames: ['create_file', 'edit_file'],
+        toolCallStepIds: new Map([['call_cf', 'step_cf']]),
+      });
+
+      const aiMsg = new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_cf',
+            name: 'create_file',
+            args: { path: '/mnt/data/x.py', content: 'print(1)' },
+          },
+        ],
+      });
+
+      await toolNode.invoke({ messages: [aiMsg] });
+
+      expect(capturedRequests).toHaveLength(1);
+      expect(capturedRequests[0].name).toBe('create_file');
+      // Existing session is injected so create_file writes into the current
+      // sandbox instead of spawning a separate one.
+      expect(capturedRequests[0].codeSessionContext?.session_id).toBe(
+        'cf-session'
+      );
+    });
   });
 });

package/src/tools/__tests__/hitl.test.ts

@@ -3996,6 +3996,91 @@ describe('AskUserQuestion — interrupt + resume', () => {
     expect(resumedAnswer).toBe('production');
   });
 
+  it('a DIRECT tool in event-driven mode can raise ask_user_question from its body and resume with the answer as its ToolMessage', async () => {
+    /**
+     * The production host shape (e.g. LibreChat's `AgentInputs.graphTools`
+     * plumb): the run is event-driven (other tools are schema-only
+     * definitions dispatched to the host), but an interrupt-capable tool is
+     * supplied as a real instance and marked direct so it executes inside
+     * the Pregel task frame. Event dispatch must never see the call — a
+     * host-side handler runs outside the graph, where `interrupt()` throws.
+     */
+    const { askUserQuestion } = await import('@/hitl');
+
+    const dispatchSpy = jest
+      .spyOn(events, 'safeDispatchCustomEvent')
+      .mockImplementation(async () => {});
+
+    let bodyRuns = 0;
+    const askTool = tool(
+      async (input: { question: string }) => {
+        bodyRuns += 1;
+        const resolution = askUserQuestion(input);
+        return resolution.answer;
+      },
+      {
+        name: 'ask_user_question',
+        description: 'Ask the user a clarifying question.',
+        schema: z.object({ question: z.string() }),
+      }
+    ) as unknown as StructuredToolInterface;
+
+    const node = new ToolNode({
+      tools: [createSchemaStub('echo'), askTool],
+      toolMap: new Map([
+        ['echo', createSchemaStub('echo')],
+        ['ask_user_question', askTool],
+      ]),
+      eventDrivenMode: true,
+      agentId: 'agent-ask-direct',
+      toolCallStepIds: new Map([['call_ask_1', 'step_call_ask_1']]),
+      directToolNames: new Set(['ask_user_question']),
+    });
+
+    const graph = buildHITLGraph(node, [
+      {
+        id: 'call_ask_1',
+        name: 'ask_user_question',
+        args: { question: 'Which environment?' },
+      },
+    ]);
+    const config = { configurable: { thread_id: 'thread-ask-direct' } };
+
+    const interrupted = await graph.invoke({ messages: [] }, config);
+    expect(isInterrupted<t.HumanInterruptPayload>(interrupted)).toBe(true);
+    if (!isInterrupted<t.HumanInterruptPayload>(interrupted)) {
+      throw new Error('expected interrupt');
+    }
+    const payload = interrupted.__interrupt__[0].value!;
+    if (payload.type !== 'ask_user_question') {
+      throw new Error('expected ask_user_question payload');
+    }
+    expect(payload.question.question).toBe('Which environment?');
+    expect(bodyRuns).toBe(1);
+
+    /** The interrupt came from the direct path — never dispatched to the host. */
+    const toolExecuteDispatches = dispatchSpy.mock.calls.filter(
+      ([event]) => event === 'on_tool_execute'
+    );
+    expect(toolExecuteDispatches).toHaveLength(0);
+
+    const resumed = (await resumeGraph(
+      graph,
+      interrupted,
+      { answer: 'staging' } satisfies t.AskUserQuestionResolution,
+      config
+    )) as MessagesUpdate;
+
+    expect(bodyRuns).toBe(2); // body re-runs from the top on the resume pass
+    const toolMessage = resumed.messages.find(
+      (m): m is ToolMessage =>
+        m._getType() === 'tool' &&
+        (m as ToolMessage).tool_call_id === 'call_ask_1'
+    );
+    expect(toolMessage).toBeDefined();
+    expect(String(toolMessage!.content)).toBe('staging');
+  });
+
   it('isAskUserQuestionInterrupt narrows the payload union correctly', async () => {
     const { isAskUserQuestionInterrupt, isToolApprovalInterrupt } =
       await import('@/types/hitl');

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

@@ -150,7 +150,8 @@ describe('JinaReranker', () => {
     });
 
     it('should log compact Axios errors without request internals', async () => {
-      const customUrl = 'https://test-jina-endpoint.com/v1/rerank?api_key=hidden';
+      const customUrl =
+        'https://test-jina-endpoint.com/v1/rerank?api_key=hidden';
       const reranker = new JinaReranker({
         apiKey: 'test-key',
         apiUrl: customUrl,
@@ -201,6 +202,49 @@ describe('JinaReranker', () => {
       expect(serializedMetadata).not.toContain('test-key');
       expect(serializedMetadata.length).toBeLessThan(500);
     });
+
+    it('should bound the rerank request with the default timeout', async () => {
+      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        logger: mockLogger,
+      });
+      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
+      const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
+        data: { results: [{ index: 0, relevance_score: 0.9 }] },
+      });
+
+      await reranker.rerank('test query', ['document1'], 1);
+
+      expect(postSpy).toHaveBeenCalledWith(
+        customUrl,
+        expect.any(Object),
+        expect.objectContaining({ timeout: 10000 })
+      );
+    });
+
+    it('should bound the rerank request with a custom timeout', async () => {
+      const customUrl = 'https://test-jina-endpoint.com/v1/rerank';
+      const reranker = new JinaReranker({
+        apiKey: 'test-key',
+        apiUrl: customUrl,
+        timeout: 2500,
+        logger: mockLogger,
+      });
+      jest.spyOn(mockLogger, 'debug').mockImplementation(() => mockLogger);
+      const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
+        data: { results: [{ index: 0, relevance_score: 0.9 }] },
+      });
+
+      await reranker.rerank('test query', ['document1'], 1);
+
+      expect(postSpy).toHaveBeenCalledWith(
+        customUrl,
+        expect.any(Object),
+        expect.objectContaining({ timeout: 2500 })
+      );
+    });
   });
 });
 
@@ -234,4 +278,29 @@ describe('createReranker', () => {
     const apiUrl = getApiUrl(reranker);
     expect(apiUrl).toBe('https://api.jina.ai/v1/rerank');
   });
+
+  it('should pass rerankerTimeout through to the rerank request', async () => {
+    const customUrl = 'https://custom-jina-endpoint.com/v1/rerank';
+    const reranker = createReranker({
+      rerankerType: 'jina',
+      jinaApiKey: 'test-key',
+      jinaApiUrl: customUrl,
+      rerankerTimeout: 4000,
+      logger: createDefaultLogger(),
+    });
+    if (!(reranker instanceof JinaReranker)) {
+      throw new Error('Expected createReranker to return a JinaReranker.');
+    }
+    const postSpy = jest.spyOn(axios, 'post').mockResolvedValueOnce({
+      data: { results: [{ index: 0, relevance_score: 0.9 }] },
+    });
+
+    await reranker.rerank('test query', ['document1'], 1);
+
+    expect(postSpy).toHaveBeenCalledWith(
+      customUrl,
+      expect.any(Object),
+      expect.objectContaining({ timeout: 4000 })
+    );
+  });
 });

package/src/tools/search/keenable-search.ts

@@ -0,0 +1,98 @@
+import axios from 'axios';
+import type * as t from './types';
+import { DATE_RANGE } from './schema';
+
+const DEFAULT_KEENABLE_TIMEOUT = 15000;
+
+/** Authenticated and keyless endpoints. Keenable works without an API key by
+ * falling back to the public endpoint; a key only lifts rate limits. */
+const KEENABLE_DEFAULT_API_URL = 'https://api.keenable.ai/v1/search';
+const KEENABLE_PUBLIC_API_URL = 'https://api.keenable.ai/v1/search/public';
+const KEENABLE_DATE_RANGES: Record<DATE_RANGE, string> = {
+  [DATE_RANGE.PAST_HOUR]: '1h',
+  [DATE_RANGE.PAST_24_HOURS]: '1d',
+  [DATE_RANGE.PAST_WEEK]: '7d',
+  [DATE_RANGE.PAST_MONTH]: '1mo',
+  [DATE_RANGE.PAST_YEAR]: '1y',
+};
+
+export const createKeenableAPI = (
+  apiKey?: string,
+  apiUrl?: string,
+  options?: t.KeenableSearchOptions
+): {
+  getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
+} => {
+  const resolvedKey = apiKey ?? process.env.KEENABLE_API_KEY;
+  const hasKey = resolvedKey != null && resolvedKey !== '';
+  const timeout = options?.timeout ?? DEFAULT_KEENABLE_TIMEOUT;
+  const resolvedUrl =
+    apiUrl ??
+    process.env.KEENABLE_API_URL ??
+    (hasKey ? KEENABLE_DEFAULT_API_URL : KEENABLE_PUBLIC_API_URL);
+
+  /** Constant for the provider's lifetime. X-Keenable-Title is required for
+   * keyless requests and used for traffic attribution; the API key only lifts
+   * rate limits, so it is sent only when present. */
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'X-Keenable-Title': options?.attributionTitle ?? 'LibreChat',
+  };
+  if (hasKey) {
+    headers['X-API-Key'] = resolvedKey;
+  }
+
+  const getSources = async ({
+    query,
+    date,
+    numResults = 8,
+  }: t.GetSourcesParams): Promise<t.SearchResult> => {
+    if (!query.trim()) {
+      return { success: false, error: 'Query cannot be empty' };
+    }
+
+    try {
+      /** Keenable's endpoint has no result-count parameter; the count is
+       * applied client-side after the response (see slice below). */
+      const payload: t.KeenableSearchPayload = { query };
+      if (options?.site != null && options.site !== '') {
+        payload.site = options.site;
+      }
+      if (date != null) {
+        payload.published_after = KEENABLE_DATE_RANGES[date];
+      }
+
+      const response = await axios.post<t.KeenableSearchResponse>(
+        resolvedUrl,
+        payload,
+        { headers, timeout }
+      );
+
+      const maxResults = Math.min(
+        Math.max(1, options?.maxResults ?? numResults),
+        20
+      );
+      const rawResults = Array.isArray(response.data.results)
+        ? response.data.results.slice(0, maxResults)
+        : [];
+
+      const organic: t.OrganicResult[] = rawResults.map((result) => ({
+        title: result.title ?? '',
+        link: result.url ?? '',
+        snippet: result.description ?? result.snippet ?? '',
+        date: result.published_at,
+      }));
+
+      return { success: true, data: { organic } };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: `Keenable API request failed: ${errorMessage}`,
+      };
+    }
+  };
+
+  return { getSources };
+};

package/src/tools/search/keenable.test.ts

@@ -0,0 +1,183 @@
+import axios from 'axios';
+import { createSearchAPI } from './search';
+import { createSearchTool } from './tool';
+import { DATE_RANGE } from './schema';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+const sampleResponse = {
+  data: {
+    results: [
+      {
+        title: 'TypeScript Best Practices 2026',
+        url: 'https://example.com/ts',
+        description: 'A comprehensive guide to TypeScript.',
+        published_at: '2026-01-15T10:30:00Z',
+      },
+      {
+        title: 'Second result',
+        url: 'https://example.com/second',
+        snippet: 'Snippet fallback when description is absent.',
+      },
+    ],
+  },
+};
+
+describe('Keenable search API', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete process.env.KEENABLE_API_KEY;
+    delete process.env.KEENABLE_API_URL;
+  });
+
+  it('returns an error for empty queries without calling the API', async () => {
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: '   ' });
+
+    expect(result).toEqual({ success: false, error: 'Query cannot be empty' });
+    expect(mockedAxios.post).not.toHaveBeenCalled();
+  });
+
+  it('hits the public endpoint and omits the API key header when keyless', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      'https://api.keenable.ai/v1/search/public',
+      { query: 'typescript' },
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'X-Keenable-Title': 'LibreChat' }),
+      })
+    );
+    const headers = mockedAxios.post.mock.calls[0][2]?.headers as Record<
+      string,
+      string
+    >;
+    expect(headers['X-API-Key']).toBeUndefined();
+    expect(result.success).toBe(true);
+  });
+
+  it('hits the authenticated endpoint and sends the API key when a key is set', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({
+      searchProvider: 'keenable',
+      keenableApiKey: 'secret-key',
+    });
+    await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      'https://api.keenable.ai/v1/search',
+      { query: 'typescript' },
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'X-API-Key': 'secret-key' }),
+      })
+    );
+  });
+
+  it('maps results into organic sources (description and snippet fallback)', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(result.data?.organic).toEqual([
+      {
+        title: 'TypeScript Best Practices 2026',
+        link: 'https://example.com/ts',
+        snippet: 'A comprehensive guide to TypeScript.',
+        date: '2026-01-15T10:30:00Z',
+      },
+      {
+        title: 'Second result',
+        link: 'https://example.com/second',
+        snippet: 'Snippet fallback when description is absent.',
+        date: undefined,
+      },
+    ]);
+  });
+
+  it('applies the site filter and limits results client-side', async () => {
+    mockedAxios.post.mockResolvedValueOnce({
+      data: {
+        results: [{ url: '1' }, { url: '2' }, { url: '3' }],
+      },
+    });
+
+    const searchAPI = createSearchAPI({
+      searchProvider: 'keenable',
+      keenableSearchOptions: { site: 'github.com', maxResults: 2 },
+    });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      expect.any(String),
+      { query: 'typescript', site: 'github.com' },
+      expect.any(Object)
+    );
+    expect(result.data?.organic).toHaveLength(2);
+  });
+
+  it('maps date ranges to Keenable published filters', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse);
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    await searchAPI.getSources({
+      query: 'typescript',
+      date: DATE_RANGE.PAST_WEEK,
+    });
+
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      expect.any(String),
+      { query: 'typescript', published_after: '7d' },
+      expect.any(Object)
+    );
+  });
+
+  it('surfaces request failures as a structured error', async () => {
+    mockedAxios.post.mockRejectedValueOnce(new Error('Network error'));
+
+    const searchAPI = createSearchAPI({ searchProvider: 'keenable' });
+    const result = await searchAPI.getSources({ query: 'typescript' });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Keenable API request failed: Network error');
+  });
+});
+
+describe('Keenable capability gating', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    delete process.env.KEENABLE_API_KEY;
+    delete process.env.KEENABLE_API_URL;
+  });
+
+  it('skips image/news/video sub-searches (organic-only provider)', async () => {
+    mockedAxios.post.mockResolvedValueOnce(sampleResponse).mockResolvedValue({
+      data: { success: true, data: { markdown: '# A', html: '<p>a</p>' } },
+    });
+
+    const searchTool = createSearchTool({
+      searchProvider: 'keenable',
+      scraperProvider: 'firecrawl',
+      firecrawlApiKey: 'k',
+      topResults: 1,
+      rerankerType: 'none',
+    });
+
+    await searchTool.invoke({
+      query: 'typescript',
+      images: true,
+      news: true,
+      videos: true,
+    });
+
+    const searchCalls = mockedAxios.post.mock.calls.filter(([url]) =>
+      (url as string).includes('keenable')
+    );
+    expect(searchCalls).toHaveLength(1);
+  });
+});