@intentic/sandbox-contract 1.147.0 → 1.149.0

package/src/schemas.ts

@@ -23,11 +23,11 @@ export const SessionTranscriptMessageSchema = z.object({ role: z.enum(["user", "
 export type SessionTranscriptMessage = z.infer<typeof SessionTranscriptMessageSchema>;
 
 // The agent runtimes the daemon can serve — the vocabulary every surface that picks an agent shares (chat
-// turns, automations). The three NATIVE providers have dedicated adapters (and their ids are reserved); any
+// turns, automations). The NATIVE providers have dedicated adapters (and their ids are reserved); any
 // other value is the id of an installed `agent`-kind capability served over ACP (Agent Client Protocol).
 // Kept as a bare string on the wire (not an enum) so an unknown id is a clean error frame from the agent
 // route — the same bet RepoParamSchema makes — and adding an ACP agent needs no contract change.
-export const NATIVE_PROVIDERS = ["claude", "codex", "grok", "kimi"] as const;
+export const NATIVE_PROVIDERS = ["claude", "codex", "grok", "kimi", "gemini"] as const;
 export type NativeProvider = (typeof NATIVE_PROVIDERS)[number];
 export const AgentProviderSchema = z.string().min(1);
 export type AgentProvider = z.infer<typeof AgentProviderSchema>;
@@ -54,6 +54,12 @@ export type EditorContext = z.infer<typeof EditorContextSchema>;
 // and filesystem paths — the regex is the injection guard. Shared by the turn input and the attach input.
 const ConversationIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/);
 
+// How tool calls are gated — the Claude Agent SDK's PermissionMode, narrowed to the four the composer offers
+// (the SDK also has 'dontAsk'/'auto', which have no UI here). The user picks one per turn AND the agent can
+// move itself between them mid-turn, so this is both a turn input and the payload of the `mode` frame.
+export const PermissionModeSchema = z.enum(["default", "acceptEdits", "plan", "bypassPermissions"]);
+export type PermissionMode = z.infer<typeof PermissionModeSchema>;
+
 export const AgentTurnSchema = z
     .object({
         prompt: z.string(),
@@ -89,8 +95,11 @@ export const AgentTurnSchema = z
         history: z.array(SessionTranscriptMessageSchema).max(200).optional(),
         // The browser sends the chosen model per turn; the provider token is the sandbox's own stored credential.
         model: z.string().optional(),
-        // When true, run the always-plan flow (propose → approve → execute). Reasoning controls are optional.
-        plan: z.boolean().optional(),
+        // How tool calls are gated for this turn (the SDK's permissionMode, verbatim). 'plan' runs the
+        // propose → approve → execute flow; 'default' prompts per tool on the permission side channel;
+        // 'acceptEdits' auto-accepts file edits; 'bypassPermissions' runs everything. The agent can move
+        // itself between modes mid-turn (EnterPlanMode/ExitPlanMode), which rides back as a `mode` frame.
+        permissionMode: PermissionModeSchema.optional(),
         effort: z.string().optional(),
         thinking: z.boolean().optional(),
         // The opt-in editor context chip: what the user is looking at, folded into the prompt daemon-side.
@@ -140,7 +149,12 @@ export const AgentActivitySchema = z.object({
 });
 export type AgentActivity = z.infer<typeof AgentActivitySchema>;
 // Which "needs you" flags are raised — the fleet badge aggregates these across all agents.
-export const AgentAttentionSchema = z.object({ plan: z.boolean(), question: z.boolean(), conflict: z.boolean() });
+export const AgentAttentionSchema = z.object({
+    plan: z.boolean(),
+    question: z.boolean(),
+    permission: z.boolean(),
+    conflict: z.boolean(),
+});
 export type AgentAttention = z.infer<typeof AgentAttentionSchema>;
 export const AgentSummarySchema = z.object({
     // The conversationId.
@@ -193,22 +207,49 @@ export type LandResult = z.infer<typeof LandResultSchema>;
 
 // The providers whose model can run UNDER the Claude Code harness through the bundled translator (CLIProxyAPI),
 // which holds their SUBSCRIPTION OAuth and re-serves it behind an Anthropic endpoint. The `claude` provider is
-// absent — native Anthropic OAuth serves it directly, without the translator.
-export const KeyedProviderSchema = z.enum(["codex", "grok"]);
+// absent — native Anthropic OAuth serves it directly, without the translator. Codex and Grok also have a native
+// runtime and so carry the harness axis; `gemini` is routed-only (Google publishes no Anthropic-protocol
+// endpoint and this sandbox bakes no Gemini runtime), so a Gemini turn is always a Claude Code turn.
+export const KeyedProviderSchema = z.enum(["codex", "grok", "gemini"]);
 export type KeyedProvider = z.infer<typeof KeyedProviderSchema>;
 
 // Which routed-provider subscriptions are connected in the translator (per provider). Drives the
 // "connected / connect subscription" state in Sandbox ▸ Agent.
-export const TranslatorAccountsSchema = z.object({ codex: z.boolean(), grok: z.boolean() });
+export const TranslatorAccountsSchema = z.object({ codex: z.boolean(), grok: z.boolean(), gemini: z.boolean() });
 export type TranslatorAccounts = z.infer<typeof TranslatorAccountsSchema>;
 
-// Side-channel bodies: the UI posts these to resolve a turn paused on a plan approval / question.
-export const DecisionSchema = z.object({ decisionId: z.string().min(1), approve: z.boolean(), feedback: z.string().optional() });
-export const AnswerSchema = z.object({
-    requestId: z.string().min(1),
-    answers: z.record(z.string(), z.array(z.string())).optional(),
-    cancelled: z.boolean().optional(),
-});
+// The side-channel body that un-parks a turn waiting on the user. Every interactive card — plan approval,
+// clarifying questions, a per-tool permission prompt — parks on the SAME registry keyed by `requestId`, so
+// one route resolves all three; the `kind` says which card answered and carries its payload.
+export const AgentReplySchema = z.discriminatedUnion("kind", [
+    // ExitPlanMode approval. `mode` is the posture to execute the approved plan in — Claude Code's "yes, and
+    // auto-accept edits" (acceptEdits) vs "yes, and manually approve edits" (default); it rides back to the SDK
+    // as a session setMode. Rejection feedback loops back into the model as the denial reason.
+    z.object({
+        kind: z.literal("plan"),
+        requestId: z.string().min(1),
+        approve: z.boolean(),
+        mode: PermissionModeSchema.optional(),
+        feedback: z.string().optional(),
+    }),
+    // AskUserQuestion picks: question text → chosen option label(s) (+ any free-text "Other"). `cancelled`
+    // is the dismissal, which tells the model to proceed on sensible defaults rather than leaving it parked.
+    z.object({
+        kind: z.literal("question"),
+        requestId: z.string().min(1),
+        answers: z.record(z.string(), z.array(z.string())).optional(),
+        cancelled: z.boolean().optional(),
+    }),
+    // A per-tool permission prompt. 'once' allows this call only; 'always' also persists the SDK's suggested
+    // rules so the same tool stops asking; 'deny' blocks it and feeds `feedback` back as the reason.
+    z.object({
+        kind: z.literal("permission"),
+        requestId: z.string().min(1),
+        decision: z.enum(["once", "always", "deny"]),
+        feedback: z.string().optional(),
+    }),
+]);
+export type AgentReply = z.infer<typeof AgentReplySchema>;
 // Steering: a user message delivered INTO the running turn (injected between tool calls, Claude Code style),
 // keyed by the conversation whose turn is in flight. NOT_FOUND when no steerable turn is running — the client
 // then falls back to a fresh send.
@@ -217,6 +258,26 @@ export const SteerSchema = z.object({ conversationId: z.string().min(1), text: z
 // /agent fetch (which sends no cancel frame).
 export const StopTurnSchema = z.object({ conversationId: z.string().min(1) });
 
+// ---- claude subscription usage ----
+// Which usage window is active for a Claude account, how much of it is spent, and when it resets. Two readers,
+// so it lives here rather than beside the stream frames: the SDK's rate_limit_event rides it out on the agent
+// stream (see the `rate_limit_info` frame in events.ts), and the daemon persists the latest snapshot per
+// account so `/claude/accounts` can answer "how much is left on each" without spending a turn to find out.
+export const RateLimitInfoSchema = z.object({
+    status: z.enum(["allowed", "allowed_warning", "rejected"]),
+    resetsAt: z.number().optional(), // epoch seconds
+    rateLimitType: z.string().optional(), // 'five_hour' | 'seven_day' | 'seven_day_opus' | ...
+    utilization: z.number().optional(), // 0-100, how much of the window is used
+});
+export type RateLimitInfo = z.infer<typeof RateLimitInfoSchema>;
+
+// The persisted view: a snapshot plus when it was taken. Within one window utilization only climbs, so a
+// snapshot stays a valid FLOOR until `resetsAt` passes — after that the window has rolled over and the store
+// drops it rather than reporting a stale number. `measuredAt` is epoch MS (matching connectedAt), while
+// `resetsAt` stays epoch SECONDS (matching the SDK frame) — they are deliberately different units.
+export const AccountUsageSchema = RateLimitInfoSchema.extend({ measuredAt: z.number() });
+export type AccountUsage = z.infer<typeof AccountUsageSchema>;
+
 // ---- provider oauth ----
 // Claude uses the PKCE authorize-URL + paste-back handshake (start → exchange). Codex uses OpenAI's device-code
 // flow (start → poll): the browser signs in at verificationUri and enters userCode; the daemon polls until done.
@@ -234,6 +295,10 @@ export const OauthAccountSchema = z.object({
     // Provider-agnostic; only Codex probes it today (Claude refreshes on-demand, Grok's tokens are OpenCode's).
     needsReauth: z.boolean().optional(),
     detail: z.string().optional(),
+    // The account's last known subscription-usage snapshot, so the picker can show what's left on each account
+    // before the user commits a turn to one. Claude-only (it is the sole provider whose stream reports a usage
+    // window) and absent until that account has run a turn — an unmeasured account reads as unknown, never 0%.
+    usage: AccountUsageSchema.optional(),
 });
 export type OauthAccount = z.infer<typeof OauthAccountSchema>;
 export const OauthAccountListSchema = z.object({ accounts: z.array(OauthAccountSchema) });
@@ -259,16 +324,48 @@ export const KimiConnectSchema = z.object({ apiKey: z.string().min(1), label: z.
 // completion and the UI polls `/grok/accounts`.
 // ponytail: OpenCode holds one xAI auth per data dir, so Grok stays single-account — the list is 0 or 1. Per
 // account would need an OpenCode server per data dir; add when there's demand.
-// A device-code login start: the verification URL + the one-time code the user enters there. Shared by the
-// native Grok flow (via OpenCode) and the routed-provider subscription connect (codex/grok via CLIProxyAPI).
+// A device-code login start: the verification URL + the one-time code the user enters there. The native Grok
+// flow (via OpenCode) — see TranslatorStartSchema for the routed-provider connect, which adds `state`.
 export const DeviceStartSchema = z.object({ url: z.string(), code: z.string() });
+// A routed-provider subscription login start (codex/grok/gemini via CLIProxyAPI). Codex and Grok mint a
+// one-time device `code` the user enters at the provider's site, and CLIProxyAPI polls to completion on its
+// own — the card only waits. Google publishes no device flow: the user approves in a browser and is redirected
+// to a loopback URL this sandbox never receives, so `code` is empty and the card asks them to paste that URL
+// back (see TranslatorCompleteSchema). Which half a provider uses is READ from the response rather than
+// hardcoded per provider, so the card needs no provider table.
+export const TranslatorStartSchema = z.object({ url: z.string(), code: z.string(), state: z.string() });
+// The paste-back half of a redirect login: the URL the provider sent the browser to, carrying the grant as
+// ?code=&state=. `state` ties it to the handshake that issued it — the translator rejects a mismatch.
+export const TranslatorCompleteSchema = z.object({
+    provider: KeyedProviderSchema,
+    redirectUrl: z.string().min(1),
+    state: z.string().min(1),
+});
 // A provider's model catalog, resolved daemon-side from live discovery with a persisted last-known-good list and
 // a seed floor (Grok via opencode.ts xaiModels, Codex via codex-models.ts, Claude via the Agent SDK's
 // supportedModels) — never empty, so the picker is never blank. `label` is the humanized display name; `default`
 // is the model a fresh chat on that provider seeds (always present). Shared by /grok/models, /codex/models,
 // /claude/models. `efforts` is the reasoning-effort tiers the model accepts (Claude reports them per model);
 // empty ⇒ the client's default tiers.
-export const ModelSchema = z.object({ id: z.string(), label: z.string(), efforts: z.array(z.string()).optional() });
+//
+// EVERY field here is provider-reported — nothing about a model is curated in this repo, so a new release or a
+// renamed family flows to the UI with no code change. Providers differ in how much they publish: the Claude
+// Agent SDK reports a display name, a capability description, effort tiers, and capability flags, while the
+// OpenAI-compatible /v1/models endpoints (codex/grok/kimi) report ids only — those rows render label-only, and
+// that absence is the honest answer rather than something to paper over with a hand-written table.
+//
+// ORDER IS MEANINGFUL: `models` arrives in the provider's own preference order, which is what the picker sorts
+// by, and `default` is the provider's own default. Neither is re-ranked locally.
+export const ModelBadgeSchema = z.enum(["reasoning", "fast"]);
+export type ModelBadge = z.infer<typeof ModelBadgeSchema>;
+export const ModelSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    efforts: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    badges: z.array(ModelBadgeSchema).optional(),
+});
+export type Model = z.infer<typeof ModelSchema>;
 export const ModelsSchema = z.object({ models: z.array(ModelSchema), default: z.string() });
 
 // ---- sessions ----
@@ -375,9 +472,14 @@ export const RepoChangesSchema = z.object({
     // Absent on an unborn HEAD (a repo initialized but never committed).
     branch: z.string().optional(),
     changes: z.array(GitChangeSchema),
+    // Why the repo could not be scanned at all, condensed to git's own one-line reason ("fatal: bad object HEAD").
+    // A repo left torn by a canceled or failed upload used to be dropped from the response entirely, so it just
+    // vanished from the panel with nothing to act on; it now arrives with empty `changes` and this set instead.
+    error: z.string().optional(),
 });
 export type RepoChanges = z.infer<typeof RepoChangesSchema>;
-// The aggregated review set across every repo (root + every discovered repo); only repos with changes appear.
+// The aggregated review set across every repo (root + every discovered repo); a repo appears when it has changes
+// or when it failed to scan.
 export const GitChangesSchema = z.object({ repos: z.array(RepoChangesSchema) });
 export type GitChanges = z.infer<typeof GitChangesSchema>;
 

package/dist/model-metadata.d.ts

@@ -1,8 +0,0 @@
-export type ModelBadge = "reasoning" | "vision" | "fast" | "agentic";
-export interface ModelMetadata {
-    readonly description?: string;
-    readonly badges?: readonly ModelBadge[];
-    readonly rank?: number;
-}
-export declare const modelMetadataFor: (id: string) => ModelMetadata | undefined;
-//# sourceMappingURL=model-metadata.d.ts.map

package/dist/model-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-metadata.d.ts","sourceRoot":"","sources":["../src/model-metadata.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAErE,MAAM,WAAW,aAAa;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAIxC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CAC1B;AA0BD,eAAO,MAAM,gBAAgB,OAAQ,MAAM,KAAG,aAAa,GAAG,SAG7D,CAAC"}

package/dist/model-metadata.js

@@ -1,24 +0,0 @@
-const FLAGSHIP = 90;
-const BALANCED = 80;
-const CODING = 65;
-const FAST = 50;
-const RULES = [
-    { pattern: /opus/, metadata: { description: `Deepest reasoning, most capable Claude`, badges: [`reasoning`, `vision`], rank: FLAGSHIP } },
-    { pattern: /sonnet/, metadata: { description: `Balanced Claude for everyday coding`, badges: [`reasoning`, `vision`], rank: BALANCED } },
-    { pattern: /haiku/, metadata: { description: `Fastest Claude, light tasks`, badges: [`fast`, `vision`], rank: FAST } },
-    { pattern: /codex.*(mini|nano)|(mini|nano).*codex/, metadata: { description: `Smaller, faster Codex`, badges: [`agentic`, `fast`], rank: FAST } },
-    { pattern: /codex/, metadata: { description: `OpenAI's agentic coding model`, badges: [`agentic`, `reasoning`], rank: CODING } },
-    { pattern: /gpt.*(mini|nano)/, metadata: { description: `Small, fast OpenAI model`, badges: [`fast`], rank: FAST } },
-    { pattern: /gpt/, metadata: { description: `OpenAI flagship, general reasoning`, badges: [`reasoning`, `vision`], rank: FLAGSHIP } },
-    { pattern: /grok.*(fast|mini)/, metadata: { description: `Speed-first Grok`, badges: [`fast`], rank: FAST } },
-    { pattern: /grok.*code/, metadata: { description: `xAI's coding model`, badges: [`agentic`, `fast`], rank: CODING } },
-    { pattern: /grok/, metadata: { description: `xAI frontier model`, badges: [`reasoning`], rank: FLAGSHIP } },
-    { pattern: /kimi.*(turbo|flash|fast)|k2.*(turbo|flash|fast)/, metadata: { description: `Speed-first Kimi`, badges: [`fast`], rank: FAST } },
-    { pattern: /kimi|k2/, metadata: { description: `Moonshot's frontier model`, badges: [`reasoning`, `agentic`], rank: FLAGSHIP } },
-    { pattern: /fast|mini|nano|lite|flash/, metadata: { badges: [`fast`], rank: FAST } },
-];
-export const modelMetadataFor = (id) => {
-    const normalized = id.toLowerCase();
-    return RULES.find((rule) => rule.pattern.test(normalized))?.metadata;
-};
-//# sourceMappingURL=model-metadata.js.map

package/dist/model-metadata.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-metadata.js","sourceRoot":"","sources":["../src/model-metadata.ts"],"names":[],"mappings":"AAmBA,MAAM,QAAQ,GAAG,EAAE,CAAC;AACpB,MAAM,QAAQ,GAAG,EAAE,CAAC;AACpB,MAAM,MAAM,GAAG,EAAE,CAAC;AAClB,MAAM,IAAI,GAAG,EAAE,CAAC;AAEhB,MAAM,KAAK,GAA4D;IACnE,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,wCAAwC,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACzI,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,qCAAqC,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACxI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IACtH,EAAE,OAAO,EAAE,uCAAuC,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IACjJ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,+BAA+B,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAChI,EAAE,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IACpH,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,oCAAoC,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IACpI,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAC7G,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IACrH,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IAC3G,EAAE,OAAO,EAAE,iDAAiD,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAC3I,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,2BAA2B,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;IAChI,EAAE,OAAO,EAAE,2BAA2B,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;CACvF,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,EAAU,EAA6B,EAAE;IACtE,MAAM,UAAU,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC;IACpC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC;AACzE,CAAC,CAAC"}

package/src/model-metadata.ts

@@ -1,44 +0,0 @@
-/* Curated presentation metadata for the model picker. The daemons discover models live and report only
- * `{ id, label, efforts? }` (ModelSchema), so descriptions and capability badges are curated here by id
- * pattern — first match wins, ordered specific → generic. An unmatched id simply renders label-only, so a
- * brand-new release degrades gracefully until a rule is added. */
-
-export type ModelBadge = "reasoning" | "vision" | "fast" | "agentic";
-
-export interface ModelMetadata {
-    readonly description?: string;
-    readonly badges?: readonly ModelBadge[];
-    // Relative capability, strongest-first — the picker sorts each provider's models by this (a version number
-    // breaks ties, so within a tier the newest generation leads). Only ever compared WITHIN one provider, so the
-    // scale is coarse: FLAGSHIP (deepest) > BALANCED (everyday) > CODING (specialized) > FAST (light/small).
-    readonly rank?: number;
-}
-
-// The coarse capability tiers `rank` draws from. Compared only within a provider, so absolute values are
-// arbitrary — only the ordering FLAGSHIP > BALANCED > CODING > FAST matters. An id matching no rule below
-// renders rankless and the picker floors it just under BALANCED (a new flagship surfaces rather than sinks).
-const FLAGSHIP = 90;
-const BALANCED = 80;
-const CODING = 65;
-const FAST = 50;
-
-const RULES: readonly { pattern: RegExp; metadata: ModelMetadata }[] = [
-    { pattern: /opus/, metadata: { description: `Deepest reasoning, most capable Claude`, badges: [`reasoning`, `vision`], rank: FLAGSHIP } },
-    { pattern: /sonnet/, metadata: { description: `Balanced Claude for everyday coding`, badges: [`reasoning`, `vision`], rank: BALANCED } },
-    { pattern: /haiku/, metadata: { description: `Fastest Claude, light tasks`, badges: [`fast`, `vision`], rank: FAST } },
-    { pattern: /codex.*(mini|nano)|(mini|nano).*codex/, metadata: { description: `Smaller, faster Codex`, badges: [`agentic`, `fast`], rank: FAST } },
-    { pattern: /codex/, metadata: { description: `OpenAI's agentic coding model`, badges: [`agentic`, `reasoning`], rank: CODING } },
-    { pattern: /gpt.*(mini|nano)/, metadata: { description: `Small, fast OpenAI model`, badges: [`fast`], rank: FAST } },
-    { pattern: /gpt/, metadata: { description: `OpenAI flagship, general reasoning`, badges: [`reasoning`, `vision`], rank: FLAGSHIP } },
-    { pattern: /grok.*(fast|mini)/, metadata: { description: `Speed-first Grok`, badges: [`fast`], rank: FAST } },
-    { pattern: /grok.*code/, metadata: { description: `xAI's coding model`, badges: [`agentic`, `fast`], rank: CODING } },
-    { pattern: /grok/, metadata: { description: `xAI frontier model`, badges: [`reasoning`], rank: FLAGSHIP } },
-    { pattern: /kimi.*(turbo|flash|fast)|k2.*(turbo|flash|fast)/, metadata: { description: `Speed-first Kimi`, badges: [`fast`], rank: FAST } },
-    { pattern: /kimi|k2/, metadata: { description: `Moonshot's frontier model`, badges: [`reasoning`, `agentic`], rank: FLAGSHIP } },
-    { pattern: /fast|mini|nano|lite|flash/, metadata: { badges: [`fast`], rank: FAST } },
-];
-
-export const modelMetadataFor = (id: string): ModelMetadata | undefined => {
-    const normalized = id.toLowerCase();
-    return RULES.find((rule) => rule.pattern.test(normalized))?.metadata;
-};