Function updateChunk

apps/sim/lib/knowledge/chunks/service.ts:330–518

(
  chunkId: string,
  updateData: {
    content?: string
    enabled?: boolean
  },
  requestId: string,
  workspaceId?: string | null
)

 * Update a single chunk
 */
export async function updateChunk(
  chunkId: string,
  updateData: {
    content?: string
    enabled?: boolean
  },
  requestId: string,
  workspaceId?: string | null
): Promise<ChunkData> {
  // Content updates run in a transaction to keep document statistics
  // consistent. The embedding API call happens BEFORE the transaction opens so
  // a held pooled connection never waits on external I/O; the transaction then
  // re-reads the chunk under a row lock and retries the whole flow in the rare
  // case a concurrent edit invalidated the regeneration decision.
  if (updateData.content !== undefined && typeof updateData.content === 'string') {
    const content = updateData.content
    const MAX_UPDATE_ATTEMPTS = 3

    for (let attempt = 1; attempt <= MAX_UPDATE_ATTEMPTS; attempt++) {
      const [preRead] = await db
        .select({ documentId: embedding.documentId, content: embedding.content })
        .from(embedding)
        .where(eq(embedding.id, chunkId))
        .limit(1)

      if (!preRead) {
        throw new Error(`Chunk ${chunkId} not found`)
      }

      // The embedding is a function of the new content alone, so generating it
      // outside the transaction is always valid.
      let regenerated: { embedding: number[]; tokenCount: number } | null = null
      if (content !== preRead.content) {
        const kbRow = await db
          .select({ embeddingModel: knowledgeBase.embeddingModel })
          .from(knowledgeBase)
          .innerJoin(document, eq(document.knowledgeBaseId, knowledgeBase.id))
          .where(eq(document.id, preRead.documentId))
          .limit(1)
        const chunkEmbeddingModel = kbRow[0]?.embeddingModel
        if (!chunkEmbeddingModel) {
          throw new Error('Knowledge base for chunk not found')
        }

        logger.info(`[${requestId}] Content changed, regenerating embedding for chunk ${chunkId}`)
        const { embeddings } = await generateEmbeddings([content], chunkEmbeddingModel, workspaceId)
        regenerated = {
          embedding: embeddings[0],
          tokenCount: estimateTokenCount(
            content,
            getEmbeddingModelInfo(chunkEmbeddingModel).tokenizerProvider
          ).count,
        }
      }

      const result = await db.transaction(async (tx) => {
        const currentChunk = await tx
          .select({