remove dead code

Author: icecrasher321

apps/sim/app/api/knowledge/[id]/documents/route.test.ts

@@ -457,11 +457,8 @@ describe('Knowledge Base Documents API Route', () => {
         },
       ],
       processingOptions: {
-        chunkSize: 1024,
-        minCharactersPerChunk: 100,
         recipe: 'default',
         lang: 'en',
-        chunkOverlap: 200,
       },
     }
 
@@ -533,11 +530,8 @@ describe('Knowledge Base Documents API Route', () => {
           },
         ],
         processingOptions: {
-          chunkSize: 50, // Invalid: too small
-          minCharactersPerChunk: 0, // Invalid: too small
           recipe: 'default',
           lang: 'en',
-          chunkOverlap: 1000, // Invalid: too large
         },
       }
 

apps/sim/app/api/knowledge/[id]/documents/route.ts

@@ -38,27 +38,14 @@ const CreateDocumentSchema = z.object({
   documentTagsData: z.string().optional(),
 })
 
-/**
- * Schema for bulk document creation with processing options.
- * Chunking fields are optional — the server falls back to the KB's stored chunkingConfig.
- *
- * Processing options units:
- * - chunkSize: tokens (1 token ≈ 4 characters)
- * - minCharactersPerChunk: characters
- * - chunkOverlap: tokens (1 token ≈ 4 characters)
- */
 const BulkCreateDocumentsSchema = z.object({
   documents: z.array(CreateDocumentSchema),
-  processingOptions: z.object({
-    /** Maximum chunk size in tokens (1 token ≈ 4 characters) */
-    chunkSize: z.number().min(100).max(4000).optional(),
-    /** Minimum chunk size in characters */
-    minCharactersPerChunk: z.number().min(1).max(2000).optional(),
-    recipe: z.string().optional(),
-    lang: z.string().optional(),
-    /** Overlap between chunks in tokens (1 token ≈ 4 characters) */
-    chunkOverlap: z.number().min(0).max(500).optional(),
-  }),
+  processingOptions: z
+    .object({
+      recipe: z.string().optional(),
+      lang: z.string().optional(),
+    })
+    .optional(),
   bulk: z.literal(true),
 })
 
@@ -247,8 +234,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
             knowledgeBaseId,
             documentsCount: createdDocuments.length,
             uploadType: 'bulk',
