fix(knowledge): skip platform reranker billing for BYOK Cohere keys

Cursor bugbot found that resolveCohereKey discarded BYOK status, so the
search route always added platform rerankerCost even when the workspace
supplied its own Cohere key.

Now resolveCohereKey returns { apiKey, isBYOK } and rerank() returns
{ results, isBYOK }. The search route checks rerankIsBYOK before adding
rerankerCost or emitting the rerankerCost/rerankerSearchUnits fields,
mirroring how generateEmbeddings handles BYOK billing.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: waleedlatif1

apps/docs/content/docs/en/tools/firecrawl.mdx

@@ -254,6 +254,8 @@ Parse uploaded documents (PDF, DOCX, HTML, etc.) into clean markdown using Firec
 | `proxy` | string | No | Proxy mode: "basic" or "auto" |
 | `zeroDataRetention` | boolean | No | Enable zero data retention. Defaults to false. |
 | `apiKey` | string | Yes | Firecrawl API key |
+| `pricing` | custom | No | No description |
+| `metadata` | string | No | No description |
 | `rateLimit` | string | No | No description |
 
 #### Output

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

@@ -358,15 +358,17 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       // `rerankApplied` = result ordering was actually replaced by the reranker output.
       let rerankBilled = false
       let rerankApplied = false
+      let rerankIsBYOK = false
       if (useReranker && rerankerModel && results.length > 0) {
         const candidateCount = results.length
         try {
-          const ranked = await rerank(
+          const { results: ranked, isBYOK } = await rerank(
             validatedData.query!,
             results.map((r) => ({ id: r.id, text: r.content })),
             { model: rerankerModel, topN: validatedData.topK, workspaceId }
           )
           rerankBilled = true
+          rerankIsBYOK = isBYOK
           if (ranked.length === 0) {
             logger.warn(
               `[${requestId}] Reranker returned 0 results; falling back to vector ordering`,
@@ -415,7 +417,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       // Add Cohere rerank cost (1 search unit per successful call, since we cap candidates ≤100).
       // Bill on every successful API response — Cohere charges even when 0 results are returned.
       let rerankerCost = 0
-      if (rerankBilled && rerankerModel) {
+      if (rerankBilled && rerankerModel && !rerankIsBYOK) {
         const pricing = getRerankModelPricing(rerankerModel)
         if (pricing) {
           rerankerCost = pricing.perSearchUnit
@@ -529,7 +531,9 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
                   },
                   model: queryEmbeddingModel,
                   pricing: cost.pricing,
-                  ...(rerankBilled ? { rerankerCost, rerankerModel, rerankerSearchUnits: 1 } : {}),
+                  ...(rerankBilled && !rerankIsBYOK
+                    ? { rerankerCost, rerankerModel, rerankerSearchUnits: 1 }
+                    : {}),
                 },
               }
             : {}),

apps/sim/lib/knowledge/reranker.ts

@@ -40,6 +40,12 @@ export interface RerankedResult<T extends RerankItem> {
   relevanceScore: number
 }
 
+export interface RerankResponse<T extends RerankItem> {
+  results: RerankedResult<T>[]
+  /** True when a workspace-supplied (BYOK) Cohere key was used. Callers should skip platform billing in that case. */
+  isBYOK: boolean
+}
+
 class RerankAPIError extends Error {
   public status: number
   constructor(message: string, status: number) {
@@ -49,18 +55,20 @@ class RerankAPIError extends Error {
   }
 }
 
-async function resolveCohereKey(workspaceId?: string | null): Promise<string> {
+async function resolveCohereKey(
+  workspaceId?: string | null
+): Promise<{ apiKey: string; isBYOK: boolean }> {
   if (workspaceId) {
     const byokResult = await getBYOKKey(workspaceId, 'cohere')
     if (byokResult) {
       logger.info('Using workspace BYOK key for Cohere reranker')
-      return byokResult.apiKey
+      return { apiKey: byokResult.apiKey, isBYOK: true }
     }
   }
   try {
-    return getRotatingApiKey('cohere')
+    return { apiKey: getRotatingApiKey('cohere'), isBYOK: false }
   } catch {
-    if (env.COHERE_API_KEY) return env.COHERE_API_KEY
+    if (env.COHERE_API_KEY) return { apiKey: env.COHERE_API_KEY, isBYOK: false }
     throw new Error(
       'No Cohere API key configured. Set COHERE_API_KEY_1/2/3 (rotation) or COHERE_API_KEY.'
     )
@@ -83,14 +91,14 @@ export async function rerank<T extends RerankItem>(
     topN?: number
     workspaceId?: string | null
   }
-): Promise<RerankedResult<T>[]> {
-  if (items.length === 0) return []
+): Promise<RerankResponse<T>> {
+  if (items.length === 0) return { results: [], isBYOK: false }
 
   if (!isSupportedRerankerModel(options.model)) {
     throw new Error(`Unsupported reranker model: ${options.model}`)
   }
 
-  const apiKey = await resolveCohereKey(options.workspaceId)
+  const { apiKey, isBYOK } = await resolveCohereKey(options.workspaceId)
   const cappedItems =
     items.length > MAX_DOCUMENTS_PER_RERANK ? items.slice(0, MAX_DOCUMENTS_PER_RERANK) : items
   if (items.length > MAX_DOCUMENTS_PER_RERANK) {
@@ -141,8 +149,11 @@ export async function rerank<T extends RerankItem>(
     }
   )
 
-  return response.results.map((r) => ({
-    item: cappedItems[r.index],
-    relevanceScore: r.relevance_score,
-  }))
+  return {
+    results: response.results.map((r) => ({
+      item: cappedItems[r.index],
+      relevanceScore: r.relevance_score,
+    })),
+    isBYOK,
+  }
 }