subochev
dba52d22fd
- SHA-256 на commonMain + SessionRegistry (LCP по префикс-хэшам, LRU 1000/6ч, Mutex) - providers[].session_header: прокси сам ставит/перезаписывает заголовок сессии - цепочка хэшей стартует с первого user-сообщения (system не склеивает сессии) - CONFIG.md + тесты (SHA-256, LCP, LRU/TTL, парсинг, стабильность префиксов)
207 lines
8.6 KiB
Kotlin
207 lines
8.6 KiB
Kotlin
package pw.binom.llmproxy
|
|
|
|
import kotlinx.coroutines.sync.Mutex
|
|
import kotlinx.coroutines.sync.withLock
|
|
import kotlinx.datetime.Clock
|
|
import kotlinx.serialization.json.JsonArray
|
|
import kotlinx.serialization.json.JsonElement
|
|
import kotlinx.serialization.json.JsonObject
|
|
import kotlinx.serialization.json.JsonPrimitive
|
|
|
|
/**
|
|
* SHA-256, чистая реализация на commonMain (без внешних зависимостей —
|
|
* KMP-зеркало их не отдаёт). Нужен для стабильного хэша префиксов истории.
|
|
*/
|
|
internal object Sha256 {
|
|
private val K = intArrayOf(
|
|
0x428a2f98, 0x71374491, 0xb5c0fbcf.toInt(), 0xe9b5dba5.toInt(), 0x3956c25b, 0x59f111f1, 0x923f82a4.toInt(), 0xab1c5ed5.toInt(),
|
|
0xd807aa98.toInt(), 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe.toInt(), 0x9bdc06a7.toInt(), 0xc19bf174.toInt(),
|
|
0xe49b69c1.toInt(), 0xefbe4786.toInt(), 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
|
0x983e5152.toInt(), 0xa831c66d.toInt(), 0xb00327c8.toInt(), 0xbf597fc7.toInt(), 0xc6e00bf3.toInt(), 0xd5a79147.toInt(), 0x06ca6351, 0x14292967,
|
|
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e.toInt(), 0x92722c85.toInt(),
|
|
0xa2bfe8a1.toInt(), 0xa81a664b.toInt(), 0xc24b8b70.toInt(), 0xc76c51a3.toInt(), 0xd192e819.toInt(), 0xd6990624.toInt(), 0xf40e3585.toInt(), 0x106aa070,
|
|
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
|
0x748f82ee, 0x78a5636f, 0x84c87814.toInt(), 0x8cc70208.toInt(), 0x90befffa.toInt(), 0xa4506ceb.toInt(), 0xbef9a3f7.toInt(), 0xc67178f2.toInt(),
|
|
)
|
|
|
|
private fun rotr(x: Int, n: Int): Int = (x ushr n) or (x shl (32 - n))
|
|
|
|
private fun pad(input: ByteArray): ByteArray {
|
|
val total = ((input.size + 9 + 63) / 64) * 64
|
|
val out = ByteArray(total)
|
|
input.copyInto(out)
|
|
out[input.size] = 0x80.toByte()
|
|
val bits = input.size.toLong() * 8
|
|
for (k in 0 until 8) {
|
|
out[total - 1 - k] = (bits ushr (8 * k)).toByte()
|
|
}
|
|
return out
|
|
}
|
|
|
|
fun hash(input: ByteArray): ByteArray {
|
|
val msg = pad(input)
|
|
val h = intArrayOf(
|
|
0x6a09e667, 0xbb67ae85.toInt(), 0x3c6ef372, 0xa54ff53a.toInt(),
|
|
0x510e527f, 0x9b05688c.toInt(), 0x1f83d9ab, 0x5be0cd19,
|
|
)
|
|
val w = IntArray(64)
|
|
var i = 0
|
|
while (i < msg.size) {
|
|
for (j in 0 until 16) {
|
|
w[j] = ((msg[i + j * 4].toInt() and 0xff) shl 24) or
|
|
((msg[i + j * 4 + 1].toInt() and 0xff) shl 16) or
|
|
((msg[i + j * 4 + 2].toInt() and 0xff) shl 8) or
|
|
(msg[i + j * 4 + 3].toInt() and 0xff)
|
|
}
|
|
for (j in 16 until 64) {
|
|
val s0 = rotr(w[j - 15], 7) xor rotr(w[j - 15], 18) xor (w[j - 15] ushr 3)
|
|
val s1 = rotr(w[j - 2], 17) xor rotr(w[j - 2], 19) xor (w[j - 2] ushr 10)
|
|
w[j] = w[j - 16] + s0 + w[j - 7] + s1
|
|
}
|
|
var a = h[0]; var b = h[1]; var c = h[2]; var d = h[3]
|
|
var e = h[4]; var f = h[5]; var g = h[6]; var hh = h[7]
|
|
for (j in 0 until 64) {
|
|
val s1 = rotr(e, 6) xor rotr(e, 11) xor rotr(e, 25)
|
|
val ch = (e and f) xor (e.inv() and g)
|
|
val t1 = hh + s1 + ch + K[j] + w[j]
|
|
val s0 = rotr(a, 2) xor rotr(a, 13) xor rotr(a, 22)
|
|
val maj = (a and b) xor (a and c) xor (b and c)
|
|
val t2 = s0 + maj
|
|
hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2
|
|
}
|
|
h[0] += a; h[1] += b; h[2] += c; h[3] += d
|
|
h[4] += e; h[5] += f; h[6] += g; h[7] += hh
|
|
i += 64
|
|
}
|
|
val out = ByteArray(32)
|
|
for (j in 0 until 8) {
|
|
out[j * 4] = (h[j] ushr 24).toByte()
|
|
out[j * 4 + 1] = (h[j] ushr 16).toByte()
|
|
out[j * 4 + 2] = (h[j] ushr 8).toByte()
|
|
out[j * 4 + 3] = h[j].toByte()
|
|
}
|
|
return out
|
|
}
|
|
}
|
|
|
|
private const val HEX = "0123456789abcdef"
|
|
|
|
/** SHA-256 строки (UTF-8) в нижнем hex. */
|
|
internal fun sha256Hex(text: String): String {
|
|
val bytes = Sha256.hash(text.encodeToByteArray())
|
|
val sb = StringBuilder(bytes.size * 2)
|
|
for (b in bytes) {
|
|
val v = b.toInt() and 0xff
|
|
sb.append(HEX[v ushr 4]).append(HEX[v and 0xf])
|
|
}
|
|
return sb.toString()
|
|
}
|
|
|
|
/**
|
|
* Инкрементальные префикс-хэши истории: H_i = sha256(H_{i-1} + "\u0000" + msg_i).
|
|
*
|
|
* Цепочка начинается с первого `user`-сообщения: system-промпт обычно
|
|
* идентичен у всех сессий одного клиента и как признак сессии бесполезен
|
|
* (иначе LCP склеивает все сессии на общем префиксе `[system]`).
|
|
* Если `messages` нет/пусто — fallback на хэш всего тела.
|
|
*/
|
|
internal fun sessionPrefixHashes(body: JsonObject): List<String> {
|
|
val messages = body["messages"] as? JsonArray
|
|
if (messages == null || messages.isEmpty()) {
|
|
return listOf(sha256Hex(body.toString()))
|
|
}
|
|
|
|
fun roleAt(i: Int): String? =
|
|
((messages[i] as? JsonObject)?.get("role") as? JsonPrimitive)?.content
|
|
|
|
var start = messages.indices.firstOrNull { roleAt(it) == "user" }
|
|
?: messages.indices.firstOrNull { roleAt(it) != "system" }
|
|
?: 0
|
|
|
|
val res = ArrayList<String>(messages.size - start)
|
|
var prev = ""
|
|
for (i in start until messages.size) {
|
|
prev = sha256Hex(prev + "\u0000" + messages[i].toString())
|
|
res.add(prev)
|
|
}
|
|
return res
|
|
}
|
|
|
|
/**
|
|
* Реестр сессий: id сессии определяется наибольшим общим префиксом (LCP)
|
|
* присланной истории. Для префиксов, которые уже встречались, возвращается
|
|
* id исходной сессии; иначе создаётся новая (id = хэш всей истории).
|
|
*
|
|
* Таблица ограничена по размеру (LRU) и времени жизни (TTL). Доступ под
|
|
* Mutex: параллельные запросы одной сессии не должны гонять состояние.
|
|
*/
|
|
class SessionRegistry(
|
|
private val maxSessions: Int = 1000,
|
|
private val ttlMillis: Long = 6 * 60 * 60 * 1000L,
|
|
) {
|
|
private class Entry(val prefixes: MutableSet<String>) {
|
|
var lastAccess: Long = 0
|
|
}
|
|
|
|
private val mutex = Mutex()
|
|
private val prefixToSession = mutableMapOf<String, String>()
|
|
|
|
/** В порядке доступа: голова — самая давняя, хвост — свежая. */
|
|
private val sessions = LinkedHashMap<String, Entry>()
|
|
|
|
suspend fun resolve(prefixHashes: List<String>): String? =
|
|
mutex.withLock { resolveLocked(prefixHashes, Clock.System.now().toEpochMilliseconds()) }
|
|
|
|
/** Синхронная (без блокировки) версия — для тестов и вызовов под mutex. */
|
|
internal fun resolveLocked(prefixHashes: List<String>, now: Long): String? {
|
|
if (prefixHashes.isEmpty()) return null
|
|
evictExpired(now)
|
|
|
|
var found: String? = null
|
|
for (i in prefixHashes.indices.reversed()) {
|
|
val s = prefixToSession[prefixHashes[i]]
|
|
if (s != null) {
|
|
found = s
|
|
break
|
|
}
|
|
}
|
|
val id = found ?: prefixHashes.last()
|
|
|
|
val entry = sessions.remove(id) ?: Entry(mutableSetOf())
|
|
for (h in prefixHashes) {
|
|
val prev = prefixToSession.put(h, id)
|
|
if (prev != null && prev != id) {
|
|
sessions[prev]?.prefixes?.remove(h)
|
|
}
|
|
entry.prefixes.add(h)
|
|
}
|
|
entry.lastAccess = now
|
|
sessions[id] = entry
|
|
evictOverflow()
|
|
return id
|
|
}
|
|
|
|
private fun drop(sessionId: String, entry: Entry) {
|
|
entry.prefixes.forEach { h -> if (prefixToSession[h] == sessionId) prefixToSession.remove(h) }
|
|
}
|
|
|
|
private fun evictExpired(now: Long) {
|
|
val it = sessions.entries.iterator()
|
|
while (it.hasNext()) {
|
|
val e = it.next()
|
|
if (now - e.value.lastAccess <= ttlMillis) break
|
|
drop(e.key, e.value)
|
|
it.remove()
|
|
}
|
|
}
|
|
|
|
private fun evictOverflow() {
|
|
val it = sessions.entries.iterator()
|
|
while (sessions.size > maxSessions && it.hasNext()) {
|
|
val e = it.next()
|
|
drop(e.key, e.value)
|
|
it.remove()
|
|
}
|
|
}
|
|
}
|