fix(knowledge): check the window on the request, rerank with any key, and start a refined search at its first page

- the filters schema stays a plain object so the Assistant's search input can still extend it; the window's order is checked on the request body
- the dashboard asks for reranking outright, and the use case reranks only when the workspace or the platform holds a key
- a refinement of the filters starts over at the first page after the reader asked for more
- a custom window's days are the reader's local days

Author: waleedlatif1

apps/sim/app/api/knowledge/search/route.test.ts

@@ -6,9 +6,6 @@ import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({ search: vi.fn() }))
-const { mockHasRotatingApiKey } = vi.hoisted(() => ({ mockHasRotatingApiKey: vi.fn(() => true) }))
-vi.mock('@/lib/core/config/api-keys', () => ({ hasRotatingApiKey: mockHasRotatingApiKey }))
-
 vi.mock('@/lib/knowledge/application/workspace-search', () => ({
   searchScopedKnowledge: { operation: { id: 'knowledge.search' }, execute: mocks.search },
 }))
@@ -50,8 +47,7 @@ describe('workspace search route', () => {
     expect(call.input.signal).toBe(request.signal)
     expect(call.input.allowPartialResults).toBe(true)
     expect(call.input.vectorBudgetMs).toBe(3000)
-    /** A person's search is reranked by the platform's cross-encoder whenever one is configured. */
-    expect(mockHasRotatingApiKey).toHaveBeenCalledWith('cohere')
+    /** A person's search asks for reranking; the use case reranks when a credential exists. */
     expect(call.input.rerankerEnabled).toBe(true)
     expect(call.input.rerankerModel).toBe('rerank-v4.0-fast')
     controller.abort()

apps/sim/app/api/knowledge/search/route.ts

@@ -4,7 +4,6 @@ import {
   internalRateLimits,
   internalSessionAuth,
 } from '@/lib/api/server/routes'
-import { hasRotatingApiKey } from '@/lib/core/config/api-keys'
 import { internalKnowledgeErrorPolicies } from '@/lib/knowledge/api/route-policies'
 import { knowledgeOperations } from '@/lib/knowledge/application/operations'
 import { searchScopedKnowledge } from '@/lib/knowledge/application/workspace-search'
@@ -31,10 +30,11 @@ export const POST = defineInternalJsonRoute({
     allowPartialResults: true,
     vectorBudgetMs: DIRECT_SEARCH_VECTOR_BUDGET_MS,
     /**
-     * A person's search is reranked by the platform's cross-encoder when one is configured;
-     * reranking is best-effort, so a provider outage leaves the fused order in place.
+     * A person's search is reranked by a cross-encoder whenever the workspace or the platform
+     * holds a key for one; the use case checks that before spending a call, and reranking stays
+     * best-effort, so a provider outage leaves the fused order in place.
      */
-    rerankerEnabled: hasRotatingApiKey('cohere'),
+    rerankerEnabled: true,
     rerankerModel: DEFAULT_RERANKER_MODEL,
     surface: 'dashboard' as const,
     signal: request.signal,

apps/sim/app/workspace/[workspaceId]/home/components/knowledge-search-results/knowledge-search-results.test.tsx

@@ -196,6 +196,35 @@ describe('result paging and the custom window', () => {
     expect(more()).toBeUndefined()
   })
 
+  it('starts a refined search over at the first page after the reader asked for more', async () => {
+    mocks.overview.mockReturnValue({
+      data: {
+        providers: [{ connectorType: 'slack', isSyncing: false }],
+        hasSearchableDocuments: true,
+      },
+    })
+    mocks.search.mockReturnValue({
+      data: {
+        query: 'launch',
+        results: Array.from({ length: 20 }, (_, n) => result(n)),
+        retrieval: { status: 'complete', timedOutLegs: [] },
+      },
+      isPending: false,
+      isFetching: false,
+      isPlaceholderData: false,
+      isError: false,
+      refetch: mocks.retry,
+    })
+    await render()
+    const button = (label: string) =>
+      [...container.querySelectorAll('button')].find((b) => b.textContent === label)!
+    await act(async () => button('Show more').click())
+    expect(mocks.search.mock.calls.at(-1)![3]).toBe(50)
+    await act(async () => button('Slack').click())
+    expect(mocks.search.mock.calls.at(-1)![2]).toEqual({ source: 'slack' })
+    expect(mocks.search.mock.calls.at(-1)![3]).toBe(20)
+  })
+
   it('searches a custom window as an inclusive range of days', async () => {
     mocks.overview.mockReturnValue({ data: { providers: [], hasSearchableDocuments: true } })
     mocks.search.mockReturnValue({
@@ -208,7 +237,8 @@ describe('result paging and the custom window', () => {
     })
     await render(undefined, '?updated=custom&from=2026-09-01&to=2026-09-10')
     const filters = mocks.search.mock.calls.at(-1)![2]
-    expect(filters.modifiedAfter).toBe('2026-09-01T00:00:00.000Z')
-    expect(filters.modifiedBefore).toBe('2026-09-10T23:59:59.999Z')
+    /** The days are the reader's own: local midnight to the last millisecond of the local day. */
+    expect(filters.modifiedAfter).toBe(new Date(2026, 8, 1).toISOString())
+    expect(filters.modifiedBefore).toBe(new Date(2026, 8, 11, 0, 0, 0, -1).toISOString())
   })
 })

apps/sim/app/workspace/[workspaceId]/home/components/knowledge-search-results/knowledge-search-results.tsx

@@ -28,6 +28,17 @@ import { useSearchIndex, useSearchSourceOverview } from '@/hooks/queries/kb/conn
 import { useWorkspaceKnowledgeSearch } from '@/hooks/queries/kb/knowledge'
 
 const DAY_MS = 24 * 60 * 60 * 1000
+
+/**
+ * The picker names calendar days; the URL keeps them as dates. A day's bounds are its local
+ * midnight and the last millisecond before the next, so "September 1" means the reader's own day.
+ */
+function startOfLocalDay(day: Date): Date {
+  return new Date(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate())
+}
+function endOfLocalDay(day: Date): Date {
+  return new Date(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate() + 1, 0, 0, 0, -1)
+}
 /** Every result without a connector is an upload; the filter names them so. */
 const UPLOAD_SOURCE = 'upload'
 
@@ -128,8 +139,11 @@ interface SearchResultsProps {
 function SearchResults({ scope, query, onSummarize }: SearchResultsProps) {
   const [hasShownFilters, setHasShownFilters] = useState(false)
   const [searchedAt] = useState(Date.now)
-  /** More results are a second, wider search: the first paint stays as quick as it is. */
-  const [expanded, setExpanded] = useState(false)
+  /**
+   * More results are a second, wider search: the first paint stays as quick as it is, and a
+   * refinement of the filters starts over at the first page.
+   */
+  const [expandedFor, setExpandedFor] = useState<string | null>(null)
   const {
     data: index,
     isPending: basesPending,
@@ -146,11 +160,13 @@ function SearchResults({ scope, query, onSummarize }: SearchResultsProps) {
     ...(window?.days
       ? { modifiedAfter: new Date(searchedAt - window.days * DAY_MS).toISOString() }
       : {}),
-    ...(custom && filters.from ? { modifiedAfter: filters.from.toISOString() } : {}),
-    ...(custom && filters.to
-      ? { modifiedBefore: new Date(filters.to.getTime() + DAY_MS - 1).toISOString() }
+    ...(custom && filters.from
+      ? { modifiedAfter: startOfLocalDay(filters.from).toISOString() }
       : {}),
+    ...(custom && filters.to ? { modifiedBefore: endOfLocalDay(filters.to).toISOString() } : {}),
   }
+  const filtersKey = JSON.stringify(searchFilters)
+  const expanded = expandedFor === filtersKey
   const {
     data: search,
     isPending,
@@ -323,7 +339,11 @@ function SearchResults({ scope, query, onSummarize }: SearchResultsProps) {
           })}
           {mayHaveMore && (
             <div className='flex px-2 py-2'>
-              <Chip variant='border' disabled={isFetching} onClick={() => setExpanded(true)}>
+              <Chip
+                variant='border'
+                disabled={isFetching}
+                onClick={() => setExpandedFor(filtersKey)}
+              >
                 Show more
               </Chip>
             </div>

apps/sim/lib/api/contracts/knowledge/search.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'vitest'
-import { internalKnowledgeSearchBodySchema } from '@/lib/api/contracts/knowledge/search'
+import {
+  internalKnowledgeSearchBodySchema,
+  workspaceKnowledgeSearchBodySchema,
+  workspaceSearchFiltersSchema,
+} from '@/lib/api/contracts/knowledge/search'
 import { RESOLVED_SECRET_PROVENANCE_FIELD } from '@/lib/execution/private-tool-metadata'
 
 describe('internal Knowledge search contract', () => {
@@ -20,3 +24,22 @@ describe('internal Knowledge search contract', () => {
     ).toMatchObject({ [RESOLVED_SECRET_PROVENANCE_FIELD]: provenance })
   })
 })
+
+describe('workspaceKnowledgeSearchBodySchema', () => {
+  it('refuses a custom window whose end precedes its start, on the request rather than the filters', () => {
+    const parsed = workspaceKnowledgeSearchBodySchema.safeParse({
+      workspaceId: 'workspace-1',
+      query: 'launch',
+      filters: {
+        modifiedAfter: '2026-09-10T00:00:00.000Z',
+        modifiedBefore: '2026-09-01T00:00:00.000Z',
+      },
+    })
+    expect(parsed.success).toBe(false)
+    if (!parsed.success) {
+      expect(parsed.error.issues[0]?.path).toEqual(['filters', 'modifiedBefore'])
+    }
+    /** The filters schema stays a plain object, so the Assistant's search input can still extend it. */
+    expect(typeof workspaceSearchFiltersSchema.extend).toBe('function')
+  })
+})

apps/sim/lib/api/contracts/knowledge/search.ts

@@ -172,38 +172,36 @@ export const workspaceKnowledgeSearchResultSchema = z.object({
 })
 export type WorkspaceKnowledgeSearchResult = z.output<typeof workspaceKnowledgeSearchResultSchema>
 
-export const workspaceSearchFiltersSchema = z
-  .object({
-    source: z.string().trim().min(1, 'Source cannot be empty').max(100).optional(),
-    modifiedAfter: z.string().datetime({ offset: true }).optional(),
-    modifiedBefore: z.string().datetime({ offset: true }).optional(),
-    documentIds: z.array(z.string().min(1).max(200)).min(1).max(20).optional(),
-  })
-  .superRefine((filters, ctx) => {
-    if (
-      filters.modifiedAfter &&
-      filters.modifiedBefore &&
-      Date.parse(filters.modifiedBefore) < Date.parse(filters.modifiedAfter)
-    ) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['modifiedBefore'],
-        message: 'modifiedBefore must not precede modifiedAfter',
-      })
-    }
-  })
+/** A plain object, so the Assistant's search input may still extend it; the window's order is checked on the request. */
+export const workspaceSearchFiltersSchema = z.object({
+  source: z.string().trim().min(1, 'Source cannot be empty').max(100).optional(),
+  modifiedAfter: z.string().datetime({ offset: true }).optional(),
+  modifiedBefore: z.string().datetime({ offset: true }).optional(),
+  documentIds: z.array(z.string().min(1).max(200)).min(1).max(20).optional(),
+})
 export type WorkspaceSearchFilters = z.output<typeof workspaceSearchFiltersSchema>
 
 /** Chunks a search asks for at first paint, and once the reader asks for more; both within `topK`'s bound. */
 export const WORKSPACE_KNOWLEDGE_SEARCH_LIMITS = { initial: 20, expanded: 50 } as const
 export type WorkspaceKnowledgeSearchLimit =
   (typeof WORKSPACE_KNOWLEDGE_SEARCH_LIMITS)[keyof typeof WORKSPACE_KNOWLEDGE_SEARCH_LIMITS]
 
-export const workspaceKnowledgeSearchBodySchema = resourceOwnerSchema.safeExtend({
-  filters: workspaceSearchFiltersSchema.optional(),
-  query: z.string().trim().min(1, 'A search query is required').max(2000, 'Query is too long'),
-  topK: z.number().int().min(1).max(50).optional().default(20),
-})
+export const workspaceKnowledgeSearchBodySchema = resourceOwnerSchema
+  .safeExtend({
+    filters: workspaceSearchFiltersSchema.optional(),
+    query: z.string().trim().min(1, 'A search query is required').max(2000, 'Query is too long'),
+    topK: z.number().int().min(1).max(50).optional().default(20),
+  })
+  .superRefine((body, ctx) => {
+    const { modifiedAfter, modifiedBefore } = body.filters ?? {}
+    if (modifiedAfter && modifiedBefore && Date.parse(modifiedBefore) < Date.parse(modifiedAfter)) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['filters', 'modifiedBefore'],
+        message: 'modifiedBefore must not precede modifiedAfter',
+      })
+    }
+  })
 export type WorkspaceKnowledgeSearchBody = z.input<typeof workspaceKnowledgeSearchBodySchema>
 
 export const workspaceKnowledgeSearchDataSchema = z.object({

apps/sim/lib/knowledge/application/search.test.ts

@@ -8,6 +8,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 
 const mocks = vi.hoisted(() => ({
+  hasRerankerCredential: vi.fn(async () => true),
   resolveWorkspace: vi.fn(),
   resolveOrganization: vi.fn(),
   requireOrganizationSearch: vi.fn(),
@@ -39,6 +40,7 @@ vi.mock('@/lib/knowledge/search/activity', () => ({
 }))
 
 vi.mock('@/lib/knowledge/reranker', () => ({
+  hasRerankerCredential: mocks.hasRerankerCredential,
   rerank: mocks.rerank,
 }))
 
@@ -866,6 +868,16 @@ describe('knowledge search application use case', () => {
      * `rerank`, the use case swallowed it, and the caller got a 200 whose results
      * were byte-identical to an unreranked search with nothing to distinguish them.
      */
+    it('never calls the reranker when neither the workspace nor the platform holds a key', async () => {
+      mocks.hasRerankerCredential.mockResolvedValueOnce(false)
+
+      const result = await rerankedSearch(true)
+
+      expect(mocks.rerank).not.toHaveBeenCalled()
+      expect(result.rerankerStatus).toBe('unavailable')
+      expect(result.results[0]).not.toHaveProperty('rerankerScore')
+    })
+
     it('reports unavailable rather than silently falling back to vector ordering', async () => {
       mocks.rerank.mockRejectedValueOnce(new Error('No Cohere API key configured.'))
 

apps/sim/lib/knowledge/application/search.ts

@@ -34,7 +34,7 @@ import { ALL_TAG_SLOTS } from '@/lib/knowledge/constants'
 import { getEmbeddingModelInfo, toKbEmbeddingDimensions } from '@/lib/knowledge/embedding-models'
 import { generateSearchEmbedding, type KbEmbeddingTarget } from '@/lib/knowledge/embeddings'
 import { runWithKnowledgeModelInputProvenance } from '@/lib/knowledge/model-input-provenance'
-import { rerank } from '@/lib/knowledge/reranker'
+import { hasRerankerCredential, rerank } from '@/lib/knowledge/reranker'
 import type { RerankerStatus } from '@/lib/knowledge/reranker-models'
 import { recordOrganizationSearchActivity } from '@/lib/knowledge/search/activity'
 import { SearchDeadlineError } from '@/lib/knowledge/search/budget'
@@ -391,7 +391,10 @@ const searchKnowledgeUseCase = defineAuthorizedKnowledgeUseCase({
       boostRecency: searchDefaults.boostRecency,
       embeddingDimensions: embeddingTarget?.dimensions,
     })
-    const useReranker = Boolean(input.rerankerEnabled && hasQuery)
+    /** A surface may ask to rerank; without a key for the workspace or the platform there is nothing to ask. */
+    const useReranker =
+      Boolean(input.rerankerEnabled && hasQuery) &&
+      (Boolean(input.rerankerApiKey) || (await hasRerankerCredential(context.workspaceId)))
     const candidateTopK = useReranker
       ? input.rerankerInputCount !== undefined
         ? Math.min(

apps/sim/lib/knowledge/reranker.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@sim/logger'
 import { sha256Hex } from '@sim/security/hash'
 import { backoffWithJitter, parseRetryAfter } from '@sim/utils/retry'
 import { getBYOKKey } from '@/lib/api-key/byok'
-import { getRotatingApiKey } from '@/lib/core/config/api-keys'
+import { getRotatingApiKey, hasRotatingApiKey } from '@/lib/core/config/api-keys'
 import { env } from '@/lib/core/config/env'
 import { isHosted } from '@/lib/core/config/env-flags'
 import {
@@ -30,6 +30,15 @@ const logger = createLogger('Reranker')
 
 const RERANK_OPERATION_TIMEOUT_MS = 30_000
 
+/**
+ * Whether a search for this workspace could be reranked at all: a workspace key, or one of the
+ * platform's. A surface that reranks "when configured" asks this before spending a call on it.
+ */
+export async function hasRerankerCredential(workspaceId?: string): Promise<boolean> {
+  if (workspaceId && (await getBYOKKey(workspaceId, 'cohere'))) return true
+  return Boolean(env.COHERE_API_KEY) || hasRotatingApiKey('cohere')
+}
+
 /**
  * Cohere bills per "search unit" = one query with up to 100 documents.
  * We cap at 100 so each rerank call costs exactly 1 unit and matches