-            chunkSize: validatedData.processingOptions.chunkSize,
-            recipe: validatedData.processingOptions.recipe,
+            recipe: validatedData.processingOptions?.recipe,
           })
         } catch (_e) {
           // Silently fail
@@ -257,7 +243,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
         processDocumentsWithQueue(
           createdDocuments,
           knowledgeBaseId,
-          validatedData.processingOptions,
+          validatedData.processingOptions ?? {},
           requestId
         ).catch((error: unknown) => {
           logger.error(`[${requestId}] Critical error in document processing pipeline:`, error)

apps/sim/app/api/knowledge/[id]/documents/upsert/route.ts

@@ -25,13 +25,12 @@ const UpsertDocumentSchema = z.object({
   fileSize: z.number().min(1, 'File size must be greater than 0'),
   mimeType: z.string().min(1, 'MIME type is required'),
   documentTagsData: z.string().optional(),
-  processingOptions: z.object({
-    chunkSize: z.number().min(100).max(4000).optional(),
-    minCharactersPerChunk: z.number().min(1).max(2000).optional(),
-    recipe: z.string().optional(),
-    lang: z.string().optional(),
-    chunkOverlap: z.number().min(0).max(500).optional(),
-  }),
+  processingOptions: z
+    .object({
+      recipe: z.string().optional(),
+      lang: z.string().optional(),
+    })
+    .optional(),
   workflowId: z.string().optional(),
 })
 
@@ -166,7 +165,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
     processDocumentsWithQueue(
       createdDocuments,
       knowledgeBaseId,
-      validatedData.processingOptions,
+      validatedData.processingOptions ?? {},
       requestId
     ).catch((error: unknown) => {
       logger.error(`[${requestId}] Critical error in document processing pipeline:`, error)
@@ -178,8 +177,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
         knowledgeBaseId,
         documentsCount: 1,
         uploadType: 'single',
-        chunkSize: validatedData.processingOptions.chunkSize,
-        recipe: validatedData.processingOptions.recipe,
+        recipe: validatedData.processingOptions?.recipe,
       })
     } catch (_e) {
       // Silently fail

apps/sim/app/workspace/[workspaceId]/knowledge/components/create-base-modal/create-base-modal.tsx

@@ -269,9 +269,6 @@ export const CreateBaseModal = memo(function CreateBaseModal({
       if (files.length > 0) {
         try {
           const uploadedFiles = await uploadFiles(files, newKnowledgeBase.id, {
-            chunkSize: data.maxChunkSize,
-            minCharactersPerChunk: data.minChunkSize,
-            chunkOverlap: data.overlapSize,
             recipe: 'default',
           })
 

apps/sim/app/workspace/[workspaceId]/knowledge/hooks/use-knowledge-upload.ts

@@ -46,9 +46,6 @@ export interface UploadError {
 }
 
 export interface ProcessingOptions {
-  chunkSize?: number
-  minCharactersPerChunk?: number
-  chunkOverlap?: number
   recipe?: string
 }
 
@@ -1011,13 +1008,6 @@ export function useKnowledgeUpload(options: UseKnowledgeUploadOptions = {}) {
           ...file,
         })),
         processingOptions: {
-          ...(processingOptions.chunkSize != null && { chunkSize: processingOptions.chunkSize }),
-          ...(processingOptions.minCharactersPerChunk != null && {
-            minCharactersPerChunk: processingOptions.minCharactersPerChunk,
-          }),
-          ...(processingOptions.chunkOverlap != null && {
-            chunkOverlap: processingOptions.chunkOverlap,
-          }),
           recipe: processingOptions.recipe ?? 'default',
           lang: 'en',
         },

apps/sim/background/knowledge-processing.ts

@@ -15,11 +15,8 @@ export type DocumentProcessingPayload = {
     mimeType: string
   }
   processingOptions: {
-    chunkSize?: number
-    minCharactersPerChunk?: number
     recipe?: string
     lang?: string
-    chunkOverlap?: number
   }
   requestId: string
 }

apps/sim/lib/knowledge/documents/service.ts

@@ -101,11 +101,8 @@ export interface DocumentData {
 }
 
 export interface ProcessingOptions {
-  chunkSize?: number
-  minCharactersPerChunk?: number
   recipe?: string
   lang?: string
-  chunkOverlap?: number
 }
 
 export interface DocumentJobData {
@@ -416,13 +413,7 @@ export async function processDocumentAsync(
     fileSize: number
     mimeType: string
   },
-  processingOptions: {
-    chunkSize?: number
-    minCharactersPerChunk?: number
-    recipe?: string
-    lang?: string
-    chunkOverlap?: number
-  }
+  processingOptions: ProcessingOptions = {}
 ): Promise<void> {
   const startTime = Date.now()
   try {
@@ -1573,16 +1564,6 @@ export async function retryDocumentProcessing(
   },
   requestId: string
 ): Promise<{ success: boolean; status: string; message: string }> {
-  const kb = await db
-    .select({
-      chunkingConfig: knowledgeBase.chunkingConfig,
-    })
-    .from(knowledgeBase)
-    .where(eq(knowledgeBase.id, knowledgeBaseId))
-    .limit(1)
-
-  const kbConfig = kb[0].chunkingConfig as { maxSize: number; minSize: number; overlap: number }
-
   await db.transaction(async (tx) => {
     await tx.delete(embedding).where(eq(embedding.documentId, documentId))
 
@@ -1600,14 +1581,6 @@ export async function retryDocumentProcessing(
       .where(eq(document.id, documentId))
   })
 
-  const processingOptions = {
-    chunkSize: kbConfig.maxSize,
-    minCharactersPerChunk: kbConfig.minSize,
-    recipe: 'default',
-    lang: 'en',
-    chunkOverlap: kbConfig.overlap,
-  }
-
   await processDocumentsWithQueue(
     [
       {
@@ -1619,7 +1592,7 @@ export async function retryDocumentProcessing(
       },
     ],
     knowledgeBaseId,
-    processingOptions,
+    {},
     requestId
   )