kami/correx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(router,inference,config): pin narration to a configured model_id

Browse Source 
[router.narration] model_id selects which provider handles narration turns
instead of generic capability routing — lets a small/fast model own narration
while the main model keeps CHAT/STEERING.

- NarrationSettings.modelId parsed from TOML, threaded via RouterConfig
  .narrationModelId into DefaultRouterFacade.narrate (3-arg route)
- DefaultInferenceRouter: exact-id match against healthy providers, with a
  post-select health check; any miss logs WARN and falls back to capability
  routing (never fails the narration turn)
- onUserInput unchanged — only narrate uses the pinned model (tested)
This commit is contained in:
kami
2026-06-10 20:53:28 +04:00
parent cc6b402a23
commit 883e23dec7
10 changed files with 192 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/server/src/main/kotlin/com/correx/apps/server/Main.kt
+1
View File
@@ -306,6 +306,7 @@ fun main() {
topP = rc.narration.topP,
maxTokens = rc.narration.maxTokens,
),
narrationModelId = rc.narration.modelId,
)
return InfrastructureModule.createRouterFacade(
eventStore = eventStore,
core/config/src/main/kotlin/com/correx/core/config/ConfigLoader.kt
+1
View File
@@ -494,6 +494,7 @@ object ConfigLoader {
topP = asDouble(routerNarrationSection["top_p"], 0.9),
maxTokens = asInt(routerNarrationSection["max_tokens"], 4096),
maxPerRun = asInt(routerNarrationSection["max_per_run"], 100),
modelId = asStringOrNull(routerNarrationSection["model_id"]),
)
val router = RouterConfig(
core/config/src/main/kotlin/com/correx/core/config/CorrexConfig.kt
+1
View File
@@ -157,6 +157,7 @@ data class NarrationSettings(
val topP: Double = 0.9,
val maxTokens: Int = 4096,
val maxPerRun: Int = 100,
val modelId: String? = null,
)
@Serializable
core/config/src/test/kotlin/com/correx/core/config/ConfigLoaderTest.kt
+25
View File
@@ -2,6 +2,7 @@ package com.correx.core.config
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertNull
class ConfigLoaderTest {
@Test
@@ -519,4 +520,28 @@ class ConfigLoaderTest {
assertEquals(180_000L, result.orchestration.stageTimeoutMs)
assertEquals(2_000, result.orchestration.journalCompactionTokenThreshold)
}
@Test
fun `parseToml parses router narration model_id`() {
val toml = """
[router.narration]
model_id = "llama-cpp:phi-3-mini"
""".trimIndent()
val result = ConfigLoader.parseTomlForTest(toml)
assertEquals("llama-cpp:phi-3-mini", result.router.narration.modelId)
}
@Test
fun `parseToml narration model_id defaults to null when absent`() {
val toml = """
[router.narration]
max_tokens = 2048
""".trimIndent()
val result = ConfigLoader.parseTomlForTest(toml)
assertNull(result.router.narration.modelId)
}
}
core/inference/build.gradle
+1
View File
@@ -8,5 +8,6 @@ dependencies {
implementation(project(":core:events"))
implementation(project(":core:context"))
implementation(project(":core:artifacts"))
implementation "org.slf4j:slf4j-api:2.0.16"
}
tasks.named("koverVerify").configure { enabled = false }
core/inference/src/main/kotlin/com/correx/core/inference/DefaultInferenceRouter.kt
+34
View File
@@ -9,6 +9,8 @@ import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeMark
import kotlin.time.TimeSource
private val log = org.slf4j.LoggerFactory.getLogger(DefaultInferenceRouter::class.java)
private data class HealthEntry(
val health: ProviderHealth,
val mark: TimeMark,
@@ -57,4 +59,36 @@ class DefaultInferenceRouter(
}
return selected
}
override suspend fun route(
stageId: StageId,
requiredCapabilities: Set<ModelCapability>,
modelId: String?,
): InferenceProvider {
if (modelId == null) return route(stageId, requiredCapabilities)
val all = registry.listAll()
val healthy = all.filter { cachedHealth(it) !is ProviderHealth.Unavailable }
val matched = healthy.firstOrNull { it.id.value == modelId }
if (matched == null) {
log.warn(
"narration model_id '{}' matched no healthy provider — falling back to capability routing",
modelId,
)
return route(stageId, requiredCapabilities)
}
when (val postHealth = matched.healthCheck()) {
is ProviderHealth.Unavailable -> {
log.warn(
"narration model_id '{}' provider failed post-select health check ({})" +
" — falling back to capability routing",
modelId,
postHealth.reason,
)
return route(stageId, requiredCapabilities)
}
else -> Unit
}
return matched
}
}
core/router/src/main/kotlin/com/correx/core/router/RouterFacade.kt
+1 -1
View File
@@ -175,7 +175,7 @@ class DefaultRouterFacade(
val contextPack = routerContextBuilder.buildNarrationContext(state, trigger, config.tokenBudget)
val provider = inferenceRouter.route(effectiveStageId, setOf(ModelCapability.General))
val provider = inferenceRouter.route(effectiveStageId, setOf(ModelCapability.General), config.narrationModelId)
val inferenceRequest = InferenceRequest(
requestId = InferenceRequestId(UUID.randomUUID().toString()),
sessionId = sessionId,
core/router/src/main/kotlin/com/correx/core/router/model/RouterConfig.kt
+1
View File
@@ -24,4 +24,5 @@ data class RouterConfig(
topP = 0.9,
maxTokens = 4096,
),
val narrationModelId: String? = null,
)
testing/contracts/src/test/kotlin/com/correx/testing/contracts/model/inference/DefaultInferenceRouterTest.kt
+40
View File
@@ -117,4 +117,44 @@ class DefaultInferenceRouterTest {
val result = router.route(stage, setOf(ModelCapability.General))
assertSame(p2, result)
}
// ── 3-arg route with modelId ───────────────────────────────────────────
@Test
fun `3-arg route selects provider by exact id match`(): Unit = runBlocking {
val p1 = provider("llama-cpp:fast-model", ModelCapability.General)
val p2 = provider("llama-cpp:big-model", ModelCapability.General)
val router = DefaultInferenceRouter(registryOf(p1, p2), firstStrategy())
val result = router.route(stage, setOf(ModelCapability.General), "llama-cpp:fast-model")
assertSame(p1, result)
}
@Test
fun `3-arg route falls back to capability routing when modelId matches no provider`(): Unit = runBlocking {
val p1 = provider("llama-cpp:only-one", ModelCapability.General)
val router = DefaultInferenceRouter(registryOf(p1), firstStrategy())
val result = router.route(stage, setOf(ModelCapability.General), "nonexistent-model")
assertSame(p1, result)
}
@Test
fun `3-arg route with null modelId delegates to 2-arg form`(): Unit = runBlocking {
val p = provider("llama-cpp:model", ModelCapability.General)
val router = DefaultInferenceRouter(registryOf(p), firstStrategy())
val result = router.route(stage, setOf(ModelCapability.General), null)
assertSame(p, result)
}
@Test
fun `3-arg route falls back to capability routing when matched provider is unhealthy`(): Unit = runBlocking {
val sick = MockInferenceProvider(
id = ProviderId("llama-cpp:sick"),
declaredCapabilities = setOf(CapabilityScore(ModelCapability.General, 1.0)),
health = ProviderHealth.Unavailable("down"),
)
val healthy = provider("llama-cpp:healthy", ModelCapability.General)
val router = DefaultInferenceRouter(registryOf(sick, healthy), firstStrategy())
val result = router.route(stage, setOf(ModelCapability.General), "llama-cpp:sick")
assertSame(healthy, result)
}
}
testing/deterministic/src/test/kotlin/RouterFacadeTest.kt
+87
View File
@@ -1186,6 +1186,93 @@ class RouterFacadeTest {
assertTrue(l3Entries.any { it.content.contains("[recalled memory]") })
}
// --------------------------------------------------------------------------
// Narration model ID routing
// --------------------------------------------------------------------------
@Test
fun `narrate passes narrationModelId to inferenceRouter 3-arg route`(): Unit = runBlocking {
val capturedModelId = mutableListOf<String?>()
val mockInferenceRouter = object : InferenceRouter {
override suspend fun route(
stageId: StageId,
requiredCapabilities: Set<ModelCapability>,
): InferenceProvider = mockProvider("narration text")
override suspend fun route(
stageId: StageId,
requiredCapabilities: Set<ModelCapability>,
modelId: String?,
): InferenceProvider {
capturedModelId.add(modelId)
return mockProvider("narration text")
}
}
val facade = DefaultRouterFacade(
routerRepository = object : RouterRepository {
override suspend fun getRouterState(sessionId: SessionId): RouterState = RouterState()
},
routerContextBuilder = object : RouterContextBuilder {
override suspend fun build(state: RouterState, budget: TokenBudget): ContextPack = emptyContextPack()
},
inferenceRouter = mockInferenceRouter,
eventStore = mockEventStore(),
config = RouterConfig(
tokenBudget = TokenBudget(limit = 5000),
narrationModelId = "llama-cpp:phi-3-mini",
),
embedder = NoopEmbedder(dimension = 8),
l3MemoryStore = InMemoryL3MemoryStore(),
)
facade.narrate(
sessionId = SessionId("test-session"),
trigger = com.correx.core.router.model.NarrationTrigger(
kind = "test",
instruction = "describe what happened",
),
)
assertEquals(1, capturedModelId.size)
assertEquals("llama-cpp:phi-3-mini", capturedModelId[0])
}
@Test
fun `onUserInput does NOT pass modelId — uses 2-arg route`(): Unit = runBlocking {
var threeArgCallCount = 0
val mockInferenceRouter = object : InferenceRouter {
override suspend fun route(
stageId: StageId,
requiredCapabilities: Set<ModelCapability>,
): InferenceProvider = mockProvider("response")
override suspend fun route(
stageId: StageId,
requiredCapabilities: Set<ModelCapability>,
modelId: String?,
): InferenceProvider {
threeArgCallCount++
return mockProvider("response")
}
}
val facade = DefaultRouterFacade(
routerRepository = object : RouterRepository {
override suspend fun getRouterState(sessionId: SessionId): RouterState = RouterState()
},
routerContextBuilder = object : RouterContextBuilder {
override suspend fun build(state: RouterState, budget: TokenBudget): ContextPack = emptyContextPack()
},
inferenceRouter = mockInferenceRouter,
eventStore = mockEventStore(),
config = RouterConfig(
tokenBudget = TokenBudget(limit = 5000),
narrationModelId = "llama-cpp:phi-3-mini",
),
embedder = NoopEmbedder(dimension = 8),
l3MemoryStore = InMemoryL3MemoryStore(),
)
facade.onUserInput(sessionId = SessionId("test-session"), input = "Hello!")
assertEquals(0, threeArgCallCount, "onUserInput must not call 3-arg route()")
}
private fun emptyContextPack(): ContextPack = ContextPack(
id = ContextPackId("empty"),
sessionId = SessionId("unknown"),