(MOT-4412) feat(llm-router): make the config form operator-friendly

llm-router/ui/page.tsx

@@ -9,5 +9,5 @@ import type { Host } from '@iii-dev/console-ui'
 import { LlmRouterConfigForm } from './src/configuration'
 
 export default function setup(host: Host) {
-  host.configForms.register('llm-router', LlmRouterConfigForm)
+  host.configForms.register('llm-router', (props) => <LlmRouterConfigForm {...props} host={host} />)
 }

llm-router/ui/src/configuration/duration.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+import { minutesToMs, msToMinutes } from './duration'
+
+describe('timeout minutes', () => {
+  it('converts the router defaults without rounding error', () => {
+    expect(msToMinutes(300_000)).toBe(5)
+    expect(msToMinutes(120_000)).toBe(2)
+    expect(minutesToMs(5)).toBe(300_000)
+    expect(minutesToMs(2)).toBe(120_000)
+  })
+
+  it('round-trips fractional minutes to whole milliseconds', () => {
+    expect(minutesToMs(1.5)).toBe(90_000)
+    expect(msToMinutes(90_000)).toBe(1.5)
+  })
+})

llm-router/ui/src/configuration/duration.ts

@@ -0,0 +1,9 @@
+/** Stream/idle timeouts are stored as milliseconds; the form edits minutes. */
+
+export function msToMinutes(ms: number): number {
+  return ms / 60_000
+}
+
+export function minutesToMs(minutes: number): number {
+  return Math.round(minutes * 60_000)
+}

llm-router/ui/src/configuration/field-error.tsx

@@ -0,0 +1,10 @@
+export { errorAt, pointer } from './pointers'
+
+export function FieldError({ message }: { message: string | null }) {
+  if (!message) return null
+  return (
+    <div className="llmr-cfg-field-error" role="alert">
+      {message}
+    </div>
+  )
+}

llm-router/ui/src/configuration/heuristics.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { moveItem, winningHeuristicIndex } from './heuristics'
+
+describe('winningHeuristicIndex', () => {
+  const rows = [
+    { pattern: '^gpt-', provider: 'openai' },
+    { pattern: 'claude', provider: 'anthropic' },
+    { pattern: '(', provider: 'broken' },
+    { pattern: '', provider: 'openai' },
+  ]
+
+  it('returns the first regex that matches the model id', () => {
+    expect(winningHeuristicIndex('gpt-4.1', rows)).toBe(0)
+    expect(winningHeuristicIndex('claude-sonnet-4', rows)).toBe(1)
+  })
+
+  it('skips invalid regex and empty patterns', () => {
+    expect(winningHeuristicIndex('nope', rows)).toBe(null)
+  })
+
+  it('returns null when the model id is empty', () => {
+    expect(winningHeuristicIndex('', rows)).toBe(null)
+    expect(winningHeuristicIndex('   ', rows)).toBe(null)
+  })
+})
+
+describe('moveItem', () => {
+  it('moves a row up or down and no-ops out of range', () => {
+    expect(moveItem(['a', 'b', 'c'], 2, 0)).toEqual(['c', 'a', 'b'])
+    expect(moveItem(['a', 'b', 'c'], 0, 1)).toEqual(['b', 'a', 'c'])
+    expect(moveItem(['a', 'b', 'c'], 0, -1)).toEqual(['a', 'b', 'c'])
+    expect(moveItem(['a', 'b', 'c'], 0, 3)).toEqual(['a', 'b', 'c'])
+  })
+})

llm-router/ui/src/configuration/heuristics.ts

@@ -0,0 +1,24 @@
+/** Draft-only heuristic preview and row reorder. Order is routing priority. */
+
+export function winningHeuristicIndex(model: string, rows: { pattern: string; provider: string }[]): number | null {
+  const needle = model.trim()
+  if (!needle) return null
+  for (let i = 0; i < rows.length; i++) {
+    const pattern = rows[i].pattern
+    if (!pattern || !rows[i].provider) continue
+    try {
+      if (new RegExp(pattern).test(needle)) return i
+    } catch {
+      // An invalid operator regex never takes the router down.
+    }
+  }
+  return null
+}
+
+export function moveItem<T>(items: T[], from: number, to: number): T[] {
+  if (to < 0 || to >= items.length || from === to) return items
+  const next = [...items]
+  const [row] = next.splice(from, 1)
+  next.splice(to, 0, row)
+  return next
+}