feat(app): simplify composer model labels (#59735)

This commit is contained in:
usrnk1
2026-10-28 11:45:56 +01:00
committed by GitHub
Unverified
parent d6867f2210
commit 950111ff2a
10 changed files with 453 additions and 77 deletions
+113 -26
View File
@@ -282,7 +282,7 @@ test("a catalog refresh cannot replace an existing session's model", async ({ pa
})
const control = page.locator('[data-action="composer-model"]')
await expect(control).toHaveText("OpenCode / Alpha")
await expect(control).toHaveText("Alpha")
await view.editor.fill("Keep my selected model")
catalog.current = provider(beta)
@@ -295,7 +295,7 @@ test("a catalog refresh cannot replace an existing session's model", async ({ pa
data: {},
},
])
await expect(control).toHaveText("OpenCode / alpha (unavailable)")
await expect(control).toHaveText("alpha (unavailable)")
await view.editor.press("Enter")
await expect(page.getByText("Select an agent and model", { exact: true })).toBeVisible()
await expect(view.editor).toHaveText("Keep my selected model")
@@ -312,7 +312,7 @@ test("a catalog refresh cannot replace an existing session's model", async ({ pa
data: {},
},
])
await expect(control).toHaveText("OpenCode / Alpha")
await expect(control).toHaveText("Alpha")
await expect(page.getByRole("button", { name: "Choose model variant", exact: true })).toHaveText("high")
await view.editor.press("Enter")
await expect.poll(() => prompts.length).toBe(1)
@@ -329,13 +329,13 @@ test("a catalog refresh cannot replace an existing session's model", async ({ pa
data: {},
},
])
await expect(control).toHaveText("OpenCode / alpha (unavailable)")
await expect(control).toHaveText("alpha (unavailable)")
await control.click()
await page
.getByRole("dialog", { name: "Select model" })
.getByRole("button", { name: "Beta Free", exact: true })
.click()
await expect(control).toHaveText("OpenCode / Beta")
await expect(control).toHaveText("Beta")
await view.editor.fill("Use the replacement I chose")
await view.editor.press("Enter")
await expect.poll(() => prompts.length).toBe(2)
@@ -387,8 +387,8 @@ test("an existing session's model never shows a fallback while its agent loads",
const agentLoaded = page.waitForResponse((response) => new URL(response.url()).pathname === "/api/agent")
agents.resolve()
await agentLoaded
await expect(control).toHaveText("OpenCode / Alpha")
expect(await page.evaluate(() => [...(window.__chipTexts ?? [])])).toEqual(["OpenCode / Alpha"])
await expect(control).toHaveText("Alpha")
expect(await page.evaluate(() => [...(window.__chipTexts ?? [])])).toEqual(["Alpha"])
})
test("a send pressed while the Location's plugins activate waits, Esc cancels it, and it sends once catalogs load", async ({
@@ -459,7 +459,7 @@ test("an opened session in another Location names its model from a loaded catalo
const control = page.locator('[data-action="composer-model"]')
await page.goto(sessionHref("ses_warm_here"))
await expect(control).toHaveText("OpenCode / Alpha")
await expect(control).toHaveText("Alpha")
const held = await holdRoute(
page,
@@ -470,7 +470,7 @@ test("an opened session in another Location names its model from a loaded catalo
try {
await page.locator(`[data-slot="vertical-tabs"] a[href="${sessionHref("ses_warm_there", SERVER)}"]`).click()
await held.arrived
await expect(control).toHaveText("OpenCode / Beta")
await expect(control).toHaveText("Beta")
await expect(page.getByRole("button", { name: "Choose model variant" })).toHaveText("high")
const painted = await control.elementHandle()
@@ -488,7 +488,7 @@ test("an opened session in another Location names its model from a loaded catalo
await Promise.all(loaded)
await expect(page.getByRole("dialog")).toBeVisible()
// The loaded selection keeps the same chip instead of replacing it.
await expect(control).toHaveText("OpenCode / Beta")
await expect(control).toHaveText("Beta")
expect(await painted?.evaluate((element) => element.isConnected)).toBe(true)
} finally {
held.release()
@@ -501,33 +501,120 @@ declare global {
}
}
test("names a Console-managed provider without its workspace unless a direct connection shares it", async ({
test("a managed composer label follows direct connections, not picker filtering or model identity", async ({
page,
}) => {
const sessions = [
{ id: "ses_managed_root", model: { id: "alpha", providerID: "opencode" } },
{ id: "ses_managed_openai", model: { id: "gpt", providerID: "console-openai" } },
]
const sessionID = "ses_managed_provider"
const connected = { direct: false }
const switches: unknown[] = []
const prompts: Parameters<NonNullable<MockServerConfig["onPrompt"]>>[0]["body"][] = []
page.on("request", (request) => {
if (request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/model`)
switches.push(request.postDataJSON())
})
const managed = { integrationID: "opencode" }
await openSession(page, {
const view = await openSession(page, {
name: "ManagedProvider",
sessions: sessions.map((session) => ({ ...session, agent: "build" })),
provider: {
sessions: [{ id: sessionID, agent: "build", model: { id: "gpt", providerID: "console-openai" } }],
provider: () => ({
all: [
{ ...managed, id: "opencode", name: "Anomaly / OpenCode", models: { alpha: { id: "alpha", name: "Alpha" } } },
{ ...managed, id: "console-openai", name: "Anomaly / OpenAI", models: { gpt: { id: "gpt", name: "GPT" } } },
{ id: "openai", name: "OpenAI", models: { gpt: { id: "gpt", name: "GPT" } } },
{
id: "opencode",
integrationID: "opencode",
name: "Anomaly / OpenCode",
models: {},
},
{
id: "console-openai",
canonical: "openai",
integrationID: "opencode",
name: "Anomaly / OpenAI",
models: { gpt: { id: "gpt", name: "GPT" } },
},
...(connected.direct
? [
{
id: "openai",
name: "OpenAI",
models: { "direct-model": { id: "direct-model", name: "Direct Model" } },
},
]
: []),
],
connected: ["opencode", "console-openai", "openai"],
connected: ["opencode", "console-openai", ...(connected.direct ? ["openai"] : [])],
default: {},
}),
onPrompt: (input) => void prompts.push(input.body),
seed: {
storage: {
"opencode.global.dat:model": {
user: [
{ providerID: "console-openai", modelID: "gpt", visibility: "show" },
{ providerID: "openai", modelID: "direct-model", visibility: "show" },
],
},
},
},
})
const control = page.locator('[data-action="composer-model"]')
await expect(control).toHaveText("OpenCode / Alpha")
await page.goto(sessionHref(sessions[1]!.id))
await expect(control).toHaveText("Anomaly / OpenAI / GPT")
const picker = page.getByRole("dialog", { name: "Select model", exact: true })
const selected = picker.locator('[data-option-key="console-openai:gpt"]')
await expect(control).toHaveText("OpenAI / GPT")
connected.direct = true
await view.push([
{
id: "evt_direct_connected",
created: T0 + 1,
type: "provider.updated",
location: { directory: view.directory },
data: {},
},
{
id: "evt_direct_models_connected",
created: T0 + 2,
type: "model.updated",
location: { directory: view.directory },
data: {},
},
])
await expect(control).toHaveText("OpenCode / OpenAI / GPT")
await expect(control).toHaveAccessibleName("OpenCode / OpenAI / GPT")
await control.click()
const search = picker.getByRole("combobox", { name: "Search models", exact: true })
await expect(picker.locator('[data-option-key="openai:direct-model"]')).toBeVisible()
await search.fill("GPT")
await expect(picker.locator('[data-option-key="openai:direct-model"]')).toHaveCount(0)
await expect(selected).toHaveAttribute("aria-current", "true")
await expect(control).toHaveText("OpenCode / OpenAI / GPT")
await search.press("Escape")
await expect(picker).toBeHidden()
connected.direct = false
await view.push([
{
id: "evt_direct_disconnected",
created: T0 + 3,
type: "provider.updated",
location: { directory: view.directory },
data: {},
},
{
id: "evt_direct_models_disconnected",
created: T0 + 4,
type: "model.updated",
location: { directory: view.directory },
data: {},
},
])
await expect(control).toHaveText("OpenAI / GPT")
await view.editor.fill("Keep the managed provider selected")
await view.editor.press("Enter")
await expect.poll(() => prompts.length).toBe(1)
expect(prompts[0]).toMatchObject({ text: "Keep the managed provider selected" })
expect(switches).toEqual([])
})
async function draft(page: Page) {
@@ -35,7 +35,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(variant).toBeFocused()
const model = composer.locator('[data-action="composer-model"]')
await expect(model).toHaveText("OpenCode / Mobile Model A")
await expect(model).toHaveText("Mobile Model A")
await expect(model).toHaveAttribute("data-control-type", "drawer")
await model.click()
const models = page.getByRole("dialog", { name: "Select model", exact: true })
@@ -88,7 +88,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(models.getByRole("button", { name: /Mobile Model A/ })).toHaveCount(0)
await search.press("Enter")
await expect(models).toBeHidden()
await expect(model).toHaveText("OpenCode / Mobile Model B")
await expect(model).toHaveText("Mobile Model B")
await expect(composer.getByRole("textbox", { name: "Prompt", exact: true })).toBeFocused()
await model.click()
@@ -133,7 +133,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(page.getByRole("menu")).toHaveCount(0)
await dialog.locator('[data-option-key="opencode:mobile-b"]').click()
await expect(dialog).toBeHidden()
await expect(model).toHaveText("OpenCode / Mobile Model B")
await expect(model).toHaveText("Mobile Model B")
await expect(page.locator('[data-slot="mobile-drawer-content"]')).toHaveCount(0)
await expect(composer.getByRole("textbox", { name: "Prompt", exact: true })).toBeFocused()
})
@@ -152,7 +152,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(flyout.getByText("Text, Image, PDF, Tools", { exact: true })).toBeVisible()
await flyout.getByRole("menuitemradio", { name: "max", exact: true }).click()
await expect(dialog).toBeHidden()
await expect(model).toHaveText("OpenCode / Mobile Model B")
await expect(model).toHaveText("Mobile Model B")
await expect(variant).toHaveText("max")
})
@@ -180,7 +180,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(rowA).toContainText("high")
await search.press("Enter")
await expect(dialog).toBeHidden()
await expect(model).toHaveText("OpenCode / Mobile Model A")
await expect(model).toHaveText("Mobile Model A")
await expect(variant).toHaveText("high")
await expect(composer.getByRole("textbox", { name: "Prompt", exact: true })).toBeFocused()
})
@@ -196,7 +196,7 @@ for (const direction of ["ltr", "rtl"] as const) {
await expect(dialog.locator('[data-option-key="opencode:mobile-a"]')).toContainText("high")
await search.press("Enter")
await expect(dialog).toBeHidden()
await expect(model).toHaveText("OpenCode / Mobile Model A")
await expect(model).toHaveText("Mobile Model A")
await expect(variant).toHaveText("high")
await expect(prompt).toBeFocused()
await expect(prompt).toHaveText("keep me")
@@ -235,7 +235,7 @@ test("model dialog toggles a favorite from the keyboard and leads with favorite
await expect(sections).toHaveText(["Favorites", "OpenCode"])
await expect(dialog.locator('[data-option-key="favorite:opencode:mobile-c"]')).toBeVisible()
await dialog.locator('[data-option-key="opencode:mobile-b"]').click()
await expect(model).toHaveText("OpenCode / Mobile Model B")
await expect(model).toHaveText("Mobile Model B")
await model.click()
await expect(sections).toHaveText(["Favorites", "Recent", "OpenCode"])
@@ -262,7 +262,7 @@ test("model dialog opens Manage models from its search row with Enter", async ({
await manage.focus()
await manage.press("Enter")
await expect(page.getByRole("dialog", { name: "Manage models", exact: true })).toBeVisible()
await expect(model).toHaveText("OpenCode / Mobile Model A")
await expect(model).toHaveText("Mobile Model A")
})
test.describe("touch composer pickers", () => {
@@ -926,7 +926,7 @@ for (const row of [
expect((await listed).ok()).toBe(true)
const composer = page.locator('[data-component="composer"]')
const send = composer.getByRole("button", { name: "Send", exact: true })
await expect(composer.locator('[data-action="composer-model"]')).toHaveText("OpenCode / Accent Model")
await expect(composer.locator('[data-action="composer-model"]')).toHaveText("Accent Model")
await view.editor.fill("Inspect this fixture workspace.")
await expect(send).toBeEnabled()
await expectBackground(send, "icon-button-contrast")
@@ -140,7 +140,7 @@ test("restores each existing session's model and variant when switching tabs", a
const composer = page.locator('[data-component="composer"]')
const modelControl = composer.locator('[data-action="composer-model"]')
const variant = composer.getByRole("button", { name: "Choose model variant", exact: true })
await expect(modelControl).toHaveText("OpenCode / Model A")
await expect(modelControl).toHaveText("Model A")
await expect(variant).toHaveText("balanced")
await variant.click()
await page.getByRole("menuitemradio", { name: "high", exact: true }).click()
@@ -148,7 +148,7 @@ test("restores each existing session's model and variant when switching tabs", a
await page.locator(`[data-titlebar-tab-link][href="${hrefB}"]`).click()
await expect(page).toHaveURL(hrefB)
await expect(modelControl).toHaveText("OpenCode / Model B")
await expect(modelControl).toHaveText("Model B")
await expect(variant).toHaveText("balanced")
await variant.click()
await page.getByRole("menuitemradio", { name: "high", exact: true }).click()
@@ -157,11 +157,11 @@ test("restores each existing session's model and variant when switching tabs", a
// A new draft starts from the current session's non-default model and chosen variant.
await page.getByRole("button", { name: "New session", exact: true }).click()
await expect(page).toHaveURL(/\/new-session\?draftId=/)
await expect(modelControl).toHaveText("OpenCode / Model B")
await expect(modelControl).toHaveText("Model B")
await expect(variant).toHaveText("high")
await page.locator(`[data-titlebar-tab-link][href="${hrefA}"]`).click()
await expect(page).toHaveURL(hrefA)
await expect(modelControl).toHaveText("OpenCode / Model A")
await expect(modelControl).toHaveText("Model A")
await expect(variant).toHaveText("high")
})
+3 -1
View File
@@ -6,6 +6,7 @@ import type { ServerSDK } from "@/runtime/server/client"
import type { SessionMessageHandoff } from "@/session/handoff"
import type { ComposerStateTarget } from "./submission-state"
import type { createComposerSubmission } from "./submission-state"
import type { ComposerModelLabel } from "./model-label"
export type ComposerControls = {
agents: {
@@ -18,10 +19,11 @@ export type ComposerControls = {
model: {
selection: ModelSelection
providerName?: string
label?: ComposerModelLabel
paid: boolean
loading: boolean
/** While loading, the expected model's names from a catalog already loaded for another Location. */
preview?: { provider?: string; model: string; variant: string; variants: string[] }
preview?: { provider?: string; model: string; label?: ComposerModelLabel; variant: string; variants: string[] }
}
}
+15 -7
View File
@@ -15,6 +15,7 @@ import { DialogSelectModelUnpaid } from "@/providers/models/unpaid"
import { formatKeybind, useCommand } from "@/shell/commands/command"
import { useLanguage } from "@/runtime/i18n/language"
import type { ComposerModel } from "./model"
import type { ComposerModelLabel } from "./model-label"
export function Composer(props: {
class?: string
@@ -42,6 +43,15 @@ export function Composer(props: {
return language.t("dialog.model.select.title")
}
const modelLabel = () => {
const preview = props.model.model.preview
const label = preview ? preview.label : props.model.model.label
if (label) return label
return { provider: preview ? preview.provider : props.model.model.providerName, model: modelName() }
}
return (
<div class="flex flex-col gap-3">
<ComposerEditor
@@ -63,8 +73,7 @@ export function Composer(props: {
title={language.t("command.model.choose")}
keybind={command.keybindParts("model.choose")}
model={props.model.model.selection}
providerName={props.model.model.preview?.provider ?? props.model.model.providerName}
modelName={modelName()}
label={modelLabel()}
onClose={props.model.restoreFocus}
onUnpaidClick={() => dialog.show(() => <DialogSelectModelUnpaid model={props.model.model.selection} />)}
/>
@@ -81,8 +90,7 @@ function ComposerModelControl(props: {
title: string
keybind: string[]
model: ComposerModel["model"]["selection"]
providerName?: string
modelName: string
label: ComposerModelLabel
onClose: () => void
onUnpaidClick: () => void
}) {
@@ -114,16 +122,16 @@ function ComposerModelControl(props: {
const content = () => (
<>
<span class="flex min-w-0 whitespace-nowrap leading-4">
<Show when={props.providerName}>
<Show when={props.label.provider}>
{(name) => (
<>
<span class="shrink-0 text-v2-text-text-faint">{name()}</span>
<bdi class="min-w-0 shrink-[2] truncate text-v2-text-text-faint">{name()}</bdi>
<Slash />
<span class="sr-only">{" / "}</span>
</>
)}
</Show>
<span class="truncate">{props.modelName}</span>
<bdi class="min-w-0 truncate">{props.label.model}</bdi>
</span>
<span class="-ml-0.5 -mr-1 flex shrink-0">
<Icon name="chevron-down" />
@@ -0,0 +1,151 @@
import { expect, test } from "bun:test"
import { composerModelLabelKey, composerModelLabels, composerProviderName } from "./model-label"
function provider(
id: string,
name: string,
options: { canonical?: string; integrationID?: string; models?: readonly (readonly [string, string])[] } = {},
) {
return {
id,
name,
canonical: options.canonical,
integrationID: options.integrationID,
models: Object.fromEntries((options.models ?? [["m", "Model"]]).map(([id, name]) => [id, { id, name }])),
}
}
function catalog(...providers: ReturnType<typeof provider>[]) {
return new Map(providers.map((provider) => [provider.id, provider]))
}
function label(labels: ReturnType<typeof composerModelLabels>, providerID: string, modelID: string) {
return labels.get(composerModelLabelKey(providerID, modelID))
}
const root = provider("opencode", "Anomaly / OpenCode", { integrationID: "opencode", models: [] })
const managed = provider("console-openai", "Anomaly / OpenAI", { integrationID: "opencode", canonical: "openai" })
test.each([
provider("opencode", "Anomaly / OpenCode", { integrationID: "opencode" }),
provider("opencode", "OpenCode"),
])("omits native provider $name", (native) => {
const all = catalog(native)
expect(composerProviderName("opencode", all)).toBeUndefined()
expect(label(composerModelLabels(all), "opencode", "m")).toEqual({ provider: undefined, model: "Model" })
})
test.each([
{ direct: provider("openai", "Renamed", { models: [] }), connected: [], expected: "OpenAI" },
{ direct: provider("openai", "Renamed", { models: [] }), connected: ["openai"], expected: "OpenCode / OpenAI" },
{
direct: provider("account", "Owls", { integrationID: "openai", models: [] }),
connected: ["account"],
expected: "OpenCode / OpenAI",
},
{
direct: provider("proxy", "OpenAI", { canonical: "openai", models: [] }),
connected: ["proxy"],
expected: "OpenAI",
},
{ direct: provider("azure", "Azure", { canonical: "openai" }), connected: ["azure"], expected: "OpenAI" },
])("matches connected stable identities, not names or canonical proxies: $direct.id / $connected", (row) => {
const all = catalog(root, managed, row.direct)
expect(composerProviderName(managed.id, all, [managed.id, ...row.connected])).toBe(row.expected)
expect(label(composerModelLabels(all, [managed.id, ...row.connected]), managed.id, "m")).toEqual({
provider: row.expected,
model: "Model",
})
})
test("only connected providers get labels", () => {
const labels = composerModelLabels(catalog(root, managed, provider("openai", "OpenAI")), [managed.id])
expect(label(labels, managed.id, "m")).toEqual({ provider: "OpenAI", model: "Model" })
expect(label(labels, "openai", "m")).toBeUndefined()
})
test("unknown managed routes do not infer identity from console prefixes or display names", () => {
const all = catalog(
root,
provider("console-openai", "Anomaly / OpenAI", { integrationID: "opencode" }),
provider("openai", "OpenAI"),
)
expect(composerProviderName("console-openai", all)).toBe("OpenAI")
expect(label(composerModelLabels(all), "console-openai", "m")).toEqual({ provider: "console-openai", model: "Model" })
})
test("duplicate provider labels use raw IDs only for overlapping model labels", () => {
const labels = composerModelLabels(
catalog(
provider("a", "OpenAI", {
models: [
["m", "Model"],
["other", "Other"],
],
}),
provider("b", "OpenAI"),
),
)
expect(label(labels, "a", "m")).toEqual({ provider: "a", model: "Model" })
expect(label(labels, "b", "m")).toEqual({ provider: "b", model: "Model" })
expect(label(labels, "a", "other")).toEqual({ provider: "OpenAI", model: "Other" })
})
test.each([
{ ids: ["gemini-4-argon", "gemini-4-argon-eap"], expected: ["Gemini", "Gemini (eap)"] },
{ ids: ["v1", "v2"], expected: ["Gemini (v1)", "Gemini (v2)"] },
{
ids: ["accounts/fireworks/models/glm", "accounts/fireworks/routers/glm-spot"],
expected: ["Gemini (models/glm)", "Gemini (routers/glm-spot)"],
},
])("same-route duplicate model names show only where their IDs differ: $ids", (row) => {
const labels = composerModelLabels(
catalog(provider("google", "Google", { models: row.ids.map((id) => [id, "Gemini"] as const) })),
)
expect(row.ids.map((id) => label(labels, "google", id)?.model)).toEqual([...row.expected])
})
test("a peer group with provider and model duplicates needs both qualifiers", () => {
const labels = composerModelLabels(
catalog(
provider("a", "OpenAI", {
models: [
["v1", "GPT"],
["v2", "GPT"],
],
}),
provider("b", "OpenAI", { models: [["m", "GPT"]] }),
),
)
expect(label(labels, "a", "v1")).toEqual({ provider: "a", model: "GPT (v1)" })
expect(label(labels, "a", "v2")).toEqual({ provider: "a", model: "GPT (v2)" })
expect(label(labels, "b", "m")).toEqual({ provider: "b", model: "GPT" })
})
test("drops the (latest) marker and keeps provider names verbatim", () => {
const all = catalog(provider("custom", " Custom / Proxy ", { models: [["m", "GPT (latest)"]] }))
expect(label(composerModelLabels(all), "custom", "m")).toEqual({ provider: " Custom / Proxy ", model: "GPT" })
})
test("tuple keys keep slash-containing provider and model identities separate", () => {
const labels = composerModelLabels(
catalog(
provider("company", "Company", { models: [["openai/gpt", "First model"]] }),
provider("company/openai", "Other", { models: [["gpt", "Second model"]] }),
),
)
expect(composerModelLabelKey("company", "openai/gpt")).toBe('["company","openai/gpt"]')
expect(labels.size).toBe(2)
expect(label(labels, "company", "openai/gpt")).toEqual({ provider: "Company", model: "First model" })
expect(label(labels, "company/openai", "gpt")).toEqual({ provider: "Other", model: "Second model" })
})
+105
View File
@@ -0,0 +1,105 @@
import { consoleProviderGroup, consoleProviderName } from "@/providers/catalog/console"
export type ComposerModelLabel = { provider?: string; model: string }
type Provider = {
id: string
name: string
canonical?: string
integrationID?: string
models: Readonly<Record<string, { id: string; name: string }>>
}
export function composerModelLabelKey(providerID: string, modelID: string) {
return JSON.stringify([providerID, modelID])
}
// Native Console models need no provider. A managed provider drops its workspace, and says it routes through
// OpenCode only when the same provider is also connected directly.
export function composerProviderName(
providerID: string,
catalog: ReadonlyMap<string, Provider>,
connected?: readonly string[],
) {
const provider = catalog.get(providerID)
if (!provider) return providerID
if (native(provider)) return
const all = [...catalog.values()]
const group = consoleProviderGroup(all)
const name =
provider.integrationID === "opencode" && group ? consoleProviderName(group, provider.name) : provider.name
if (provider.integrationID !== "opencode" || !provider.canonical) return name
const active = connected && new Set(connected)
const direct = all.some(
(item) =>
!native(item) &&
item.integrationID !== "opencode" &&
(!active || active.has(item.id)) &&
(item.integrationID ?? item.id) === provider.canonical,
)
return direct ? `OpenCode / ${name}` : name
}
export function composerModelLabels(
catalog: ReadonlyMap<string, Provider>,
connected?: readonly string[],
): ReadonlyMap<string, ComposerModelLabel> {
const active = connected && new Set(connected)
const rows = [...catalog.values()]
.filter((provider) => !active || active.has(provider.id))
.flatMap((provider) => {
const name = composerProviderName(provider.id, catalog, connected)
return Object.values(provider.models).map((model) => {
const label = model.name.replace("(latest)", "").trim()
return {
key: composerModelLabelKey(provider.id, model.id),
providerID: provider.id,
modelID: model.id,
provider: name,
model: label,
text: name ? `${name} / ${label}` : label,
}
})
})
const groups = Map.groupBy(rows, (row) => row.text)
return new Map(
rows.map((row) => {
const peers = groups.get(row.text) ?? []
const provider = peers.some((other) => other.providerID !== row.providerID) ? row.providerID : row.provider
const same = peers.filter((other) => other.providerID === row.providerID).map((other) => other.modelID)
const suffix = same.length > 1 ? row.modelID.slice(sharedPrefix(same)).replace(/^[-_./:]+/, "") : ""
return [row.key, { provider, model: suffix ? `${row.model} (${suffix})` : row.model }]
}),
)
}
// The part of the IDs they all share, cut back to a separator so "v1" and "v2" share nothing
// while "gemini-4-argon" and "gemini-4-argon-eap" share "gemini-4-argon".
function sharedPrefix(ids: string[]) {
const first = ids[0] ?? ""
const separator = (char: string | undefined) => !!char && /[-_./:]/.test(char)
const boundary = (n: number) =>
n === 0 || ids.every((id) => n === id.length || separator(id[n]) || separator(id[n - 1]))
const differs = first.split("").findIndex((char, index) => ids.some((id) => id[index] !== char))
const common = differs === -1 ? first.length : differs
return Array.from({ length: common + 1 }, (_, index) => common - index).find(boundary) ?? 0
}
function native(provider: Provider) {
return provider.id === "opencode" && (!provider.integrationID || provider.integrationID === "opencode")
}
+36 -26
View File
@@ -10,8 +10,8 @@ import { useModels } from "@/providers/models/models"
import { cycleModelVariant, getConfiguredAgentVariant, resolveModelVariant } from "@/providers/models/variant"
import { useComposerState } from "./persistence"
import { useConfiguredModel } from "@/providers/models/configured"
import { consoleProviderGroup, consoleProviderName } from "@/providers/catalog/console"
import { useGlobal } from "@/runtime/server/runtime"
import { composerModelLabelKey, composerModelLabels, composerProviderName } from "./model-label"
export function createComposerControls(input: { model?: ModelSelection } = {}) {
const local = useLocal()
@@ -20,7 +20,12 @@ export function createComposerControls(input: { model?: ModelSelection } = {}) {
const providers = useProviders(() => sdk().directory)
const models = useGlobal().models
const providerName = (providerID: string, catalog = providers.all()) => composerProviderName(providerID, catalog)
const modelLabels = createMemo(() =>
composerModelLabels(
providers.all(),
providers.connected().map((provider) => provider.id),
),
)
const loading = () => {
const selection = input.model ?? local.model
@@ -39,24 +44,41 @@ export function createComposerControls(input: { model?: ModelSelection } = {}) {
if (!expected) return
const catalogs = providers.ready()
? [providers.all()]
? [
{
all: providers.all(),
connected: providers.connected().map((provider) => provider.id),
},
]
: [undefined, ...data.session.list().map((item) => item.location)].map((location) => {
const provider = data.location.provider.list(location)
const catalog = data.location.model.list(location)
return provider && catalog ? normalizeProviderList(provider, catalog).all : undefined
if (!provider || !catalog) return
const normalized = normalizeProviderList(provider, catalog)
return { all: normalized.all, connected: normalized.connected }
})
const match = catalogs
.map((all) => all && { all, model: all.get(expected.model.providerID)?.models[expected.model.modelID] })
.map(
(catalog) =>
catalog && {
...catalog,
model: catalog.all.get(expected.model.providerID)?.models[expected.model.modelID],
},
)
.find((item) => !!item?.model)
if (!match?.model) return
const variants = Object.keys(match.model.variants ?? {})
return {
provider: providerName(expected.model.providerID, match.all),
provider: composerProviderName(expected.model.providerID, match.all, match.connected),
model: match.model.name.replace("(latest)", "").trim(),
label: composerModelLabels(match.all, match.connected).get(
composerModelLabelKey(expected.model.providerID, expected.model.modelID),
),
variants,
variant:
resolveModelVariant({
@@ -82,8 +104,14 @@ export function createComposerControls(input: { model?: ModelSelection } = {}) {
},
model: {
selection,
// A model the catalog no longer offers still names its provider.
providerName: key && providerName(key.providerID),
providerName:
key &&
composerProviderName(
key.providerID,
providers.all(),
providers.connected().map((provider) => provider.id),
),
label: key && modelLabels().get(composerModelLabelKey(key.providerID, key.modelID)),
paid: providers.paid().length > 0,
// The session's model applies only to its agent, so resolve agents before showing a model.
loading: loading(),
@@ -93,24 +121,6 @@ export function createComposerControls(input: { model?: ModelSelection } = {}) {
})
}
// Like the model picker, a Console-managed provider drops its "Workspace / " prefix unless the
// same provider is also connected directly and the workspace is what tells them apart.
export function composerProviderName(providerID: string, catalog: ReturnType<typeof normalizeProviderList>["all"]) {
const provider = catalog.get(providerID)
if (!provider) return providerID
const all = [...catalog.values()]
const managed = consoleProviderGroup(all)
if (!managed?.providers.includes(provider)) return provider.name
const direct = all.some((item) => !managed.providers.includes(item) && canonical(item) === canonical(provider))
return direct ? provider.name : consoleProviderName(managed, provider.name)
}
const canonical = (provider: { id: string; canonical?: string }) =>
provider.canonical ?? provider.id.replace(/^console-/, "")
export function createComposerModelSelection(input: {
agent: () => { name: string; model?: ModelKey; variant?: string } | undefined
}) {
+17 -4
View File
@@ -41,7 +41,7 @@ import { SessionTodoPill } from "./todo-pill"
import { sessionTodos, todoFinished } from "./todos"
import { useOpenSessionRoute } from "../session-identity-header"
import { resolveSessionComposerSelection } from "./selection"
import { composerProviderName } from "@/composer/selection"
import { composerModelLabelKey, composerModelLabels, composerProviderName } from "@/composer/model-label"
import { useProviders } from "@/providers/catalog/providers"
import { SubagentBar } from "./subagent-bar"
import { createSessionRequestModel } from "../requests/model"
@@ -469,17 +469,30 @@ export function ActiveSessionComposerRegion(props: {
const providers = useProviders(() => props.session.data.info()?.location.directory)
const modelLabels = createMemo(() =>
composerModelLabels(
providers.all(),
providers.connected().map((provider) => provider.id),
),
)
const subagentModel = () => {
const ref =
props.session.data.info()?.model ??
props.session.history.messages().findLast((message) => message.type === "assistant")?.model
if (!ref) return
const catalog = providers.all()
const label = modelLabels().get(composerModelLabelKey(ref.providerID, ref.id))
return {
provider: composerProviderName(ref.providerID, catalog),
name: catalog.get(ref.providerID)?.models[ref.id]?.name.replace("(latest)", "").trim() ?? ref.id,
provider: label
? label.provider
: composerProviderName(
ref.providerID,
providers.all(),
providers.connected().map((provider) => provider.id),
),
name: label?.model ?? ref.id,
variant: ref.variant,
}
}