Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
26674257aThis file is pinned to the selected release. Download the original to open it in your design tool.
import { mkdtemp, mkdir, rm, writeFile } from 'fs/promises'
import { tmpdir } from 'os'
import { join } from 'path'
import { afterEach, describe, expect, it } from 'vitest'
import type { RegisteredSession } from './registry.js'
import {
codexEffortAllowed,
encodeRuntimeProfile,
parseRuntimeProfile,
parseCursorModelsOutput,
RuntimeProfileManager,
supportsNativeRuntimeControl,
} from './runtimeProfile.js'
const cleanup: string[] = []
afterEach(async () => {
await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true })))
})
function session(engine: RegisteredSession['engine']): RegisteredSession {
return {
schemaVersion: 2,
active: true,
sessionId: 'session:1', engine, launcherId: 'h1', agentId: 'h1', boundAt: 0, transcriptPath: '/tmp/session.jsonl', projectDir: 'tmp', cwd: '/tmp',
tmuxPane: '%1', source: null, title: null, model: null,
runtimes: [{ backend: 'tmux', paneId: '%1' }], primaryRuntimeKey: 'tmux\u0000%1',
cliVersion: engine === 'codex' ? '0.144.5' : engine === 'cursor' ? '2026.07.20-8cc9c0b' : '2.1.212', processIdentity: null,
registeredAt: 1, updatedAt: 1, lastHookAt: 1, lastTranscriptAt: 1,
}
}
describe('RuntimeProfileManager', () => {
it('keeps agents that have not bound a session yet out of one another state', () => {
// An agent awaiting its first bind carries `sessionId: ''`, which is not an identity: keyed on it,
// EVERY unbound agent shared one entry, across engines. Measured — a claude agent ten seconds old
// was retargeted onto a grid, the "what model was it on?" read answered `opencode/big-pickle`
// (an OpenCode agent had sat at `''` first), and the pane came home with
// `ANTHROPIC_MODEL=opencode/big-pickle`. Claude Code: "There's an issue with the selected model".
const manager = new RuntimeProfileManager()
const unboundOpencode = { ...session('opencode'), sessionId: '' }
const unboundClaude = { ...session('claude'), sessionId: '' }
manager.ingestPane(unboundOpencode, ' ┃ Build · Big Pickle OpenCode Zen', true)
// Not "the other agent's model" and not the first agent's own either: with no session there is
// nowhere to keep one, which is the truth about an engine that has not started talking yet.
expect(manager.selectedModel(unboundClaude)).toBeNull()
expect(manager.selectedModel(unboundOpencode)).toBeNull()
// A bound agent is unaffected — the fix removes a shared bucket, not the feature.
const bound = session('codex')
manager.ingestPane(bound, 'gpt-5.6-terra high ·', true)
expect(parseRuntimeProfile(manager.selectedModel(bound))).toMatchObject({
engine: 'codex', model: 'gpt-5.6-terra', effort: 'high',
})
})
it('limits Codex Max and Ultra to GPT-5.6 models', () => {
expect(codexEffortAllowed('gpt-5.6-sol', 'max')).toBe(true)
expect(codexEffortAllowed('gpt-5.6-terra', 'ultra')).toBe(true)
expect(codexEffortAllowed('codex-auto-review', 'ultra')).toBe(true)
expect(codexEffortAllowed('gpt-5.5', 'max')).toBe(false)
expect(codexEffortAllowed('gpt-5.3-codex-spark', 'ultra')).toBe(false)
expect(codexEffortAllowed('gpt-5.4', 'xhigh')).toBe(true)
})
it('round trips opaque session-scoped profiles', () => {
const id = encodeRuntimeProfile({ sessionId: 'session:1', engine: 'codex', model: 'provider/model:v2', effort: 'xhigh' })
expect(parseRuntimeProfile(id)).toEqual({
id, sessionId: 'session:1', engine: 'codex', model: 'provider/model:v2', effort: 'xhigh',
})
expect(parseRuntimeProfile('runtime-v1:session%3A1:codex:gpt-5.6-sol@ultra')).toMatchObject({
sessionId: 'session:1', engine: 'codex', model: 'gpt-5.6-sol', effort: 'ultra',
})
expect(parseRuntimeProfile('runtime-v1:%ZZ:codex:model@high')).toBeNull()
// Every engine that can produce options must also parse them back. Widening the picker to a new
// engine and forgetting this line is silent: the id round-trips through web and device fine, then
// setProfile rejects it as INVALID_RUNTIME_PROFILE the moment someone picks a row.
for (const engine of ['claude', 'codex', 'cursor', 'opencode', 'pi', 'hermes', 'commandcode', 'devin', 'muse', 'amp', 'kilo', 'grok']) {
expect(parseRuntimeProfile(`runtime-v1:s1:${engine}:some-model@high`)).toMatchObject({ engine })
}
expect(parseRuntimeProfile('runtime-v1:cursor-1:cursor:gpt-5.6-sol@none')).toMatchObject({
engine: 'cursor', effort: 'none',
})
})
it('parses Cursor catalog variants without hardcoding the account model list', () => {
const entries = parseCursorModelsOutput([
'Available models',
'',
'auto - Auto (current, default)',
'gpt-5.6-sol-none - GPT-5.6 Sol 1M None',
'gpt-5.6-sol-extra-high-fast - GPT-5.6 Sol Extra High Fast',
'claude-opus-4-8-thinking-high - Opus 4.8 1M Thinking',
'gpt-5.3-codex-low - Codex 5.3 Low',
'gpt-5.3-codex - Codex 5.3',
'Tip: ignored',
].join('\n'))
expect(entries.map((entry) => ({
rawId: entry.target.rawId,
model: entry.target.modelKey,
effort: entry.effort,
context: entry.target.context,
fast: entry.target.fast,
thinking: entry.target.thinking,
}))).toEqual([
{ rawId: 'auto', model: 'auto', effort: 'auto', context: null, fast: null, thinking: null },
{ rawId: 'gpt-5.6-sol-none', model: 'gpt-5.6-sol', effort: 'none', context: '1m', fast: false, thinking: false },
{ rawId: 'gpt-5.6-sol-extra-high-fast', model: 'gpt-5.6-sol-fast', effort: 'xhigh', context: null, fast: true, thinking: false },
{ rawId: 'claude-opus-4-8-thinking-high', model: 'claude-opus-4-8-thinking', effort: 'high', context: '1m', fast: false, thinking: true },
{ rawId: 'gpt-5.3-codex-low', model: 'gpt-5.3-codex', effort: 'low', context: null, fast: false, thinking: false },
{ rawId: 'gpt-5.3-codex', model: 'gpt-5.3-codex', effort: 'medium', context: null, fast: false, thinking: false },
])
})
it('offers no switching outside Claude and Codex', async () => {
// View-only engines still SHOW what they run (the ingest paths do that); they just have nothing to
// pick and nothing to drive. Both gates are asserted: an empty catalogue, and a refusal to control.
const manager = new RuntimeProfileManager()
for (const engine of ['cursor', 'commandcode', 'devin', 'pi', 'opencode', 'hermes', 'grok'] as const) {
const value = { ...session('cursor'), engine }
expect(supportsNativeRuntimeControl(value)).toBe(false)
await expect(manager.modelsForSession(value)).resolves.toEqual([])
}
})
it('is display-only through an OpenRouter gateway, but still names the model it runs', async () => {
// `ori claude` runs the same CLI with gateway model discovery, so its picker holds the user's
// OpenRouter catalog, not the native aliases this controller types. Both gates must hold — an empty
// catalogue AND a refusal to control — or a stale profile id from an older client drives the pane.
const manager = new RuntimeProfileManager()
for (const engine of ['claude', 'codex'] as const) {
const value = { ...session(engine), gateway: 'ori' as const }
expect(supportsNativeRuntimeControl(value)).toBe(false)
await expect(manager.modelsForSession(value)).resolves.toEqual([])
}
// Displaying it is the whole point of the flag being separate from `engine`: the chip still works.
const value = { ...session('claude'), gateway: 'ori' as const }
manager.hydrate(value, [])
manager.ingest(value, JSON.stringify({ type: 'assistant', message: { model: 'anthropic/claude-sonnet-4.6' } }))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
engine: 'claude', // NOT a new engine — the badge stays Claude Code
model: 'anthropic/claude-sonnet-4.6', // the OpenRouter id, percent-encoded in the profile
effort: 'auto',
})
// The same session without the flag keeps the native catalogue and native control.
const native = session('claude')
expect(supportsNativeRuntimeControl(native)).toBe(true)
await expect(manager.modelsForSession(native)).resolves.not.toEqual([])
})
it('supports both captured Codex picker generations', () => {
const value = session('codex')
expect(supportsNativeRuntimeControl(value)).toBe(true)
value.cliVersion = '0.145.0'
expect(supportsNativeRuntimeControl(value)).toBe(true)
value.cliVersion = '0.146.0'
expect(supportsNativeRuntimeControl(value)).toBe(false)
})
it('surfaces a Cursor model from the transcript even before any effort is known', () => {
// Regression: selectedModel() returns null unless BOTH axes are known, and Cursor's transcript
// reports the model while the reasoning level exists only in the pane footer. The model was
// therefore discarded whenever the footer had not been read yet, and the device showed no model
// at all for a Cursor agent.
const manager = new RuntimeProfileManager()
const value = session('cursor')
manager.hydrate(value, [])
manager.ingest(value, JSON.stringify({ model: 'gpt-5.6-sol' }))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
engine: 'cursor',
model: 'gpt-5.6-sol',
effort: 'auto',
})
})
it('names an OpenCode model the catalog does not list, with its reasoning level', () => {
const value = session('opencode')
const manager = new RuntimeProfileManager()
// A real footer from a machine with no provider connected: OpenCode runs a built-in free model
// that `opencode models` never prints, so there is no catalog entry to resolve against and the
// chips used to stay blank while the terminal named the model two lines below.
manager.ingestPane(value, '┃ Build · Ox Alpha Free (Unlimited) OpenCode Zen · high')
const profile = manager.selectedModel(value)
expect(profile).not.toBeNull()
const decoded = parseRuntimeProfile(profile!)
expect(decoded?.model).toBe('Ox Alpha Free (Unlimited) OpenCode Zen')
expect(decoded?.effort).toBe('high')
})
it('observes Grok model metadata and its live footer effort', () => {
const manager = new RuntimeProfileManager()
const value = session('grok')
manager.hydrate(value, [])
manager.ingest(value, JSON.stringify({
params: { update: { _meta: { modelId: 'grok-4.5' } } },
}))
manager.ingestPane(value, 'Grok 4.5 (medium) · always-approve')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
engine: 'grok',
model: 'grok-4.5',
effort: 'medium',
})
})
it('observes Cursor Auto model and effort from the idle footer with context usage', () => {
const manager = new RuntimeProfileManager()
const value = session('cursor')
manager.hydrate(value, [])
manager.ingestPane(value, [
'previous output',
'→ Add a follow-up',
'',
'Auto · 12.7% Run Everything',
'~/demo · main',
].join('\n'))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'auto',
effort: 'auto',
})
})
it('observes Cursor native-default models from usage and No Thinking footers', () => {
const manager = new RuntimeProfileManager()
const value = session('cursor')
manager.hydrate(value, [])
manager.ingestPane(value, [
'→ Add a follow-up',
'',
'Haiku 4.5 · 12.8% Run Everything',
'~/demo · main',
].join('\n'))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'haiku-4.5',
effort: 'auto',
})
manager.ingestPane(value, '→ Add a follow-up\nSonnet 4.5 No Thinking')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'sonnet-4.5',
effort: 'auto',
})
})
it('keeps synthetic Cursor routing details out of the public runtime profile', () => {
const manager = new RuntimeProfileManager()
const value = session('cursor')
manager.hydrate(value, [])
manager.ingestPane(value, [
'→ Add a follow-up',
'',
'Composer 2.5 · 15.7% Run Everything',
'~/demo · main',
].join('\n'))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'composer-2.5',
effort: 'auto',
})
manager.ingestPane(value, '→ Add a follow-up\nComposer 2.5 1M Thinking Fast High')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'composer-2.5-1m-thinking-fast',
effort: 'high',
})
})
it('observes Claude model from JSONL and effort from the live pane', () => {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [JSON.stringify({ type: 'assistant', message: { model: 'claude-opus-4-8' } })])
expect(manager.selectedModel(value)).toBeNull()
manager.ingestPane(value, 'Opus 4.8 (1M context) with high effort\n❯ ')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({
model: 'opus', effort: 'high',
})
})
it('hydrates Claude effort from effective settings and backfills the transcript CLI version', async () => {
const cwd = await mkdtemp(join(tmpdir(), 'machine-runtime-'))
cleanup.push(cwd)
await mkdir(join(cwd, '.claude'))
await writeFile(join(cwd, '.claude', 'settings.local.json'), JSON.stringify({ effortLevel: 'low' }))
const manager = new RuntimeProfileManager()
const value = { ...session('claude'), cwd, cliVersion: null }
manager.hydrate(value, [JSON.stringify({
type: 'assistant', version: '2.1.212', message: { model: 'claude-opus-4-8' },
})])
await manager.ingestConfig(value, true)
expect(value.cliVersion).toBe('2.1.212')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'opus', effort: 'low' })
})
it('keeps supported Claude effort on a local model change and falls back to auto otherwise', () => {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [])
manager.ingestPane(value, 'Opus 4.8 with high effort\n❯ ', true)
manager.ingest(value, JSON.stringify({ message: { content: [{ text: 'Set model to Sonnet 5' }] } }))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'sonnet', effort: 'high' })
manager.ingest(value, JSON.stringify({ message: { content: [{ text: 'Set model to Haiku 4.5' }] } }))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'haiku', effort: 'auto' })
})
// Opus 5 shipped as a new family version AND as a 1M-context variant. Both had to stop resetting the
// observed effort: the effort table used to hardcode `opus-4-[78]` and never stripped the `[1m]` suffix,
// so `Opus 5 (1M context)` — and even `Opus 4.8 (1M context)` — looked effort-less and fell back to auto.
it('keeps Claude effort across a switch to a new family version and to a 1M-context variant', () => {
for (const setModel of ['Opus 5', 'Opus 5 (1M context)', 'Opus 4.8 (1M context)', 'Fable 5 (1M context)']) {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [])
manager.ingestPane(value, 'Opus 4.8 with high effort\n❯ ', true)
manager.ingest(value, JSON.stringify({ message: { content: [{ text: `Set model to ${setModel}` }] } }))
expect(parseRuntimeProfile(manager.selectedModel(value))?.effort, setModel).toBe('high')
}
})
it('observes an Opus 5 pane status line (model + effort)', () => {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [])
manager.ingestPane(value, 'Opus 5 (1M context) with high effort\n❯ ')
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'opus', effort: 'high' })
})
it('publishes Claude aliases in native picker order without provider-model duplicates', async () => {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [JSON.stringify({
type: 'assistant', message: { model: 'claude-opus-4-8' },
})])
manager.ingestPane(value, 'Opus 4.8 with high effort\n❯ ', true)
const profiles = (await manager.modelsForSession(value))
.map((option) => parseRuntimeProfile(option.id))
.filter((profile): profile is NonNullable<typeof profile> => profile !== null)
expect([...new Set(profiles.map((profile) => profile.model))]).toEqual([
'default', 'opus', 'fable', 'sonnet', 'haiku',
])
expect(profiles.filter((profile) => profile.model === 'sonnet').map((profile) => profile.effort)).toContain('ultracode')
expect(profiles.filter((profile) => profile.model === 'haiku').map((profile) => profile.effort)).toEqual(['auto'])
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'opus' })
value.cliVersion = '2.1.208'
const olderProfiles = (await manager.modelsForSession(value))
.map((option) => parseRuntimeProfile(option.id))
.filter((profile): profile is NonNullable<typeof profile> => profile !== null)
expect(olderProfiles.map((profile) => profile.effort)).not.toContain('ultracode')
})
it('observes Claude ultracode effort from JSONL and the live footer', () => {
const manager = new RuntimeProfileManager()
const value = session('claude')
manager.hydrate(value, [])
manager.ingestPane(value, 'Opus 4.8 with high effort\n❯ ', true)
manager.ingest(value, JSON.stringify({
type: 'user', message: { content: '<local-command-stdout>Set effort level to ultracode (this session only): xhigh + dynamic workflow orchestration</local-command-stdout>' },
}))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'opus', effort: 'ultracode' })
manager.confirmEffort(value.sessionId, 'auto')
manager.ingestPane(value, 'old output\n──────────────── ultracode ─\n❯\n────────────────', true)
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'opus', effort: 'ultracode' })
})
it('observes Codex model, effort, and plan mode from rollout settings', () => {
const manager = new RuntimeProfileManager()
const value = session('codex')
manager.hydrate(value, [JSON.stringify({ type: 'session_meta', payload: { cli_version: '0.144.5' } })])
manager.ingest(value, JSON.stringify({
type: 'event_msg',
payload: {
type: 'thread_settings_applied',
thread_settings: { model: 'gpt-5.6-sol', reasoning_effort: 'high', collaboration_mode: { mode: 'plan' } },
},
}))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ model: 'gpt-5.6-sol', effort: 'high' })
expect(manager.getState(value.sessionId).mode).toBe('plan')
expect(value.cliVersion).toBe('0.144.5')
})
it('observes Codex ultra effort from rollout and pane state', () => {
const manager = new RuntimeProfileManager()
const value = session('codex')
manager.hydrate(value, [])
manager.ingest(value, JSON.stringify({
type: 'turn_context', payload: { model: 'gpt-5.6-sol', reasoning_effort: 'ultra' },
}))
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ effort: 'ultra' })
manager.ingestPane(value, '› \ngpt-5.6-sol ultra ·', true)
expect(parseRuntimeProfile(manager.selectedModel(value))).toMatchObject({ effort: 'ultra' })
})
})