lael-labs/t3code

apps/server/src/provider/Layers/ClaudeProvider.ts+0−5

   type ClaudeSettings,
   type ModelCapabilities,
   type ModelSelection,
-  ProviderDriverKind,
   type ServerProviderModel,
   type ServerProviderSlashCommand,
 } from "@t3tools/contracts";
   optionDescriptors: [],
 });
-const PROVIDER = ProviderDriverKind.make("claudeAgent");
 const CLAUDE_PRESENTATION = {
   displayName: "Claude",
   showInteractionModeToggle: true,
   const checkedAt = DateTime.formatIso(yield* DateTime.now);
   const allModels = providerModelsFromSettings(
     BUILT_IN_MODELS,
-    PROVIDER,
     claudeSettings.customModels,
     DEFAULT_CLAUDE_MODEL_CAPABILITIES,
   );
   const models = providerModelsFromSettings(
     getBuiltInClaudeModelsForVersion(parsedVersion),
-    PROVIDER,
     claudeSettings.customModels,
     DEFAULT_CLAUDE_MODEL_CAPABILITIES,
   );
     const checkedAt = yield* nowIso;
     const models = providerModelsFromSettings(
       BUILT_IN_MODELS,
-      PROVIDER,
       claudeSettings.customModels,
       DEFAULT_CLAUDE_MODEL_CAPABILITIES,
     );

apps/server/src/provider/Layers/CursorProvider.ts+1−4

   ServerProviderModel,
   ServerProviderState,
 } from "@t3tools/contracts";
-import { ProviderDriverKind } from "@t3tools/contracts";
 import type * as EffectAcpSchema from "effect-acp/schema";
 import { causeErrorTag } from "@t3tools/shared/observability";
 import * as Crypto from "effect/Crypto";
 const decodeCursorListAvailableModelsResponse = Schema.decodeUnknownEffect(
   CursorListAvailableModelsResponse,
 );
-const PROVIDER = ProviderDriverKind.make("cursor");
 const CURSOR_PRESENTATION = {
   displayName: "Cursor",
   badgeLabel: "Early Access",
 export function getCursorFallbackModels(
   cursorSettings: Pick<CursorSettings, "customModels">,
 ): ReadonlyArray<ServerProviderModel> {
-  return providerModelsFromSettings([], PROVIDER, cursorSettings.customModels, EMPTY_CAPABILITIES);
+  return providerModelsFromSettings([], cursorSettings.customModels, EMPTY_CAPABILITIES);
 }
 /** Timeout for `agent about` — it's slower than a simple `--version` probe. */
     checkedAt: input.checkedAt,
     models: providerModelsFromSettings(
       input.discoveredModels ?? [],
-      PROVIDER,
       input.cursorSettings.customModels,
       EMPTY_CAPABILITIES,
     ),

apps/server/src/provider/Layers/GrokProvider.ts+1−8

 import {
   type GrokSettings,
   type ModelCapabilities,
-  ProviderDriverKind,
   type ServerProvider,
   type ServerProviderModel,
 } from "@t3tools/contracts";
   showInteractionModeToggle: false,
   requiresNewThreadForModelChange: true,
 } as const;
