From 950111ff2ad0a324db7950f172c84760bc962469 Mon Sep 17 00:00:00 2001 From: usrnk1 <7547651+usrnk1@users.noreply.github.com> Date: Wed, 28 Oct 2026 11:45:56 +0100 Subject: [PATCH] feat(app): simplify composer model labels (#59735) --- packages/app/e2e/regression/composer.spec.ts | 139 +++++++++++++--- .../regression/mobile-model-pickers.spec.ts | 16 +- .../app/e2e/regression/new-session.spec.ts | 2 +- .../user-story/model-selection-flow.spec.ts | 8 +- packages/app/src/composer/adapter.ts | 4 +- packages/app/src/composer/composer.tsx | 22 ++- packages/app/src/composer/model-label.test.ts | 151 ++++++++++++++++++ packages/app/src/composer/model-label.ts | 105 ++++++++++++ packages/app/src/composer/selection.ts | 62 ++++--- packages/app/src/session/composer/region.tsx | 21 ++- 10 files changed, 453 insertions(+), 77 deletions(-) create mode 100644 packages/app/src/composer/model-label.test.ts create mode 100644 packages/app/src/composer/model-label.ts diff --git a/packages/app/e2e/regression/composer.spec.ts b/packages/app/e2e/regression/composer.spec.ts index b445134847c..b1920203403 100644 --- a/packages/app/e2e/regression/composer.spec.ts +++ b/packages/app/e2e/regression/composer.spec.ts @@ -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>[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) { diff --git a/packages/app/e2e/regression/mobile-model-pickers.spec.ts b/packages/app/e2e/regression/mobile-model-pickers.spec.ts index bec1d4f60dd..0b888921135 100644 --- a/packages/app/e2e/regression/mobile-model-pickers.spec.ts +++ b/packages/app/e2e/regression/mobile-model-pickers.spec.ts @@ -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", () => { diff --git a/packages/app/e2e/regression/new-session.spec.ts b/packages/app/e2e/regression/new-session.spec.ts index 54159b0e75a..f4dbba44f0d 100644 --- a/packages/app/e2e/regression/new-session.spec.ts +++ b/packages/app/e2e/regression/new-session.spec.ts @@ -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") diff --git a/packages/app/e2e/user-story/model-selection-flow.spec.ts b/packages/app/e2e/user-story/model-selection-flow.spec.ts index aa473cef684..f244db683a7 100644 --- a/packages/app/e2e/user-story/model-selection-flow.spec.ts +++ b/packages/app/e2e/user-story/model-selection-flow.spec.ts @@ -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") }) diff --git a/packages/app/src/composer/adapter.ts b/packages/app/src/composer/adapter.ts index e55190d8100..0b9fc5abc0d 100644 --- a/packages/app/src/composer/adapter.ts +++ b/packages/app/src/composer/adapter.ts @@ -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[] } } } diff --git a/packages/app/src/composer/composer.tsx b/packages/app/src/composer/composer.tsx index b26f59c56bb..0c359b2cf49 100644 --- a/packages/app/src/composer/composer.tsx +++ b/packages/app/src/composer/composer.tsx @@ -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 (
dialog.show(() => )} /> @@ -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 = () => ( <> - + {(name) => ( <> - {name()} + {name()} {" / "} )} - {props.modelName} + {props.label.model} diff --git a/packages/app/src/composer/model-label.test.ts b/packages/app/src/composer/model-label.test.ts new file mode 100644 index 00000000000..5b7bccc438b --- /dev/null +++ b/packages/app/src/composer/model-label.test.ts @@ -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[]) { + return new Map(providers.map((provider) => [provider.id, provider])) +} + +function label(labels: ReturnType, 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" }) +}) diff --git a/packages/app/src/composer/model-label.ts b/packages/app/src/composer/model-label.ts new file mode 100644 index 00000000000..7eaf932f667 --- /dev/null +++ b/packages/app/src/composer/model-label.ts @@ -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> +} + +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, + 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, + connected?: readonly string[], +): ReadonlyMap { + 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") +} diff --git a/packages/app/src/composer/selection.ts b/packages/app/src/composer/selection.ts index d1722fc5a10..2013ee5bbf7 100644 --- a/packages/app/src/composer/selection.ts +++ b/packages/app/src/composer/selection.ts @@ -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["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 }) { diff --git a/packages/app/src/session/composer/region.tsx b/packages/app/src/session/composer/region.tsx index 29e32ac7300..0140bd8a7f3 100644 --- a/packages/app/src/session/composer/region.tsx +++ b/packages/app/src/session/composer/region.tsx @@ -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, } }