chore: import upstream snapshot with attribution

apps/sim/tools/knowledge/search.ts

@@ -0,0 +1,210 @@
+import { DEFAULT_RERANKER_MODEL } from '@/lib/knowledge/reranker-models'
+import type { KnowledgeSearchResponse } from '@/tools/knowledge/types'
+import { enrichKBTagFiltersSchema } from '@/tools/schema-enrichers'
+import { parseTagFilters } from '@/tools/shared/tags'
+import type { ToolConfig } from '@/tools/types'
+
+export const knowledgeSearchTool: ToolConfig<any, KnowledgeSearchResponse> = {
+  id: 'knowledge_search',
+  name: 'Knowledge Search',
+  description: 'Search for similar content in a knowledge base using vector similarity',
+  version: '1.0.0',
+
+  params: {
+    knowledgeBaseId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'ID of the knowledge base to search in',
+    },
+    query: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Search query text (optional when using tag filters)',
+    },
+    topK: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Number of most similar results to return (1-100)',
+    },
+    tagFilters: {
+      type: 'array',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Array of tag filters with tagName and tagValue properties',
+      items: {
+        type: 'object',
+        properties: {
+          tagName: { type: 'string' },
+          tagValue: { type: 'string' },
+        },
+      },
+    },
+    rerankerEnabled: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Whether to apply Cohere reranking to vector search results',
+    },
+    rerankerModel: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description:
+        'Cohere rerank model to use (one of: rerank-v4.0-pro, rerank-v4.0-fast, rerank-v3.5)',
+    },
+    rerankerInputCount: {
+      type: 'number',
+      required: false,
+      visibility: 'user-only',
+      description:
+        'Number of vector results sent to the Cohere reranker (1–100). Defaults to topK × 4 capped at 100.',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Cohere API key for reranker (self-hosted deployments only)',
+    },
+  },
+
+  schemaEnrichment: {
+    tagFilters: {
+      dependsOn: 'knowledgeBaseId',
+      enrichSchema: enrichKBTagFiltersSchema,
+    },
+  },
+
+  request: {
+    url: () => '/api/knowledge/search',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => {
+      const workflowId = params._context?.workflowId
+
+      // Use single knowledge base ID
+      const knowledgeBaseIds = [params.knowledgeBaseId]
+
+      // Parse tag filters from various formats (array, JSON string)
+      const structuredFilters = parseTagFilters(params.tagFilters)
+
+      const rerankerEnabled = params.rerankerEnabled === true || params.rerankerEnabled === 'true'
+      const rerankerModel =
+        typeof params.rerankerModel === 'string' && params.rerankerModel.length > 0
+          ? params.rerankerModel
+          : DEFAULT_RERANKER_MODEL
+      const rerankerApiKey =
+        typeof params.apiKey === 'string' && params.apiKey.length > 0 ? params.apiKey : undefined
+      const rawInputCount =
+        params.rerankerInputCount !== undefined &&
+        params.rerankerInputCount !== null &&
+        params.rerankerInputCount !== ''
+          ? Number(params.rerankerInputCount)
+          : Number.NaN
+      const rerankerInputCount = Number.isFinite(rawInputCount)
+        ? Math.max(1, Math.min(100, Math.floor(rawInputCount)))
+        : undefined
+
+      const requestBody = {
+        knowledgeBaseIds,
+        query: params.query,
+        topK: params.topK ? Math.max(1, Math.min(100, Number(params.topK))) : 10,
+        ...(structuredFilters.length > 0 && { tagFilters: structuredFilters }),
+        ...(rerankerEnabled && {
+          rerankerEnabled: true,
+          rerankerModel,
+          ...(rerankerInputCount !== undefined && { rerankerInputCount }),
+          ...(rerankerApiKey && { rerankerApiKey }),
+        }),
+        ...(workflowId && { workflowId }),
+        // The executor rolls this search's cost up at workflow completion, so
+        // tell the route not to also meter it (avoids double-billing).
+        skipUsageBilling: true,
+      }
+
+      return requestBody
+    },
+  },
+  transformResponse: async (response): Promise<KnowledgeSearchResponse> => {
+    const result = await response.json()
+    const data = result.data || result
+
+    // Restructure cost: extract tokens/model to top level for logging
+    let costFields: Record<string, unknown> = {}
+    if (data.cost && typeof data.cost === 'object') {
+      const {
+        tokens,
+        model,
+        input,
+        output: outputCost,
+        total,
+        rerankerCost,
+        rerankerModel,
+        rerankerSearchUnits,
+      } = data.cost
+      costFields = {
+        cost: {
+          input,
+          output: outputCost,
+          total,
+          ...(typeof rerankerCost === 'number' && { rerankerCost }),
+          ...(typeof rerankerModel === 'string' && { rerankerModel }),
+          ...(typeof rerankerSearchUnits === 'number' && { rerankerSearchUnits }),
+        },
+        ...(tokens && { tokens }),
+        ...(model && { model }),
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        results: data.results || [],
+        query: data.query,
+        totalResults: data.totalResults || 0,
+        ...costFields,
+      },
+    }
+  },
+
+  outputs: {
+    results: {
+      type: 'array',
+      description: 'Array of search results from the knowledge base',
+      items: {
+        type: 'object',
+        properties: {
+          documentId: { type: 'string', description: 'Document ID' },
+          documentName: { type: 'string', description: 'Document name' },
+          sourceUrl: {
+            type: 'string',
+            nullable: true,
+            description:
+              'URL to the original source document (e.g., Confluence page, Google Doc, Notion page). Null for documents without an external source.',
+          },
+          content: { type: 'string', description: 'Content of the result' },
+          chunkIndex: { type: 'number', description: 'Index of the chunk within the document' },
+          similarity: { type: 'number', description: 'Similarity score of the result' },
+          metadata: { type: 'object', description: 'Metadata of the result, including tags' },
+        },
+      },
+    },
+    query: {
+      type: 'string',
+      description: 'The search query that was executed',
+    },
+    totalResults: {
+      type: 'number',
+      description: 'Total number of results found',
+    },
+    cost: {
+      type: 'object',
+      description: 'Cost information for the search operation',
+      optional: true,
+    },
+  },
+}