From c0a7b2003c372440e452c9839679e994e92a8299 Mon Sep 17 00:00:00 2001 From: Josh Joseph Date: Tue, 10 Nov 2026 08:13:14 +0000 Subject: [PATCH 1/7] Show opt-in smart-routing savings in Claude --- README.md | 41 +- docs/claude-mod.md | 48 +++ skills/smart-router/SKILL.md | 5 +- src/ucode/agents/claude_mods/register.ts | 382 ++++++++++++++++- .../claude_mods/smart-routing-status.ts | 14 +- src/ucode/constants.py | 2 + src/ucode/databricks.py | 32 ++ src/ucode/smart_routing/config.py | 20 + src/ucode/smart_routing/orchestrator.py | 22 + src/ucode/smart_routing/pricing.py | 294 +++++++++++++ src/ucode/smart_routing/savings.py | 172 ++++++++ src/ucode/smart_routing/session_env.py | 5 +- src/ucode/smart_routing/v2.py | 129 +++++- tests/README.md | 34 +- tests/conftest.py | 2 + tests/integration/README.md | 24 +- .../test_ug_smart_routing_hooks.py | 1 + tests/native_claude/messages_api.py | 99 +++++ tests/native_claude/mod_tests/savings.test.ts | 128 ++++++ tests/native_claude/session.py | 26 +- tests/native_claude/test_mod.py | 389 +++++++++++++++++- tests/test_claude_mod.py | 16 +- tests/test_claude_smart_routing_v2.py | 27 ++ tests/test_smart_router.py | 11 +- tests/test_smart_routing_config.py | 77 +++- tests/test_smart_routing_pricing.py | 322 +++++++++++++++ tests/test_smart_routing_savings.py | 327 +++++++++++++++ 27 files changed, 2576 insertions(+), 73 deletions(-) create mode 100644 src/ucode/smart_routing/pricing.py create mode 100644 src/ucode/smart_routing/savings.py create mode 100644 tests/native_claude/messages_api.py create mode 100644 tests/native_claude/mod_tests/savings.test.ts create mode 100644 tests/test_smart_routing_pricing.py create mode 100644 tests/test_smart_routing_savings.py diff --git a/README.md b/README.md index 0e388eb87..70dc70c92 100644 --- a/README.md +++ b/README.md @@ -573,14 +573,15 @@ Use `SMART_ROUTER_CONFIG_VERSION` at launch to select a smart-routing configurat Each version defines separate Claude Code and Codex flag mappings; the existing versions use identical mappings for both agents. The Claude-only version disables routing for Codex: -| Version | Routed agents | Subagent routing | First-prompt routing | Orchestrator | -| --- | --- | --- | --- | --- | -| `first_prompt_and_subagent_no_orch_v0` | Claude, Codex | On | On | Off | -| `subagent_only_v0` | Claude, Codex | On | Off | Off | -| `subagent_only_v1` | Claude, Codex | On | Off | Off | -| `subagent_orch_v0` | Claude, Codex | On | Off | On | -| `subagent_orch_v1` | Claude, Codex | On | Off | On | -| `subagent_orch_v0_claude_only` | Claude | On | Off | On | +| Version | Routed agents | Subagent routing | First-prompt routing | Orchestrator | Claude savings | +| --- | --- | --- | --- | --- | --- | +| `first_prompt_and_subagent_no_orch_v0` | Claude, Codex | On | On | Off | Off | +| `subagent_only_v0` | Claude, Codex | On | Off | Off | Off | +| `subagent_only_v1` | Claude, Codex | On | Off | Off | Off | +| `subagent_orch_v0` | Claude, Codex | On | Off | On | Off | +| `subagent_orch_v1` | Claude, Codex | On | Off | On | Off | +| `subagent_orch_v0_claude_only` | Claude | On | Off | On | Off | +| `subagent_orch_savings_v0` | Claude, Codex | On | Off | On | On | `first_prompt_and_subagent_no_orch_v0` routes the first prompt and subagents without orchestration: `ENABLE_SMART_ROUTING_V2=1`, `ENABLE_SMART_ROUTING_SUBAGENT_ONLY=0`, and @@ -593,12 +594,24 @@ managed default model, without routing or orchestration. `--enable-smart-routing workspace smart routing keep this version, so Codex stays unrouted: ug warns and launches it like a plain `ug codex`, without the Smart Router skills or routing hooks. +`subagent_orch_savings_v0` uses the routing and orchestration flags from `subagent_orch_v1` +and sets `ENABLE_SMART_ROUTING_SAVINGS=1`. Savings tracking, endpoint-price refresh, +pricing, and the above-prompt savings row are opt-in and currently +implemented for Claude. Every existing preset sets this flag to `"0"`, overriding an +inherited `"1"`. Without a selector, explicitly set `ENABLE_SMART_ROUTING_SAVINGS=1` +with routing enabled to use the feature. + +```bash +SMART_ROUTER_CONFIG_VERSION=subagent_orch_savings_v0 ug claude +``` + `SMART_ROUTER_NAME` still selects the router independently of the preset. -Smart-routed Claude and Codex sessions install `smart-router`. The `subagent_orch_v0` -and `subagent_orch_v1` versions also install and activate the bundled `smart-router-orchestrator` skill. -`--enable-smart-routing` and workspace smart routing select `subagent_orch_v0_claude_only`, which -installs both skills for Claude only; Codex gets neither. For example: +Smart-routed Claude and Codex sessions install `smart-router`. The `subagent_orch_v0`, +`subagent_orch_v1`, and `subagent_orch_savings_v0` versions also install and activate the +bundled `smart-router-orchestrator` skill. Without a known version, `--enable-smart-routing` +and workspace smart routing select `subagent_orch_v0_claude_only`, which installs both +skills for Claude only; Codex gets neither. For example: ```bash SMART_ROUTER_CONFIG_VERSION=subagent_orch_v0 ug claude @@ -606,8 +619,8 @@ SMART_ROUTER_CONFIG_VERSION=subagent_orch_v0 ug claude The version takes precedence over conflicting legacy flags. Once the agent is selected, UG expands its mapping into -`ENABLE_SMART_ROUTING_V2`, `ENABLE_SMART_ROUTING_SUBAGENT_ONLY`, and -`ENABLE_SMART_ROUTER_ORCHESTRATOR` for the launched session. When the version is +`ENABLE_SMART_ROUTING_V2`, `ENABLE_SMART_ROUTING_SUBAGENT_ONLY`, +`ENABLE_SMART_ROUTER_ORCHESTRATOR`, and `ENABLE_SMART_ROUTING_SAVINGS` for the launched session. When the version is unset or empty, these legacy flags retain their existing behavior, including first-prompt routing through `ENABLE_SMART_ROUTING_V2=1`. Unknown versions are ignored: no preset is applied, the inherited environment is unchanged, and commands continue normally. diff --git a/docs/claude-mod.md b/docs/claude-mod.md index d81bfa318..b3d3daeb3 100644 --- a/docs/claude-mod.md +++ b/docs/claude-mod.md @@ -225,3 +225,51 @@ but no inherited model or counterfactual native choice is guessed. The existing `requested_model` remains UG's routed target, not Claude's original choice. Actual execution still requires the child transcript or the separate subagent-start audit; that event can omit its model. Existing records are not backfilled. + +## Savings estimate + +`hooks/register.ts` draws a row above the prompt, styled like the status band: the +estimated savings from smart routing, with the amount in a pill (green for a saving, +yellow when routing cost more), and, when the launch activates Smart Router Orchestrator, +the skill's `metadata.version` from `SKILL.claude.md`, labeled +`Unity Gateway Smart Router v`. The row appears only once there is an estimate, +and then takes the status band's place, so the two never stack; the prompt hint row still +shows the routing state. Its handler decides before running the other `AbovePrompt` +handlers, so the band steps aside whichever order Claude runs them in. For each turn +request, main agent and subagents, the mod sums token usage by the model that served it +and its baseline. Main is its own baseline, and a subagent's baseline is the main model +in effect when it ran. +Under first-prompt routing, requests before the user changes the main model are priced +against the model selected when the first prompt was submitted, before the router's +`/model` command. A manual selection before that prompt becomes the baseline. Later +model changes affect only subsequent usage. Claude's native `$.session.model()` returns +the resolved model ID, including for configured family aliases such as `sonnet`. + +After each turn the mod writes those sums to `savings_usage`, a file in the launch's +temporary directory. It then runs the `savings_pricer` argv +(`python -P -m ucode.smart_routing.savings`), which prices the sums from the +workspace's cached endpoint rates and prints the estimate's parts (direction, amount, +percent) as one JSON line. Each savings-enabled routed launch +refreshes that cache on a background thread. The cache key includes the workspace ID +on shared hosts, since dollar rates can differ between organizations. An estimate is hidden, not undercounted, +when any served or baseline model has no rate. The orchestrator version is passed +as `orchestrator_version`. + +Savings hooks live in `hooks/register.ts` alongside the routing controls: Claude +allows one hook module per plugin and its capability scanner follows engine API +calls only within that module. The shared `session.start` handler seeds the start model, +and `prompt.submit` captures the baseline before first-prompt routing. That capture is +persisted with the totals so a mod reload does not replace it with the routed model. +Savings failures, including denied reads of its environment flag, leave model requests +running. Savings handlers are registered only when the launch options explicitly enable +the feature. A failed usage-file write hides the estimate and retains the in-memory +totals for the next turn's write. + +The entire savings mod requires `ENABLE_SMART_ROUTING_SAVINGS=1`. Otherwise no usage +is tracked or written, no endpoint rates are fetched, no pricer runs, and no savings row is +shown; the three options stay at their declared defaults. +All existing versioned configurations set the flag to `"0"`. Select +`SMART_ROUTER_CONFIG_VERSION=subagent_orch_savings_v0` to enable it with subagent +routing and orchestration. Session routing off/on also disables/restores savings +from the launch baseline. Both the mod and pricer read the saved session controls; +CLI toggles update a mounted savings row within one second. diff --git a/skills/smart-router/SKILL.md b/skills/smart-router/SKILL.md index 9c5f25c5e..fbbfae61b 100644 --- a/skills/smart-router/SKILL.md +++ b/skills/smart-router/SKILL.md @@ -46,4 +46,7 @@ Continue in the root unless the user explicitly requests a subagent. Honor that native tools and normal harness model selection, without Smart Router Orchestrator; keep routing off. Existing children can finish. When turned on, apply the `smart-router-orchestrator` skill to further work only if the session was launched with `ENABLE_SMART_ROUTER_ORCHESTRATOR=1`. -Do not change the orchestration feature flag. Return the command's result. +For launches with `ENABLE_SMART_ROUTING_SAVINGS=1`, off/on also disables/restores +savings tracking and its display row. All earlier versioned presets disable savings; +`subagent_orch_savings_v0` enables it with subagent routing and orchestration. +Do not change the orchestration or savings launch baseline. Return the command's result. diff --git a/src/ucode/agents/claude_mods/register.ts b/src/ucode/agents/claude_mods/register.ts index c7a198bf8..adce322d1 100644 --- a/src/ucode/agents/claude_mods/register.ts +++ b/src/ucode/agents/claude_mods/register.ts @@ -1,5 +1,5 @@ import type { EngineInterface, On, PluginOptions } from 'claude-code'; -import { endStatusBandTurn, registerStatusBand, showStatusBand } from './smart-routing-status.ts'; +import { endStatusBandTurn, registerStatusBand, showStatusBand, startStatusBandTurn } from './smart-routing-status.ts'; import { endSubagentRoutingTurn, registerSubagentRouting } from './subagent-routing.ts'; import { CLI_AGENT, @@ -30,28 +30,34 @@ async function readEnvironment($: EngineInterface): Promise { ENABLE_SMART_ROUTING_V2: await $.env.get('ENABLE_SMART_ROUTING_V2'), ENABLE_SMART_ROUTING_SUBAGENT_ONLY: await $.env.get('ENABLE_SMART_ROUTING_SUBAGENT_ONLY'), ENABLE_SMART_ROUTER_ORCHESTRATOR: await $.env.get('ENABLE_SMART_ROUTER_ORCHESTRATOR'), + ENABLE_SMART_ROUTING_SAVINGS: await readSavingsFlag($), CLAUDE_CODE_EXTRA_BODY: await $.env.get('CLAUDE_CODE_EXTRA_BODY'), }; } -async function readOrchestratorState($: EngineInterface, options: PluginOptions): Promise { - if (!options.orchestratorInstructions) return false; - const current = await readEnvironment($); - const sessionFile = await $.env.get('UCODE_SESSION_ENV_FILE'); - if (sessionFile) { - try { +async function withSessionControls($: EngineInterface, current: Environment): Promise { + try { + const sessionFile = await $.env.get('UCODE_SESSION_ENV_FILE'); + if (sessionFile) { const overrides = JSON.parse(await $.fs.read(sessionFile)); for (const key of [ 'ENABLE_SMART_ROUTING_V2', 'ENABLE_SMART_ROUTING_SUBAGENT_ONLY', 'ENABLE_SMART_ROUTER_ORCHESTRATOR', + 'ENABLE_SMART_ROUTING_SAVINGS', ]) { if (typeof overrides?.[key] === 'string') current[key] = overrides[key]; } - } catch { - // Match the routing hooks' inherited-environment fallback for unreadable controls. } + } catch { + // Match the routing hooks' inherited-environment fallback for unreadable controls. } + return current; +} + +async function readOrchestratorState($: EngineInterface, options: PluginOptions): Promise { + if (!options.orchestratorInstructions) return false; + const current = await withSessionControls($, await readEnvironment($)); return isRoutingEnabled(current) && current.ENABLE_SMART_ROUTER_ORCHESTRATOR === '1'; } @@ -60,6 +66,7 @@ async function writeEnvironment($: EngineInterface, env: Environment): Promise { + startStatusBandTurn(); + await savingsPromptSubmit($, e); + return next(e); + }); + + // Claude permits one unmatched turn.step handler, so orchestration and savings share it. + on('turn.step', async function* ($, e, forward) { + async function* next(request: typeof e) { + const agent = str(request.agentId); + let trackSavings = false; + let baseline: string | null = null; + try { + trackSavings = await ready($); + if (trackSavings) { + if (agent === null) { + lastMainModel = str(request.model) ?? lastMainModel; + firstMainModel ??= lastMainModel; + firstPromptSeen = true; + userSwitched ||= lastMainModel !== firstMainModel; + } else baseline = lastMainModel ?? (await mainModel($)); + } + } catch { + trackSavings = false; + } + const beforeUserSwitch = !userSwitched; + const result = yield* forward(request); + try { + const usage = (result as any)?.usage; + const served = str(request.model) ?? str(usage?.model); + const base = agent === null ? served : baseline; + if (trackSavings && await ready($) && usage && served && base) { + accumulate(agent ?? 'main', base, served, beforeUserSwitch, usage); + dirty = true; + } + } catch {} + return result; + } const active = await readOrchestratorState($, options); if (active !== orchestratorActive) { orchestratorActive = active; @@ -180,7 +227,7 @@ export function register(on: On, options: PluginOptions): void { } return {text: `Smart Router is ${action}`}; }); - registerStatusBand(on); + registerStatusBand(on, () => savingsShown); registerSubagentRouting(on, options); // Claude allows one unmatched turn.complete handler per plugin, so both modules share it. on('turn.complete', ($, e, next) => { @@ -189,3 +236,316 @@ export function register(on: On, options: PluginOptions): void { return next(e); }); } + +// Price turn-step usage by the requested model ID; gateway response IDs can drift. +// Subagents use the current main model as their baseline. First-prompt routing uses +// the user's pre-routing model until a later manual switch. See docs/claude-mod.md. + +const USAGE_VERSION = 1; +const PRICER_TIMEOUT_MS = 20_000; +const TOKEN_KEYS = [ + 'input_tokens', + 'output_tokens', + 'cache_creation_input_tokens', + 'cache_read_input_tokens', +] as const; +const CACHE_SPLIT_KEYS = ['ephemeral_5m_input_tokens', 'ephemeral_1h_input_tokens'] as const; + +type Totals = Record<(typeof TOKEN_KEYS)[number], number> & { + cache_creation?: Partial>; +}; +type Entry = { + agent: string; + baseline: string; + served: string; + before_user_switch: boolean; + usage: Totals; +}; +// The pricer's segment: a saving, or a cost increase when routing chose pricier models. +type Estimate = { saved: boolean; amount: string; percent: string }; + +const num = (value: unknown): number => + typeof value === 'number' && Number.isFinite(value) ? value : 0; + +const str = (value: unknown): string | null => (typeof value === 'string' && value ? value : null); + +// Set from the launch's plugin options by register. +let pricer: string[] = []; +let usagePath: string | null = null; +let enabled = false; +let version: string | null = null; + +const entries = new Map(); +// The model selected before first-prompt routing. Seeded at launch, then captured +// when the user submits the first prompt so a preceding /model choice is honored. +let startModel: string | null = null; +let firstPromptSeen = false; +// The model the main loop last named, used as the subagent request's baseline. +let lastMainModel: string | null = null; +// The model the main loop's first request named (first-prompt routing's pick). +let firstMainModel: string | null = null; +// Whether a main request has since named another model, which only the user does. +let userSwitched = false; +let seeding: Promise | undefined; +let estimate: Estimate | null = null; +// Whether the current render draws the row, which hides the status band. +let savingsShown = false; +let dirty = false; +let running = false; +let rerun = false; + +async function mainModel($: any): Promise { + try { + return str(await $.session.model()); + } catch { + return null; + } +} + +function accumulate( + agent: string, + baseline: string, + served: string, + beforeUserSwitch: boolean, + usage: any, +): void { + const key = JSON.stringify([agent, baseline, served, beforeUserSwitch]); + let entry = entries.get(key); + if (!entry) { + entry = { + agent, + baseline, + served, + before_user_switch: beforeUserSwitch, + usage: { + input_tokens: 0, + output_tokens: 0, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + }; + entries.set(key, entry); + } + for (const k of TOKEN_KEYS) entry.usage[k] += num(usage[k]); + // The 5m/1h cache-write split is only summed where the API reported it. + const split = usage.cache_creation; + if (split && typeof split === 'object') { + const sums = entry.usage.cache_creation ?? {}; + for (const k of CACHE_SPLIT_KEYS) if (k in split) sums[k] = (sums[k] ?? 0) + num(split[k]); + entry.usage.cache_creation = sums; + } +} + +// A mod reload resets module state while the session carries on, so the first +// hook of a fresh module instance picks up where the last one left off from the +// file it wrote. A missing or malformed file just means starting empty. +async function loadUsage($: any): Promise { + try { + const saved = JSON.parse(await $.fs.read(usagePath)); + if (!saved || saved.version !== USAGE_VERSION || !Array.isArray(saved.entries)) return; + for (const item of saved.entries) { + const agent = str(item?.agent); + const baseline = str(item?.baseline); + const served = str(item?.served); + if (agent && baseline && served && item.usage && typeof item.usage === 'object') { + accumulate(agent, baseline, served, item.before_user_switch === true, item.usage); + dirty = true; + } + } + startModel ??= str(saved.start_model); + lastMainModel ??= str(saved.main_model); + firstMainModel ??= str(saved.first_main_model); + firstPromptSeen ||= saved.first_prompt_seen === true || firstMainModel !== null; + userSwitched ||= saved.user_switched === true; + } catch {} +} + +async function readSavingsFlag($: EngineInterface): Promise { + try { + return await $.env.get('ENABLE_SMART_ROUTING_SAVINGS'); + } catch { + return undefined; + } +} + +async function readSavingsState($: EngineInterface): Promise { + if (!enabled) return false; + const current = await withSessionControls($, { + ENABLE_SMART_ROUTING_SAVINGS: await readSavingsFlag($), + }); + return current.ENABLE_SMART_ROUTING_SAVINGS === '1'; +} + +// State is seeded once per module instance, by whichever hook runs first; +// concurrent hooks wait on the same load. +async function ready($: any): Promise { + try { + if (!await readSavingsState($)) return false; + seeding ??= loadUsage($); + await seeding; + return true; + } catch { + return false; + } +} + +async function savingsPromptSubmit($: EngineInterface, e: any): Promise { + try { + if (e.isMeta || e.command || !e.text.trim() || e.text.trimStart().startsWith('/')) return; + if (!await ready($) || firstPromptSeen) return; + // This runs before UserPromptSubmit blocks the prompt for the PTY router. + startModel = await mainModel($); + firstPromptSeen = true; + dirty = true; + void flush($); + } catch {} +} + +function estimateOf(value: any): Estimate | null { + if (!value || typeof value !== 'object' || typeof value.saved !== 'boolean') return null; + const amount = str(value.amount); + const percent = str(value.percent); + return amount && percent ? { saved: value.saved, amount, percent } : null; +} + +// The pricer's last stdout line; a failed run drops the estimate, which would be stale. +async function runPricer($: any): Promise { + try { + const run = await $.process.run([...pricer, '--usage', usagePath], { + timeoutMs: PRICER_TIMEOUT_MS, + }); + if (run?.exitCode === 0) { + const out = JSON.parse(String(run.stdout ?? '').trim().split('\n').pop() ?? ''); + if (out && typeof out === 'object') return estimateOf(out.savings); + } + } catch {} + return null; +} + +async function writeAndPrice($: any): Promise { + dirty = false; + try { + await $.fs.write( + usagePath, + JSON.stringify({ + version: USAGE_VERSION, + start_model: startModel, + main_model: lastMainModel, + first_main_model: firstMainModel, + first_prompt_seen: firstPromptSeen, + user_switched: userSwitched, + entries: Array.from(entries.values()), + }), + ); + } catch (error) { + // Retry at the next turn.complete rather than pricing a file that is not there. + dirty = true; + setEstimate($, null); + throw error; + } + setEstimate($, await runPricer($)); +} + +function setEstimate($: EngineInterface, next: Estimate | null): void { + if (JSON.stringify(next) !== JSON.stringify(estimate)) { + estimate = next; + // Claude Code only redraws the band when its props change, not when module state does. + $.ui.invalidate('ui.render'); + } +} + +// One pricer run at a time; a request that arrives mid-run just asks for another. +async function flush($: any): Promise { + if (!await ready($)) return; + if (running) { + rerun = true; + return; + } + running = true; + try { + do { + rerun = false; + await writeAndPrice($); + } while (rerun); + } catch { + } finally { + running = false; + } +} + +// Styled like the status band: a bold label, the amount in a pill, a dim italic trailer. +// Nothing until there is an estimate: the band and prompt hint already show routing state. +function savingsRow({ Box, Text }: any): unknown { + if (!estimate) return null; + const color = estimate.saved ? 'green' : 'yellow'; + const children: unknown[] = [ + Text({ + bold: true, + children: [estimate.saved ? '💰 Est. saved with smart routing' : 'Smart routing cost'], + }), + Text({ bold: true, color: 'black', backgroundColor: color, children: [` ${estimate.amount} `] }), + Text({ color, children: [`${estimate.saved ? '' : 'more '}(${estimate.percent})`] }), + ]; + if (version) { + children.push( + Text({ dimColor: true, italic: true, children: [`— Unity Gateway Smart Router v${version}`] }), + ); + } + return Box({ flexDirection: 'row', columnGap: 1, children }); +} + +function registerSavings(on: On, options: PluginOptions): void { + if (options.ENABLE_SMART_ROUTING_SAVINGS !== '1') return; + const raw = options as Record; + pricer = + Array.isArray(raw.savings_pricer) && raw.savings_pricer.every(arg => typeof arg === 'string') + ? (raw.savings_pricer as string[]) + : []; + usagePath = str(raw.savings_usage); + enabled = pricer.length > 0 && usagePath !== null; + version = str(raw.orchestrator_version); + let savingsActive = false; + let refresh: { cancel: () => void } | undefined; + + // Price at the end of each turn, off the turn's critical path. The status band holds the + // event's one unmatched hook, so this one matches every turn instead. + on('turn.complete', { isAborted: [false, true] }, async ($, e, next) => { + const result = await next(e); + if ((await ready($)) && dirty) void flush($); + return result; + }); + + on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => { + savingsActive = await readSavingsState($); + // CLI toggles change the file without updating Claude's cached render props. + if (enabled && !refresh) { + try { + refresh = $.clock.every(1000, async () => { + try { + const active = await readSavingsState($); + if (active !== savingsActive) { + savingsActive = active; + $.ui.invalidate('ui.render'); + } + } catch {} + }); + } catch {} + } + // Decided before the inner handlers run, so the status band sees it whichever + // handler Claude Code runs first. + savingsShown = savingsActive && estimate !== null; + const theirs = await next(e); + if (!savingsShown) return theirs; + const ui = $.ui.resolve(e); + const row = savingsRow(ui); + if (row === null) return theirs; + return theirs ? ui.Box({ flexDirection: 'column', children: [theirs, row] }) : row; + }); +} + +async function savingsSessionStart($: EngineInterface): Promise { + if (await ready($)) { + startModel ??= await mainModel($); + void flush($); + } +} diff --git a/src/ucode/agents/claude_mods/smart-routing-status.ts b/src/ucode/agents/claude_mods/smart-routing-status.ts index bd9e6c879..122631837 100644 --- a/src/ucode/agents/claude_mods/smart-routing-status.ts +++ b/src/ucode/agents/claude_mods/smart-routing-status.ts @@ -13,6 +13,10 @@ export function showStatusBand(): void { band.isHideArmed = false } +export function startStatusBandTurn(): void { + if (band.isVisible) band.isHideArmed = true +} + // Hides the band at the end of an armed turn; true when the band changed and needs a redraw. // The register module owns the one turn.complete handler, which the routing cards share. export function endStatusBandTurn(): boolean { @@ -53,14 +57,10 @@ async function readRoutingState($: any): Promise { } } -export const registerStatusBand = (on: On): void => { +// isReplaced lets another above-prompt row take the band's place while it shows. +export const registerStatusBand = (on: On, isReplaced: () => boolean = () => false): void => { let running = 0 let refresh: { cancel: () => void } | undefined - on('prompt.submit', ($, e, next) => { - if (band.isVisible) band.isHideArmed = true - return next(e) - }) - // The prompt hint row always carries the state as a plain tail, so it stays visible after // the band hides and flips as soon as a toggle succeeds. on('ui.render', { component: 'PromptHint' }, async ($, e, next) => { @@ -79,7 +79,7 @@ export const registerStatusBand = (on: On): void => { on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => { const theirs = await next(e) - if (!band.isVisible) return theirs + if (!band.isVisible || isReplaced()) return theirs const { Box, Text } = $.ui.resolve(e) const { enabled, firstPrompt } = await readRoutingState($) diff --git a/src/ucode/constants.py b/src/ucode/constants.py index e0bdf3854..a53750b2d 100644 --- a/src/ucode/constants.py +++ b/src/ucode/constants.py @@ -11,6 +11,7 @@ ENABLE_SMART_ROUTING_ENV_VAR = "ENABLE_SMART_ROUTING_V2" ENABLE_SUBAGENT_ROUTING_ENV_VAR = "ENABLE_SMART_ROUTING_SUBAGENT_ONLY" +ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR = "ENABLE_SMART_ROUTING_SAVINGS" ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR = "ENABLE_SMART_ROUTER_ORCHESTRATOR" SMART_ROUTER_CONFIG_VERSION_ENV_VAR = "SMART_ROUTER_CONFIG_VERSION" ISAAC_SMART_ROUTER_FEEDBACK_ENV_VAR = "ISAAC_SMART_ROUTER_FEEDBACK" @@ -18,6 +19,7 @@ ENABLE_SMART_ROUTING_ENV_VAR, ENABLE_SUBAGENT_ROUTING_ENV_VAR, ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR, ) MODEL_PROVIDER_SERVICE_HEADER = "Databricks-Model-Provider-Service" diff --git a/src/ucode/databricks.py b/src/ucode/databricks.py index 6f0397528..e927fedfb 100644 --- a/src/ucode/databricks.py +++ b/src/ucode/databricks.py @@ -2684,6 +2684,38 @@ def fetch_external_model_prices(workspace: str, token: str) -> tuple[list[dict], return models, None +# Per-token rates for Databricks-hosted (`system.ai`) model services from the gateway's +# pay-per-token endpoint-rates API, which the smart-routing savings estimate prices usage with. +# The model names travel as repeated `databricks_hosted_model_services` query parameters. +_ENDPOINT_RATES_API_PATH = "/api/ai-gateway/v2/endpoint-rates:batchGet" +_SYSTEM_AI_MODEL_PREFIX = "system.ai." + + +def fetch_endpoint_rates( + workspace: str, token: str, model_services: list[str] +) -> tuple[list[dict], str | None]: + """Batch-fetch per-token rates for ``system.ai`` model services. + + Returns ``(rates, reason)`` with each rate the raw ``EndpointRate`` entry; models the caller + can't see are absent rather than errors. Names outside ``system.ai`` are dropped because the + API rejects them. ``reason`` is non-None on failure so callers omit the estimate, not fail. + """ + names = sorted({name for name in model_services if name.startswith(_SYSTEM_AI_MODEL_PREFIX)}) + if not names: + return [], "no system.ai model services to price" + query = urlencode([("databricks_hosted_model_services", name) for name in names]) + url = f"https://{workspace_hostname(workspace)}{_ENDPOINT_RATES_API_PATH}?{query}" + payload, reason = _http_get_json(url, token, timeout=30) + if reason is not None: + return [], reason + if not isinstance(payload, dict): + return [], "endpoint-rates returned an unexpected response shape" + rates = payload.get("model_service_rates") + if not isinstance(rates, list): + return [], None + return [rate for rate in rates if isinstance(rate, dict)], None + + # The `update_mask` paths a config PATCH sends. The server rejects paths outside its mutable set, # so this omits `spec_version` (an estore-internal format marker, still sent in the body; naming it # in the mask is the 400 this fixes) and the reserved/deprecated fields (`display_name`, `tracing`, diff --git a/src/ucode/smart_routing/config.py b/src/ucode/smart_routing/config.py index c26d57453..7579e851d 100644 --- a/src/ucode/smart_routing/config.py +++ b/src/ucode/smart_routing/config.py @@ -10,6 +10,7 @@ AGENT_CODEX, ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, ENABLE_SMART_ROUTING_ENV_VAR, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR, ENABLE_SUBAGENT_ROUTING_ENV_VAR, SMART_ROUTER_CONFIG_VERSION_ENV_VAR, SMART_ROUTING_ENV_KEYS, @@ -33,6 +34,9 @@ # Preserve subagent_orch_v0 for Claude, with all Codex routing flags disabled. SUBAGENT_ORCH_V0_CLAUDE_ONLY = "subagent_orch_v0_claude_only" +# Subagent orchestration with the Claude savings estimate enabled. +SUBAGENT_ORCH_SAVINGS_V0 = "subagent_orch_savings_v0" + # Selected by --enable-smart-routing and managed smart routing when no known version is set. DEFAULT_ENABLED_VERSION = SUBAGENT_ORCH_V0_CLAUDE_ONLY @@ -43,26 +47,37 @@ ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "0", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, SUBAGENT_ONLY_V0: { ENABLE_SMART_ROUTING_ENV_VAR: "0", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, SUBAGENT_ONLY_V1: { ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, SUBAGENT_ORCH_V0: { ENABLE_SMART_ROUTING_ENV_VAR: "0", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, SUBAGENT_ORCH_V1: { ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", + }, + SUBAGENT_ORCH_SAVINGS_V0: { + ENABLE_SMART_ROUTING_ENV_VAR: "1", + ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", + ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "1", }, } @@ -88,6 +103,10 @@ AGENT_CLAUDE: _BASE_VERSIONS[SUBAGENT_ORCH_V1], AGENT_CODEX: _BASE_VERSIONS[SUBAGENT_ORCH_V1], }, + SUBAGENT_ORCH_SAVINGS_V0: { + AGENT_CLAUDE: _BASE_VERSIONS[SUBAGENT_ORCH_SAVINGS_V0], + AGENT_CODEX: _BASE_VERSIONS[SUBAGENT_ORCH_SAVINGS_V0], + }, # Codex opts out of routing and orchestration; Claude keeps subagent_orch_v0. SUBAGENT_ORCH_V0_CLAUDE_ONLY: { AGENT_CLAUDE: _BASE_VERSIONS[SUBAGENT_ORCH_V0], @@ -95,6 +114,7 @@ ENABLE_SMART_ROUTING_ENV_VAR: "0", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "0", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, }, } diff --git a/src/ucode/smart_routing/orchestrator.py b/src/ucode/smart_routing/orchestrator.py index c84000bc2..2669beac3 100644 --- a/src/ucode/smart_routing/orchestrator.py +++ b/src/ucode/smart_routing/orchestrator.py @@ -80,6 +80,28 @@ def skill_directory() -> Path: return skills._skills_source() / skills.SMART_ROUTER_ORCHESTRATOR_SKILL +def skill_version(*, agent: str) -> str | None: + """The ``metadata.version`` in the agent's skill frontmatter, or None when it can't be read.""" + try: + text = skills.skill_entrypoint(skill_directory(), agent).read_text(encoding="utf-8") + except (OSError, UnicodeError): + return None + lines = text.splitlines() + if not lines or lines[0].strip() != "---": + return None + in_metadata = False + for line in lines[1:]: + if line.strip() == "---": + break + if not line.startswith((" ", "\t")): + in_metadata = line.rstrip() == "metadata:" + continue + key, separator, value = line.strip().partition(":") + if in_metadata and separator and key == "version": + return value.strip().strip("\"'") or None + return None + + def add_claude_agents(plugin_dir: Path) -> None: """Load roles alongside the router's exact-model agents, only for this launch.""" if feature_enabled(agent=AGENT_CLAUDE): diff --git a/src/ucode/smart_routing/pricing.py b/src/ucode/smart_routing/pricing.py new file mode 100644 index 000000000..d18b7cc01 --- /dev/null +++ b/src/ucode/smart_routing/pricing.py @@ -0,0 +1,294 @@ +"""Per-token model prices and the cost of coding-agent token usage. + +The launcher fetches rates from the AI Gateway's endpoint-rates API (``prices_from_endpoint_rates``) +and caches them per workspace (``price_cache_path``) for the savings pricer to read; this module +defines that cache and the arithmetic. A token class with no rate makes a response unpriceable, and +the pricer drops the estimate rather than undercount it. The API returns per-million-token +dollar rates for input, output, and cache tokens (5-minute and 1-hour writes, and reads), which the +estimate needs because fixed multipliers don't hold across models (Opus 5.5 cache reads bill at +0.05x input, Opus 4.8's at 0.1x). A model whose org has no DBU-to-dollar conversion stays unpriced. + +Stdlib-only on purpose: the savings pricer imports this in a fresh process after every turn, and the +CLI's usual imports (Rich, Typer, the Databricks SDK, even ``urllib.request``) take about a second. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import tempfile +import time +from collections.abc import Iterable, Mapping +from dataclasses import dataclass, fields +from decimal import Decimal, InvalidOperation +from pathlib import Path +from typing import Any, NamedTuple + +_PRICE_CACHE_VERSION = 1 +_MILLION = Decimal(1_000_000) +_CONTEXT_SUFFIX_RE = re.compile(r"\[[^\]]*\]$") +_ANTHROPIC_AIGW_PREFIX_RE = re.compile(r"^anthropic-aigw-[0-9a-f]{8}-") +# The gateway reports some served models by their provider id, e.g. Bedrock's +# `anthropic.claude-haiku-4-5-20251001-v1:0` for a request to `system.ai.claude-haiku-4-5`. +_PROVIDER_PREFIX_RE = re.compile(r"^(?:(?:us|eu|apac|au|jp|global)\.)?anthropic\.") +_PROVIDER_SUFFIX_RE = re.compile(r"(?:-20\d{6})?(?:-v\d+(?::\d+)?)?$") +# Other served models are reported by a deployment id that drifts from the model service name: +# `glm-5.3-flash` for `system.ai.glm-5-3-flash`, `glm-5-3-colo-on-sp-v1` for `system.ai.glm-5-3`. +_DEPLOYMENT_SUFFIX_RE = re.compile(r"-colo-on-[a-z0-9]+(?:-v\d+(?::\d+)?)?$") + + +def model_key(model: str) -> str: + """Collapse the spellings of one model id that Claude Code and the gateway use. + + Mirrors ``routing.unwrap_anthropic_gateway_model`` + ``routing.normalize_model`` without + importing ``routing``, whose ``urllib.request`` import alone costs ~0.2s of pricer startup. + Also drops a ``[1m]`` context-window selector (a window, not a price), and the provider prefix, + date/version suffix and deployment spelling of a served id, so it keys the same as the + requested model. + """ + name = _CONTEXT_SUFFIX_RE.sub("", (model or "").strip().lower()) + name = _ANTHROPIC_AIGW_PREFIX_RE.sub("", name).rsplit("/", 1)[-1] + for prefix in ("databricks-", "system.ai."): + if name.startswith(prefix): + name = name[len(prefix) :] + break + name, provider = _PROVIDER_PREFIX_RE.subn("", name) + name = name.split("@", 1)[0] + if provider: + name = _PROVIDER_SUFFIX_RE.sub("", name) + name = _DEPLOYMENT_SUFFIX_RE.sub("", name) + # Model service names spell versions with dashes. + return name.replace(".", "-") + + +@dataclass(frozen=True) +class ModelPrice: + """USD per million tokens by token class; ``None`` where the gateway reports no rate.""" + + input: Decimal | None = None + output: Decimal | None = None + cache_read: Decimal | None = None + cache_write_5m: Decimal | None = None + cache_write_1h: Decimal | None = None + # Rates for requests whose prompt exceeds the threshold (e.g. Sonnet 4.x above 200k tokens). + long_context_threshold: int | None = None + long_context: ModelPrice | None = None + + +_RATE_FIELDS = tuple( + field.name for field in fields(ModelPrice) if not field.name.startswith("long_context") +) + + +class TokenUsage(NamedTuple): + """One model response's billed tokens, split by the classes that are priced separately.""" + + input: int = 0 + cache_write_5m: int = 0 + cache_write_1h: int = 0 + cache_read: int = 0 + output: int = 0 + + @classmethod + def from_message_usage( + cls, usage: Mapping[str, Any], *, uncovered_writes_1h: bool = False + ) -> TokenUsage: + """Read an Anthropic Messages ``usage`` object as Claude Code records it in transcripts. + + Cache writes are split by TTL because a 1-hour write bills at twice the input rate and a + 5-minute write at 1.25x; ug enables 1-hour caching. Writes the breakdown doesn't cover are + billed as 5-minute writes, the API's default TTL. A caller whose usage never carries the + breakdown, but whose session ran with 1-hour caching, sets ``uncovered_writes_1h`` so those + writes aren't undercounted at the 5-minute rate. + """ + creation = usage.get("cache_creation") + creation = creation if isinstance(creation, Mapping) else {} + write_1h = _count(creation.get("ephemeral_1h_input_tokens")) + write_5m = _count(creation.get("ephemeral_5m_input_tokens")) + uncovered = max(_count(usage.get("cache_creation_input_tokens")) - write_1h - write_5m, 0) + if uncovered_writes_1h: + write_1h += uncovered + else: + write_5m += uncovered + return cls( + input=_count(usage.get("input_tokens")), + cache_write_5m=write_5m, + cache_write_1h=write_1h, + cache_read=_count(usage.get("cache_read_input_tokens")), + output=_count(usage.get("output_tokens")), + ) + + @property + def prompt_tokens(self) -> int: + """Every input-side token, which is what long-context price thresholds measure.""" + return self.input + self.cache_write_5m + self.cache_write_1h + self.cache_read + + +def _count(value: object) -> int: + return value if isinstance(value, int) and not isinstance(value, bool) and value > 0 else 0 + + +def token_cost(price: ModelPrice, tokens: TokenUsage) -> Decimal | None: + """USD cost of one response, or None when a token class it used has no rate. + + Returning None rather than pricing a missing rate at zero keeps callers from showing a figure + that silently undercounts. + """ + if ( + price.long_context is not None + and price.long_context_threshold is not None + and tokens.prompt_tokens > price.long_context_threshold + ): + price = price.long_context + total = Decimal(0) + for count, rate in ( + (tokens.input, price.input), + (tokens.cache_write_5m, price.cache_write_5m), + (tokens.cache_write_1h, price.cache_write_1h), + (tokens.cache_read, price.cache_read), + (tokens.output, price.output), + ): + if count <= 0: + continue + if rate is None: + return None + total += Decimal(count) * rate + return total / _MILLION + + +def _rate(raw: object) -> Decimal | None: + if isinstance(raw, bool) or not isinstance(raw, int | float | str) or not str(raw).strip(): + return None + try: + rate = Decimal(str(raw).strip()) + except InvalidOperation: + return None + return rate if rate.is_finite() and rate >= 0 else None + + +def _dump_price(price: ModelPrice) -> dict[str, Any]: + dumped: dict[str, Any] = { + name: str(value) for name in _RATE_FIELDS if (value := getattr(price, name)) is not None + } + if price.long_context is not None and price.long_context_threshold is not None: + dumped["long_context_threshold"] = price.long_context_threshold + dumped["long_context"] = _dump_price(price.long_context) + return dumped + + +def _load_price(raw: object) -> ModelPrice | None: + if not isinstance(raw, Mapping): + return None + rates = {name: _rate(raw.get(name)) for name in _RATE_FIELDS} + threshold = raw.get("long_context_threshold") + long_context = _load_price(raw.get("long_context")) + if isinstance(threshold, bool) or not isinstance(threshold, int) or long_context is None: + threshold, long_context = None, None + return ModelPrice(**rates, long_context_threshold=threshold, long_context=long_context) + + +# The endpoint-rates API groups each model's costs by unit; the estimate is in dollars. +_DOLLARS_UNIT = "USD" +# `TokenType` enum names → the ``ModelPrice`` field each bills. CACHE_CREATION is the API's default +# 5-minute cache write; CACHE_CREATION_1H is the 1-hour write ug enables. +_TOKEN_TYPE_FIELDS = { + "TOKEN_TYPE_INPUT": "input", + "TOKEN_TYPE_OUTPUT": "output", + "TOKEN_TYPE_CACHE_CREATION": "cache_write_5m", + "TOKEN_TYPE_CACHE_CREATION_1H": "cache_write_1h", + "TOKEN_TYPE_CACHE_READ": "cache_read", +} + + +def prices_from_endpoint_rates(rates: Iterable[object]) -> dict[str, ModelPrice]: + """Map endpoint-rates ``EndpointRate`` entries to prices keyed by their model service. + + Reads the ``USD`` group of each entry's ``costs`` (a per-million-token ``cost`` per + ``token_type``). The API omits the dollar group when the org has no DBU-to-dollar conversion + configured; those models are left unpriced rather than shown in DBUs. + """ + prices: dict[str, ModelPrice] = {} + for rate in rates: + if not isinstance(rate, Mapping): + continue + service = rate.get("model_service") + costs = rate.get("costs") + if not isinstance(service, str) or not service or not isinstance(costs, list): + continue + dollars = next( + (c for c in costs if isinstance(c, Mapping) and c.get("unit") == _DOLLARS_UNIT), None + ) + token_costs = dollars.get("token_costs") if isinstance(dollars, Mapping) else None + if not isinstance(token_costs, list): + continue + rate_fields: dict[str, Decimal] = {} + for entry in token_costs: + if not isinstance(entry, Mapping): + continue + field = _TOKEN_TYPE_FIELDS.get(entry.get("token_type")) + value = _rate(entry.get("cost")) + if field is not None and value is not None: + rate_fields[field] = value + price = ModelPrice( + input=rate_fields.get("input"), + output=rate_fields.get("output"), + cache_read=rate_fields.get("cache_read"), + cache_write_5m=rate_fields.get("cache_write_5m"), + cache_write_1h=rate_fields.get("cache_write_1h"), + ) + if price.input is not None or price.output is not None: + prices[service] = price + return prices + + +def price_cache_path(app_dir: Path, workspace: str) -> Path: + """Cache for a full workspace key (including its id on a shared host).""" + host = workspace.strip().lower().removeprefix("https://").rstrip("/") + digest = hashlib.sha256(host.encode("utf-8")).hexdigest()[:16] + return app_dir / f"model-prices-{digest}.json" + + +def write_price_cache( + path: Path, prices: Mapping[str, ModelPrice], *, now: float | None = None +) -> None: + """Atomically replace the price cache so a concurrent pricer never reads a partial file. + + ``prices`` is keyed by any spelling of the model id; entries are stored under ``model_key``. + """ + payload = { + "version": _PRICE_CACHE_VERSION, + "fetched_at": now if now is not None else time.time(), + "models": {model_key(model): _dump_price(price) for model, price in prices.items()}, + } + path.parent.mkdir(parents=True, exist_ok=True) + fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp") + try: + with os.fdopen(fd, "w", encoding="utf-8") as handle: + json.dump(payload, handle, separators=(",", ":")) + os.replace(temporary, path) + except BaseException: + Path(temporary).unlink(missing_ok=True) + raise + + +def read_price_cache(path: Path) -> tuple[dict[str, ModelPrice], str] | None: + """Load prices keyed by ``model_key``, plus a fingerprint that changes on every refresh.""" + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except (OSError, ValueError): + return None + if not isinstance(payload, dict) or payload.get("version") != _PRICE_CACHE_VERSION: + return None + models = payload.get("models") + if not isinstance(models, dict): + return None + prices = { + key: price + for key, raw in models.items() + if isinstance(key, str) and (price := _load_price(raw)) is not None + } + if not prices: + return None + return prices, str(payload.get("fetched_at")) diff --git a/src/ucode/smart_routing/savings.py b/src/ucode/smart_routing/savings.py new file mode 100644 index 000000000..63d93049f --- /dev/null +++ b/src/ucode/smart_routing/savings.py @@ -0,0 +1,172 @@ +"""Price the Claude mod's token sums into a smart-routing savings estimate. + +The savings estimate assumes every token the session used, main agent and subagents alike, would +otherwise have run on the baseline main-agent model:: + + saved = sum(tokens * price(baseline)) - sum(tokens * price(model that served them)) + +per token class. The mod (``agents/claude_mods/register.ts``) sums each turn request's usage by +(agent, baseline, served) and runs this module on that file after every turn; it prints one JSON +line with the segment the mod draws. A main-agent request is its own baseline, and a subagent's is +the main model in effect when it ran, so switching models with ``/model`` never reprices earlier +work. Under first-prompt routing, where the router also picks the main model, requests from before +the user changed the main model are priced against the model selected before submitting the first +prompt, so a manual selection before routing becomes the baseline. A negative +result (routing chose pricier models) is shown as a cost increase. + +Keep imports lightweight: the mod runs this in a fresh process after every turn, +and the CLI's usual imports take about a second. +""" + +from __future__ import annotations + +import argparse +import json +from decimal import ROUND_HALF_UP, Decimal +from pathlib import Path + +from ucode.constants import AGENT_CLAUDE, ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR +from ucode.smart_routing.pricing import ( + ModelPrice, + TokenUsage, + model_key, + read_price_cache, + token_cost, +) +from ucode.smart_routing.session_env import effective_environment + +MODULE = "ucode.smart_routing.savings" +# The file the mod writes its token sums to, in the launch directory; the mod reads its path from +# the plugin options, so only the version is shared with it. +USAGE_FILENAME = "savings-usage.json" +_USAGE_VERSION = 1 +_CENT = Decimal("0.01") + + +def pricer_argv(*, python: str, price_cache: Path, baseline_session_start: bool) -> list[str]: + """The command the Claude mod runs (plus ``--usage PATH``) to price its token sums.""" + # -P keeps the launch directory off sys.path, so a project file can't shadow a stdlib module. + argv = [python, "-P", "-m", MODULE, "--price-cache", str(price_cache)] + if baseline_session_start: + argv.append("--baseline-session-start") + return argv + + +def _response_costs( + prices: dict[str, ModelPrice], served_key: str, baseline_key: str, tokens: TokenUsage +) -> tuple[Decimal, Decimal] | None: + """``(actual, baseline)`` dollars for one entry, or None when either model can't be priced.""" + served_price = prices.get(served_key) + baseline_price = prices.get(baseline_key) + if served_price is None or baseline_price is None: + return None + actual = token_cost(served_price, tokens) + baseline = token_cost(baseline_price, tokens) + if actual is None or baseline is None: + return None + return actual, baseline + + +def usage_savings( + usage_path: Path, *, price_cache: Path, baseline_session_start: bool +) -> tuple[Decimal, Decimal] | None: + """The ``(saved, baseline)`` dollars for the mod's token sums, or None with nothing to claim. + + None until routing changed some model, and whenever an entry is malformed, baseline-less or + unpriced: an undercounted figure would be worse than none. A file that can't be read as the + mod's format at all is an error, not an empty estimate. + """ + document = json.loads(usage_path.read_text(encoding="utf-8")) + if not isinstance(document, dict) or document.get("version") != _USAGE_VERSION: + raise ValueError(f"unsupported savings usage file: {usage_path}") + entries = document.get("entries") + if not isinstance(entries, list): + raise ValueError(f"unsupported savings usage file: {usage_path}") + fixed_baseline = None + if baseline_session_start: + start = document.get("start_model") + if not isinstance(start, str) or not start: + return None + fixed_baseline = start + cached = read_price_cache(price_cache) + if cached is None: + return None + prices = cached[0] + + actual_total = baseline_total = Decimal(0) + rerouted = False + for entry in entries: + if not isinstance(entry, dict): + return None + usage, served = entry.get("usage"), entry.get("served") + baseline = entry.get("baseline") + if fixed_baseline is not None and entry.get("before_user_switch") is True: + baseline = fixed_baseline + if not isinstance(usage, dict) or not isinstance(served, str) or not served: + return None + if not isinstance(baseline, str) or not baseline: + return None + # The mod's usage has no cache-write TTL split, and ug launches Claude with 1-hour caching. + tokens = TokenUsage.from_message_usage(usage, uncovered_writes_1h=True) + if not any(tokens): + continue + served_key, baseline_key = model_key(served), model_key(baseline) + costs = _response_costs(prices, served_key, baseline_key, tokens) + if costs is None: + return None + actual_total += costs[0] + baseline_total += costs[1] + rerouted = rerouted or served_key != baseline_key + if not rerouted or baseline_total <= 0: + return None + return baseline_total - actual_total, baseline_total + + +def savings_segment(saved: Decimal, baseline: Decimal) -> dict[str, object]: + """The estimate's parts, for the mod to style: a saving, or an honest cost increase.""" + percent = (abs(saved) / baseline * 100).quantize(Decimal(1), rounding=ROUND_HALF_UP) + magnitude = abs(saved) + amount = ( + "<$0.01" if magnitude < _CENT else f"${magnitude.quantize(_CENT, rounding=ROUND_HALF_UP):,}" + ) + return {"saved": saved >= 0, "amount": amount, "percent": f"{percent}%"} + + +def usage_output(usage_path: Path, *, price_cache: Path, baseline_session_start: bool) -> str: + """The one JSON line the mod reads: its savings segment, or null.""" + # The mod must get a parseable line whatever goes wrong. + savings = None + try: + computed = usage_savings( + usage_path, price_cache=price_cache, baseline_session_start=baseline_session_start + ) + savings = None if computed is None else savings_segment(*computed) + except Exception: # noqa: BLE001 + pass + return json.dumps({"savings": savings}) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser( + prog=MODULE, description="Price the Claude mod's token sums as a JSON line." + ) + parser.add_argument("--usage", type=Path, required=True) + parser.add_argument("--price-cache", type=Path, required=True) + parser.add_argument("--baseline-session-start", action="store_true") + args = parser.parse_args(argv) + line = ( + usage_output( + args.usage, + price_cache=args.price_cache, + baseline_session_start=args.baseline_session_start, + ) + if effective_environment(agent=AGENT_CLAUDE).get(ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR) + == "1" + else json.dumps({"savings": None}) + ) + print(line) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/ucode/smart_routing/session_env.py b/src/ucode/smart_routing/session_env.py index cb154074b..9831d3402 100644 --- a/src/ucode/smart_routing/session_env.py +++ b/src/ucode/smart_routing/session_env.py @@ -10,7 +10,6 @@ from collections.abc import Mapping, MutableMapping from pathlib import Path -from ucode.config_io import atomic_write_json from ucode.constants import SMART_ROUTING_ENV_KEYS from ucode.smart_routing.config import resolve_environment @@ -21,6 +20,8 @@ def start_session(env: MutableMapping[str, str] | None = None) -> Path: """Create an empty override file and expose it to the launched harness.""" + from ucode.config_io import atomic_write_json + target = os.environ if env is None else env path = Path(tempfile.mkdtemp(prefix="ug-session-env-")) / "env.json" atomic_write_json(path, {}) @@ -73,6 +74,8 @@ def effective_environment(env: Mapping[str, str] | None = None, *, agent: str) - def set_session_environment(values: Mapping[str, str]) -> None: """Atomically replace the current session's allowlisted overrides.""" + from ucode.config_io import atomic_write_json + path = session_env_path() try: _read(path) diff --git a/src/ucode/smart_routing/v2.py b/src/ucode/smart_routing/v2.py index 101036044..72014452f 100644 --- a/src/ucode/smart_routing/v2.py +++ b/src/ucode/smart_routing/v2.py @@ -8,6 +8,7 @@ import socket import subprocess import sys +import threading import time import urllib.request from collections.abc import Callable, Mapping, MutableMapping @@ -33,6 +34,7 @@ AGENT_CODEX, ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, ENABLE_SMART_ROUTING_ENV_VAR, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR, ENABLE_SUBAGENT_ROUTING_ENV_VAR, LOOPBACK_HOST, SMART_ROUTER_CONFIG_VERSION_ENV_VAR, @@ -42,6 +44,7 @@ from ucode.databricks import ( AnthropicModelCatalog, build_auth_token_argv, + fetch_endpoint_rates, list_anthropic_model_catalog, list_anthropic_models, maybe_add_gpt_1m_suffix, @@ -58,7 +61,7 @@ install_skill, uninstall_agent_skill, ) -from ucode.smart_routing import claude_routing, orchestrator, routing +from ucode.smart_routing import claude_routing, orchestrator, pricing, routing, savings from ucode.smart_routing.claude_hooks import ( FIRST_PROMPT_SOCKET_ENV, ROUTE_SUBAGENT_MOD_EVENT, @@ -70,6 +73,7 @@ from ucode.smart_routing.config import apply_config, apply_enabled_version, resolve_environment from ucode.smart_routing.session_env import SESSION_ENV_VAR, SESSION_PYTHON_ENV_VAR, start_session from ucode.ui import print_note, print_warning +from ucode.workspace import state_workspace_key LEGACY_STATE_KEY = "smart_routing_enabled" @@ -94,6 +98,13 @@ CLAUDE_ROUTE_SELECTION_TIMEOUT_S = 20.0 CLAUDE_ROUTED_AGENT_PREFIX = "ucode-route-" CLAUDE_ROUTING_PLUGIN_NAME = "ug-smart-router" +# Native plugin options for the savings mod, at the values Claude fills in for a launch that omits +# them: no pricer (the estimate is off) and no orchestrator skill version to show. +CLAUDE_SAVINGS_OPTION_DEFAULTS: dict[str, str | list[str]] = { + "savings_pricer": [], + "savings_usage": "", + "orchestrator_version": "", +} CLAUDE_ROUTED_AGENT_PROMPT = ( "Complete the delegated task exactly as requested. Follow the parent agent's instructions and " "return a concise report of your findings or changes." @@ -369,6 +380,89 @@ def _claude_mod_launch_options(env: Mapping[str, str] | None = None) -> dict: } +def savings_enabled(env: Mapping[str, str] | None = None) -> bool: + """Whether a routed Claude launch explicitly enables the savings feature.""" + source = resolve_environment(env, agent=AGENT_CLAUDE) + return source.get(ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR) == "1" + + +def _claude_savings_launch_options( + launch_dir: Path, *, price_cache: Path, baseline_session_start: bool +) -> dict[str, str | list[str]]: + """Options for the savings mod: the pricer it runs after each turn, the file it sums usage + into, and the orchestrator skill version it shows when the launch activates that skill.""" + options = dict(CLAUDE_SAVINGS_OPTION_DEFAULTS) + if not savings_enabled(): + return options + options["savings_pricer"] = savings.pricer_argv( + python=sys.executable, + price_cache=price_cache, + baseline_session_start=baseline_session_start, + ) + options["savings_usage"] = str(launch_dir / savings.USAGE_FILENAME) + if orchestrator.feature_enabled(agent=AGENT_CLAUDE): + options["orchestrator_version"] = orchestrator.skill_version(agent=AGENT_CLAUDE) or "" + return options + + +# Claude settings env keys that name the main model a session may start on. +_MAIN_MODEL_ENV_KEYS = ( + "ANTHROPIC_MODEL", + "ANTHROPIC_DEFAULT_FABLE_MODEL", + "ANTHROPIC_DEFAULT_OPUS_MODEL", + "ANTHROPIC_DEFAULT_SONNET_MODEL", + "ANTHROPIC_DEFAULT_HAIKU_MODEL", +) + + +def _savings_model_services(models: list[str | None], settings: dict) -> list[str]: + """The ``system.ai`` model services a session's responses can be priced against. + + Covers the routable models plus the main model, which the baseline prices every token at and + which can come from a pinned ``--model`` or Claude's default-model env rather than the catalog. + """ + env = settings.get("env") + env = env if isinstance(env, dict) else {} + candidates = [*models, *(env.get(key) for key in _MAIN_MODEL_ENV_KEYS)] + services: set[str] = set() + for model in candidates: + if not isinstance(model, str) or not model: + continue + name = _canonical_claude_model_id(_unwrapped_claude_model_id(model.strip())) + name = name.removesuffix("[1m]") + if name.startswith("system.ai."): + services.add(name) + return sorted(services) + + +def _refresh_savings_prices( + workspace: str, token: str, model_services: list[str], price_cache: Path +) -> None: + """Fetch this launch's per-token rates and cache them for the savings pricer. + + On failure the previous cache stays; without one the estimate stays hidden. + """ + try: + rates, _reason = fetch_endpoint_rates(workspace, token, model_services) + prices = pricing.prices_from_endpoint_rates(rates) + if prices: + pricing.write_price_cache(price_cache, prices) + except Exception: # noqa: BLE001 - a background refresh must never surface in the agent's TUI + return + + +def _start_savings_price_refresh( + workspace: str, token: str, model_services: list[str], price_cache: Path +) -> None: + """Refresh prices off the launch path so a slow rates API never delays Claude's startup.""" + threading.Thread( + target=_refresh_savings_prices, + args=(workspace, token, model_services, price_cache), + name="ug-savings-prices", + daemon=True, + ).start() + + def _claude_mod_launch_args(options: Mapping[str, object]) -> list[str]: # Replayed prompt snapshots bypass tool.describe, even after cache invalidation. return ["--system-prompt-snapshot", "off"] if options.get("orchestratorInstructions") else [] @@ -426,6 +520,25 @@ def _write_routed_claude_plugin(plugin_dir: Path, model_ids: list[str]) -> None: "title": "Recipe", "description": "Original routing recipe", }, + "savings_pricer": { + "type": "string", + "multiple": True, + "default": CLAUDE_SAVINGS_OPTION_DEFAULTS["savings_pricer"], + "title": "Savings pricer", + "description": "Command that prices the session's token sums", + }, + "savings_usage": { + "type": "string", + "default": CLAUDE_SAVINGS_OPTION_DEFAULTS["savings_usage"], + "title": "Savings usage file", + "description": "Launch-scoped file the token sums are written to", + }, + "orchestrator_version": { + "type": "string", + "default": CLAUDE_SAVINGS_OPTION_DEFAULTS["orchestrator_version"], + "title": "Orchestrator skill version", + "description": "Smart Router Orchestrator skill version, when it is active", + }, }, }, ) @@ -735,6 +848,7 @@ def launch_claude( env[ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR] = ( "1" if orchestrator.feature_enabled(agent=AGENT_CLAUDE) else "0" ) + env[ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR] = "1" if savings_enabled() else "0" if route_first_prompt: env[ENABLE_SMART_ROUTING_ENV_VAR] = "1" else: @@ -773,13 +887,26 @@ def route_prompt(prompt: str) -> claude_pty.FirstPromptRoute: session_path = _prepare_smart_router_session("claude") env[SESSION_ENV_VAR] = str(session_path) env[SESSION_PYTHON_ENV_VAR] = os.environ[SESSION_PYTHON_ENV_VAR] + # The savings pricer reads rates from this cache, since it runs after every turn and + # can't wait on the network; the refresh below fills it. + price_cache = pricing.price_cache_path(APP_DIR, state_workspace_key(state) or workspace) mod_options = { **_claude_mod_launch_options({**resolve_environment(agent=AGENT_CLAUDE), **env}), "routeCommand": routing_hook_argv(routing_state, ROUTE_SUBAGENT_MOD_EVENT), + **_claude_savings_launch_options( + launch_dir, price_cache=price_cache, baseline_session_start=route_first_prompt + ), } settings.setdefault("pluginConfigs", {}).setdefault(CLAUDE_ROUTING_PLUGIN_NAME, {})[ "options" ] = mod_options + if savings_enabled(): + _start_savings_price_refresh( + workspace, + token, + _savings_model_services([*model_ids, launch_model], settings), + price_cache, + ) try: write_json_file(settings_path, settings) _write_routed_claude_plugin(plugin_dir, model_ids) diff --git a/tests/README.md b/tests/README.md index bf990076c..d6b4eef87 100644 --- a/tests/README.md +++ b/tests/README.md @@ -247,6 +247,34 @@ Its Claude decoy catalog includes both Claude and Codex decoys; neither belongs The managed Claude parent-schema journey expects numbered GPT models to carry `[1m]` in the picker while retaining the catalog's display label. +Savings estimate coverage: `test_smart_routing_savings.py` prices the mod's token sums +(per-entry and first-prompt baselines, unpriced or malformed entries, the pricer's single +JSON line). `test_smart_routing_pricing.py` covers endpoint rates, distinct model versions, +and distinct price-cache paths for workspaces sharing a host. Shared-host launch wiring +is not covered by these component checks. +The pricer subprocess checks explicit opt-in; unset, empty, zero, and invalid values +stay off. Preset coverage in +`test_smart_routing_config.py` checks the savings flag, inherited-value precedence, +restoration, and launch/session off controls. `test_smart_router.py` checks that the skill +toggle writes all managed flags. +`test_claude_mod.py` checks native literal setters against the flag registry. In the +native suite, options reach the mod unchanged, configured aliases resolve to model IDs, +and disabled sessions create no usage file even with stale savings options. A controlled +local Messages API drives real main and subagent requests and checks exact input, output, +and cache-token totals, including a routed child whose requested and execution models differ. +These sessions explicitly allow Agent in the default permission +mode, keeping auto-mode classifier requests out of the prepared model responses. +Alias checks accept the context selector retained by Claude 2.1.290. Native model commands +and a blocked-prompt replay check the pre-routing baseline and preserve earlier usage after +a later model change. CLI off/on controls exclude disabled turns from the totals; pricer +subprocesses honor the saved +controls and fall back to inherited settings when the file is malformed. Native UI +component tests check that off/on hides/restores a mounted row and failed usage writes +hide stale estimates until a successful write. Capability tests deny the savings flag +read and verify that startup and requests still run. +These are native component checks, not live gateway/model or TUI coverage. +Endpoint-price refresh failures and orchestrator-version display are not covered automatically. + Dedicated CUJs reuse `integration/utils` session/terminal mechanics and file-task and transcript readers, not its config stubs or pytest fixtures. Prompt/model correlation remains CUJ-specific. Concurrent runs may read the same CUJ workspace. @@ -899,9 +927,9 @@ dialog cannot borrow the confirmation footer from a previous dialog. and matching prompt/compaction hook content for Claude and Codex. It also covers shared `SKILL.md` bundles. These are component checks, not live agent execution. -`test_smart_routing_config.py` includes a 162-case Cartesian component oracle: all three legacy -routing flags take unset, `0`, and `1`, while the selector takes unset or one of the five -supported presets, including the customer first-prompt-and-subagent mode. It uses the named +`test_smart_routing_config.py` checks unset, disabled, enabled, and conflicting combinations of +the routing, orchestration, and savings flags against the supported presets, including the +first-prompt-and-subagent and savings modes. It uses the named version constants but independently hardcodes each preset's settings and asserts exact `resolve_environment` and `apply_config` settings, true-unset omission, unrelated-key and input preservation, valid-selector consumption, and environment restoration. diff --git a/tests/conftest.py b/tests/conftest.py index 9ed1a884f..d9b98d1ba 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -179,6 +179,8 @@ def reject_privileged_write(path, _desired_text): monkeypatch.delenv("ENABLE_SMART_ROUTER_ORCHESTRATOR", raising=False) monkeypatch.delenv("SMART_ROUTER_CONFIG_VERSION", raising=False) monkeypatch.delenv("SMART_ROUTER_NAME", raising=False) + # Savings stays off unless a test explicitly enables it. + monkeypatch.delenv("ENABLE_SMART_ROUTING_SAVINGS", raising=False) # On Windows, resolve_command swaps a bare program name for whatever `shutil.which` # finds on the developer's PATH (e.g. a real `codex.CMD`). Rebind only the compatibility # helper's `shutil` so argv stays host-independent; helper tests patch `which` explicitly. diff --git a/tests/integration/README.md b/tests/integration/README.md index 0f4927b60..a788c719d 100644 --- a/tests/integration/README.md +++ b/tests/integration/README.md @@ -1026,9 +1026,9 @@ selected model and rationale and matches the decision log. The native mod applie that model at spawn without rewriting the reviewed tool input. Native task-header rendering is outside that CLI-contract check. -The unit/component `../test_smart_routing_config.py` includes a 162-case Cartesian oracle over all -three legacy routing flags (`None`, `0`, `1`) and six selector forms (`None` plus the five -supported presets, including the internal first-prompt-and-subagent mode). It independently +The unit/component `../test_smart_routing_config.py` checks unset, disabled, enabled, and +conflicting combinations of the routing, orchestration, and savings flags against the +supported presets, including first-prompt-and-subagent and savings modes. It independently hardcodes preset values and asserts exact `resolve_environment` and `apply_config` settings, true-unset omission, unrelated-key and input preservation, valid-selector consumption, and environment restoration. @@ -1842,6 +1842,24 @@ Local Claude mod confirmation replaces the old saved-control-file/assistant-turn Codex retains its CLI control-file checks. No extra TUI sessions or tasks are added. Clear/reload, compaction, and denied-write rollback are not independently checked. +Savings gating and `subagent_orch_savings_v0` have component coverage in +`test_smart_routing_config.py` and the pricer subprocess tests in `test_smart_routing_savings.py`. +Native component tests check opt-in usage-file creation, opt-out preservation, resolved +model aliases, and continued requests after a denied savings-flag read. A controlled +local Messages API exercises real Claude main/subagent requests and token accounting. +This includes a routed child whose requested and execution models differ. +Those component sessions explicitly allow Agent in the default permission mode; they +do not exercise the auto-mode safety classifier. Alias checks also accept the context +selector retained by Claude 2.1.290. +Native model commands and a blocked-prompt replay verify baseline capture before routing +and preserve prior usage after later model changes. CLI off/on excludes disabled turns +from native usage totals. Native UI component tests cover mounted-row updates after +CLI toggles and hiding stale estimates on failed usage writes. Pricer subprocesses read +the saved session controls. Pricing tests keep shared-host workspace cache paths and +model versions distinct; shared-host launch wiring is not covered. +Live savings accumulation, display, and session off/on are not covered by the +integration suite. + Subagent-routing failures have shared warning coverage in `test_codex_routing.py`; the live hook journeys retain their routing assertions and include stderr when no decision is returned. This diagnostic coverage does not prove routing service health. diff --git a/tests/integration/test_ug_smart_routing_hooks.py b/tests/integration/test_ug_smart_routing_hooks.py index 12f106ed3..346f46f82 100644 --- a/tests/integration/test_ug_smart_routing_hooks.py +++ b/tests/integration/test_ug_smart_routing_hooks.py @@ -224,6 +224,7 @@ def _toggle_with_skill( "ENABLE_SMART_ROUTING_V2": "0", "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "0", "ENABLE_SMART_ROUTER_ORCHESTRATOR": "0", + "ENABLE_SMART_ROUTING_SAVINGS": "0", } ) assert json.loads(controls[0].read_text()) != expected diff --git a/tests/native_claude/messages_api.py b/tests/native_claude/messages_api.py new file mode 100644 index 000000000..7a610c14e --- /dev/null +++ b/tests/native_claude/messages_api.py @@ -0,0 +1,99 @@ +"""Controlled Messages responses for testing the real Claude request/usage boundary.""" + +from __future__ import annotations + +import json +import threading +from collections.abc import Iterator +from contextlib import contextmanager +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + + +def _stream(reply: dict, model: str, index: int) -> bytes: + usage = reply["usage"] + events = [ + { + "type": "message_start", + "message": { + "id": f"msg_fixture_{index}", + "type": "message", + "role": "assistant", + "model": reply.get("model", model), + "content": [], + "stop_reason": None, + "stop_sequence": None, + "usage": {**usage, "output_tokens": 0}, + }, + } + ] + for i, block in enumerate(reply["content"]): + is_tool = block["type"] == "tool_use" + start = {**block, "input": {}} if is_tool else {**block, "text": ""} + delta = ( + {"type": "input_json_delta", "partial_json": json.dumps(block["input"])} + if is_tool + else {"type": "text_delta", "text": block["text"]} + ) + events.extend( + [ + {"type": "content_block_start", "index": i, "content_block": start}, + {"type": "content_block_delta", "index": i, "delta": delta}, + {"type": "content_block_stop", "index": i}, + ] + ) + events.extend( + [ + { + "type": "message_delta", + "delta": { + "stop_reason": "tool_use" + if any(block["type"] == "tool_use" for block in reply["content"]) + else "end_turn", + "stop_sequence": None, + }, + "usage": {"output_tokens": usage["output_tokens"]}, + }, + {"type": "message_stop"}, + ] + ) + return "".join( + f"event: {event['type']}\ndata: {json.dumps(event)}\n\n" for event in events + ).encode() + + +@contextmanager +def messages_api(replies: list[dict]) -> Iterator[tuple[str, list[dict]]]: + requests: list[dict] = [] + lock = threading.Lock() + + class Handler(BaseHTTPRequestHandler): + def log_message(self, format, *args): + pass + + def do_POST(self): + request = json.loads(self.rfile.read(int(self.headers.get("content-length", 0)))) + if self.path.split("?")[0] != "/v1/messages": + self.send_error(404) + return + with lock: + index = len(requests) + requests.append(request) + if index >= len(replies): + self.send_error(500, "Unexpected model request") + return + body = _stream(replies[index], request["model"], index) + self.send_response(200) + self.send_header("content-type", "text/event-stream") + self.send_header("content-length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + try: + yield f"http://127.0.0.1:{server.server_port}", requests + finally: + server.shutdown() + server.server_close() + thread.join(timeout=5) diff --git a/tests/native_claude/mod_tests/savings.test.ts b/tests/native_claude/mod_tests/savings.test.ts new file mode 100644 index 000000000..4d1030bb9 --- /dev/null +++ b/tests/native_claude/mod_tests/savings.test.ts @@ -0,0 +1,128 @@ +import type { On } from 'claude-code'; +import { expect, mock, test } from 'claude-code/testing'; + +const options = { + ENABLE_SMART_ROUTING_V2: '0', + ENABLE_SMART_ROUTING_SUBAGENT_ONLY: '1', + ENABLE_SMART_ROUTER_ORCHESTRATOR: '1', + ENABLE_SMART_ROUTING_SAVINGS: '1', + orchestratorInstructions: 'Delegate using Agent.', + savings_pricer: ['/python', '-m', 'ucode.smart_routing.savings'], + savings_usage: '/session/usage.json', + recipe: 'task_v3', + unset: [], +}; + +test('a denied savings read preserves orchestration, startup and model requests', { options }, async ($, on) => { + const env: Record = { ...options } as any; + on('env.get', (_, e) => { + if (e.name === 'ENABLE_SMART_ROUTING_SAVINGS') return { deny: 'savings read denied' }; + return { value: env[e.name] }; + }); + on('env.set', (_, e) => { + env[e.name] = e.value; + return { value: undefined }; + }); + on('session.start', () => ({ cwd: '/session' })); + on('prompt.submit', (_, e) => ({ text: e.text })); + on('tool.describe', (_, e) => ({ description: e.description })); + on('turn.complete', () => ({ text: 'done' })); + let requests = 0; + on('turn.step', async function* (_, e) { + requests += 1; + return { turnId: e.turnId, index: e.index, answer: 'done', toolUses: [] }; + }); + + let denied = false; + try { + await $.env.get('ENABLE_SMART_ROUTING_SAVINGS'); + } catch { + denied = true; + } + expect(denied).toBe(true); + expect(await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/session' })) + .toEqual({ cwd: '/session' }); + expect((await $.tool.describe({ tool: 'Agent', description: 'Native Agent description.' })).description) + .toContain(options.orchestratorInstructions); + expect((await $.prompt.submit({ text: 'hello' })).text).toBe('hello'); + for (const agentId of [undefined, 'child']) { + const result = await $.turn.step({ + turnId: 'turn', index: 0, messageCount: 1, model: 'claude-sonnet-4-6', agentId, + }).next(); + expect(result.done).toBe(true); + expect(result.value.answer).toBe('done'); + } + expect(requests).toBe(2); + expect((await $.turn.complete({ answer: 'done' })).text).toBe('done'); +}); + +async function savingsRow($: any, on: On) { + const state = { controls: {} as Record, failWrites: false, writes: 0, prices: 0 }; + const clock = mock.clock(on); + const env: Record = { ...options, UCODE_SESSION_ENV_FILE: '/session/env.json' }; + on('env.get', (_, e) => ({ value: env[e.name] })); + on('env.set', (_, e) => { + env[e.name] = e.value; + return { value: undefined }; + }); + on('fs.read', (_, e) => ({ value: JSON.stringify(e.path === '/session/env.json' ? state.controls : { + version: 1, + start_model: 'claude-opus-4-8', + first_main_model: 'claude-opus-4-8', + main_model: 'claude-opus-4-8', + first_prompt_seen: true, + entries: [{ + agent: 'child', baseline: 'claude-opus-4-8', served: 'claude-sonnet-4-6', + before_user_switch: true, usage: { input_tokens: 100, output_tokens: 10 }, + }], + }) })); + on('fs.write', () => { + state.writes += 1; + return state.failWrites ? { deny: 'ENOSPC' } : { value: undefined }; + }); + on('process.run', () => { + state.prices += 1; + return { value: { exitCode: 0, stderr: '', stdout: JSON.stringify({ + savings: { saved: true, amount: '$0.18', percent: '60%' }, + }) } }; + }); + on('session.start', () => ({ cwd: '/session' })); + on('turn.complete', () => ({ text: 'done' })); + on('turn.step', async function* (_, e) { + return { turnId: e.turnId, index: e.index, answer: 'done', toolUses: [], usage: { input_tokens: 1, output_tokens: 1 } }; + }); + on('ui.render', { component: 'AbovePrompt' }, ($, e) => $.ui.resolve(e).Text({ children: ['theirs'] })); + await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/session' }); + const row = await $.ui.mount({ plugin: 'ug-smart-router', surface: 'terminal', component: 'AbovePrompt', props: {} }); + await clock.advance(1); + expect(JSON.stringify(await row.drawn())).toContain('$0.18'); + return { state, clock, row }; +} + +test('saved off/on controls hide and restore a mounted savings row', { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on); + state.controls = { ENABLE_SMART_ROUTING_SAVINGS: '0' }; + await clock.advance(1000); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + state.controls = {}; + await clock.advance(1000); + expect(JSON.stringify(await row.drawn())).toContain('$0.18'); +}); + +test('a failed usage write removes the stale estimate until a later write succeeds', { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on); + const priced = state.prices; + state.failWrites = true; + await $.turn.step({ turnId: 'turn', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.writes).toBe(2); + expect(state.prices).toBe(priced); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + + state.failWrites = false; + await $.turn.complete({ answer: 'retry', isAborted: false }); + await clock.advance(1); + expect(state.prices).toBe(priced + 1); + expect(JSON.stringify(await row.drawn())).toContain('$0.18'); +}); diff --git a/tests/native_claude/session.py b/tests/native_claude/session.py index 4b6e2a2c9..5a1847cea 100644 --- a/tests/native_claude/session.py +++ b/tests/native_claude/session.py @@ -20,7 +20,18 @@ class Session: - def __init__(self, binary, root, env, api="http://127.0.0.1:1", route_command=(), resume=None): + def __init__( + self, + binary, + root, + env, + api="http://127.0.0.1:1", + route_command=(), + options=None, + resume=None, + model="claude-sonnet-4-6", + hooks=None, + ): self.root = root root.mkdir() resume_args = [] @@ -38,7 +49,11 @@ def __init__(self, binary, root, env, api="http://127.0.0.1:1", route_command=() shutil.copyfile( Path(__file__).parents[2] / "skills/smart-router/SKILL.md", skill / "SKILL.md" ) - options = {**_claude_mod_launch_options(env), "routeCommand": list(route_command)} + options = { + **_claude_mod_launch_options(env), + **(options or {}), + "routeCommand": list(route_command), + } settings = { "env": { **resolve_environment(env, agent=AGENT_CLAUDE), @@ -46,6 +61,8 @@ def __init__(self, binary, root, env, api="http://127.0.0.1:1", route_command=() }, "pluginConfigs": {CLAUDE_ROUTING_PLUGIN_NAME: {"options": options}}, } + if hooks is not None: + settings["hooks"] = hooks process_env = { **{ key: os.environ[key] @@ -77,9 +94,12 @@ def __init__(self, binary, root, env, api="http://127.0.0.1:1", route_command=() "--settings", json.dumps(settings), "--model", - "claude-sonnet-4-6", + model, "--tools", "Agent", + # The fixture allows Agent explicitly; auto mode adds classifier requests. + "--permission-mode", + "default", "--allowedTools", "Agent", "--plugin-dir", diff --git a/tests/native_claude/test_mod.py b/tests/native_claude/test_mod.py index 9173139a1..6dd3c4cfd 100644 --- a/tests/native_claude/test_mod.py +++ b/tests/native_claude/test_mod.py @@ -4,25 +4,61 @@ import json import os +import shlex import shutil import subprocess import sys import threading +import time from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from uuid import uuid4 +import pytest +from messages_api import messages_api from session import Session from ucode.agents.claude import _header_mod_files -from ucode.smart_routing import config, orchestrator, session_env +from ucode.smart_routing import config, orchestrator, savings, session_env from ucode.smart_routing.v2 import ( + CLAUDE_SAVINGS_OPTION_DEFAULTS, _claude_mod_launch_options, _routed_claude_agent_name, _write_routed_claude_plugin, ) +def _savings_options(root: Path, *, first_prompt: bool = False) -> dict: + return { + # A space and a non-ASCII character check the argv survives the options round trip. + "savings_pricer": savings.pricer_argv( + python=sys.executable, + price_cache=root / "no prices λ.json", + baseline_session_start=first_prompt, + ), + "savings_usage": str(root / savings.USAGE_FILENAME), + "orchestrator_version": "1.2.0", + } + + +def _recorded_usage(path: Path, entry_count: int, *, output_tokens: int = 0) -> dict: + deadline = time.monotonic() + 10 + recorded = None + while time.monotonic() < deadline: + try: + recorded = json.loads(path.read_text(encoding="utf-8")) + if ( + len(recorded["entries"]) == entry_count + and sum(entry["usage"]["output_tokens"] for entry in recorded["entries"]) + == output_tokens + ): + return recorded + except (OSError, ValueError): + pass + time.sleep(0.05) + pytest.fail(f"savings did not record {entry_count} entries: {recorded}") + + def test_mod_validation_and_event_forwarding(native_binary, tmp_path): path = tmp_path / "plugin" _write_routed_claude_plugin(path, []) @@ -44,7 +80,10 @@ def test_mod_validation_and_event_forwarding(native_binary, tmp_path): ) assert result.returncode == 0, result.stdout + result.stderr if command == "validate": - assert "./register.ts hooks: session.start" in result.stdout + hooks = next( + line for line in result.stdout.splitlines() if "./register.ts hooks:" in line + ) + assert "session.start" in hooks def test_header_mod_validation_and_merge(native_binary, tmp_path): @@ -67,18 +106,356 @@ def test_header_mod_validation_and_merge(native_binary, tmp_path): def test_native_options_are_launch_local(native_binary, tmp_path): env = { - "SMART_ROUTER_CONFIG_VERSION": config.SUBAGENT_ORCH_V0_CLAUDE_ONLY, + "SMART_ROUTER_CONFIG_VERSION": config.SUBAGENT_ORCH_SAVINGS_V0, "SMART_ROUTER_NAME": 'custom "quoted" λ', } + savings_options = _savings_options(tmp_path / "a") with ( - Session(native_binary, tmp_path / "a", env) as a, + Session(native_binary, tmp_path / "a", env, options=savings_options) as a, Session(native_binary, tmp_path / "b", {}) as b, ): - assert a.observe()["options"] == _claude_mod_launch_options(env) - assert b.observe()["options"] == _claude_mod_launch_options({}) + assert a.observe()["options"] == {**_claude_mod_launch_options(env), **savings_options} + # Claude fills in the declared defaults for options a launch omits. + assert b.observe()["options"] == { + **_claude_mod_launch_options({}), + **CLAUDE_SAVINGS_OPTION_DEFAULTS, + } assert not (a.plugin / "hooks/launch.json").exists() +def test_savings_mod_records_the_start_model(native_binary, tmp_path): + root = tmp_path / "session" + options = _savings_options(root) + usage = Path(options["savings_usage"]) + with Session( + native_binary, root, {"ENABLE_SMART_ROUTING_SAVINGS": "1"}, options=options + ) as session: + session.observe() + # The mod writes its sums off the session.start critical path. + deadline = time.monotonic() + 10 + while True: + try: + recorded = json.loads(usage.read_text(encoding="utf-8")) + break + except (OSError, ValueError): + assert time.monotonic() < deadline, "the savings mod never wrote its usage file" + time.sleep(0.1) + + assert recorded == { + "version": 1, + "start_model": "claude-sonnet-4-6", + "main_model": None, + "first_main_model": None, + "first_prompt_seen": False, + "user_switched": False, + "entries": [], + } + + +@pytest.mark.parametrize( + ("alias", "family", "model"), + [ + ("sonnet", "SONNET", "system.ai.claude-sonnet-4-6"), + ("opus[1m]", "OPUS", "system.ai.claude-opus-4-8"), + ], +) +def test_savings_mod_resolves_the_starting_alias(native_binary, tmp_path, alias, family, model): + root = tmp_path / "session" + options = _savings_options(root, first_prompt=True) + with Session( + native_binary, + root, + { + "ENABLE_SMART_ROUTING_SAVINGS": "1", + f"ANTHROPIC_DEFAULT_{family}_MODEL": model, + }, + model=alias, + options=options, + ) as session: + session.observe() + recorded = _recorded_usage(Path(options["savings_usage"]), 0) + + # Claude 2.1.290 retains the context selector; newer builds omit it. + expected_models = (model, model + "[1m]") if alias.endswith("[1m]") else (model,) + assert recorded["start_model"] in expected_models + + +@pytest.mark.parametrize("routed", [False, True]) +def test_savings_mod_tracks_native_main_and_subagent_usage(native_binary, tmp_path, routed): + """Real Claude executes Agent and parses controlled API usage for every turn step.""" + root = tmp_path / "session" + options = _savings_options(root) + main = "claude-sonnet-4-6" + child = "claude-haiku-4-5" + route = json.dumps({"model": child, "rationale": "Synthetic route"}) + counts = [ + { + "input_tokens": 11, + "output_tokens": 13, + "cache_creation_input_tokens": 17, + "cache_read_input_tokens": 19, + }, + { + "input_tokens": 23, + "output_tokens": 29, + "cache_creation_input_tokens": 31, + "cache_read_input_tokens": 37, + }, + { + "input_tokens": 41, + "output_tokens": 43, + "cache_creation_input_tokens": 47, + "cache_read_input_tokens": 53, + }, + ] + replies = [ + { + "content": [ + { + "type": "tool_use", + "id": "toolu_fixture_child", + "name": "Agent", + "input": { + "description": "Read the child assignment", + "prompt": "Reply with child done.", + "subagent_type": "general-purpose", + "model": "sonnet" if routed else "haiku", + "run_in_background": False, + }, + } + ], + "usage": counts[0], + }, + { + "content": [{"type": "text", "text": "child done"}], + "usage": counts[1], + # The API's deployment spelling must not replace the requested billing model. + "model": "anthropic.claude-haiku-4-5-20251001-v1:0", + }, + {"content": [{"type": "text", "text": "parent done"}], "usage": counts[2]}, + ] + with ( + messages_api(replies) as (api, requests), + Session( + native_binary, + root, + { + "ENABLE_SMART_ROUTING_SAVINGS": "1", + "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "1" if routed else "0", + "ANTHROPIC_DEFAULT_HAIKU_MODEL": child, + }, + api=api, + options=options, + route_command=(sys.executable, "-c", f"print({route!r})") if routed else (), + ) as session, + ): + result = session.send("Delegate the child assignment, then say parent done.") + assert result["result"] == "parent done" + assert [request["model"] for request in requests] == [main, child, main] + assert "child done" in json.dumps(requests[2]["messages"]) + recorded = _recorded_usage(Path(options["savings_usage"]), 2, output_tokens=85) + + entries = recorded["entries"] + parent_entry = next(entry for entry in entries if entry["agent"] == "main") + child_entry = next(entry for entry in entries if entry["agent"] != "main") + assert parent_entry == { + "agent": "main", + "baseline": main, + "served": main, + "before_user_switch": True, + "usage": { + "input_tokens": 52, + "output_tokens": 56, + "cache_creation_input_tokens": 64, + "cache_read_input_tokens": 72, + }, + } + assert child_entry == { + "agent": child_entry["agent"], + "baseline": main, + "served": child, + "before_user_switch": True, + "usage": counts[1], + } + assert recorded["start_model"] == recorded["main_model"] == main + assert recorded["user_switched"] is False + + +def test_savings_baseline_uses_manual_model_before_first_prompt(native_binary, tmp_path): + root = tmp_path / "session" + options = _savings_options(root, first_prompt=True) + selected = "claude-haiku-4-5" + replies = [ + { + "content": [{"type": "text", "text": "done"}], + "usage": {"input_tokens": 10, "output_tokens": 5}, + } + ] + with ( + messages_api(replies) as (api, requests), + Session( + native_binary, + root, + {"ENABLE_SMART_ROUTING_SAVINGS": "1", "ANTHROPIC_DEFAULT_HAIKU_MODEL": selected}, + api=api, + options=options, + ) as session, + ): + session.send("/model haiku") + assert session.send("Reply with done.")["result"] == "done" + recorded = _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=5) + + assert [request["model"] for request in requests] == [selected] + assert recorded["start_model"] == selected + assert recorded["entries"][0]["baseline"] == selected + assert recorded["entries"][0]["served"] == selected + + +def test_savings_baseline_survives_routed_replay_and_later_model_change(native_binary, tmp_path): + """Exercise the native block/model/replay sequence used by the PTY, then a user switch.""" + root = tmp_path / "session" + options = _savings_options(root, first_prompt=True) + blocked = tmp_path / "blocked" + hook = tmp_path / "block_first.py" + hook.write_text( + "import json, sys\n" + "from pathlib import Path\n" + "payload = json.load(sys.stdin)\n" + "marker = Path(sys.argv[1])\n" + "if not payload['prompt'].lstrip().startswith('/') and not marker.exists():\n" + " marker.write_text('blocked')\n" + " print(json.dumps({'decision': 'block', 'reason': 'First prompt captured'}))\n" + ) + selected, routed, later = "claude-haiku-4-5", "claude-opus-4-8", "claude-sonnet-4-6" + replies = [ + { + "content": [{"type": "text", "text": "done"}], + "usage": {"input_tokens": 10, "output_tokens": 5}, + }, + { + "content": [{"type": "text", "text": "second done"}], + "usage": {"input_tokens": 20, "output_tokens": 7}, + }, + ] + with ( + messages_api(replies) as (api, requests), + Session( + native_binary, + root, + { + "ENABLE_SMART_ROUTING_SAVINGS": "1", + "ANTHROPIC_DEFAULT_HAIKU_MODEL": selected, + "ANTHROPIC_DEFAULT_OPUS_MODEL": routed, + "ANTHROPIC_DEFAULT_SONNET_MODEL": later, + }, + api=api, + options=options, + hooks={ + "UserPromptSubmit": [ + { + "hooks": [ + { + "type": "command", + "command": shlex.join([sys.executable, str(hook), str(blocked)]), + } + ] + } + ] + }, + ) as session, + ): + session.send("/model haiku") + blocked_result = session.send("Reply with done.") + assert blocked_result["num_turns"] == 0 + assert "First prompt captured" in blocked_result["result"] + assert blocked.read_text() == "blocked" + assert requests == [] + # The PTY sends this native command after the hook has blocked the prompt. + session.send("/model opus") + assert session.send("Reply with done.")["result"] == "done" + first = _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=5) + session.send("/model sonnet") + assert session.send("Now reply with second done.")["result"] == "second done" + recorded = _recorded_usage(Path(options["savings_usage"]), 2, output_tokens=12) + + assert [request["model"] for request in requests] == [routed, later] + assert first["start_model"] == recorded["start_model"] == selected + assert recorded["first_main_model"] == routed + assert recorded["first_prompt_seen"] is True + assert recorded["user_switched"] is True + earlier = next(entry for entry in recorded["entries"] if entry["served"] == routed) + assert first["entries"] == [earlier] + assert earlier["before_user_switch"] is True + current = next(entry for entry in recorded["entries"] if entry["served"] == later) + assert current["before_user_switch"] is False + assert current["baseline"] == later + + +def test_savings_tracking_obeys_cli_session_controls(native_binary, tmp_path): + root = tmp_path / "session" + options = _savings_options(root) + env = { + "ENABLE_SMART_ROUTING_V2": "0", + "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "1", + "ENABLE_SMART_ROUTER_ORCHESTRATOR": "0", + "ENABLE_SMART_ROUTING_SAVINGS": "1", + "PYTHONPATH": str(Path(__file__).parents[2] / "src"), + } + controls = session_env.start_session(env) + replies = [ + {"content": [{"type": "text", "text": "done"}], "usage": usage} + for usage in ( + {"input_tokens": 10, "output_tokens": 5}, + {"input_tokens": 20, "output_tokens": 7}, + {"input_tokens": 30, "output_tokens": 11}, + ) + ] + try: + with ( + messages_api(replies) as (api, requests), + Session(native_binary, root, env, api=api, options=options) as session, + ): + assert session.send("Reply with done.")["result"] == "done" + _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=5) + for action in ("disable", "enable"): + result = subprocess.run( + [sys.executable, "-m", "ucode.cli", "claude", f"--{action}-smart-routing"], + env=env, + stdin=subprocess.DEVNULL, + capture_output=True, + text=True, + timeout=10, + ) + assert result.returncode == 0, result.stderr + saved_controls = json.loads(controls.read_text()) + if action == "disable": + assert saved_controls["ENABLE_SMART_ROUTING_SAVINGS"] == "0" + else: + assert saved_controls == {} + assert session.send("Reply with done again.")["result"] == "done" + recorded = _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=16) + assert len(requests) == 3 + assert recorded["entries"][0]["usage"] == { + "input_tokens": 40, + "output_tokens": 16, + "cache_creation_input_tokens": 0, + "cache_read_input_tokens": 0, + } + finally: + shutil.rmtree(controls.parent) + + +@pytest.mark.parametrize("flag", [None, "", "0"]) +def test_disabled_savings_does_not_create_usage_file(native_binary, tmp_path, flag): + root = tmp_path / "session" + options = _savings_options(root) + env = {} if flag is None else {"ENABLE_SMART_ROUTING_SAVINGS": flag} + # Stale savings options must not enable the feature without an explicit flag. + with Session(native_binary, root, env, options=options) as session: + session.observe() + assert not Path(options["savings_usage"]).exists() + + def test_orchestrator_instructions_follow_native_toggles(native_binary, tmp_path): """Native and CLI toggles update request guidance without changing the Agent schema. diff --git a/tests/test_claude_mod.py b/tests/test_claude_mod.py index 77ba25bf7..1b8c31723 100644 --- a/tests/test_claude_mod.py +++ b/tests/test_claude_mod.py @@ -123,6 +123,7 @@ def test_launch_options_resolve_versions_without_mutating_input(version): "ENABLE_SMART_ROUTING_V2": "0", "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "0", "ENABLE_SMART_ROUTER_ORCHESTRATOR": "0", + "ENABLE_SMART_ROUTING_SAVINGS": "0", "SMART_ROUTER_NAME": " custom_recipe ", } before = env.copy() @@ -149,10 +150,23 @@ def test_launch_options_preserve_empty_and_absent_values(): "ENABLE_SMART_ROUTING_V2": "", "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "", "ENABLE_SMART_ROUTER_ORCHESTRATOR": "", - "unset": ["ENABLE_SMART_ROUTING_SUBAGENT_ONLY", "ENABLE_SMART_ROUTER_ORCHESTRATOR"], + "ENABLE_SMART_ROUTING_SAVINGS": "", + "unset": [ + "ENABLE_SMART_ROUTING_SUBAGENT_ONLY", + "ENABLE_SMART_ROUTER_ORCHESTRATOR", + "ENABLE_SMART_ROUTING_SAVINGS", + ], "recipe": "stable", "routeCommand": [], "orchestratorInstructions": "", "isaacExecutable": str(Path(isaac).absolute()) if isaac else "", "isaacFeedbackDirectory": str(Path.home() / ".isaac" / "feedback"), } + + +def test_native_mod_covers_every_managed_flag(): + source = (Path(v2.__file__).parents[1] / "agents/claude_mods/register.ts").read_text() + for key in SMART_ROUTING_ENV_KEYS: + assert f"$.env.get('{key}')" in source + assert f"$.env.set('{key}', env.{key})" in source + assert f"{key}: enabled ? original('{key}') : '0'" in source diff --git a/tests/test_claude_smart_routing_v2.py b/tests/test_claude_smart_routing_v2.py index 6e5bacdcf..5611a4e4c 100644 --- a/tests/test_claude_smart_routing_v2.py +++ b/tests/test_claude_smart_routing_v2.py @@ -510,6 +510,7 @@ def send_signal(self, _signal): assert settings["pluginConfigs"][v2.CLAUDE_ROUTING_PLUGIN_NAME] == { "options": { **v2._claude_mod_launch_options({**os.environ, **settings["env"]}), + **v2.CLAUDE_SAVINGS_OPTION_DEFAULTS, "routeCommand": [ "/bin/ug", "claude-router-hook", @@ -595,6 +596,32 @@ def wait(self): assert claude_hooks.FIRST_PROMPT_SOCKET_ENV not in captured["settings"]["env"] +class TestSavingsModelServices: + def test_prices_routable_and_main_models_by_system_ai_name(self): + services = v2._savings_model_services( + [ + "system.ai.claude-opus-4-8[1m]", + "anthropic-aigw-73ea02b2-system.ai.glm-5-2", + "databricks-claude-sonnet-5", + "opus", + None, + ], + { + "env": { + "ANTHROPIC_DEFAULT_OPUS_MODEL": "system.ai.claude-opus-5-5", + "UNRELATED": "system.ai.not-a-main-model", + } + }, + ) + + assert services == [ + "system.ai.claude-opus-4-8", + "system.ai.claude-opus-5-5", + "system.ai.claude-sonnet-5", + "system.ai.glm-5-2", + ] + + class TestV2ModelPickerDiscovery: """modelPicker takes priority over gateway model discovery for smart routing.""" diff --git a/tests/test_smart_router.py b/tests/test_smart_router.py index e603f6d98..921506db0 100644 --- a/tests/test_smart_router.py +++ b/tests/test_smart_router.py @@ -13,6 +13,7 @@ from typer.testing import CliRunner from ucode import cli, config_io, skills +from ucode.constants import SMART_ROUTING_ENV_KEYS from ucode.skills import SMART_ROUTER_SKILL from ucode.smart_routing import session_env, v2 @@ -71,15 +72,7 @@ def test_skill_toggles_with_launch_installation_despite_shadowed_path(tmp_path, ) assert result.returncode == 0, result.stdout + result.stderr assert f"Smart Router is {'off' if action == 'disable' else 'on'}" in result.stdout - expected = ( - { - v2.ENABLE_SMART_ROUTING_ENV_VAR: "0", - v2.ENABLE_SUBAGENT_ROUTING_ENV_VAR: "0", - v2.ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", - } - if action == "disable" - else {} - ) + expected = dict.fromkeys(SMART_ROUTING_ENV_KEYS, "0") if action == "disable" else {} assert json.loads(session_path.read_text()) == expected diff --git a/tests/test_smart_routing_config.py b/tests/test_smart_routing_config.py index 1766a9d1d..49b3b1c4f 100644 --- a/tests/test_smart_routing_config.py +++ b/tests/test_smart_routing_config.py @@ -9,6 +9,7 @@ AGENT_CODEX, ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, ENABLE_SMART_ROUTING_ENV_VAR, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR, ENABLE_SUBAGENT_ROUTING_ENV_VAR, SMART_ROUTER_CONFIG_VERSION_ENV_VAR, ) @@ -19,26 +20,37 @@ ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "0", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, config.SUBAGENT_ONLY_V0: { ENABLE_SMART_ROUTING_ENV_VAR: "0", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, config.SUBAGENT_ONLY_V1: { ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "0", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, config.SUBAGENT_ORCH_V0: { ENABLE_SMART_ROUTING_ENV_VAR: "0", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", }, config.SUBAGENT_ORCH_V1: { ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", + }, + config.SUBAGENT_ORCH_SAVINGS_V0: { + ENABLE_SMART_ROUTING_ENV_VAR: "1", + ENABLE_SUBAGENT_ROUTING_ENV_VAR: "1", + ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "1", }, } @@ -51,6 +63,7 @@ def test_absent_or_unknown_selector_is_a_no_op(selector): ENABLE_SMART_ROUTING_ENV_VAR: "1", ENABLE_SUBAGENT_ROUTING_ENV_VAR: "0", ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR: "1", + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", "INHERITED_SETTING": "preserved", } expected = applied.copy() @@ -64,9 +77,17 @@ def test_absent_or_unknown_selector_is_a_no_op(selector): assert applied == original -@pytest.mark.parametrize("ENABLE_SMART_ROUTING_V2", [None, "0", "1"]) -@pytest.mark.parametrize("ENABLE_SMART_ROUTING_SUBAGENT_ONLY", [None, "0", "1"]) -@pytest.mark.parametrize("ENABLE_SMART_ROUTER_ORCHESTRATOR", [None, "0", "1"]) +@pytest.mark.parametrize( + "legacy_values", + [ + (None, None, None, None), + ("0", "0", "0", "0"), + ("1", "1", "1", "1"), + ("1", "0", "1", "0"), + ("0", "1", "0", "1"), + ], + ids=["unset", "disabled", "enabled", "mixed", "mixed-inverse"], +) @pytest.mark.parametrize( "SMART_ROUTER_CONFIG_VERSION", [ @@ -76,20 +97,21 @@ def test_absent_or_unknown_selector_is_a_no_op(selector): config.SUBAGENT_ONLY_V1, config.SUBAGENT_ORCH_V0, config.SUBAGENT_ORCH_V1, + config.SUBAGENT_ORCH_SAVINGS_V0, ], ) -def test_smart_routing_config_cartesian_grid( - ENABLE_SMART_ROUTING_V2, - ENABLE_SMART_ROUTING_SUBAGENT_ONLY, - ENABLE_SMART_ROUTER_ORCHESTRATOR, - SMART_ROUTER_CONFIG_VERSION, -): +def test_smart_routing_config_precedence(legacy_values, SMART_ROUTER_CONFIG_VERSION): source = { environment_key: value - for environment_key, value in ( - (ENABLE_SMART_ROUTING_ENV_VAR, ENABLE_SMART_ROUTING_V2), - (ENABLE_SUBAGENT_ROUTING_ENV_VAR, ENABLE_SMART_ROUTING_SUBAGENT_ONLY), - (ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, ENABLE_SMART_ROUTER_ORCHESTRATOR), + for environment_key, value in zip( + ( + ENABLE_SMART_ROUTING_ENV_VAR, + ENABLE_SUBAGENT_ROUTING_ENV_VAR, + ENABLE_SMART_ROUTER_ORCHESTRATOR_ENV_VAR, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR, + ), + legacy_values, + strict=True, ) if value is not None } @@ -261,6 +283,7 @@ def test_agent_config_selection_and_session_precedence(monkeypatch, agent, enabl "ENABLE_SMART_ROUTING_V2": "0", "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "0", "ENABLE_SMART_ROUTER_ORCHESTRATOR": "0", + "ENABLE_SMART_ROUTING_SAVINGS": "0", }, ) source = {"SMART_ROUTER_CONFIG_VERSION": "subagent_orch_v0"} @@ -268,6 +291,7 @@ def test_agent_config_selection_and_session_precedence(monkeypatch, agent, enabl "ENABLE_SMART_ROUTING_V2": "0", "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": enabled, "ENABLE_SMART_ROUTER_ORCHESTRATOR": enabled, + "ENABLE_SMART_ROUTING_SAVINGS": "0", } assert config.resolve_environment(source, agent=agent) == expected assert v2.smart_routing_enabled(source, default=True, agent=agent) == (enabled == "1") @@ -283,6 +307,32 @@ def test_agent_config_selection_and_session_precedence(monkeypatch, agent, enabl } +@pytest.mark.parametrize("agent", [AGENT_CLAUDE, AGENT_CODEX]) +def test_savings_preset_launch_and_session_off_restore_the_baseline(agent, tmp_path): + source = { + SMART_ROUTER_CONFIG_VERSION_ENV_VAR: config.SUBAGENT_ORCH_SAVINGS_V0, + ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "0", + } + original = source.copy() + previous = v2.override_smart_routing(False, source, agent=agent) + assert all(source[key] == "0" for key in config.SMART_ROUTING_ENV_KEYS) + v2.restore_smart_routing_env(previous, source) + assert source == original + + controls = tmp_path / "session.json" + controls.write_text('{"ENABLE_SMART_ROUTING_SAVINGS":"0"}') + source[session_env.SESSION_ENV_VAR] = str(controls) + effective = session_env.effective_environment(source, agent=agent) + assert effective[ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR] == "0" + assert effective[ENABLE_SUBAGENT_ROUTING_ENV_VAR] == "1" + + +def test_savings_alone_does_not_enable_routing(): + source = {ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR: "1"} + assert not v2.smart_routing_enabled(source, default=False, agent=AGENT_CLAUDE) + assert not v2.first_prompt_routing_enabled(source, agent=AGENT_CLAUDE) + + @pytest.mark.parametrize("shell_value", ["0", "1"]) @pytest.mark.parametrize( ("version", "harnesses"), @@ -292,6 +342,7 @@ def test_agent_config_selection_and_session_precedence(monkeypatch, agent, enabl (config.SUBAGENT_ONLY_V1, (AGENT_CLAUDE, AGENT_CODEX)), (config.SUBAGENT_ORCH_V0, (AGENT_CLAUDE, AGENT_CODEX)), (config.SUBAGENT_ORCH_V1, (AGENT_CLAUDE, AGENT_CODEX)), + (config.SUBAGENT_ORCH_SAVINGS_V0, (AGENT_CLAUDE, AGENT_CODEX)), (config.SUBAGENT_ORCH_V0_CLAUDE_ONLY, (AGENT_CLAUDE,)), ], ) diff --git a/tests/test_smart_routing_pricing.py b/tests/test_smart_routing_pricing.py new file mode 100644 index 000000000..02566e92e --- /dev/null +++ b/tests/test_smart_routing_pricing.py @@ -0,0 +1,322 @@ +"""Tests for per-token model pricing used by the smart-routing savings estimate.""" + +from __future__ import annotations + +import json +from decimal import Decimal + +import pytest + +from ucode.smart_routing import pricing +from ucode.smart_routing.pricing import ModelPrice, TokenUsage +from ucode.workspace_key import workspace_key + +# Catalog list prices (USD per million tokens) for the two Claude route arms. +OPUS = ModelPrice( + input=Decimal("5"), + output=Decimal("25"), + cache_read=Decimal("0.5"), + cache_write_5m=Decimal("6.25"), + cache_write_1h=Decimal("10"), +) +SONNET_4 = ModelPrice( + input=Decimal("3"), + output=Decimal("15"), + cache_read=Decimal("0.3"), + cache_write_5m=Decimal("3.75"), + long_context_threshold=200_000, + long_context=ModelPrice( + input=Decimal("6"), + output=Decimal("22.5"), + cache_read=Decimal("0.6"), + cache_write_5m=Decimal("7.5"), + ), +) + + +class TestModelKey: + @pytest.mark.parametrize( + "model", + [ + "claude-opus-4-8", + "system.ai.claude-opus-4-8", + "system.ai.claude-opus-4-8[1m]", + "databricks-claude-opus-4-8", + "anthropic-aigw-1a2b3c4d-claude-opus-4-8", + "SYSTEM.AI.Claude-Opus-4-8", + "anthropic.claude-opus-4-8", + "global.anthropic.claude-opus-4-8", + "us.anthropic.claude-opus-4-8-20260101-v1:0", + "claude-opus-4-8@default", + ], + ) + def test_collapses_gateway_spellings(self, model): + assert pricing.model_key(model) == "claude-opus-4-8" + + def test_matches_a_served_bedrock_id_to_the_requested_model(self): + # The gateway reports Haiku responses by their Bedrock id. + assert pricing.model_key("anthropic.claude-haiku-4-5-20251001-v1:0") == pricing.model_key( + "system.ai.claude-haiku-4-5" + ) + + def test_unwraps_non_claude_gateway_models(self): + assert pricing.model_key("anthropic-aigw-73ea02b2-system.ai.glm-5-2") == "glm-5-2" + + @pytest.mark.parametrize( + ("served", "requested"), + [ + ("glm-5.3-flash", "system.ai.glm-5-3-flash"), + ("glm-5-3-colo-on-sp-v1", "system.ai.glm-5-3"), + ("kimi-k3-colo-on-sp-v1", "system.ai.kimi-k3"), + ], + ) + def test_matches_a_served_deployment_id_to_the_requested_model(self, served, requested): + assert pricing.model_key(served) == pricing.model_key(requested) + + def test_keeps_distinct_models_distinct(self): + assert pricing.model_key("system.ai.claude-sonnet-5") != pricing.model_key( + "system.ai.claude-opus-4-8" + ) + + @pytest.mark.parametrize("model", ["deepseek-v3", "deepseek-v4", "custom-20261001"]) + def test_preserves_model_versions_outside_provider_ids(self, model): + assert pricing.model_key(f"system.ai.{model}") == model + + +class TestTokenUsage: + def test_splits_cache_writes_by_ttl(self): + tokens = TokenUsage.from_message_usage( + { + "input_tokens": 2, + "cache_creation_input_tokens": 6509, + "cache_read_input_tokens": 143654, + "output_tokens": 695, + "cache_creation": { + "ephemeral_1h_input_tokens": 6000, + "ephemeral_5m_input_tokens": 9, + }, + } + ) + + # The 500 writes the breakdown doesn't cover bill at the default 5-minute TTL. + assert tokens == TokenUsage( + input=2, cache_write_5m=509, cache_write_1h=6000, cache_read=143654, output=695 + ) + assert tokens.prompt_tokens == 2 + 6509 + 143654 + + def test_treats_missing_breakdown_as_five_minute_writes(self): + tokens = TokenUsage.from_message_usage({"cache_creation_input_tokens": 40}) + + assert tokens == TokenUsage(cache_write_5m=40) + + def test_can_bill_writes_the_breakdown_does_not_cover_as_one_hour_writes(self): + unsplit = {"cache_creation_input_tokens": 40} + partial = { + "cache_creation_input_tokens": 6509, + "cache_creation": {"ephemeral_1h_input_tokens": 6000, "ephemeral_5m_input_tokens": 9}, + } + + assert TokenUsage.from_message_usage(unsplit, uncovered_writes_1h=True) == TokenUsage( + cache_write_1h=40 + ) + # The breakdown's own 5-minute writes stay 5-minute; only the 500 uncovered move to 1-hour. + assert TokenUsage.from_message_usage(partial, uncovered_writes_1h=True) == TokenUsage( + cache_write_5m=9, cache_write_1h=6500 + ) + + @pytest.mark.parametrize("bad", [None, -5, True, "12", 1.5]) + def test_ignores_non_count_values(self, bad): + assert TokenUsage.from_message_usage({"input_tokens": bad, "output_tokens": 3}) == ( + TokenUsage(output=3) + ) + + +class TestTokenCost: + def test_prices_every_token_class_at_its_own_rate(self): + tokens = TokenUsage( + input=1_000, cache_write_5m=2_000, cache_write_1h=3_000, cache_read=100_000, output=500 + ) + + # 1k*5 + 2k*6.25 + 3k*10 + 100k*0.5 + 500*25 = 110,000 micro-dollars. + assert pricing.token_cost(OPUS, tokens) == Decimal("0.11") + + def test_uses_long_context_rates_above_the_threshold(self): + short = TokenUsage(input=100_000, output=1_000) + long = TokenUsage(input=150_000, cache_read=60_000, output=1_000) + + assert pricing.token_cost(SONNET_4, short) == Decimal("0.315") + assert pricing.token_cost(SONNET_4, long) == Decimal("0.9585") + + def test_returns_none_when_a_used_class_has_no_rate(self): + # SONNET_4 publishes no 1-hour write rate. + assert pricing.token_cost(SONNET_4, TokenUsage(cache_write_1h=10)) is None + + def test_missing_rate_for_an_unused_class_is_fine(self): + assert pricing.token_cost(SONNET_4, TokenUsage(input=100_000)) == Decimal("0.3") + + +class TestPriceCache: + def test_round_trips_distinct_model_versions(self, tmp_path): + path = tmp_path / "model-prices.json" + prices = { + "deepseek-v3": ModelPrice(input=Decimal("1"), output=Decimal("2")), + "deepseek-v4": ModelPrice(input=Decimal("3"), output=Decimal("4")), + } + pricing.write_price_cache(path, prices) + + cached = pricing.read_price_cache(path) + + assert cached is not None + assert cached[0] == prices + + def test_round_trips_prices_under_model_keys(self, tmp_path): + path = tmp_path / "cache" / "model-prices.json" + pricing.write_price_cache( + path, {"system.ai.claude-opus-4-8": OPUS, "claude-sonnet-4": SONNET_4}, now=100.0 + ) + + cached = pricing.read_price_cache(path) + + assert cached is not None + prices, fingerprint = cached + assert prices == {"claude-opus-4-8": OPUS, "claude-sonnet-4": SONNET_4} + assert fingerprint == "100.0" + assert [entry.name for entry in path.parent.iterdir()] == ["model-prices.json"] + + def test_fingerprint_changes_on_refresh(self, tmp_path): + path = tmp_path / "model-prices.json" + pricing.write_price_cache(path, {"claude-opus-4-8": OPUS}, now=100.0) + first = pricing.read_price_cache(path) + pricing.write_price_cache(path, {"claude-opus-4-8": OPUS}, now=200.0) + + assert first is not None and pricing.read_price_cache(path) is not None + assert first[1] != pricing.read_price_cache(path)[1] + + @pytest.mark.parametrize( + "content", + [ + "not json", + json.dumps({"version": 999, "models": {"claude-opus-4-8": {"input": "5"}}}), + json.dumps({"version": 1, "models": {}}), + json.dumps({"version": 1, "models": []}), + ], + ) + def test_unusable_cache_reads_as_absent(self, tmp_path, content): + path = tmp_path / "model-prices.json" + path.write_text(content) + + assert pricing.read_price_cache(path) is None + + def test_missing_cache_reads_as_absent(self, tmp_path): + assert pricing.read_price_cache(tmp_path / "missing.json") is None + + +class TestEndpointRates: + @staticmethod + def _rate(service: str, *, usd: dict | None = None, dbu: dict | None = None) -> dict: + """An ``EndpointRate`` entry: costs grouped by unit, each a token_type->cost (per 1M).""" + costs = [] + for unit, table in (("DBU", dbu), ("USD", usd)): + if table is not None: + costs.append( + { + "unit": unit, + "token_costs": [ + {"token_type": token_type, "cost": cost} + for token_type, cost in table.items() + ], + } + ) + return {"model_service": service, "costs": costs} + + def test_reads_dollar_rates_keyed_by_model_service(self): + rates = [ + self._rate( + "system.ai.claude-fable-5", + dbu={"TOKEN_TYPE_INPUT": 142.858}, # priced in USD; the DBU group is ignored + usd={"TOKEN_TYPE_INPUT": 10.00006, "TOKEN_TYPE_OUTPUT": 50.00002}, + ), + self._rate( + "system.ai.glm-5-3", + usd={"TOKEN_TYPE_INPUT": 1.4, "TOKEN_TYPE_OUTPUT": 4.3999998}, + ), + ] + + assert pricing.prices_from_endpoint_rates(rates) == { + "system.ai.claude-fable-5": ModelPrice( + input=Decimal("10.00006"), output=Decimal("50.00002") + ), + "system.ai.glm-5-3": ModelPrice(input=Decimal("1.4"), output=Decimal("4.3999998")), + } + + def test_reads_all_token_classes_including_cache(self): + rates = [ + self._rate( + "system.ai.claude-opus-4-8", + usd={ + "TOKEN_TYPE_INPUT": 5, + "TOKEN_TYPE_OUTPUT": 25, + "TOKEN_TYPE_CACHE_READ": 0.5, + "TOKEN_TYPE_CACHE_CREATION": 6.25, + "TOKEN_TYPE_CACHE_CREATION_1H": 10, + }, + ) + ] + + assert pricing.prices_from_endpoint_rates(rates) == { + "system.ai.claude-opus-4-8": ModelPrice( + input=Decimal("5"), + output=Decimal("25"), + cache_read=Decimal("0.5"), + cache_write_5m=Decimal("6.25"), + cache_write_1h=Decimal("10"), + ) + } + + def test_skips_models_without_a_dollar_group(self): + rates = [ + # No USD group: the org has no DBU-to-dollar conversion, so we can't price it. + self._rate("system.ai.glm-5-3", dbu={"TOKEN_TYPE_INPUT": 20}), + self._rate("system.ai.kimi-k3", usd={}), # dollar group present but empty + {"model_service": "system.ai.no-costs"}, # no costs field + { + "costs": [ + {"unit": "USD", "token_costs": [{"token_type": "TOKEN_TYPE_INPUT", "cost": 1}]} + ] + }, + "not-a-rate", + ] + + assert pricing.prices_from_endpoint_rates(rates) == {} + + def test_endpoint_prices_survive_the_cache(self, tmp_path): + path = tmp_path / "model-prices.json" + prices = pricing.prices_from_endpoint_rates( + [ + self._rate( + "system.ai.claude-haiku-4-5", + usd={"TOKEN_TYPE_INPUT": 1, "TOKEN_TYPE_OUTPUT": 5}, + ) + ] + ) + pricing.write_price_cache(path, prices) + + cached = pricing.read_price_cache(path) + + assert cached is not None + served = pricing.model_key("anthropic.claude-haiku-4-5-20251001-v1:0") + assert cached[0][served] == ModelPrice(input=Decimal("1"), output=Decimal("5")) + + +class TestPriceCachePath: + def test_is_stable_per_workspace_and_distinct_across_workspaces(self, tmp_path): + first = pricing.price_cache_path(tmp_path, "https://A.cloud.databricks.com/") + + assert first == pricing.price_cache_path(tmp_path, "https://a.cloud.databricks.com") + assert first != pricing.price_cache_path(tmp_path, "https://b.cloud.databricks.com") + shared_host = "https://shared.cloud.databricks.com" + assert pricing.price_cache_path(tmp_path, workspace_key(shared_host, "123")) != ( + pricing.price_cache_path(tmp_path, workspace_key(shared_host, "456")) + ) + assert first.parent == tmp_path + assert first.name.startswith("model-prices-") and first.suffix == ".json" diff --git a/tests/test_smart_routing_savings.py b/tests/test_smart_routing_savings.py new file mode 100644 index 000000000..f45d9215f --- /dev/null +++ b/tests/test_smart_routing_savings.py @@ -0,0 +1,327 @@ +"""Tests for pricing the Claude mod's token sums into the smart-routing savings estimate.""" + +from __future__ import annotations + +import json +import os +import subprocess +import sys +from decimal import Decimal +from pathlib import Path + +import pytest + +from ucode.smart_routing import pricing, savings +from ucode.smart_routing.pricing import ModelPrice + +OPUS_ID = "system.ai.claude-opus-4-8" +SONNET_ID = "system.ai.claude-sonnet-5" +PRICES = { + OPUS_ID: ModelPrice( + input=Decimal("5"), + output=Decimal("25"), + cache_read=Decimal("0.5"), + cache_write_5m=Decimal("6.25"), + cache_write_1h=Decimal("10"), + ), + SONNET_ID: ModelPrice( + input=Decimal("2"), + output=Decimal("10"), + cache_read=Decimal("0.2"), + cache_write_5m=Decimal("2.5"), + cache_write_1h=Decimal("4"), + ), +} +# Main-agent request: $0.07505 on Opus (10*5 + 100k*0.5 + 1k*25), $0.03002 on Sonnet. +MAIN_USAGE = {"input_tokens": 10, "cache_read_input_tokens": 100_000, "output_tokens": 1_000} +# Subagent request: $0.122 on Sonnet (1k*2 + 20k*4 + 4k*10), $0.305 at Opus rates. +SUBAGENT_USAGE = { + "input_tokens": 1_000, + "cache_creation_input_tokens": 20_000, + "cache_creation": {"ephemeral_1h_input_tokens": 20_000, "ephemeral_5m_input_tokens": 0}, + "output_tokens": 4_000, +} + + +@pytest.fixture +def price_cache(tmp_path) -> Path: + path = tmp_path / "model-prices.json" + pricing.write_price_cache(path, PRICES, now=1.0) + return path + + +def entry( + agent: str, baseline: str | None, served: str, usage: dict, *, before_user_switch: bool = False +) -> dict: + found = { + "agent": agent, + "served": served, + "before_user_switch": before_user_switch, + "usage": usage, + } + return found if baseline is None else {**found, "baseline": baseline} + + +def write_usage(tmp_path: Path, entries: list, *, start_model: str | None = OPUS_ID) -> Path: + path = tmp_path / savings.USAGE_FILENAME + path.write_text( + json.dumps({"version": 1, "start_model": start_model, "entries": entries}), + encoding="utf-8", + ) + return path + + +def saved(amount: str, percent: str) -> dict: + return {"saved": True, "amount": amount, "percent": percent} + + +def cost_more(amount: str, percent: str) -> dict: + return {"saved": False, "amount": amount, "percent": percent} + + +def priced(usage: Path, price_cache: Path, *, first_prompt: bool = False) -> dict | None: + line = savings.usage_output(usage, price_cache=price_cache, baseline_session_start=first_prompt) + assert "\n" not in line + return json.loads(line)["savings"] + + +class TestUsageSavings: + def test_prices_tokens_against_each_entrys_baseline(self, tmp_path, price_cache): + entries = [ + entry("main", OPUS_ID, OPUS_ID, MAIN_USAGE), + entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE), + ] + + # Baseline $0.38005 - actual $0.19705. + assert priced(write_usage(tmp_path, entries), price_cache) == saved("$0.18", "48%") + + def test_an_entrys_baseline_is_the_main_model_when_its_request_ran(self, tmp_path, price_cache): + entries = [ + entry("main", OPUS_ID, OPUS_ID, MAIN_USAGE), + entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE), + # After the user's `/model sonnet`, subagents on Sonnet saved nothing. + entry("main", SONNET_ID, SONNET_ID, MAIN_USAGE), + entry("a1", SONNET_ID, SONNET_ID, SUBAGENT_USAGE), + ] + + assert priced(write_usage(tmp_path, entries), price_cache) == saved("$0.18", "34%") + + def test_shows_a_net_cost_increase_honestly(self, tmp_path, price_cache): + entries = [ + entry("main", SONNET_ID, SONNET_ID, MAIN_USAGE), + entry("a1", SONNET_ID, OPUS_ID, SUBAGENT_USAGE), + ] + + # Baseline $0.15202 vs actual $0.33502. + assert priced(write_usage(tmp_path, entries), price_cache) == cost_more("$0.18", "120%") + + def test_nothing_to_claim_until_a_model_was_swapped(self, tmp_path, price_cache): + entries = [entry("main", OPUS_ID, OPUS_ID, MAIN_USAGE)] + + assert priced(write_usage(tmp_path, entries), price_cache) is None + + def test_bills_entries_without_the_cache_write_split_as_one_hour_writes( + self, tmp_path, price_cache + ): + usage = { + "input_tokens": 1_000, + "cache_creation_input_tokens": 20_000, + "output_tokens": 4_000, + } + + # ug launches Claude with 1-hour caching, so unsplit writes bill at the 1-hour rate, as + # SUBAGENT_USAGE does: $0.122 on Sonnet vs $0.305 at Opus rates. + assert priced( + write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, usage)]), price_cache + ) == saved("$0.18", "60%") + + def test_honors_an_explicit_cache_write_split(self, tmp_path, price_cache): + usage = { + "input_tokens": 1_000, + "cache_creation_input_tokens": 20_000, + "cache_creation": {"ephemeral_1h_input_tokens": 0, "ephemeral_5m_input_tokens": 20_000}, + "output_tokens": 4_000, + } + + # The split says 5-minute writes: $0.092 on Sonnet vs $0.23 at Opus rates. + assert priced( + write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, usage)]), price_cache + ) == saved("$0.14", "60%") + + def test_skips_entries_without_tokens(self, tmp_path, price_cache): + entries = [ + entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE), + entry("a2", "unpriced-baseline", "unpriced-served", {"input_tokens": 0}), + ] + + assert priced(write_usage(tmp_path, entries), price_cache) == saved("$0.18", "60%") + + def test_first_prompt_routing_prices_against_the_start_model(self, tmp_path, price_cache): + # Under first-prompt routing the router picks the main model too, so an entry's own + # baseline (the routed model) would hide the saving; until the user switches the main + # model its presence or absence is ignored. + entries = [ + entry("main", SONNET_ID, SONNET_ID, MAIN_USAGE, before_user_switch=True), + entry("a1", None, SONNET_ID, SUBAGENT_USAGE, before_user_switch=True), + ] + usage = write_usage(tmp_path, entries, start_model=OPUS_ID) + + # Baseline $0.38005 at Opus vs actual $0.15202 on Sonnet. + assert priced(usage, price_cache, first_prompt=True) == saved("$0.23", "60%") + assert priced(usage, price_cache) is None + + def test_first_prompt_routing_prices_entries_after_a_user_switch_as_their_own( + self, tmp_path, price_cache + ): + entries = [ + entry("main", SONNET_ID, SONNET_ID, MAIN_USAGE, before_user_switch=True), + entry("a1", SONNET_ID, SONNET_ID, SUBAGENT_USAGE, before_user_switch=True), + # The user's `/model opus`, then `/model sonnet`. + entry("main", OPUS_ID, OPUS_ID, MAIN_USAGE), + entry("main", SONNET_ID, SONNET_ID, MAIN_USAGE), + ] + usage = write_usage(tmp_path, entries, start_model=OPUS_ID) + + # Baseline $0.48512 - actual $0.25709. + assert priced(usage, price_cache, first_prompt=True) == saved("$0.23", "47%") + + @pytest.mark.parametrize("start_model", [None, ""]) + def test_first_prompt_routing_without_a_start_model_has_no_estimate( + self, tmp_path, price_cache, start_model + ): + entries = [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)] + usage = write_usage(tmp_path, entries, start_model=start_model) + + assert priced(usage, price_cache, first_prompt=True) is None + + @pytest.mark.parametrize( + ("baseline", "served"), + [ + # An unpriced served model, or an unpriced baseline, would undercount. + (OPUS_ID, "system.ai.claude-mystery-1"), + ("system.ai.claude-mystery-1", SONNET_ID), + # Baseline-less or model-less entries. + (None, SONNET_ID), + ("", SONNET_ID), + (OPUS_ID, ""), + ], + ) + def test_an_unpriced_or_baseline_less_entry_voids_the_estimate( + self, tmp_path, price_cache, baseline, served + ): + entries = [ + entry("a0", OPUS_ID, SONNET_ID, SUBAGENT_USAGE), + entry("a1", baseline, served, SUBAGENT_USAGE), + ] + + assert priced(write_usage(tmp_path, entries), price_cache) is None + + @pytest.mark.parametrize( + "bad", ["nope", 7, {"baseline": OPUS_ID, "served": SONNET_ID}, {"baseline": OPUS_ID}] + ) + def test_a_malformed_entry_voids_the_estimate(self, tmp_path, price_cache, bad): + entries = [entry("a0", OPUS_ID, SONNET_ID, SUBAGENT_USAGE), bad] + + assert priced(write_usage(tmp_path, entries), price_cache) is None + + def test_without_prices_there_is_no_estimate(self, tmp_path, price_cache): + price_cache.unlink() + entries = [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)] + + assert priced(write_usage(tmp_path, entries), price_cache) is None + + @pytest.mark.parametrize( + "text", + [None, "not json", "[]", json.dumps({"version": 2, "entries": []}), '{"version": 1}'], + ) + def test_an_unusable_file_has_no_estimate(self, tmp_path, price_cache, text): + usage = tmp_path / savings.USAGE_FILENAME + if text is not None: + usage.write_text(text, encoding="utf-8") + + assert priced(usage, price_cache) is None + + +class TestSavingsSegment: + def test_rounds_to_cents_and_whole_percent(self): + assert savings.savings_segment(Decimal("1234.565"), Decimal("2469.13")) == saved( + "$1,234.57", "50%" + ) + + def test_negative_reads_as_a_cost_increase(self): + assert savings.savings_segment(Decimal("-0.04"), Decimal("0.40")) == cost_more( + "$0.04", "10%" + ) + + def test_sub_cent_amounts_are_not_shown_as_zero(self): + assert savings.savings_segment(Decimal("0.004"), Decimal("1")) == saved("<$0.01", "0%") + + +class TestPricerCommand: + @staticmethod + def run( + price_cache: Path, + usage: Path, + *, + first_prompt: bool = False, + flag: str | None = "1", + controls: Path | None = None, + ): + argv = savings.pricer_argv( + python=sys.executable, price_cache=price_cache, baseline_session_start=first_prompt + ) + env = {**os.environ, "PYTHONIOENCODING": "ascii"} + env.pop("ENABLE_SMART_ROUTING_SAVINGS", None) + env.pop("UCODE_SESSION_ENV_FILE", None) + if controls is not None: + env["UCODE_SESSION_ENV_FILE"] = str(controls) + if flag is not None: + env["ENABLE_SMART_ROUTING_SAVINGS"] = flag + # The line must survive an ASCII stdout locale. + return subprocess.run( + [*argv, "--usage", str(usage)], + capture_output=True, + env=env, + timeout=30, + check=False, + ) + + def test_prints_exactly_one_json_line(self, tmp_path, price_cache): + usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + + result = self.run(price_cache, usage) + + assert result.returncode == 0, result.stderr + assert result.stdout.count(b"\n") == 1 + assert json.loads(result.stdout.decode("utf-8")) == {"savings": saved("$0.18", "60%")} + + def test_never_fails_the_mod(self, tmp_path, price_cache): + result = self.run(price_cache, tmp_path / "missing.json", first_prompt=True) + + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout) == {"savings": None} + + @pytest.mark.parametrize("flag", [None, "", "0", "true"]) + def test_disabled_pricer_returns_no_estimate(self, tmp_path, price_cache, flag): + usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + result = self.run(price_cache, usage, flag=flag) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout) == {"savings": None} + + def test_pricer_obeys_session_controls(self, tmp_path, price_cache): + usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + controls = tmp_path / "session-env.json" + for overrides, expected in ( + ({"ENABLE_SMART_ROUTING_SAVINGS": "0"}, None), + ({}, saved("$0.18", "60%")), + ): + controls.write_text(json.dumps(overrides)) + result = self.run(price_cache, usage, controls=controls) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout) == {"savings": expected} + + controls.write_text("invalid JSON") + fallback = self.run(price_cache, usage, controls=controls) + assert fallback.returncode == 0, fallback.stderr + assert json.loads(fallback.stdout) == {"savings": saved("$0.18", "60%")} + assert b"using the inherited environment" in fallback.stderr From 98d1a3af3fdca21a5612bf77c3537857a6c9b7b1 Mon Sep 17 00:00:00 2001 From: Josh Joseph Date: Tue, 10 Nov 2026 08:15:49 +0000 Subject: [PATCH 2/7] Reuse session controls in the savings mod --- src/ucode/agents/claude_mods/register.ts | 28 ++++++++++++++---------- src/ucode/smart_routing/v2.py | 4 +++- tests/native_claude/test_mod.py | 2 +- 3 files changed, 20 insertions(+), 14 deletions(-) diff --git a/src/ucode/agents/claude_mods/register.ts b/src/ucode/agents/claude_mods/register.ts index adce322d1..4636cd266 100644 --- a/src/ucode/agents/claude_mods/register.ts +++ b/src/ucode/agents/claude_mods/register.ts @@ -1,5 +1,5 @@ import type { EngineInterface, On, PluginOptions } from 'claude-code'; -import { endStatusBandTurn, registerStatusBand, showStatusBand, startStatusBandTurn } from './smart-routing-status.ts'; +import { endStatusBandTurn, registerStatusBand, showStatusBand } from './smart-routing-status.ts'; import { endSubagentRoutingTurn, registerSubagentRouting } from './subagent-routing.ts'; import { CLI_AGENT, @@ -10,6 +10,7 @@ import { RECIPE_FIELD, } from './constants.ts'; import { mergeExtraBody } from './extra-body.ts'; +import { startStatusBandTurn } from './smart-routing-status.ts'; import { createIsaacFeedbackState, registerIsaacFeedback } from './isaac-feedback.ts'; import { isRoutingEnabled } from './routing-state.ts'; @@ -35,10 +36,11 @@ async function readEnvironment($: EngineInterface): Promise { }; } -async function withSessionControls($: EngineInterface, current: Environment): Promise { - try { - const sessionFile = await $.env.get('UCODE_SESSION_ENV_FILE'); - if (sessionFile) { +async function readSessionEnvironment($: EngineInterface): Promise { + const current = await readEnvironment($); + const sessionFile = await $.env.get('UCODE_SESSION_ENV_FILE'); + if (sessionFile) { + try { const overrides = JSON.parse(await $.fs.read(sessionFile)); for (const key of [ 'ENABLE_SMART_ROUTING_V2', @@ -48,16 +50,16 @@ async function withSessionControls($: EngineInterface, current: Environment): Pr ]) { if (typeof overrides?.[key] === 'string') current[key] = overrides[key]; } + } catch { + // Match the routing hooks' inherited-environment fallback for unreadable controls. } - } catch { - // Match the routing hooks' inherited-environment fallback for unreadable controls. } return current; } async function readOrchestratorState($: EngineInterface, options: PluginOptions): Promise { if (!options.orchestratorInstructions) return false; - const current = await withSessionControls($, await readEnvironment($)); + const current = await readSessionEnvironment($); return isRoutingEnabled(current) && current.ENABLE_SMART_ROUTER_ORCHESTRATOR === '1'; } @@ -370,10 +372,12 @@ async function readSavingsFlag($: EngineInterface): Promise async function readSavingsState($: EngineInterface): Promise { if (!enabled) return false; - const current = await withSessionControls($, { - ENABLE_SMART_ROUTING_SAVINGS: await readSavingsFlag($), - }); - return current.ENABLE_SMART_ROUTING_SAVINGS === '1'; + try { + const current = await readSessionEnvironment($); + return current.ENABLE_SMART_ROUTING_SAVINGS === '1'; + } catch { + return false; + } } // State is seeded once per module instance, by whichever hook runs first; diff --git a/src/ucode/smart_routing/v2.py b/src/ucode/smart_routing/v2.py index 72014452f..48569c08e 100644 --- a/src/ucode/smart_routing/v2.py +++ b/src/ucode/smart_routing/v2.py @@ -17,6 +17,8 @@ from tempfile import TemporaryDirectory from typing import NoReturn, TextIO +import ucode.smart_routing.pricing as pricing +import ucode.smart_routing.savings as savings from ucode import claude_answer_delivery, config_io from ucode.codex_config import ( codex_config_args, @@ -61,7 +63,7 @@ install_skill, uninstall_agent_skill, ) -from ucode.smart_routing import claude_routing, orchestrator, pricing, routing, savings +from ucode.smart_routing import claude_routing, orchestrator, routing from ucode.smart_routing.claude_hooks import ( FIRST_PROMPT_SOCKET_ENV, ROUTE_SUBAGENT_MOD_EVENT, diff --git a/tests/native_claude/test_mod.py b/tests/native_claude/test_mod.py index 6dd3c4cfd..9d791973e 100644 --- a/tests/native_claude/test_mod.py +++ b/tests/native_claude/test_mod.py @@ -15,9 +15,9 @@ from uuid import uuid4 import pytest -from messages_api import messages_api from session import Session +from tests.native_claude.messages_api import messages_api from ucode.agents.claude import _header_mod_files from ucode.smart_routing import config, orchestrator, savings, session_env from ucode.smart_routing.v2 import ( From 0cb44017923d2827ce25b8346a2a47b4acd96755 Mon Sep 17 00:00:00 2001 From: Josh Joseph Date: Tue, 10 Nov 2026 18:22:49 +0000 Subject: [PATCH 3/7] Remove unused savings pricing paths and tests --- AGENTS.md | 2 +- src/ucode/smart_routing/pricing.py | 39 ++++++----------------------- src/ucode/smart_routing/savings.py | 5 ++-- tests/README.md | 3 +-- tests/test_claude_mod.py | 8 ------ tests/test_smart_routing_pricing.py | 32 +++-------------------- 6 files changed, 14 insertions(+), 75 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 5e9e690fb..e9468c1ae 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -76,7 +76,7 @@ atomically; the mod itself still writes no file. off overrides. Keep routing activation limited to the V2 and subagent-only flags: orchestration alone must not enable routing. Add regression tests for the new parameter's controls. Session overrides must apply after version resolution. - Update the native Claude mod's literal setters and registry coverage test in the same change. + Update the native Claude mod's literal setters and validate its capabilities in the same change. `_validate_versions` runs at module import and rejects missing keys, unknown keys, and invalid values. Do not weaken the complete-key check or infer required keys from `_VERSIONS`. diff --git a/src/ucode/smart_routing/pricing.py b/src/ucode/smart_routing/pricing.py index d18b7cc01..3e4b35390 100644 --- a/src/ucode/smart_routing/pricing.py +++ b/src/ucode/smart_routing/pricing.py @@ -72,14 +72,9 @@ class ModelPrice: cache_read: Decimal | None = None cache_write_5m: Decimal | None = None cache_write_1h: Decimal | None = None - # Rates for requests whose prompt exceeds the threshold (e.g. Sonnet 4.x above 200k tokens). - long_context_threshold: int | None = None - long_context: ModelPrice | None = None -_RATE_FIELDS = tuple( - field.name for field in fields(ModelPrice) if not field.name.startswith("long_context") -) +_RATE_FIELDS = tuple(field.name for field in fields(ModelPrice)) class TokenUsage(NamedTuple): @@ -120,11 +115,6 @@ def from_message_usage( output=_count(usage.get("output_tokens")), ) - @property - def prompt_tokens(self) -> int: - """Every input-side token, which is what long-context price thresholds measure.""" - return self.input + self.cache_write_5m + self.cache_write_1h + self.cache_read - def _count(value: object) -> int: return value if isinstance(value, int) and not isinstance(value, bool) and value > 0 else 0 @@ -136,12 +126,6 @@ def token_cost(price: ModelPrice, tokens: TokenUsage) -> Decimal | None: Returning None rather than pricing a missing rate at zero keeps callers from showing a figure that silently undercounts. """ - if ( - price.long_context is not None - and price.long_context_threshold is not None - and tokens.prompt_tokens > price.long_context_threshold - ): - price = price.long_context total = Decimal(0) for count, rate in ( (tokens.input, price.input), @@ -168,25 +152,16 @@ def _rate(raw: object) -> Decimal | None: return rate if rate.is_finite() and rate >= 0 else None -def _dump_price(price: ModelPrice) -> dict[str, Any]: - dumped: dict[str, Any] = { +def _dump_price(price: ModelPrice) -> dict[str, str]: + return { name: str(value) for name in _RATE_FIELDS if (value := getattr(price, name)) is not None } - if price.long_context is not None and price.long_context_threshold is not None: - dumped["long_context_threshold"] = price.long_context_threshold - dumped["long_context"] = _dump_price(price.long_context) - return dumped def _load_price(raw: object) -> ModelPrice | None: if not isinstance(raw, Mapping): return None - rates = {name: _rate(raw.get(name)) for name in _RATE_FIELDS} - threshold = raw.get("long_context_threshold") - long_context = _load_price(raw.get("long_context")) - if isinstance(threshold, bool) or not isinstance(threshold, int) or long_context is None: - threshold, long_context = None, None - return ModelPrice(**rates, long_context_threshold=threshold, long_context=long_context) + return ModelPrice(**{name: _rate(raw.get(name)) for name in _RATE_FIELDS}) # The endpoint-rates API groups each model's costs by unit; the estimate is in dollars. @@ -273,8 +248,8 @@ def write_price_cache( raise -def read_price_cache(path: Path) -> tuple[dict[str, ModelPrice], str] | None: - """Load prices keyed by ``model_key``, plus a fingerprint that changes on every refresh.""" +def read_price_cache(path: Path) -> dict[str, ModelPrice] | None: + """Load prices keyed by ``model_key``.""" try: payload = json.loads(path.read_text(encoding="utf-8")) except (OSError, ValueError): @@ -291,4 +266,4 @@ def read_price_cache(path: Path) -> tuple[dict[str, ModelPrice], str] | None: } if not prices: return None - return prices, str(payload.get("fetched_at")) + return prices diff --git a/src/ucode/smart_routing/savings.py b/src/ucode/smart_routing/savings.py index 63d93049f..6a6520c32 100644 --- a/src/ucode/smart_routing/savings.py +++ b/src/ucode/smart_routing/savings.py @@ -88,10 +88,9 @@ def usage_savings( if not isinstance(start, str) or not start: return None fixed_baseline = start - cached = read_price_cache(price_cache) - if cached is None: + prices = read_price_cache(price_cache) + if prices is None: return None - prices = cached[0] actual_total = baseline_total = Decimal(0) rerouted = False diff --git a/tests/README.md b/tests/README.md index d6b4eef87..fad6b6cc8 100644 --- a/tests/README.md +++ b/tests/README.md @@ -257,8 +257,7 @@ stay off. Preset coverage in `test_smart_routing_config.py` checks the savings flag, inherited-value precedence, restoration, and launch/session off controls. `test_smart_router.py` checks that the skill toggle writes all managed flags. -`test_claude_mod.py` checks native literal setters against the flag registry. In the -native suite, options reach the mod unchanged, configured aliases resolve to model IDs, +In the native suite, options reach the mod unchanged, configured aliases resolve to model IDs, and disabled sessions create no usage file even with stale savings options. A controlled local Messages API drives real main and subagent requests and checks exact input, output, and cache-token totals, including a routed child whose requested and execution models differ. diff --git a/tests/test_claude_mod.py b/tests/test_claude_mod.py index 1b8c31723..47c900658 100644 --- a/tests/test_claude_mod.py +++ b/tests/test_claude_mod.py @@ -162,11 +162,3 @@ def test_launch_options_preserve_empty_and_absent_values(): "isaacExecutable": str(Path(isaac).absolute()) if isaac else "", "isaacFeedbackDirectory": str(Path.home() / ".isaac" / "feedback"), } - - -def test_native_mod_covers_every_managed_flag(): - source = (Path(v2.__file__).parents[1] / "agents/claude_mods/register.ts").read_text() - for key in SMART_ROUTING_ENV_KEYS: - assert f"$.env.get('{key}')" in source - assert f"$.env.set('{key}', env.{key})" in source - assert f"{key}: enabled ? original('{key}') : '0'" in source diff --git a/tests/test_smart_routing_pricing.py b/tests/test_smart_routing_pricing.py index 02566e92e..2766d86de 100644 --- a/tests/test_smart_routing_pricing.py +++ b/tests/test_smart_routing_pricing.py @@ -24,13 +24,6 @@ output=Decimal("15"), cache_read=Decimal("0.3"), cache_write_5m=Decimal("3.75"), - long_context_threshold=200_000, - long_context=ModelPrice( - input=Decimal("6"), - output=Decimal("22.5"), - cache_read=Decimal("0.6"), - cache_write_5m=Decimal("7.5"), - ), ) @@ -102,7 +95,6 @@ def test_splits_cache_writes_by_ttl(self): assert tokens == TokenUsage( input=2, cache_write_5m=509, cache_write_1h=6000, cache_read=143654, output=695 ) - assert tokens.prompt_tokens == 2 + 6509 + 143654 def test_treats_missing_breakdown_as_five_minute_writes(self): tokens = TokenUsage.from_message_usage({"cache_creation_input_tokens": 40}) @@ -140,13 +132,6 @@ def test_prices_every_token_class_at_its_own_rate(self): # 1k*5 + 2k*6.25 + 3k*10 + 100k*0.5 + 500*25 = 110,000 micro-dollars. assert pricing.token_cost(OPUS, tokens) == Decimal("0.11") - def test_uses_long_context_rates_above_the_threshold(self): - short = TokenUsage(input=100_000, output=1_000) - long = TokenUsage(input=150_000, cache_read=60_000, output=1_000) - - assert pricing.token_cost(SONNET_4, short) == Decimal("0.315") - assert pricing.token_cost(SONNET_4, long) == Decimal("0.9585") - def test_returns_none_when_a_used_class_has_no_rate(self): # SONNET_4 publishes no 1-hour write rate. assert pricing.token_cost(SONNET_4, TokenUsage(cache_write_1h=10)) is None @@ -167,7 +152,7 @@ def test_round_trips_distinct_model_versions(self, tmp_path): cached = pricing.read_price_cache(path) assert cached is not None - assert cached[0] == prices + assert cached == prices def test_round_trips_prices_under_model_keys(self, tmp_path): path = tmp_path / "cache" / "model-prices.json" @@ -178,20 +163,9 @@ def test_round_trips_prices_under_model_keys(self, tmp_path): cached = pricing.read_price_cache(path) assert cached is not None - prices, fingerprint = cached - assert prices == {"claude-opus-4-8": OPUS, "claude-sonnet-4": SONNET_4} - assert fingerprint == "100.0" + assert cached == {"claude-opus-4-8": OPUS, "claude-sonnet-4": SONNET_4} assert [entry.name for entry in path.parent.iterdir()] == ["model-prices.json"] - def test_fingerprint_changes_on_refresh(self, tmp_path): - path = tmp_path / "model-prices.json" - pricing.write_price_cache(path, {"claude-opus-4-8": OPUS}, now=100.0) - first = pricing.read_price_cache(path) - pricing.write_price_cache(path, {"claude-opus-4-8": OPUS}, now=200.0) - - assert first is not None and pricing.read_price_cache(path) is not None - assert first[1] != pricing.read_price_cache(path)[1] - @pytest.mark.parametrize( "content", [ @@ -305,7 +279,7 @@ def test_endpoint_prices_survive_the_cache(self, tmp_path): assert cached is not None served = pricing.model_key("anthropic.claude-haiku-4-5-20251001-v1:0") - assert cached[0][served] == ModelPrice(input=Decimal("1"), output=Decimal("5")) + assert cached[served] == ModelPrice(input=Decimal("1"), output=Decimal("5")) class TestPriceCachePath: From 6d0110186f56c9d40466ed8a3186d17d5e51ee6b Mon Sep 17 00:00:00 2001 From: Josh Joseph Date: Wed, 11 Nov 2026 01:59:02 +0000 Subject: [PATCH 4/7] Fix savings history, persistence, and price cache updates --- docs/claude-mod.md | 13 ++-- src/ucode/agents/claude_mods/register.ts | 66 +++++++++--------- src/ucode/smart_routing/pricing.py | 46 +++++++++---- src/ucode/smart_routing/savings.py | 36 ++++++++-- tests/README.md | 7 +- tests/integration/README.md | 12 ++-- tests/native_claude/mod_tests/savings.test.ts | 30 ++++++-- tests/native_claude/test_mod.py | 69 ++++++++++++++----- tests/test_smart_routing_pricing.py | 24 ++++--- tests/test_smart_routing_savings.py | 40 +++++++++-- 10 files changed, 239 insertions(+), 104 deletions(-) diff --git a/docs/claude-mod.md b/docs/claude-mod.md index b3d3daeb3..d7a1fceff 100644 --- a/docs/claude-mod.md +++ b/docs/claude-mod.md @@ -242,15 +242,18 @@ in effect when it ran. Under first-prompt routing, requests before the user changes the main model are priced against the model selected when the first prompt was submitted, before the router's `/model` command. A manual selection before that prompt becomes the baseline. Later -model changes affect only subsequent usage. Claude's native `$.session.model()` returns +model changes affect only subsequent usage, including changes made during a turn with +savings disabled. Request-specific model overrides leave the selected main model unchanged. +Claude's native `$.session.model()` returns the resolved model ID, including for configured family aliases such as `sonnet`. -After each turn the mod writes those sums to `savings_usage`, a file in the launch's -temporary directory. It then runs the `savings_pricer` argv -(`python -P -m ucode.smart_routing.savings`), which prices the sums from the +After each turn the mod passes a snapshot of those sums on stdin to `savings_pricer` +(`python -P -m ucode.smart_routing.savings --write-usage`). The pricer atomically replaces +`savings_usage` in the launch's temporary directory, then prices the sums from the workspace's cached endpoint rates and prints the estimate's parts (direction, amount, percent) as one JSON line. Each savings-enabled routed launch -refreshes that cache on a background thread. The cache key includes the workspace ID +refreshes that cache on a background thread. Concurrent refreshes merge their model sets +under a file lock. The cache key includes the workspace ID on shared hosts, since dollar rates can differ between organizations. An estimate is hidden, not undercounted, when any served or baseline model has no rate. The orchestrator version is passed as `orchestrator_version`. diff --git a/src/ucode/agents/claude_mods/register.ts b/src/ucode/agents/claude_mods/register.ts index 4636cd266..eb2c1eff5 100644 --- a/src/ucode/agents/claude_mods/register.ts +++ b/src/ucode/agents/claude_mods/register.ts @@ -1,5 +1,5 @@ import type { EngineInterface, On, PluginOptions } from 'claude-code'; -import { endStatusBandTurn, registerStatusBand, showStatusBand } from './smart-routing-status.ts'; +import { endStatusBandTurn, registerStatusBand, showStatusBand, startStatusBandTurn } from './smart-routing-status.ts'; import { endSubagentRoutingTurn, registerSubagentRouting } from './subagent-routing.ts'; import { CLI_AGENT, @@ -10,7 +10,6 @@ import { RECIPE_FIELD, } from './constants.ts'; import { mergeExtraBody } from './extra-body.ts'; -import { startStatusBandTurn } from './smart-routing-status.ts'; import { createIsaacFeedbackState, registerIsaacFeedback } from './isaac-feedback.ts'; import { isRoutingEnabled } from './routing-state.ts'; @@ -154,19 +153,27 @@ export function register(on: On, options: PluginOptions): void { // Claude permits one unmatched turn.step handler, so orchestration and savings share it. on('turn.step', async function* ($, e, forward) { + let current: Environment = {}; + if (options.orchestratorInstructions || enabled) { + try { current = await readSessionEnvironment($); } catch {} + } async function* next(request: typeof e) { const agent = str(request.agentId); let trackSavings = false; let baseline: string | null = null; try { - trackSavings = await ready($); - if (trackSavings) { - if (agent === null) { - lastMainModel = str(request.model) ?? lastMainModel; + trackSavings = await ready($, current); + // Keep selection history while accounting is off. A request may override its + // model without changing the user's selection for later main/child work. + if (enabled) { + const selected = await mainModel($); + if (agent === null && selected) { + lastMainModel = selected; firstMainModel ??= lastMainModel; firstPromptSeen = true; userSwitched ||= lastMainModel !== firstMainModel; - } else baseline = lastMainModel ?? (await mainModel($)); + dirty = true; + } else baseline = selected ?? lastMainModel; } } catch { trackSavings = false; @@ -184,7 +191,8 @@ export function register(on: On, options: PluginOptions): void { } catch {} return result; } - const active = await readOrchestratorState($, options); + const active = Boolean(options.orchestratorInstructions) && isRoutingEnabled(current) + && current.ENABLE_SMART_ROUTER_ORCHESTRATOR === '1'; if (active !== orchestratorActive) { orchestratorActive = active; // A CLI/skill toggle changes the session file without notifying this process. @@ -282,11 +290,11 @@ const entries = new Map(); // when the user submits the first prompt so a preceding /model choice is honored. let startModel: string | null = null; let firstPromptSeen = false; -// The model the main loop last named, used as the subagent request's baseline. +// The selected main model, used as the subagent request's baseline. let lastMainModel: string | null = null; -// The model the main loop's first request named (first-prompt routing's pick). +// The selected model at the first main request (first-prompt routing's pick). let firstMainModel: string | null = null; -// Whether a main request has since named another model, which only the user does. +// Whether the selected main model has changed since the first request. let userSwitched = false; let seeding: Promise | undefined; let estimate: Estimate | null = null; @@ -370,10 +378,10 @@ async function readSavingsFlag($: EngineInterface): Promise } } -async function readSavingsState($: EngineInterface): Promise { +async function readSavingsState($: EngineInterface, snapshot?: Environment): Promise { if (!enabled) return false; try { - const current = await readSessionEnvironment($); + const current = snapshot ?? await readSessionEnvironment($); return current.ENABLE_SMART_ROUTING_SAVINGS === '1'; } catch { return false; @@ -382,12 +390,12 @@ async function readSavingsState($: EngineInterface): Promise { // State is seeded once per module instance, by whichever hook runs first; // concurrent hooks wait on the same load. -async function ready($: any): Promise { +async function ready($: any, snapshot?: Environment): Promise { try { - if (!await readSavingsState($)) return false; + if (!enabled) return false; seeding ??= loadUsage($); await seeding; - return true; + return await readSavingsState($, snapshot); } catch { return false; } @@ -412,26 +420,12 @@ function estimateOf(value: any): Estimate | null { return amount && percent ? { saved: value.saved, amount, percent } : null; } -// The pricer's last stdout line; a failed run drops the estimate, which would be stale. -async function runPricer($: any): Promise { - try { - const run = await $.process.run([...pricer, '--usage', usagePath], { - timeoutMs: PRICER_TIMEOUT_MS, - }); - if (run?.exitCode === 0) { - const out = JSON.parse(String(run.stdout ?? '').trim().split('\n').pop() ?? ''); - if (out && typeof out === 'object') return estimateOf(out.savings); - } - } catch {} - return null; -} - async function writeAndPrice($: any): Promise { dirty = false; try { - await $.fs.write( - usagePath, - JSON.stringify({ + const run = await $.process.run([...pricer, '--usage', usagePath, '--write-usage'], { + timeoutMs: PRICER_TIMEOUT_MS, + stdin: JSON.stringify({ version: USAGE_VERSION, start_model: startModel, main_model: lastMainModel, @@ -440,14 +434,16 @@ async function writeAndPrice($: any): Promise { user_switched: userSwitched, entries: Array.from(entries.values()), }), - ); + }); + if (run?.exitCode !== 0) throw new Error('Could not persist savings usage.'); + const out = JSON.parse(String(run.stdout ?? '').trim().split('\n').pop() ?? ''); + setEstimate($, estimateOf(out?.savings)); } catch (error) { // Retry at the next turn.complete rather than pricing a file that is not there. dirty = true; setEstimate($, null); throw error; } - setEstimate($, await runPricer($)); } function setEstimate($: EngineInterface, next: Estimate | null): void { diff --git a/src/ucode/smart_routing/pricing.py b/src/ucode/smart_routing/pricing.py index 3e4b35390..e1c75de81 100644 --- a/src/ucode/smart_routing/pricing.py +++ b/src/ucode/smart_routing/pricing.py @@ -26,6 +26,11 @@ from pathlib import Path from typing import Any, NamedTuple +from ucode.os_compatibility.file_lock_cross_os import ( + acquire_exclusive_file_lock, + release_file_lock, +) + _PRICE_CACHE_VERSION = 1 _MILLION = Decimal(1_000_000) _CONTEXT_SUFFIX_RE = re.compile(r"\[[^\]]*\]$") @@ -228,24 +233,33 @@ def price_cache_path(app_dir: Path, workspace: str) -> Path: def write_price_cache( path: Path, prices: Mapping[str, ModelPrice], *, now: float | None = None ) -> None: - """Atomically replace the price cache so a concurrent pricer never reads a partial file. + """Merge refreshed rates without losing models fetched by another launch. ``prices`` is keyed by any spelling of the model id; entries are stored under ``model_key``. """ - payload = { - "version": _PRICE_CACHE_VERSION, - "fetched_at": now if now is not None else time.time(), - "models": {model_key(model): _dump_price(price) for model, price in prices.items()}, - } path.parent.mkdir(parents=True, exist_ok=True) - fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp") - try: - with os.fdopen(fd, "w", encoding="utf-8") as handle: - json.dump(payload, handle, separators=(",", ":")) - os.replace(temporary, path) - except BaseException: - Path(temporary).unlink(missing_ok=True) - raise + with path.with_name(f"{path.name}.lock").open("a") as lock: + acquire_exclusive_file_lock(lock, timeout=5) + try: + merged = read_price_cache(path) or {} + merged.update({model_key(model): price for model, price in prices.items()}) + payload = { + "version": _PRICE_CACHE_VERSION, + "fetched_at": now if now is not None else time.time(), + "models": {model: _dump_price(price) for model, price in merged.items()}, + } + fd, temporary = tempfile.mkstemp( + dir=path.parent, prefix=f".{path.name}.", suffix=".tmp" + ) + try: + with os.fdopen(fd, "w", encoding="utf-8") as handle: + json.dump(payload, handle, separators=(",", ":")) + os.replace(temporary, path) + except BaseException: + Path(temporary).unlink(missing_ok=True) + raise + finally: + release_file_lock(lock) def read_price_cache(path: Path) -> dict[str, ModelPrice] | None: @@ -262,7 +276,9 @@ def read_price_cache(path: Path) -> dict[str, ModelPrice] | None: prices = { key: price for key, raw in models.items() - if isinstance(key, str) and (price := _load_price(raw)) is not None + if isinstance(key, str) + and (price := _load_price(raw)) is not None + and (price.input is not None or price.output is not None) } if not prices: return None diff --git a/src/ucode/smart_routing/savings.py b/src/ucode/smart_routing/savings.py index 6a6520c32..871053f28 100644 --- a/src/ucode/smart_routing/savings.py +++ b/src/ucode/smart_routing/savings.py @@ -6,7 +6,8 @@ saved = sum(tokens * price(baseline)) - sum(tokens * price(model that served them)) per token class. The mod (``agents/claude_mods/register.ts``) sums each turn request's usage by -(agent, baseline, served) and runs this module on that file after every turn; it prints one JSON +(agent, baseline, served) and sends this module a snapshot after every turn; it persists the +snapshot atomically and prints one JSON line with the segment the mod draws. A main-agent request is its own baseline, and a subagent's is the main model in effect when it ran, so switching models with ``/model`` never reprices earlier work. Under first-prompt routing, where the router also picks the main model, requests from before @@ -22,6 +23,7 @@ import argparse import json +import sys from decimal import ROUND_HALF_UP, Decimal from pathlib import Path @@ -36,7 +38,7 @@ from ucode.smart_routing.session_env import effective_environment MODULE = "ucode.smart_routing.savings" -# The file the mod writes its token sums to, in the launch directory; the mod reads its path from +# The file holding the mod's token sums, in the launch directory; the mod reads its path from # the plugin options, so only the version is shared with it. USAGE_FILENAME = "savings-usage.json" _USAGE_VERSION = 1 @@ -126,7 +128,9 @@ def savings_segment(saved: Decimal, baseline: Decimal) -> dict[str, object]: percent = (abs(saved) / baseline * 100).quantize(Decimal(1), rounding=ROUND_HALF_UP) magnitude = abs(saved) amount = ( - "<$0.01" if magnitude < _CENT else f"${magnitude.quantize(_CENT, rounding=ROUND_HALF_UP):,}" + "<$0.01" + if 0 < magnitude < _CENT + else f"${magnitude.quantize(_CENT, rounding=ROUND_HALF_UP):,}" ) return {"saved": saved >= 0, "amount": amount, "percent": f"{percent}%"} @@ -150,17 +154,39 @@ def main(argv: list[str] | None = None) -> int: prog=MODULE, description="Price the Claude mod's token sums as a JSON line." ) parser.add_argument("--usage", type=Path, required=True) + parser.add_argument( + "--write-usage", action="store_true", help="Save the JSON snapshot on stdin." + ) parser.add_argument("--price-cache", type=Path, required=True) parser.add_argument("--baseline-session-start", action="store_true") args = parser.parse_args(argv) + enabled = ( + effective_environment(agent=AGENT_CLAUDE).get(ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR) == "1" + ) + if args.write_usage: + try: + if not enabled: + raise ValueError("savings accounting is disabled") + document = json.loads(sys.stdin.buffer.read()) + if ( + not isinstance(document, dict) + or document.get("version") != _USAGE_VERSION + or not isinstance(document.get("entries"), list) + ): + raise ValueError("unsupported savings usage snapshot") + from ucode.config_io import atomic_write_json + + atomic_write_json(args.usage, document) + except Exception: # noqa: BLE001 - keep the snapshot in the mod for a later write + print(json.dumps({"savings": None})) + return 1 line = ( usage_output( args.usage, price_cache=args.price_cache, baseline_session_start=args.baseline_session_start, ) - if effective_environment(agent=AGENT_CLAUDE).get(ENABLE_SMART_ROUTING_SAVINGS_ENV_VAR) - == "1" + if enabled else json.dumps({"savings": None}) ) print(line) diff --git a/tests/README.md b/tests/README.md index fad6b6cc8..96231d83b 100644 --- a/tests/README.md +++ b/tests/README.md @@ -249,7 +249,8 @@ picker while retaining the catalog's display label. Savings estimate coverage: `test_smart_routing_savings.py` prices the mod's token sums (per-entry and first-prompt baselines, unpriced or malformed entries, the pricer's single -JSON line). `test_smart_routing_pricing.py` covers endpoint rates, distinct model versions, +JSON line, snapshot persistence/rejection and zero-dollar display). `test_smart_routing_pricing.py` +covers endpoint rates, concurrent refreshes of distinct model sets, empty-price rejection, and distinct price-cache paths for workspaces sharing a host. Shared-host launch wiring is not covered by these component checks. The pricer subprocess checks explicit opt-in; unset, empty, zero, and invalid values @@ -265,7 +266,9 @@ These sessions explicitly allow Agent in the default permission mode, keeping auto-mode classifier requests out of the prepared model responses. Alias checks accept the context selector retained by Claude 2.1.290. Native model commands and a blocked-prompt replay check the pre-routing baseline and preserve earlier usage after -a later model change. CLI off/on controls exclude disabled turns from the totals; pricer +a later model change, including switching away and back while accounting is off. Native SDK +checks keep request-specific model overrides out of the selected main/child baseline. +CLI off/on controls exclude disabled turns from the totals; pricer subprocesses honor the saved controls and fall back to inherited settings when the file is malformed. Native UI component tests check that off/on hides/restores a mounted row and failed usage writes diff --git a/tests/integration/README.md b/tests/integration/README.md index a788c719d..b5a299ae4 100644 --- a/tests/integration/README.md +++ b/tests/integration/README.md @@ -1852,11 +1852,15 @@ Those component sessions explicitly allow Agent in the default permission mode; do not exercise the auto-mode safety classifier. Alias checks also accept the context selector retained by Claude 2.1.290. Native model commands and a blocked-prompt replay verify baseline capture before routing -and preserve prior usage after later model changes. CLI off/on excludes disabled turns -from native usage totals. Native UI component tests cover mounted-row updates after +and preserve prior usage after later model changes, including switching away and back +while accounting is off. Request-specific model overrides retain the selected main/child +baseline in native SDK tests. CLI off/on excludes disabled turns from native usage totals. +Native UI component tests cover mounted-row updates after CLI toggles and hiding stale estimates on failed usage writes. Pricer subprocesses read -the saved session controls. Pricing tests keep shared-host workspace cache paths and -model versions distinct; shared-host launch wiring is not covered. +the saved session controls and validate snapshot persistence/rejection. Pricing tests keep +shared-host workspace cache paths and concurrently refreshed model sets distinct, reject +empty prices and distinguish zero savings from sub-cent amounts. Shared-host launch wiring +is not covered. Live savings accumulation, display, and session off/on are not covered by the integration suite. diff --git a/tests/native_claude/mod_tests/savings.test.ts b/tests/native_claude/mod_tests/savings.test.ts index 4d1030bb9..35fbfd835 100644 --- a/tests/native_claude/mod_tests/savings.test.ts +++ b/tests/native_claude/mod_tests/savings.test.ts @@ -57,7 +57,10 @@ test('a denied savings read preserves orchestration, startup and model requests' }); async function savingsRow($: any, on: On) { - const state = { controls: {} as Record, failWrites: false, writes: 0, prices: 0 }; + const state = { + controls: {} as Record, failWrites: false, writes: 0, prices: 0, + usage: null as any, + }; const clock = mock.clock(on); const env: Record = { ...options, UCODE_SESSION_ENV_FILE: '/session/env.json' }; on('env.get', (_, e) => ({ value: env[e.name] })); @@ -76,11 +79,11 @@ async function savingsRow($: any, on: On) { before_user_switch: true, usage: { input_tokens: 100, output_tokens: 10 }, }], }) })); - on('fs.write', () => { + on('session.model', () => ({ value: 'claude-opus-4-8' })); + on('process.run', (_, e) => { state.writes += 1; - return state.failWrites ? { deny: 'ENOSPC' } : { value: undefined }; - }); - on('process.run', () => { + if (state.failWrites) return { value: { exitCode: 1, stderr: '', stdout: '{"savings":null}' } }; + state.usage = JSON.parse(e.init.stdin); state.prices += 1; return { value: { exitCode: 0, stderr: '', stdout: JSON.stringify({ savings: { saved: true, amount: '$0.18', percent: '60%' }, @@ -109,6 +112,23 @@ test('saved off/on controls hide and restore a mounted savings row', { options } expect(JSON.stringify(await row.drawn())).toContain('$0.18'); }); +test('a request model override keeps the selected main model and child baseline', { options }, async ($, on) => { + const { state, clock } = await savingsRow($, on); + await $.turn.step({ turnId: 'turn', index: 0, messageCount: 1, model: 'claude-haiku-4-5' }).next(); + await $.turn.step({ + turnId: 'child-turn', index: 0, messageCount: 1, model: 'claude-sonnet-4-6', agentId: 'child-2', + }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.main_model).toBe('claude-opus-4-8'); + expect(state.usage.user_switched).toBe(false); + expect(state.usage.entries.find((entry: any) => entry.agent === 'child-2')).toEqual({ + agent: 'child-2', baseline: 'claude-opus-4-8', served: 'claude-sonnet-4-6', + before_user_switch: true, + usage: { input_tokens: 1, output_tokens: 1, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }, + }); +}); + test('a failed usage write removes the stale estimate until a later write succeeds', { options }, async ($, on) => { const { state, clock, row } = await savingsRow($, on); const priced = state.prices; diff --git a/tests/native_claude/test_mod.py b/tests/native_claude/test_mod.py index 9d791973e..496870ed9 100644 --- a/tests/native_claude/test_mod.py +++ b/tests/native_claude/test_mod.py @@ -311,7 +311,10 @@ def test_savings_baseline_uses_manual_model_before_first_prompt(native_binary, t assert recorded["entries"][0]["served"] == selected -def test_savings_baseline_survives_routed_replay_and_later_model_change(native_binary, tmp_path): +@pytest.mark.parametrize("accounting_off", [False, True]) +def test_savings_baseline_survives_routed_replay_and_later_model_change( + native_binary, tmp_path, request, accounting_off +): """Exercise the native block/model/replay sequence used by the PTY, then a user switch.""" root = tmp_path / "session" options = _savings_options(root, first_prompt=True) @@ -326,7 +329,19 @@ def test_savings_baseline_survives_routed_replay_and_later_model_change(native_b " marker.write_text('blocked')\n" " print(json.dumps({'decision': 'block', 'reason': 'First prompt captured'}))\n" ) - selected, routed, later = "claude-haiku-4-5", "claude-opus-4-8", "claude-sonnet-4-6" + selected, routed, later = "claude-opus-4-8", "claude-sonnet-4-6", "claude-haiku-4-5" + env = { + "ENABLE_SMART_ROUTING_V2": "1", + "ENABLE_SMART_ROUTING_SUBAGENT_ONLY": "0", + "ENABLE_SMART_ROUTER_ORCHESTRATOR": "0", + "ENABLE_SMART_ROUTING_SAVINGS": "1", + "ANTHROPIC_DEFAULT_OPUS_MODEL": selected, + "ANTHROPIC_DEFAULT_SONNET_MODEL": routed, + "ANTHROPIC_DEFAULT_HAIKU_MODEL": later, + "PYTHONPATH": str(Path(__file__).parents[2] / "src"), + } + controls = session_env.start_session(env) + request.addfinalizer(lambda: shutil.rmtree(controls.parent)) replies = [ { "content": [{"type": "text", "text": "done"}], @@ -337,17 +352,19 @@ def test_savings_baseline_survives_routed_replay_and_later_model_change(native_b "usage": {"input_tokens": 20, "output_tokens": 7}, }, ] + if accounting_off: + replies.append( + { + "content": [{"type": "text", "text": "third done"}], + "usage": {"input_tokens": 30, "output_tokens": 11}, + } + ) with ( messages_api(replies) as (api, requests), Session( native_binary, root, - { - "ENABLE_SMART_ROUTING_SAVINGS": "1", - "ANTHROPIC_DEFAULT_HAIKU_MODEL": selected, - "ANTHROPIC_DEFAULT_OPUS_MODEL": routed, - "ANTHROPIC_DEFAULT_SONNET_MODEL": later, - }, + env, api=api, options=options, hooks={ @@ -364,31 +381,47 @@ def test_savings_baseline_survives_routed_replay_and_later_model_change(native_b }, ) as session, ): - session.send("/model haiku") + session.send("/model opus") blocked_result = session.send("Reply with done.") assert blocked_result["num_turns"] == 0 assert "First prompt captured" in blocked_result["result"] assert blocked.read_text() == "blocked" assert requests == [] # The PTY sends this native command after the hook has blocked the prompt. - session.send("/model opus") + session.send("/model sonnet") assert session.send("Reply with done.")["result"] == "done" first = _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=5) - session.send("/model sonnet") - assert session.send("Now reply with second done.")["result"] == "second done" - recorded = _recorded_usage(Path(options["savings_usage"]), 2, output_tokens=12) + steps = [("disable" if accounting_off else None, "haiku", "second done")] + if accounting_off: + steps.append(("enable", "sonnet", "third done")) + for action, model, answer in steps: + if action: + toggle = subprocess.run( + [sys.executable, "-m", "ucode.cli", "claude", f"--{action}-smart-routing"], + env=env, + stdin=subprocess.DEVNULL, + capture_output=True, + text=True, + timeout=10, + ) + assert toggle.returncode == 0, toggle.stderr + session.send(f"/model {model}") + assert session.send(f"Now reply with {answer}.")["result"] == answer + recorded = _recorded_usage( + Path(options["savings_usage"]), 2, output_tokens=16 if accounting_off else 12 + ) - assert [request["model"] for request in requests] == [routed, later] + expected_models = [routed, later, routed] if accounting_off else [routed, later] + assert [request["model"] for request in requests] == expected_models assert first["start_model"] == recorded["start_model"] == selected assert recorded["first_main_model"] == routed assert recorded["first_prompt_seen"] is True assert recorded["user_switched"] is True - earlier = next(entry for entry in recorded["entries"] if entry["served"] == routed) + earlier = next(entry for entry in recorded["entries"] if entry["before_user_switch"]) assert first["entries"] == [earlier] assert earlier["before_user_switch"] is True - current = next(entry for entry in recorded["entries"] if entry["served"] == later) - assert current["before_user_switch"] is False - assert current["baseline"] == later + current = next(entry for entry in recorded["entries"] if not entry["before_user_switch"]) + assert current["served"] == current["baseline"] == (routed if accounting_off else later) def test_savings_tracking_obeys_cli_session_controls(native_binary, tmp_path): diff --git a/tests/test_smart_routing_pricing.py b/tests/test_smart_routing_pricing.py index 2766d86de..0f535b3d1 100644 --- a/tests/test_smart_routing_pricing.py +++ b/tests/test_smart_routing_pricing.py @@ -3,6 +3,7 @@ from __future__ import annotations import json +from concurrent.futures import ThreadPoolExecutor from decimal import Decimal import pytest @@ -46,18 +47,13 @@ class TestModelKey: def test_collapses_gateway_spellings(self, model): assert pricing.model_key(model) == "claude-opus-4-8" - def test_matches_a_served_bedrock_id_to_the_requested_model(self): - # The gateway reports Haiku responses by their Bedrock id. - assert pricing.model_key("anthropic.claude-haiku-4-5-20251001-v1:0") == pricing.model_key( - "system.ai.claude-haiku-4-5" - ) - def test_unwraps_non_claude_gateway_models(self): assert pricing.model_key("anthropic-aigw-73ea02b2-system.ai.glm-5-2") == "glm-5-2" @pytest.mark.parametrize( ("served", "requested"), [ + ("anthropic.claude-haiku-4-5-20251001-v1:0", "system.ai.claude-haiku-4-5"), ("glm-5.3-flash", "system.ai.glm-5-3-flash"), ("glm-5-3-colo-on-sp-v1", "system.ai.glm-5-3"), ("kimi-k3-colo-on-sp-v1", "system.ai.kimi-k3"), @@ -147,7 +143,14 @@ def test_round_trips_distinct_model_versions(self, tmp_path): "deepseek-v3": ModelPrice(input=Decimal("1"), output=Decimal("2")), "deepseek-v4": ModelPrice(input=Decimal("3"), output=Decimal("4")), } - pricing.write_price_cache(path, prices) + # Different launches can refresh disjoint model sets in the same workspace. + with ThreadPoolExecutor(max_workers=2) as pool: + writes = [ + pool.submit(pricing.write_price_cache, path, {model: price}) + for model, price in prices.items() + ] + for write in writes: + write.result() cached = pricing.read_price_cache(path) @@ -164,7 +167,10 @@ def test_round_trips_prices_under_model_keys(self, tmp_path): assert cached is not None assert cached == {"claude-opus-4-8": OPUS, "claude-sonnet-4": SONNET_4} - assert [entry.name for entry in path.parent.iterdir()] == ["model-prices.json"] + assert {entry.name for entry in path.parent.iterdir()} == { + "model-prices.json", + "model-prices.json.lock", + } @pytest.mark.parametrize( "content", @@ -173,6 +179,8 @@ def test_round_trips_prices_under_model_keys(self, tmp_path): json.dumps({"version": 999, "models": {"claude-opus-4-8": {"input": "5"}}}), json.dumps({"version": 1, "models": {}}), json.dumps({"version": 1, "models": []}), + json.dumps({"version": 1, "models": {"claude-opus-4-8": {}}}), + json.dumps({"version": 1, "models": {"claude-opus-4-8": {"input": "invalid"}}}), ], ) def test_unusable_cache_reads_as_absent(self, tmp_path, content): diff --git a/tests/test_smart_routing_savings.py b/tests/test_smart_routing_savings.py index f45d9215f..a057fca33 100644 --- a/tests/test_smart_routing_savings.py +++ b/tests/test_smart_routing_savings.py @@ -253,8 +253,9 @@ def test_negative_reads_as_a_cost_increase(self): "$0.04", "10%" ) - def test_sub_cent_amounts_are_not_shown_as_zero(self): - assert savings.savings_segment(Decimal("0.004"), Decimal("1")) == saved("<$0.01", "0%") + @pytest.mark.parametrize("value,amount", [("0.004", "<$0.01"), ("0", "$0.00")]) + def test_formats_sub_cent_and_zero_amounts(self, value, amount): + assert savings.savings_segment(Decimal(value), Decimal("1")) == saved(amount, "0%") class TestPricerCommand: @@ -266,6 +267,7 @@ def run( first_prompt: bool = False, flag: str | None = "1", controls: Path | None = None, + snapshot: bytes | None = None, ): argv = savings.pricer_argv( python=sys.executable, price_cache=price_cache, baseline_session_start=first_prompt @@ -277,23 +279,43 @@ def run( env["UCODE_SESSION_ENV_FILE"] = str(controls) if flag is not None: env["ENABLE_SMART_ROUTING_SAVINGS"] = flag + if snapshot is not None: + argv.append("--write-usage") # The line must survive an ASCII stdout locale. return subprocess.run( [*argv, "--usage", str(usage)], capture_output=True, env=env, + input=snapshot, timeout=30, check=False, ) - def test_prints_exactly_one_json_line(self, tmp_path, price_cache): + @pytest.mark.parametrize("persist", [False, True]) + def test_prints_exactly_one_json_line(self, tmp_path, price_cache, persist): usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + snapshot = usage.read_bytes() if persist else None + if persist: + usage.write_text('{"version":1,"entries":[]}', encoding="utf-8") - result = self.run(price_cache, usage) + result = self.run(price_cache, usage, snapshot=snapshot) assert result.returncode == 0, result.stderr assert result.stdout.count(b"\n") == 1 assert json.loads(result.stdout.decode("utf-8")) == {"savings": saved("$0.18", "60%")} + if snapshot is not None: + assert json.loads(usage.read_bytes()) == json.loads(snapshot) + + @pytest.mark.parametrize("snapshot", [b"invalid", b"[]", b'{"version":999,"entries":[]}']) + def test_rejected_snapshot_preserves_usage(self, tmp_path, price_cache, snapshot): + usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + previous = usage.read_bytes() + + result = self.run(price_cache, usage, snapshot=snapshot) + + assert result.returncode == 1 + assert json.loads(result.stdout) == {"savings": None} + assert usage.read_bytes() == previous def test_never_fails_the_mod(self, tmp_path, price_cache): result = self.run(price_cache, tmp_path / "missing.json", first_prompt=True) @@ -308,17 +330,21 @@ def test_disabled_pricer_returns_no_estimate(self, tmp_path, price_cache, flag): assert result.returncode == 0, result.stderr assert json.loads(result.stdout) == {"savings": None} - def test_pricer_obeys_session_controls(self, tmp_path, price_cache): + @pytest.mark.parametrize("persist", [False, True]) + def test_pricer_obeys_session_controls(self, tmp_path, price_cache, persist): usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + snapshot = usage.read_bytes() if persist else None controls = tmp_path / "session-env.json" for overrides, expected in ( ({"ENABLE_SMART_ROUTING_SAVINGS": "0"}, None), ({}, saved("$0.18", "60%")), ): controls.write_text(json.dumps(overrides)) - result = self.run(price_cache, usage, controls=controls) - assert result.returncode == 0, result.stderr + result = self.run(price_cache, usage, controls=controls, snapshot=snapshot) + assert result.returncode == (1 if persist and expected is None else 0), result.stderr assert json.loads(result.stdout) == {"savings": expected} + if snapshot is not None: + assert json.loads(usage.read_bytes()) == json.loads(snapshot) controls.write_text("invalid JSON") fallback = self.run(price_cache, usage, controls=controls) From 9974560245fd2c1096b9014e81cd8fca28ca78ec Mon Sep 17 00:00:00 2001 From: Josh Joseph Date: Wed, 11 Nov 2026 23:46:03 +0000 Subject: [PATCH 5/7] Test endpoint rates and native savings launch --- tests/README.md | 15 +- tests/endpoint_rates_transport.py | 136 ++++++++++ tests/integration/README.md | 13 +- tests/native_claude/test_savings_launch.py | 293 +++++++++++++++++++++ tests/test_workspace_selection.py | 107 ++++++++ 5 files changed, 559 insertions(+), 5 deletions(-) create mode 100644 tests/endpoint_rates_transport.py create mode 100644 tests/native_claude/test_savings_launch.py diff --git a/tests/README.md b/tests/README.md index 96231d83b..b9a553129 100644 --- a/tests/README.md +++ b/tests/README.md @@ -41,6 +41,7 @@ journeys use vendor model IDs. | Category | Location | What it proves | | --- | --- | --- | | Unit/component | Existing `test_*.py` files | Individual behavior; dependencies may be mocked | +| Native launch components | `native_claude/test_savings_launch.py` | Real UG/Claude launch, local HTTPS endpoint rates and prepared Messages responses | | Dedicated-workspace CUJ | `e2e_cuj/test_*.py` | Real user journeys against read-only, preconfigured workspaces | | Existing e2e | `test_e2e*.py` | Real workspace behavior with some patched setup/internal calls | | Connector skill behavior | `connector_behavior/test_*.py` | Real Claude decisions with generated guidance and synthetic connector tools | @@ -251,8 +252,16 @@ Savings estimate coverage: `test_smart_routing_savings.py` prices the mod's toke (per-entry and first-prompt baselines, unpriced or malformed entries, the pricer's single JSON line, snapshot persistence/rejection and zero-dollar display). `test_smart_routing_pricing.py` covers endpoint rates, concurrent refreshes of distinct model sets, empty-price rejection, -and distinct price-cache paths for workspaces sharing a host. Shared-host launch wiring -is not covered by these component checks. +and distinct price-cache paths for workspaces sharing a host. +`test_workspace_selection.py::TestEndpointRatesTransport` exercises the real HTTPS client +through a loopback CONNECT/TLS fixture, with child-only CA trust and certificate/hostname +verification. It checks repeated sorted model names, empty eligible input, both workspace +selectors and their absence on another host, payload shapes, HTTP errors and closed connections. +`native_claude/test_savings_launch.py` invokes the real savings-enabled UG launcher and +Claude binary. It checks generated pricer/usage/version options, the exact main/default/routable +model-service union, and separate shared-host workspace caches. A native turn completes +while rates are withheld; after release the cache fills and another turn completes. Failed +refreshes preserve prior cache bytes or leave the estimate absent, with a completed native turn. The pricer subprocess checks explicit opt-in; unset, empty, zero, and invalid values stay off. Preset coverage in `test_smart_routing_config.py` checks the savings flag, inherited-value precedence, @@ -275,7 +284,7 @@ component tests check that off/on hides/restores a mounted row and failed usage hide stale estimates until a successful write. Capability tests deny the savings flag read and verify that startup and requests still run. These are native component checks, not live gateway/model or TUI coverage. -Endpoint-price refresh failures and orchestrator-version display are not covered automatically. +Live endpoint compatibility and interactive orchestrator-version display remain unverified. Dedicated CUJs reuse `integration/utils` session/terminal mechanics and file-task and transcript readers, not its config stubs or pytest fixtures. Prompt/model diff --git a/tests/endpoint_rates_transport.py b/tests/endpoint_rates_transport.py new file mode 100644 index 000000000..d8a2e87e4 --- /dev/null +++ b/tests/endpoint_rates_transport.py @@ -0,0 +1,136 @@ +"""Loopback CONNECT/TLS transport for endpoint-rate component tests.""" + +from __future__ import annotations + +import datetime +import json +import os +import ssl +import sys +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path + +from cryptography import x509 +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import rsa +from cryptography.x509.oid import NameOID + +WORKSPACE = "https://rates.test" +OTHER_WORKSPACE = "https://other.test" +SYNTHETIC_BEARER = "local-endpoint-rates-fixture" + + +class EndpointRatesTransport: + def __init__(self, root: Path, payload, *, status=200, hold=False, disconnect=False): + self.requests = [] + self.targets = [] + self.requested = threading.Event() + self.release = threading.Event() + self.finished = threading.Event() + self.errors = [] + if not hold: + self.release.set() + + root.mkdir(parents=True, exist_ok=True) + key = rsa.generate_private_key(public_exponent=65537, key_size=2048) + subject = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Endpoint rates fixture")]) + now = datetime.datetime.now(datetime.UTC) + certificate = ( + x509.CertificateBuilder() + .subject_name(subject) + .issuer_name(subject) + .public_key(key.public_key()) + .serial_number(x509.random_serial_number()) + .not_valid_before(now - datetime.timedelta(minutes=1)) + .not_valid_after(now + datetime.timedelta(hours=1)) + .add_extension(x509.BasicConstraints(ca=True, path_length=None), critical=True) + .add_extension( + x509.SubjectAlternativeName( + [x509.DNSName("rates.test"), x509.DNSName("other.test")] + ), + critical=False, + ) + .sign(key, hashes.SHA256()) + ) + self.ca = root / "ca.pem" + self.ca.write_bytes(certificate.public_bytes(serialization.Encoding.PEM)) + key_path = root / "key.pem" + key_path.write_bytes( + key.private_bytes( + serialization.Encoding.PEM, + serialization.PrivateFormat.PKCS8, + serialization.NoEncryption(), + ) + ) + key_path.chmod(0o600) + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.load_cert_chain(self.ca, key_path) + fixture = self + + class Handler(BaseHTTPRequestHandler): + def log_message(self, format, *args): + pass + + def do_GET(self): + fixture.requests.append( + {"path": self.path, "headers": {k.lower(): v for k, v in self.headers.items()}} + ) + fixture.requested.set() + if not fixture.release.wait(timeout=30): + raise TimeoutError("endpoint-rate response was not released") + if not disconnect: + body = json.dumps(payload).encode() + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + self.wfile.flush() + self.close_connection = True + + def do_CONNECT(self): + fixture.targets.append(self.path) + if self.path not in {"rates.test:443", "other.test:443"}: + self.send_error(502, "Unexpected destination") + return + self.send_response(200) + self.end_headers() + self.wfile.flush() + self.connection.settimeout(35) + try: + with context.wrap_socket(self.connection, server_side=True) as connection: + Handler(connection, self.client_address, self.server) + except Exception as exc: + fixture.errors.append(repr(exc)) + finally: + fixture.finished.set() + self.close_connection = True + + self.server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + self.thread = threading.Thread(target=self.server.serve_forever, daemon=True) + + def child_environment(self, home: Path) -> dict[str, str]: + home.mkdir(parents=True, exist_ok=True) + return { + **{key: os.environ[key] for key in ("SYSTEMROOT", "TEMP", "TMP") if key in os.environ}, + "PATH": os.pathsep.join([str(Path(sys.executable).parent), os.defpath]), + "HOME": str(home), + "USERPROFILE": str(home), + "PYTHONNOUSERSITE": "1", + "SSL_CERT_FILE": str(self.ca), + "HTTPS_PROXY": f"http://127.0.0.1:{self.server.server_port}", + "NO_PROXY": "127.0.0.1,localhost", + } + + def __enter__(self): + self.thread.start() + return self + + def __exit__(self, *_args): + self.release.set() + self.server.shutdown() + self.server.server_close() + self.thread.join(timeout=5) + assert not self.thread.is_alive() + assert not self.errors, self.errors diff --git a/tests/integration/README.md b/tests/integration/README.md index b5a299ae4..58b721aad 100644 --- a/tests/integration/README.md +++ b/tests/integration/README.md @@ -1859,8 +1859,17 @@ Native UI component tests cover mounted-row updates after CLI toggles and hiding stale estimates on failed usage writes. Pricer subprocesses read the saved session controls and validate snapshot persistence/rejection. Pricing tests keep shared-host workspace cache paths and concurrently refreshed model sets distinct, reject -empty prices and distinguish zero savings from sub-cent amounts. Shared-host launch wiring -is not covered. +empty prices and distinguish zero savings from sub-cent amounts. +`../test_workspace_selection.py::TestEndpointRatesTransport` covers the real endpoint client +over loopback CONNECT/TLS: repeated parameters, host-scoped selectors, payload shapes and +HTTP/connection failures, with certificate verification and a child-only test CA. +`../native_claude/test_savings_launch.py` exercises the real UG/Claude launch with prepared +local Messages responses. Generated options, the main/default/routable service union and +workspace-ID cache selection are checked while the child is alive. A completed native turn +precedes release of a held rates response; a later turn runs after the cache fills. HTTP and +closed-connection refresh failures preserve an existing cache or leave the estimate absent +while a native turn completes. These are local component checks; live endpoint compatibility +and interactive orchestrator-version display remain unverified. Live savings accumulation, display, and session off/on are not covered by the integration suite. diff --git a/tests/native_claude/test_savings_launch.py b/tests/native_claude/test_savings_launch.py new file mode 100644 index 000000000..e4b4e60e6 --- /dev/null +++ b/tests/native_claude/test_savings_launch.py @@ -0,0 +1,293 @@ +"""Real UG/native Claude launch with loopback endpoint rates and prepared Messages replies.""" + +from __future__ import annotations + +import json +import os +import queue +import signal +import subprocess +import sys +import threading +import time +from decimal import Decimal +from pathlib import Path +from urllib.parse import parse_qsl, urlsplit + +import pytest + +from tests.endpoint_rates_transport import SYNTHETIC_BEARER, WORKSPACE, EndpointRatesTransport +from tests.native_claude.messages_api import messages_api +from tests.native_claude.session import Session +from tests.native_claude.test_mod import _recorded_usage +from ucode.smart_routing import orchestrator, pricing +from ucode.workspace import workspace_key + +MAIN_MODEL = "system.ai.claude-opus-4-8" +DEFAULT_MODEL = "system.ai.claude-opus-4-6" +ROUTABLE_MODELS = ["system.ai.claude-sonnet-4-6", "system.ai.claude-haiku-4-5"] +MODEL_SERVICES = sorted([MAIN_MODEL, DEFAULT_MODEL, *ROUTABLE_MODELS]) +WORKSPACE_ID = "111" + +_LAUNCH = """ +import sys, threading +from ucode.agents import claude +from ucode.smart_routing import v2 +from ucode.workspace import pin + +binary, workspace, workspace_id, model, settings = sys.argv[1:] +managed = claude._managed_settings_path() +assert managed is None or not managed.exists(), 'Native launch test needs an isolated managed-settings directory' +pin(workspace, workspace_id) +try: + v2.launch_claude( + {'workspace': workspace, 'workspace_id': workspace_id}, + ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', + '--verbose', '--setting-sources', 'user', '--settings', settings, + '--tools', '', '--permission-mode', 'default'], + binary=binary, user_settings_path=claude.CLAUDE_USER_SETTINGS_PATH, + launch_model=model, compose_settings=claude._compose_v2_settings, + launch_model_args=claude._launch_model_args, model_name=claude._maybe_add_1m_suffix, + ) +finally: + # Wait for the real daemon before checking the persistent cache after launch exits. + for worker in threading.enumerate(): + if worker.name == 'ug-savings-prices': + worker.join(timeout=35) + assert not worker.is_alive(), 'Endpoint refresh did not finish' +""" + + +class SavingsLaunch(Session): + """Reuse the native stream driver, with UG constructing all launch options and plugins.""" + + def __init__(self, binary, root, transport, api): + self.root = root + self.transport = transport + self.env = { + **transport.child_environment(root), + "CLAUDE_CONFIG_DIR": str(root / ".claude"), + "DATABRICKS_BEARER": SYNTHETIC_BEARER, + "ANTHROPIC_BASE_URL": api, + "ANTHROPIC_API_KEY": "local-messages-fixture", + "SMART_ROUTER_CONFIG_VERSION": "subagent_orch_savings_v0", + "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1", + "CLAUDE_CODE_MAX_RETRIES": "0", + "CLAUDE_CODE_ELEGANT_MEADOW": "1", + "DISABLE_AUTOUPDATER": "1", + "TMPDIR": str(root / "tmp"), + } + (root / "tmp").mkdir() + self.user_settings = root / ".claude/settings.json" + self.user_settings.parent.mkdir() + self.user_settings.write_text( + json.dumps( + { + "modelPicker": {"options": [{"model": model} for model in ROUTABLE_MODELS]}, + "env": { + "ANTHROPIC_MODEL": DEFAULT_MODEL, + "ANTHROPIC_DEFAULT_OPUS_MODEL": DEFAULT_MODEL, + "ANTHROPIC_DEFAULT_SONNET_MODEL": ROUTABLE_MODELS[0], + "ANTHROPIC_DEFAULT_HAIKU_MODEL": ROUTABLE_MODELS[1], + }, + } + ) + ) + self.original_settings = self.user_settings.read_bytes() + self.proc = subprocess.Popen( + [ + sys.executable, + "-P", + "-c", + _LAUNCH, + binary, + WORKSPACE, + WORKSPACE_ID, + MAIN_MODEL, + str(self.user_settings), + ], + cwd=root, + env=self.env, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + start_new_session=True, + ) + self.lines = queue.Queue() + self.errors = [] + self.readers = [ + threading.Thread( + target=lambda: [self.lines.put(line) for line in self.proc.stdout], daemon=True + ), + threading.Thread(target=lambda: self.errors.extend(self.proc.stderr), daemon=True), + ] + for reader in self.readers: + reader.start() + + def settings(self): + paths = list((self.root / ".ucode").glob("claude-v2-*/settings.json")) + assert len(paths) == 1, paths + return paths[0], json.loads(paths[0].read_text()) + + def __exit__(self, exc_type, *_args): + self.transport.release.set() + self.proc.stdin.close() + try: + self.proc.wait(timeout=40) + except subprocess.TimeoutExpired: + os.killpg(self.proc.pid, signal.SIGKILL) + self.proc.wait(timeout=5) + raise + finally: + for reader in self.readers: + reader.join(timeout=5) + self.proc.stdout.close() + self.proc.stderr.close() + if exc_type is None: + assert self.proc.returncode == 0, "".join(self.errors) + assert self.user_settings.read_bytes() == self.original_settings + + +def _cache_path(root, workspace_id=WORKSPACE_ID): + return pricing.price_cache_path(root / ".ucode", workspace_key(WORKSPACE, workspace_id)) + + +def _assert_launch_options(session): + path, settings = session.settings() + options = settings["pluginConfigs"]["ug-smart-router"]["options"] + assert options["savings_pricer"] == [ + sys.executable, + "-P", + "-m", + "ucode.smart_routing.savings", + "--price-cache", + str(_cache_path(session.root)), + ] + assert options["savings_usage"] == str(path.parent / "savings-usage.json") + assert options["orchestrator_version"] + assert options["orchestrator_version"] == orchestrator.skill_version(agent="claude") + assert settings["env"]["ENABLE_SMART_ROUTING_SAVINGS"] == "1" + assert settings["env"]["ENABLE_SMART_ROUTING_SUBAGENT_ONLY"] == "1" + return options + + +def _assert_rates_request(transport): + assert transport.targets == ["rates.test:443"] + assert len(transport.requests) == 1 + request = transport.requests[0] + url = urlsplit(request["path"]) + assert url.path == "/api/ai-gateway/v2/endpoint-rates:batchGet" + assert parse_qsl(url.query) == [ + ("databricks_hosted_model_services", model) for model in MODEL_SERVICES + ] + for name in ("x-databricks-org-id", "x-databricks-workspace-id"): + assert request["headers"][name] == WORKSPACE_ID + assert request["headers"]["authorization"] == f"Bearer {SYNTHETIC_BEARER}" + + +def test_savings_launch_completes_a_turn_before_rates_arrive(native_binary, tmp_path): + root = tmp_path / "session" + other_cache = _cache_path(root, "222") + pricing.write_price_cache(other_cache, {MAIN_MODEL: pricing.ModelPrice(input=Decimal("99"))}) + other_bytes = other_cache.read_bytes() + payload = { + "model_service_rates": [ + { + "model_service": model, + "costs": [ + { + "unit": "USD", + "token_costs": [ + {"token_type": "TOKEN_TYPE_INPUT", "cost": "1"}, + {"token_type": "TOKEN_TYPE_OUTPUT", "cost": "5"}, + ], + } + ], + } + for model in MODEL_SERVICES + ] + } + replies = [ + { + "content": [{"type": "text", "text": "before rates"}], + "usage": {"input_tokens": 7, "output_tokens": 11}, + }, + { + "content": [{"type": "text", "text": "after rates"}], + "usage": {"input_tokens": 13, "output_tokens": 17}, + }, + ] + with ( + EndpointRatesTransport(tmp_path / "tls", payload, hold=True) as transport, + messages_api(replies) as (api, requests), + SavingsLaunch(native_binary, root, transport, api) as session, + ): + assert transport.requested.wait(timeout=15) + assert session.send("Reply with before rates.")["result"] == "before rates" + assert not transport.release.is_set() and not transport.finished.is_set() + assert not _cache_path(root).exists() + options = _assert_launch_options(session) + usage = Path(options["savings_usage"]) + _recorded_usage(usage, 1, output_tokens=11) + _assert_rates_request(transport) + + transport.release.set() + deadline = time.monotonic() + 10 + while not _cache_path(root).exists() and time.monotonic() < deadline: + time.sleep(0.05) + cache = json.loads(_cache_path(root).read_text()) + assert cache["version"] == 1 + assert cache["models"] == { + model.removeprefix("system.ai."): {"input": "1", "output": "5"} + for model in MODEL_SERVICES + } + assert session.send("Reply with after rates.")["result"] == "after rates" + recorded = _recorded_usage(usage, 1, output_tokens=28) + assert recorded["entries"][0]["usage"]["input_tokens"] == 20 + assert recorded["entries"][0]["baseline"] == MAIN_MODEL + assert recorded["entries"][0]["served"] == MAIN_MODEL + assert [request["model"] for request in requests] == [MAIN_MODEL, MAIN_MODEL] + assert other_cache.read_bytes() == other_bytes + + +@pytest.mark.parametrize("disconnect", [False, True], ids=["http-error", "closed-connection"]) +@pytest.mark.parametrize("cached", [False, True], ids=["cold-cache", "prior-cache"]) +def test_savings_launch_survives_failed_rate_refresh(native_binary, tmp_path, disconnect, cached): + root = tmp_path / "session" + cache = _cache_path(root) + if cached: + pricing.write_price_cache(cache, {MAIN_MODEL: pricing.ModelPrice(input=Decimal("7"))}) + before = cache.read_bytes() if cached else None + replies = [ + { + "content": [{"type": "text", "text": "rates unavailable"}], + "usage": {"input_tokens": 7, "output_tokens": 11}, + } + ] + with ( + EndpointRatesTransport( + tmp_path / "tls", {}, status=503, disconnect=disconnect + ) as transport, + messages_api(replies) as (api, requests), + SavingsLaunch(native_binary, root, transport, api) as session, + ): + assert session.send("Reply with rates unavailable.")["result"] == "rates unavailable" + assert transport.finished.wait(timeout=10) + _assert_rates_request(transport) + options = _assert_launch_options(session) + _recorded_usage(Path(options["savings_usage"]), 1, output_tokens=11) + if not cached: + result = subprocess.run( + [*options["savings_pricer"], "--usage", options["savings_usage"]], + input="", + capture_output=True, + text=True, + timeout=10, + env=session.env, + cwd=root, + ) + assert result.returncode == 0, result.stderr + assert json.loads(result.stdout) == {"savings": None} + assert [request["model"] for request in requests] == [MAIN_MODEL] + assert (cache.read_bytes() if cache.exists() else None) == before diff --git a/tests/test_workspace_selection.py b/tests/test_workspace_selection.py index be175f54d..a94ed2263 100644 --- a/tests/test_workspace_selection.py +++ b/tests/test_workspace_selection.py @@ -8,13 +8,22 @@ import io import json +import subprocess +import sys from email.message import Message from unittest.mock import patch +from urllib.parse import parse_qsl, urlsplit import pytest import ucode.databricks as db_mod import ucode.workspace as workspace_mod +from tests.endpoint_rates_transport import ( + OTHER_WORKSPACE, + SYNTHETIC_BEARER, + WORKSPACE, + EndpointRatesTransport, +) from ucode import gateway_proxy, mcp, mcp_connection_login, skills_usage from ucode.agents import claude, codex, copilot, gemini, kilo, opencode, pi, vscode from ucode.state import build_agent_state @@ -265,6 +274,104 @@ def test_classic_argv_is_unchanged(self): assert "--workspace-id" not in db_mod.build_otel_headers_argv(CLASSIC) +class TestEndpointRatesTransport: + def fetch(self, transport, home, models, workspace=WORKSPACE): + result = subprocess.run( + [ + sys.executable, + "-P", + "-c", + "import json, sys; from ucode.databricks import fetch_endpoint_rates; " + "from ucode.workspace import pin; data = json.load(sys.stdin); " + "pin(data['selected'], data['workspace_id']); " + "print(json.dumps(fetch_endpoint_rates(data['workspace'], data['token'], data['models'])))", + ], + input=json.dumps( + { + "selected": WORKSPACE, + "workspace_id": WSID, + "workspace": workspace, + "token": SYNTHETIC_BEARER, + "models": models, + } + ), + capture_output=True, + text=True, + timeout=40, + env=transport.child_environment(home), + cwd=home, + ) + assert result.returncode == 0, result.stderr + return json.loads(result.stdout) + + @pytest.mark.parametrize( + "workspace,selectors", [(WORKSPACE + ":8443", SELECTOR), (OTHER_WORKSPACE, {})] + ) + def test_repeated_names_and_host_scoped_workspace_headers(self, tmp_path, workspace, selectors): + names = ["system.ai.claude-haiku-4-5", "system.ai.claude-sonnet-4-6"] + rates = [{"model_service": names[0]}] + with EndpointRatesTransport(tmp_path / "tls", {"model_service_rates": rates}) as transport: + assert self.fetch( + transport, + tmp_path / "home", + [names[1], "custom.model", names[0], names[1]], + workspace, + ) == [rates, None] + assert transport.targets == [f"{urlsplit(workspace).hostname}:443"] + assert len(transport.requests) == 1 + request = transport.requests[0] + url = urlsplit(request["path"]) + assert url.path == "/api/ai-gateway/v2/endpoint-rates:batchGet" + assert parse_qsl(url.query) == [ + ("databricks_hosted_model_services", name) for name in names + ] + assert request["headers"]["authorization"] == f"Bearer {SYNTHETIC_BEARER}" + assert {name: request["headers"].get(name.lower()) for name in SELECTOR} == { + name: selectors.get(name) for name in SELECTOR + } + + def test_ineligible_models_make_no_request(self, tmp_path): + with EndpointRatesTransport(tmp_path / "tls", {}) as transport: + assert self.fetch( + transport, tmp_path / "home", ["custom.model", "claude-sonnet-4-6"] + ) == [[], "no system.ai model services to price"] + assert transport.targets == transport.requests == [] + + @pytest.mark.parametrize( + "payload,expected", + [ + ([], [[], "endpoint-rates returned an unexpected response shape"]), + ({}, [[], None]), + ({"model_service_rates": {}}, [[], None]), + ( + { + "model_service_rates": [ + None, + "invalid", + [], + {"model_service": "system.ai.example"}, + ] + }, + [[{"model_service": "system.ai.example"}], None], + ), + ], + ) + def test_response_shapes(self, tmp_path, payload, expected): + with EndpointRatesTransport(tmp_path / "tls", payload) as transport: + assert self.fetch(transport, tmp_path / "home", ["system.ai.example"]) == expected + assert len(transport.requests) == 1 + + @pytest.mark.parametrize("disconnect", [False, True]) + def test_http_and_connection_failures_are_optional(self, tmp_path, disconnect): + with EndpointRatesTransport( + tmp_path / "tls", {}, status=503, disconnect=disconnect + ) as transport: + rates, reason = self.fetch(transport, tmp_path / "home", ["system.ai.example"]) + assert rates == [] + assert reason.startswith("network error:" if disconnect else "HTTP 503") + assert len(transport.requests) == 1 + + class TestLoopbackProxy: def test_proxy_applies_the_selection(self, selected): server, cache, client = gateway_proxy.start_otel_proxy(SHARED, lambda force: "tok", port=0) From 5b96e93c38bbe14587d21bde0a124d206d96bc68 Mon Sep 17 00:00:00 2001 From: "josh.joseph" Date: Fri, 13 Nov 2026 20:43:37 +0000 Subject: [PATCH 6/7] Document native offline savings flow --- docs/demos/pr-850/README.md | 21 +++++ docs/demos/pr-850/offline-savings.mp4 | Bin 0 -> 241039 bytes docs/demos/pr-850/provenance.json | 120 ++++++++++++++++++++++++++ 3 files changed, 141 insertions(+) create mode 100644 docs/demos/pr-850/README.md create mode 100644 docs/demos/pr-850/offline-savings.mp4 create mode 100644 docs/demos/pr-850/provenance.json diff --git a/docs/demos/pr-850/README.md b/docs/demos/pr-850/README.md new file mode 100644 index 000000000..e3625d629 --- /dev/null +++ b/docs/demos/pr-850/README.md @@ -0,0 +1,21 @@ +[Watch the native offline savings recording](offline-savings.mp4) (21.55 seconds, 241 KB). + +Claude Code 2.1.322 runs the savings-enabled `subagent_orch_savings_v0` preset. +The native router selects Sonnet for a child that reads `invoice-note.txt` and +verifies `50 - 8 = 42`. The prompt shows estimated savings of **$0.23 (57%)**; +`/smart-router off` hides the estimate and `/smart-router on` restores it. + +**OFFLINE FIXTURE:** Messages responses, token usage, routing selection and endpoint +rates are prepared local inputs in a network namespace with loopback only. This +does not measure actual billing or live-gateway savings. The native Agent and Read +tools, routing CLI, accounting, display and session controls execute normally. + +The MP4 replays captured native terminal text in monochrome at its original timing, +with onboarding trimmed and brief viewing holds. T3 preview capture was unavailable +because no automation host was connected. Raw transcripts and profile data remain +private; [provenance](provenance.json) records the runtime, source and media hashes. + +The recording uses source commit `1721714aa99d86659735bd729830d5e5b97279c0`, +which passed 468 selected component, integration-contract and native-client cases, +plus Ruff, formatting and type checks. This documentation commit leaves those +validated source bytes unchanged. diff --git a/docs/demos/pr-850/offline-savings.mp4 b/docs/demos/pr-850/offline-savings.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..ecc4e80ba1014814e2412fb28738a75f7318ade7 GIT binary patch literal 241039 zcmeFXbx>r>voP4WyW8OIE`tsZ1B1J}yTjn_It=bMxVyUy3=V_4yZbg*-n-v#zli;3 z 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%0DCUB>{PY_CT1E;F!og_Hzw++SP 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 Date: Sun, 15 Nov 2026 08:47:03 +0000 Subject: [PATCH 7/7] Fix savings state tracking and gateway alias pricing --- docs/claude-mod.md | 6 +- src/ucode/agents/claude_mods/register.ts | 31 +++-- src/ucode/smart_routing/pricing.py | 2 +- src/ucode/smart_routing/savings.py | 2 + tests/README.md | 8 +- tests/integration/README.md | 6 +- tests/native_claude/mod_tests/savings.test.ts | 118 +++++++++++++++++- tests/native_claude/test_mod.py | 1 + tests/test_smart_routing_pricing.py | 7 +- tests/test_smart_routing_savings.py | 20 +++ 10 files changed, 179 insertions(+), 22 deletions(-) diff --git a/docs/claude-mod.md b/docs/claude-mod.md index 67f8d2d62..83ae4382c 100644 --- a/docs/claude-mod.md +++ b/docs/claude-mod.md @@ -274,7 +274,8 @@ Under first-prompt routing, requests before the user changes the main model are against the model selected when the first prompt was submitted, before the router's `/model` command. A manual selection before that prompt becomes the baseline. Later model changes affect only subsequent usage, including changes made during a turn with -savings disabled. Request-specific model overrides leave the selected main model unchanged. +savings disabled. Child requests observe those changes even before the next parent request. +Request-specific model overrides leave the selected main model unchanged. Claude's native `$.session.model()` returns the resolved model ID, including for configured family aliases such as `sonnet`. @@ -297,7 +298,8 @@ persisted with the totals so a mod reload does not replace it with the routed mo Savings failures, including denied reads of its environment flag, leave model requests running. Savings handlers are registered only when the launch options explicitly enable the feature. A failed usage-file write hides the estimate and retains the in-memory -totals for the next turn's write. +totals for the next turn's write. If a completed tracked request has no usage, the estimate +stays hidden for that session, including after a mod reload, because its totals are incomplete. The entire savings mod requires `ENABLE_SMART_ROUTING_SAVINGS=1`. Otherwise no usage is tracked or written, no endpoint rates are fetched, no pricer runs, and no savings row is diff --git a/src/ucode/agents/claude_mods/register.ts b/src/ucode/agents/claude_mods/register.ts index 53fbd828b..bb6b978d6 100644 --- a/src/ucode/agents/claude_mods/register.ts +++ b/src/ucode/agents/claude_mods/register.ts @@ -170,13 +170,16 @@ export function register(on: On, options: PluginOptions): void { // model without changing the user's selection for later main/child work. if (enabled) { const selected = await mainModel($); - if (agent === null && selected) { + if (selected) { lastMainModel = selected; - firstMainModel ??= lastMainModel; - firstPromptSeen = true; - userSwitched ||= lastMainModel !== firstMainModel; + if (agent === null) { + firstMainModel ??= selected; + firstPromptSeen = true; + } + userSwitched ||= firstMainModel !== null && selected !== firstMainModel; dirty = true; - } else baseline = selected ?? lastMainModel; + } + if (agent !== null) baseline = selected ?? lastMainModel; } } catch { trackSavings = false; @@ -187,9 +190,15 @@ export function register(on: On, options: PluginOptions): void { const usage = (result as any)?.usage; const served = str(request.model) ?? str(usage?.model); const base = agent === null ? served : baseline; - if (trackSavings && await ready($) && usage && served && base) { - accumulate(agent ?? 'main', base, served, beforeUserSwitch, usage); - dirty = true; + if (trackSavings && await ready($)) { + if (!usage) { + incompleteUsage = true; + dirty = true; + setEstimate($, null); + } else if (served && base) { + accumulate(agent ?? 'main', base, served, beforeUserSwitch, usage); + dirty = true; + } } } catch {} return result; @@ -311,6 +320,8 @@ let lastMainModel: string | null = null; let firstMainModel: string | null = null; // Whether the selected main model has changed since the first request. let userSwitched = false; +// Missing usage cannot be recovered by repricing the later session totals. +let incompleteUsage = false; let seeding: Promise | undefined; let estimate: Estimate | null = null; // Whether the current render draws the row, which hides the status band. @@ -382,6 +393,7 @@ async function loadUsage($: any): Promise { firstMainModel ??= str(saved.first_main_model); firstPromptSeen ||= saved.first_prompt_seen === true || firstMainModel !== null; userSwitched ||= saved.user_switched === true; + incompleteUsage ||= saved.incomplete_usage === true; } catch {} } @@ -447,12 +459,13 @@ async function writeAndPrice($: any): Promise { first_main_model: firstMainModel, first_prompt_seen: firstPromptSeen, user_switched: userSwitched, + incomplete_usage: incompleteUsage, entries: Array.from(entries.values()), }), }); if (run?.exitCode !== 0) throw new Error('Could not persist savings usage.'); const out = JSON.parse(String(run.stdout ?? '').trim().split('\n').pop() ?? ''); - setEstimate($, estimateOf(out?.savings)); + setEstimate($, incompleteUsage ? null : estimateOf(out?.savings)); } catch (error) { // Retry at the next turn.complete rather than pricing a file that is not there. dirty = true; diff --git a/src/ucode/smart_routing/pricing.py b/src/ucode/smart_routing/pricing.py index e1c75de81..9d2b2e6c2 100644 --- a/src/ucode/smart_routing/pricing.py +++ b/src/ucode/smart_routing/pricing.py @@ -34,7 +34,7 @@ _PRICE_CACHE_VERSION = 1 _MILLION = Decimal(1_000_000) _CONTEXT_SUFFIX_RE = re.compile(r"\[[^\]]*\]$") -_ANTHROPIC_AIGW_PREFIX_RE = re.compile(r"^anthropic-aigw-[0-9a-f]{8}-") +_ANTHROPIC_AIGW_PREFIX_RE = re.compile(r"^anthropic-aigw-[0-9a-f]{7,8}-") # The gateway reports some served models by their provider id, e.g. Bedrock's # `anthropic.claude-haiku-4-5-20251001-v1:0` for a request to `system.ai.claude-haiku-4-5`. _PROVIDER_PREFIX_RE = re.compile(r"^(?:(?:us|eu|apac|au|jp|global)\.)?anthropic\.") diff --git a/src/ucode/smart_routing/savings.py b/src/ucode/smart_routing/savings.py index 871053f28..b3e9425a5 100644 --- a/src/ucode/smart_routing/savings.py +++ b/src/ucode/smart_routing/savings.py @@ -84,6 +84,8 @@ def usage_savings( entries = document.get("entries") if not isinstance(entries, list): raise ValueError(f"unsupported savings usage file: {usage_path}") + if document.get("incomplete_usage") is True: + return None fixed_baseline = None if baseline_session_start: start = document.get("start_model") diff --git a/tests/README.md b/tests/README.md index 92c08aacf..57da81f30 100644 --- a/tests/README.md +++ b/tests/README.md @@ -437,7 +437,8 @@ Savings estimate coverage: `test_smart_routing_savings.py` prices the mod's toke (per-entry and first-prompt baselines, unpriced or malformed entries, the pricer's single JSON line, snapshot persistence/rejection and zero-dollar display). `test_smart_routing_pricing.py` covers endpoint rates, concurrent refreshes of distinct model sets, empty-price rejection, -and distinct price-cache paths for workspaces sharing a host. +and distinct price-cache paths for workspaces sharing a host. Seven- and eight-digit gateway +alias prefixes resolve to the same prices. Incomplete usage snapshots produce no estimate. `test_workspace_selection.py::TestEndpointRatesTransport` exercises the real HTTPS client through a loopback CONNECT/TLS fixture, with child-only CA trust and certificate/hostname verification. It checks repeated sorted model names, empty eligible input, both workspace @@ -466,7 +467,10 @@ CLI off/on controls exclude disabled turns from the totals; pricer subprocesses honor the saved controls and fall back to inherited settings without writing to stderr when the file is malformed. Native UI component tests check that off/on hides/restores a mounted row and failed usage writes -hide stale estimates until a successful write. Capability tests deny the savings flag +hide stale estimates until a successful write. Missing usage hides the row immediately and +across later flushes, off/on controls and module initialization; an in-flight price result +cannot restore it. Child-only model switches update subsequent baselines, including while +accounting is off. Capability tests deny the savings flag read and verify that startup and requests still run. These are native component checks, not live gateway/model or TUI coverage. Live endpoint compatibility and interactive orchestrator-version display remain unverified. diff --git a/tests/integration/README.md b/tests/integration/README.md index 55e500363..c2cec6fb0 100644 --- a/tests/integration/README.md +++ b/tests/integration/README.md @@ -2062,7 +2062,11 @@ and preserve prior usage after later model changes, including switching away and while accounting is off. Request-specific model overrides retain the selected main/child baseline in native SDK tests. CLI off/on excludes disabled turns from native usage totals. Native UI component tests cover mounted-row updates after -CLI toggles and hiding stale estimates on failed usage writes. Pricer subprocesses read +CLI toggles and hiding stale estimates on failed usage writes. Missing usage stays hidden +across later flushes and module initialization, including an in-flight price response. +Child steps observe model switches without another parent request, including with accounting +off. Pricing accepts seven- and eight-digit gateway alias prefixes. These are offline component +checks. Pricer subprocesses read the saved session controls, fall back without stderr output for malformed controls, and validate snapshot persistence/rejection. Pricing tests keep shared-host workspace cache paths and concurrently refreshed model sets distinct, reject diff --git a/tests/native_claude/mod_tests/savings.test.ts b/tests/native_claude/mod_tests/savings.test.ts index 35fbfd835..f98921a63 100644 --- a/tests/native_claude/mod_tests/savings.test.ts +++ b/tests/native_claude/mod_tests/savings.test.ts @@ -56,10 +56,13 @@ test('a denied savings read preserves orchestration, startup and model requests' expect((await $.turn.complete({ answer: 'done' })).text).toBe('done'); }); -async function savingsRow($: any, on: On) { +async function savingsRow($: any, on: On, incompleteUsage = false) { const state = { controls: {} as Record, failWrites: false, writes: 0, prices: 0, usage: null as any, + selectedModel: 'claude-opus-4-8', + responseUsage: { input_tokens: 1, output_tokens: 1 } as any, + priceBarrier: null as Promise | null, }; const clock = mock.clock(on); const env: Record = { ...options, UCODE_SESSION_ENV_FILE: '/session/env.json' }; @@ -74,17 +77,19 @@ async function savingsRow($: any, on: On) { first_main_model: 'claude-opus-4-8', main_model: 'claude-opus-4-8', first_prompt_seen: true, + incomplete_usage: incompleteUsage, entries: [{ agent: 'child', baseline: 'claude-opus-4-8', served: 'claude-sonnet-4-6', before_user_switch: true, usage: { input_tokens: 100, output_tokens: 10 }, }], }) })); - on('session.model', () => ({ value: 'claude-opus-4-8' })); - on('process.run', (_, e) => { + on('session.model', () => ({ value: state.selectedModel })); + on('process.run', async (_, e) => { state.writes += 1; if (state.failWrites) return { value: { exitCode: 1, stderr: '', stdout: '{"savings":null}' } }; state.usage = JSON.parse(e.init.stdin); state.prices += 1; + if (state.priceBarrier) await state.priceBarrier; return { value: { exitCode: 0, stderr: '', stdout: JSON.stringify({ savings: { saved: true, amount: '$0.18', percent: '60%' }, }) } }; @@ -92,13 +97,13 @@ async function savingsRow($: any, on: On) { on('session.start', () => ({ cwd: '/session' })); on('turn.complete', () => ({ text: 'done' })); on('turn.step', async function* (_, e) { - return { turnId: e.turnId, index: e.index, answer: 'done', toolUses: [], usage: { input_tokens: 1, output_tokens: 1 } }; + return { turnId: e.turnId, index: e.index, answer: 'done', toolUses: [], usage: state.responseUsage }; }); on('ui.render', { component: 'AbovePrompt' }, ($, e) => $.ui.resolve(e).Text({ children: ['theirs'] })); await $.session.start({ surface: 'terminal', isInteractive: true, cwd: '/session' }); const row = await $.ui.mount({ plugin: 'ug-smart-router', surface: 'terminal', component: 'AbovePrompt', props: {} }); await clock.advance(1); - expect(JSON.stringify(await row.drawn())).toContain('$0.18'); + expect(JSON.stringify(await row.drawn()).includes('$0.18')).toBe(!incompleteUsage); return { state, clock, row }; } @@ -146,3 +151,106 @@ test('a failed usage write removes the stale estimate until a later write succee expect(state.prices).toBe(priced + 1); expect(JSON.stringify(await row.drawn())).toContain('$0.18'); }); + + +test('a background child observes a model switch before another parent request', { options }, async ($, on) => { + const { state, clock } = await savingsRow($, on); + state.selectedModel = 'claude-sonnet-4-6'; + await $.turn.step({ + turnId: 'child-turn', index: 1, messageCount: 2, model: 'claude-haiku-4-5', agentId: 'background-child', + }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.main_model).toBe('claude-sonnet-4-6'); + expect(state.usage.user_switched).toBe(true); + expect(state.usage.entries.find((entry: any) => entry.agent === 'child').before_user_switch).toBe(true); + expect(state.usage.entries.find((entry: any) => entry.agent === 'background-child')).toEqual({ + agent: 'background-child', baseline: 'claude-sonnet-4-6', served: 'claude-haiku-4-5', + before_user_switch: false, + usage: { input_tokens: 1, output_tokens: 1, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 }, + }); +}); + +test('child steps retain a model switch while accounting is off', { options }, async ($, on) => { + const { state, clock } = await savingsRow($, on); + state.controls = { ENABLE_SMART_ROUTING_SAVINGS: '0' }; + state.selectedModel = 'claude-sonnet-4-6'; + await $.turn.step({ + turnId: 'off-turn', index: 0, messageCount: 1, model: 'claude-haiku-4-5', agentId: 'off-child', + }).next(); + state.controls = {}; + state.selectedModel = 'claude-opus-4-8'; + await $.turn.step({ + turnId: 'on-turn', index: 0, messageCount: 1, model: 'claude-sonnet-4-6', agentId: 'on-child', + }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.user_switched).toBe(true); + expect(state.usage.entries.some((entry: any) => entry.agent === 'off-child')).toBe(false); + expect(state.usage.entries.find((entry: any) => entry.agent === 'on-child').before_user_switch).toBe(false); +}); + +for (const agentId of [undefined, 'child-without-usage']) { + test(`missing ${agentId ? 'child' : 'main'} usage keeps the estimate hidden after later flushes`, { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on); + state.responseUsage = undefined; + await $.turn.step({ turnId: 'missing', index: 0, messageCount: 1, model: 'claude-sonnet-4-6', agentId }).next(); + await clock.advance(1); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.incomplete_usage).toBe(true); + state.responseUsage = { input_tokens: 1, output_tokens: 1 }; + await $.turn.step({ turnId: 'later', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.incomplete_usage).toBe(true); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + state.controls = { ENABLE_SMART_ROUTING_SAVINGS: '0' }; + await clock.advance(1000); + state.controls = {}; + await clock.advance(1000); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + }); +} + +test('an incomplete saved snapshot remains hidden after module initialization', { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on, true); + await $.turn.step({ turnId: 'later', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.incomplete_usage).toBe(true); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); +}); + +test('untracked missing usage does not invalidate an enabled estimate', { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on); + state.controls = { ENABLE_SMART_ROUTING_SAVINGS: '0' }; + state.responseUsage = undefined; + await $.turn.step({ turnId: 'off', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + state.controls = {}; + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.incomplete_usage === true).toBe(false); + expect(JSON.stringify(await row.drawn())).toContain('$0.18'); +}); + +test('an in-flight price result cannot restore an estimate after missing usage', { options }, async ($, on) => { + const { state, clock, row } = await savingsRow($, on); + let release!: () => void; + state.priceBarrier = new Promise(resolve => { release = resolve; }); + await $.turn.step({ turnId: 'priced', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.writes).toBe(2); + state.responseUsage = undefined; + await $.turn.step({ turnId: 'missing', index: 0, messageCount: 1, model: 'claude-opus-4-8' }).next(); + release(); + state.priceBarrier = null; + await clock.advance(1); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); + await $.turn.complete({ answer: 'done', isAborted: false }); + await clock.advance(1); + expect(state.usage.incomplete_usage).toBe(true); + expect(JSON.stringify(await row.drawn())).not.toContain('$0.18'); +}); diff --git a/tests/native_claude/test_mod.py b/tests/native_claude/test_mod.py index 9eed63936..3e7c31b5a 100644 --- a/tests/native_claude/test_mod.py +++ b/tests/native_claude/test_mod.py @@ -148,6 +148,7 @@ def test_savings_mod_records_the_start_model(native_binary, tmp_path): "first_main_model": None, "first_prompt_seen": False, "user_switched": False, + "incomplete_usage": False, "entries": [], } diff --git a/tests/test_smart_routing_pricing.py b/tests/test_smart_routing_pricing.py index 0f535b3d1..3781f6ea8 100644 --- a/tests/test_smart_routing_pricing.py +++ b/tests/test_smart_routing_pricing.py @@ -37,6 +37,8 @@ class TestModelKey: "system.ai.claude-opus-4-8[1m]", "databricks-claude-opus-4-8", "anthropic-aigw-1a2b3c4d-claude-opus-4-8", + "anthropic-aigw-1a2b3c4-claude-opus-4-8", + "anthropic-aigw-1A2B3C4-claude-opus-4-8[1m]", "SYSTEM.AI.Claude-Opus-4-8", "anthropic.claude-opus-4-8", "global.anthropic.claude-opus-4-8", @@ -47,8 +49,9 @@ class TestModelKey: def test_collapses_gateway_spellings(self, model): assert pricing.model_key(model) == "claude-opus-4-8" - def test_unwraps_non_claude_gateway_models(self): - assert pricing.model_key("anthropic-aigw-73ea02b2-system.ai.glm-5-2") == "glm-5-2" + @pytest.mark.parametrize("prefix", ["73ea02b", "73ea02b2"]) + def test_unwraps_non_claude_gateway_models(self, prefix): + assert pricing.model_key(f"anthropic-aigw-{prefix}-system.ai.glm-5-2") == "glm-5-2" @pytest.mark.parametrize( ("served", "requested"), diff --git a/tests/test_smart_routing_savings.py b/tests/test_smart_routing_savings.py index 255003b4f..dddcc47a1 100644 --- a/tests/test_smart_routing_savings.py +++ b/tests/test_smart_routing_savings.py @@ -224,6 +224,26 @@ def test_a_malformed_entry_voids_the_estimate(self, tmp_path, price_cache, bad): assert priced(write_usage(tmp_path, entries), price_cache) is None + @pytest.mark.parametrize("first_prompt", [False, True]) + def test_incomplete_usage_hides_previously_positive_totals( + self, tmp_path, price_cache, first_prompt + ): + usage = write_usage(tmp_path, [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]) + assert priced(usage, price_cache, first_prompt=first_prompt) == saved("$0.18", "60%") + document = json.loads(usage.read_text(encoding="utf-8")) + document["incomplete_usage"] = True + usage.write_text(json.dumps(document), encoding="utf-8") + + assert priced(usage, price_cache, first_prompt=first_prompt) is None + + def test_prices_a_seven_digit_gateway_alias(self, tmp_path, price_cache): + usage = write_usage( + tmp_path, + [entry("a1", OPUS_ID, "anthropic-aigw-1a2b3c4-claude-sonnet-5", SUBAGENT_USAGE)], + ) + + assert priced(usage, price_cache) == saved("$0.18", "60%") + def test_without_prices_there_is_no_estimate(self, tmp_path, price_cache): price_cache.unlink() entries = [entry("a1", OPUS_ID, SONNET_ID, SUBAGENT_USAGE)]