feat: support SGLang KV events in VLLMAdapter

SGLang's BlockStored event may have fewer fields than vLLM (omitting
medium, lora_name, extra_keys when they are None/default). This change
pads shorter msgpack arrays with nil values before struct
deserialization, allowing VLLMAdapter to handle both vLLM and SGLang
events transparently.

Author: bongwoobak

pkg/kvevents/engineadapter/vllm_adapter.go

@@ -118,6 +118,18 @@ func (v *VLLMAdapter) getHashAsUint64(raw any) (uint64, error) {
 	}
 }
 
+const (
+	// Expected field counts for msgpack array structs.
+	// Used for padding shorter arrays from SGLang which may omit trailing optional fields.
+	// See SGLang source: sglang/srt/disaggregation/kv_events.py (BlockStored, BlockRemoved classes)
+	blockStoredFieldCount  = 9 // tag + block_hashes + parent + tokens + block_size + lora_id + medium + lora_name + extra_keys
+	blockRemovedFieldCount = 3 // tag + block_hashes + medium
+
+	// Minimum required fields (excluding trailing optional ones).
+	blockStoredMinFields  = 5 // tag + block_hashes + parent + tokens + block_size
+	blockRemovedMinFields = 2 // tag + block_hashes
+)
+
 // vLLM msgpack-specific event structures.
 // These structs are designed for msgpack array encoding and match vLLM's format.
 type msgpackVLLMEventBatch struct {
@@ -188,10 +200,31 @@ func (v *VLLMAdapter) decodeVLLMEvent(rawEventBytes []byte) (kvevents.GenericEve
 	return converter(rawEventBytes)
 }
 
-// convertBlockStoredEvent decodes and converts a msgpack vLLM BlockStored event to a generic event.
+// convertBlockStoredEvent decodes and converts a BlockStored event to a generic event.
+// Supports both vLLM and SGLang by padding shorter arrays with nil for trailing optional fields.
+// SGLang may omit medium, lora_name, and extra_keys when they are None/default.
+// See: sglang/srt/disaggregation/kv_events.py (BlockStored class, array_like=True, omit_defaults=True)
 func (v *VLLMAdapter) convertBlockStoredEvent(rawEventBytes []byte) (kvevents.GenericEvent, error) {
+	var fields []any
+	if err := msgpack.Unmarshal(rawEventBytes, &fields); err != nil {
+		return nil, fmt.Errorf("failed to decode BlockStored event: %w", err)
+	}
+
+	if len(fields) < blockStoredMinFields {
+		return nil, fmt.Errorf("BlockStored event has too few fields: %d (minimum %d)", len(fields), blockStoredMinFields)
+	}
+
+	// Pad to full struct size so msgpack array decode succeeds.
+	for len(fields) < blockStoredFieldCount {
+		fields = append(fields, nil)
+	}
+	paddedBytes, err := msgpack.Marshal(fields)
+	if err != nil {
+		return nil, fmt.Errorf("failed to re-marshal padded BlockStored event: %w", err)
+	}
+
 	var vllmEvent msgpackVLLMBlockStoredEvent
-	if err := msgpack.Unmarshal(rawEventBytes, &vllmEvent); err != nil {
+	if err := msgpack.Unmarshal(paddedBytes, &vllmEvent); err != nil {
 		return nil, fmt.Errorf("failed to decode BlockStored event: %w", err)
 	}
 
@@ -244,10 +277,29 @@ func (v *VLLMAdapter) convertBlockStoredEvent(rawEventBytes []byte) (kvevents.Ge
 	}, nil
 }
 
-// convertBlockRemovedEvent decodes and converts a msgpack vLLM BlockRemoved event to a generic event.
+// convertBlockRemovedEvent decodes and converts a BlockRemoved event to a generic event.
+// Supports both vLLM and SGLang by padding shorter arrays with nil for trailing optional fields.
+// See: sglang/srt/disaggregation/kv_events.py (BlockRemoved class, array_like=True, omit_defaults=True)
 func (v *VLLMAdapter) convertBlockRemovedEvent(rawEventBytes []byte) (kvevents.GenericEvent, error) {
+	var fields []any
+	if err := msgpack.Unmarshal(rawEventBytes, &fields); err != nil {
+		return nil, fmt.Errorf("failed to decode BlockRemoved event: %w", err)
+	}
+
+	if len(fields) < blockRemovedMinFields {
+		return nil, fmt.Errorf("BlockRemoved event has too few fields: %d (minimum %d)", len(fields), blockRemovedMinFields)
+	}
+
+	for len(fields) < blockRemovedFieldCount {
+		fields = append(fields, nil)
+	}
+	paddedBytes, err := msgpack.Marshal(fields)
+	if err != nil {
+		return nil, fmt.Errorf("failed to re-marshal padded BlockRemoved event: %w", err)
+	}
+
 	var vllmEvent msgpackVLLMBlockRemovedEvent
-	if err := msgpack.Unmarshal(rawEventBytes, &vllmEvent); err != nil {
+	if err := msgpack.Unmarshal(paddedBytes, &vllmEvent); err != nil {
 		return nil, fmt.Errorf("failed to decode BlockRemoved event: %w", err)
 	}
 

pkg/kvevents/engineadapter/vllm_adapter_test.go

@@ -178,26 +178,38 @@ func TestDecodeVLLMEvent_BlockStoredWithLora(t *testing.T) {
 	assert.Equal(t, [][]any{{"uuid-A", "salt"}, nil}, blockStored.ExtraKeys)
 }
 
-// TestDecodeVLLMEvent_BlockStoredMissingLoraName tests decoding with missing field.
+// TestDecodeVLLMEvent_BlockStoredMissingLoraName tests decoding with missing trailing fields.
+// This matches SGLang's BlockStored format which has no lora_name or extra_keys.
 func TestDecodeVLLMEvent_BlockStoredMissingLoraName(t *testing.T) {
 	adapter := NewVLLMAdapter()
 
-	vllmEvent := []any{
+	// SGLang format: 7 fields (tag + 6 data fields, no lora_name, no extra_keys)
+	sglangEvent := []any{
 		"BlockStored",
 		[]any{uint64(300), uint64(301)},
 		uint64(299),
 		[]uint32{7, 8, 9},
 		64,
-		123,
-		"gpu",
+		nil,  // lora_id
+		"GPU", // medium
 	}
 
-	rawBytes, err := msgpack.Marshal(vllmEvent)
+	rawBytes, err := msgpack.Marshal(sglangEvent)
 	require.NoError(t, err)
 
 	event, err := adapter.decodeVLLMEvent(rawBytes)
-	assert.Error(t, err)
-	assert.Nil(t, event)
+	require.NoError(t, err, "SGLang format without lora_name should decode successfully")
+	require.NotNil(t, event)
+
+	blockStored, ok := event.(*kvevents.BlockStoredEvent)
+	require.True(t, ok)
+	assert.Equal(t, []uint64{300, 301}, blockStored.BlockHashes)
+	assert.Equal(t, uint64(299), blockStored.ParentHash)
+	assert.Equal(t, []uint32{7, 8, 9}, blockStored.Tokens)
+	assert.Equal(t, "GPU", blockStored.DeviceTier)
+	assert.Nil(t, blockStored.LoraID)
+	assert.Nil(t, blockStored.LoraName, "SGLang does not send lora_name")
+	assert.Nil(t, blockStored.ExtraKeys, "SGLang does not send extra_keys")
 }
 
 // TestDecodeVLLMEvent_BlockStoredInvalidExtraKeys tests invalid extra_keys type.