-const PROVIDER = ProviderDriverKind.make("grok");
 const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({
   optionDescriptors: [],
 });
   customModels: ReadonlyArray<string> | undefined,
   builtInModels: ReadonlyArray<ServerProviderModel> = GROK_BUILT_IN_MODELS,
 ): ReadonlyArray<ServerProviderModel> {
-  return providerModelsFromSettings(
+  return providerModelsFromSettings(builtInModels, customModels ?? [], EMPTY_CAPABILITIES);
-    builtInModels,
-    PROVIDER,
-    customModels ?? [],
-    EMPTY_CAPABILITIES,
-  );
 }
 function buildGrokDiscoveredModelsFromSessionModelState(

apps/server/src/provider/Layers/OpenCodeProvider.ts+3−22

 import {
-  ProviderDriverKind,
   type ModelCapabilities,
   type OpenCodeSettings,
   type ServerProviderModel,
 } from "../opencodeRuntime.ts";
 import type { Agent, ProviderListResponse } from "@opencode-ai/sdk/v2";
-const PROVIDER = ProviderDriverKind.make("opencode");
 const OPENCODE_PRESENTATION = {
   displayName: "OpenCode",
   showInteractionModeToggle: false,
     const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
     const models = providerModelsFromSettings(
       [],
-      PROVIDER,
       openCodeSettings.customModels,
       DEFAULT_OPENCODE_MODEL_CAPABILITIES,
     );
       presentation: OPENCODE_PRESENTATION,
       enabled: openCodeSettings.enabled,
       checkedAt,
-      models: providerModelsFromSettings(
+      models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
-        [],
-        PROVIDER,
-        customModels,
-        DEFAULT_OPENCODE_MODEL_CAPABILITIES,
-      ),
       probe: {
         installed: failure.installed,
         version,
       presentation: OPENCODE_PRESENTATION,
       enabled: false,
       checkedAt,
-      models: providerModelsFromSettings(
+      models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
-        [],
-        PROVIDER,
-        customModels,
-        DEFAULT_OPENCODE_MODEL_CAPABILITIES,
-      ),
       probe: {
         installed: false,
         version: null,
         presentation: OPENCODE_PRESENTATION,
         enabled: openCodeSettings.enabled,
         checkedAt,
-        models: providerModelsFromSettings(
+        models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
-          [],
-          PROVIDER,
-          customModels,
-          DEFAULT_OPENCODE_MODEL_CAPABILITIES,
-        ),
         probe: {
           installed: true,
           version,
   const models = providerModelsFromSettings(
     flattenOpenCodeModels(inventoryExit.value),
-    PROVIDER,
     customModels,
     DEFAULT_OPENCODE_MODEL_CAPABILITIES,
   );

apps/server/src/provider/providerSnapshot.test.ts+20−2

@@ -1,5 +1,5 @@
1	import { describe, expect, it } from "@effect/vitest";	1	import { describe, expect, it } from "@effect/vitest";
2	import { ProviderDriverKind, type ModelCapabilities } from "@t3tools/contracts";	2	import type { ModelCapabilities } from "@t3tools/contracts";
3	import { HostProcessPlatform } from "@t3tools/shared/hostProcess";	3	import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
4	import { createModelCapabilities } from "@t3tools/shared/model";	4	import { createModelCapabilities } from "@t3tools/shared/model";
5	import * as Effect from "effect/Effect";	5	import * as Effect from "effect/Effect";
@@ -38,7 +38,6 @@ describe("providerModelsFromSettings", () => { · 32 unmodified lines
38	it("applies the provided capabilities to custom models", () => {	38	it("applies the provided capabilities to custom models", () => {
39	const models = providerModelsFromSettings(	39	const models = providerModelsFromSettings(
40	[],	40	[],
41	ProviderDriverKind.make("opencode"),
42	["openai/gpt-5"],	41	["openai/gpt-5"],
43	OPENCODE_CUSTOM_MODEL_CAPABILITIES,	42	OPENCODE_CUSTOM_MODEL_CAPABILITIES,
44	);	43	);
@@ -52,6 +51,25 @@ describe("providerModelsFromSettings", () => { · 7 unmodified lines
52	},	51	},
53	]);	52	]);
54	});	53	});
		54
		55	it("preserves a custom slug that collides with a provider alias", () => {
		56	const capabilities = createModelCapabilities({ optionDescriptors: [] });
		57	const models = providerModelsFromSettings(
		58	[
		59	{
		60	slug: "claude-opus-4-8",
		61	name: "Claude Opus 4.8",
		62	isCustom: false,
		63	capabilities,
		64	},
		65	],
		66	[" opus "],
		67	capabilities,
		68	);
		69
		70	expect(models.map((model) => model.slug)).toEqual(["claude-opus-4-8", "opus"]);
		71	expect(models[1]?.isCustom).toBe(true);
		72	});
55	});	73	});
56		74
57	describe("ProviderCommandNotFoundError", () => {	75	describe("ProviderCommandNotFoundError", () => {

apps/server/src/provider/providerSnapshot.ts+2−3

 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { normalizeModelSlug } from "@t3tools/shared/model";
+import { normalizeCustomModelSlug } from "@t3tools/shared/model";
 import { isWindowsCommandNotFound } from "../processRunner.ts";
 import { createProviderVersionAdvisory } from "./providerMaintenance.ts";
 import { collectUint8StreamText } from "../stream/collectUint8StreamText.ts";
 export function providerModelsFromSettings(
   builtInModels: ReadonlyArray<ServerProviderModel>,
-  provider: ProviderDriverKind,
   customModels: ReadonlyArray<string>,
   customModelCapabilities: ModelCapabilities,
 ): ReadonlyArray<ServerProviderModel> {
   const customEntries: ServerProviderModel[] = [];
   for (const candidate of customModels) {
-    const normalized = normalizeModelSlug(candidate, provider);
+    const normalized = normalizeCustomModelSlug(candidate);
     if (!normalized || seen.has(normalized)) {
       continue;
     }

apps/web/src/components/settings/ProviderModelsSection.tsx+2−2

@@ -16,7 +16,7 @@ import { · 15 unmodified lines
16	type ProviderInstanceId,	16	type ProviderInstanceId,
17	type ServerProviderModel,	17	type ServerProviderModel,
18	} from "@t3tools/contracts";	18	} from "@t3tools/contracts";
19	import { normalizeModelSlug } from "@t3tools/shared/model";	19	import { normalizeCustomModelSlug } from "@t3tools/shared/model";
20		20
21	import { cn } from "../../lib/utils";	21	import { cn } from "../../lib/utils";
22	import { sortModelsForProviderInstance } from "../../modelOrdering";	22	import { sortModelsForProviderInstance } from "../../modelOrdering";
@@ -111,7 +111,7 @@ export function ProviderModelsSection({ · 88 unmodified lines
111	}, [favoriteModelSet, modelOrder, models]);	111	}, [favoriteModelSet, modelOrder, models]);
112		112
113	const handleAdd = () => {	113	const handleAdd = () => {
114	const normalized = driverKind ? normalizeModelSlug(input, driverKind) : input.trim() \|\| null;	114	const normalized = normalizeCustomModelSlug(input);
115	if (!normalized) {	115	if (!normalized) {
116	setError("Enter a model slug.");	116	setError("Enter a model slug.");
117	return;	117	return;

apps/web/src/modelSelection.test.ts+33−0

@@ -101,6 +101,39 @@ describe("instance-scoped model selection", () => { · 100 unmodified lines
101	).toBe("openai/gpt-5.5");	101	).toBe("openai/gpt-5.5");
102	});	102	});
103		103
		104	it("preserves a custom slug that collides with a provider alias", () => {
		105	const providers = [
		106	provider({
		107	provider: ProviderDriverKind.make("claudeAgent"),
		108	instanceId: "claude_openrouter",
		109	models: ["claude-opus-4-8"],
		110	}),
		111	];
		112	const settings: UnifiedSettings = {
		113	...settingsWithProviderInstances(),
		114	providerInstances: {
		115	...settingsWithProviderInstances().providerInstances,
		116	[ProviderInstanceId.make("claude_openrouter")]: {
		117	driver: ProviderDriverKind.make("claudeAgent"),
		118	config: { customModels: ["opus"] },
		119	},
		120	},
		121	};
		122	const openrouter = deriveProviderInstanceEntries(providers)[0]!;
		123
		124	expect(
		125	getAppModelOptionsForInstance(settings, openrouter).map((option) => option.slug),
		126	).toEqual(["claude-opus-4-8", "opus"]);
		127	expect(
		128	resolveAppModelSelectionForInstance(
		129	ProviderInstanceId.make("claude_openrouter"),
		130	settings,
		131	providers,
		132	"opus",
		133	),
		134	).toBe("opus");
		135	});
		136
104	it("includes Grok custom models from the selected provider instance", () => {	137	it("includes Grok custom models from the selected provider instance", () => {
105	const providers = [provider({ provider: ProviderDriverKind.make("grok"), instanceId: "grok" })];	138	const providers = [provider({ provider: ProviderDriverKind.make("grok"), instanceId: "grok" })];
106	const settings: UnifiedSettings = {	139	const settings: UnifiedSettings = {

apps/web/src/modelSelection.ts+4−6

 } from "@t3tools/contracts";
 import {
   createModelSelection,
-  normalizeModelSlug,
+  normalizeCustomModelSlug,
   resolveSelectableModel,
 } from "@t3tools/shared/model";
 import { getComposerProviderState } from "./components/chat/composerProviderState";
 export function normalizeCustomModelSlugs(
   models: Iterable<string | null | undefined>,
   builtInModelSlugs: ReadonlySet<string>,
-  provider: ProviderDriverKind = ProviderDriverKind.make("codex"),
 ): string[] {
   const normalizedModels: string[] = [];
   const seen = new Set<string>();
   for (const candidate of models) {
-    const normalized = normalizeModelSlug(candidate, provider);
+    const normalized = normalizeCustomModelSlug(candidate);
     if (
       !normalized ||
       normalized.length > MAX_CUSTOM_MODEL_LENGTH ||
   // see the user's authored custom models.
   const defaultInstanceId = defaultInstanceIdForDriver(provider);
   const customModels = readInstanceCustomModels(settings, defaultInstanceId, provider);
-  for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs, provider)) {
+  for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs)) {
     if (seen.has(slug)) {
       continue;
     }
   );
   const customModels = readInstanceCustomModels(settings, entry.instanceId, entry.driverKind);
-  const normalizer = entry.driverKind;
+  for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs)) {
-  for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs, normalizer)) {
     if (seen.has(slug)) {
       continue;
     }

packages/shared/src/model.test.ts+12−1

 import { describe, expect, it } from "vite-plus/test";
-import { ProviderInstanceId, type ModelCapabilities } from "@t3tools/contracts";
+import { ProviderDriverKind, ProviderInstanceId, type ModelCapabilities } from "@t3tools/contracts";
 import {
   buildProviderOptionSelectionsFromDescriptors,
   getProviderOptionDescriptors,
   getProviderOptionBooleanSelectionValue,
   getProviderOptionStringSelectionValue,
+  normalizeCustomModelSlug,
+  normalizeModelSlug,
 } from "./model.ts";
 const codexCaps: ModelCapabilities = createModelCapabilities({
     expect(getModelSelectionBooleanOptionValue(selection, "fastMode")).toBe(true);
   });
 });
+describe("model slug normalization", () => {
+  it("preserves exact custom slugs instead of expanding provider aliases", () => {
+    const claude = ProviderDriverKind.make("claudeAgent");
+    expect(normalizeModelSlug("opus", claude)).toBe("claude-opus-4-8");
+    expect(normalizeCustomModelSlug(" opus ")).toBe("opus");
+  });
+});

packages/shared/src/model.ts+10−5

   model: string | null | undefined,
   provider: ProviderDriverKind = DEFAULT_PROVIDER_DRIVER_KIND,
 ): string | null {
-  if (typeof model !== "string") {
+  const trimmed = normalizeCustomModelSlug(model);
-    return null;
-  }
-  const trimmed = model.trim();
   if (!trimmed) {
     return null;
   }
   return typeof aliased === "string" ? aliased : trimmed;
 }
+/** Custom model identifiers are provider-owned, so only trim them; never expand aliases. */
+export function normalizeCustomModelSlug(model: string | null | undefined): string | null {
+  if (typeof model !== "string") {
+    return null;
+  }
+  return model.trim() || null;
+}
 export function resolveSelectableModel(
   provider: ProviderDriverKind,
   value: string | null | undefined,