- Orchestrate Claude Code, Codex, OpenCode, Cursor, and Grok from one surface.
+ Orchestrate Claude Code, Codex, Cline, OpenCode, Cursor, and Grok from one surface.
Bring your own subscription. Fork the whole thing.
@@ -186,8 +186,8 @@ const mobileEndorsementRows = [
diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx
index e77c05549265..6b6092577ccb 100644
--- a/apps/web/src/components/settings/SettingsPanels.tsx
+++ b/apps/web/src/components/settings/SettingsPanels.tsx
@@ -75,6 +75,7 @@ import {
import {
applyProviderInstanceSettings,
deriveProviderInstanceEntries,
+ filterTextGenerationProviderInstanceEntries,
sortProviderInstanceEntries,
} from "../../providerInstances";
import { ensureLocalApi, readLocalApi } from "../../localApi";
@@ -1874,8 +1875,10 @@ export function GeneralSettingsPanel() {
const textGenInstanceId = textGenerationModelSelection.instanceId;
const textGenModel = textGenerationModelSelection.model;
const textGenModelOptions = textGenerationModelSelection.options;
- const textGenerationModelInstanceEntries = sortProviderInstanceEntries(
- applyProviderInstanceSettings(deriveProviderInstanceEntries(serverProviders), settings),
+ const textGenerationModelInstanceEntries = filterTextGenerationProviderInstanceEntries(
+ sortProviderInstanceEntries(
+ applyProviderInstanceSettings(deriveProviderInstanceEntries(serverProviders), settings),
+ ),
);
const textGenInstanceEntry = textGenerationModelInstanceEntries.find(
(entry) => entry.instanceId === textGenInstanceId,
diff --git a/apps/web/src/components/settings/SourceControlWritingSettings.test.ts b/apps/web/src/components/settings/SourceControlWritingSettings.test.ts
new file mode 100644
index 000000000000..5dddde282d16
--- /dev/null
+++ b/apps/web/src/components/settings/SourceControlWritingSettings.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+ hasUsableSourceControlWriterModel,
+ sourceControlWriterUnavailableMessage,
+ sourceControlWriterToggleState,
+} from "./SourceControlWritingSettings";
+
+const model = { slug: "model", name: "Model", isCustom: false, capabilities: null } as const;
+
+describe("source control writer model toggle", () => {
+ it("allows clearing a stale override when no supported model is available", () => {
+ expect(
+ sourceControlWriterToggleState({
+ hasOverride: true,
+ hasSupportedModel: false,
+ }),
+ ).toEqual({ checked: true, disabled: false });
+ });
+
+ it("prevents enabling a new override when no supported model is available", () => {
+ expect(
+ sourceControlWriterToggleState({
+ hasOverride: false,
+ hasSupportedModel: false,
+ }),
+ ).toEqual({ checked: false, disabled: true });
+ });
+
+ it("requires an enabled and available instance for a new override", () => {
+ expect(
+ hasUsableSourceControlWriterModel([
+ { enabled: false, isAvailable: true, status: "ready", models: [model] },
+ { enabled: true, isAvailable: false, status: "ready", models: [model] },
+ ]),
+ ).toBe(false);
+ expect(
+ hasUsableSourceControlWriterModel([
+ { enabled: true, isAvailable: true, status: "ready", models: [model] },
+ ]),
+ ).toBe(true);
+ });
+
+ it("rejects errored and empty provider catalogs for a new override", () => {
+ expect(
+ hasUsableSourceControlWriterModel([
+ { enabled: true, isAvailable: true, status: "error", models: [model] },
+ { enabled: true, isAvailable: true, status: "ready", models: [] },
+ ]),
+ ).toBe(false);
+ });
+
+ it("explains the unavailable state whether the override is off or needs clearing", () => {
+ expect(
+ sourceControlWriterUnavailableMessage({
+ hasOverride: false,
+ hasSupportedModel: false,
+ }),
+ ).toBe("No enabled and available text generation provider with models is available.");
+ expect(
+ sourceControlWriterUnavailableMessage({
+ hasOverride: true,
+ hasSupportedModel: false,
+ }),
+ ).toBe(
+ "The selected source control writer is unavailable. Turn off this override or enable a text generation provider with models.",
+ );
+ expect(
+ sourceControlWriterUnavailableMessage({
+ hasOverride: true,
+ hasSupportedModel: true,
+ }),
+ ).toBeNull();
+ });
+});
diff --git a/apps/web/src/components/settings/SourceControlWritingSettings.tsx b/apps/web/src/components/settings/SourceControlWritingSettings.tsx
index d7c094af372b..e1f2689a0bad 100644
--- a/apps/web/src/components/settings/SourceControlWritingSettings.tsx
+++ b/apps/web/src/components/settings/SourceControlWritingSettings.tsx
@@ -9,7 +9,9 @@ import { usePrimarySettings, useUpdatePrimarySettings } from "../../hooks/useSet
import {
applyProviderInstanceSettings,
deriveProviderInstanceEntries,
+ filterTextGenerationProviderInstanceEntries,
sortProviderInstanceEntries,
+ type ProviderInstanceEntry,
} from "../../providerInstances";
import {
getCustomModelOptionsByInstance,
@@ -40,6 +42,37 @@ const MODE_OPTIONS: Record
+ >,
+): boolean {
+ return entries.some(
+ (entry) =>
+ entry.enabled && entry.isAvailable && entry.status === "ready" && entry.models.length > 0,
+ );
+}
+
export function SourceControlWritingSettingsSection() {
const settings = usePrimarySettings();
const updateSettings = useUpdatePrimarySettings();
@@ -60,9 +93,20 @@ export function SourceControlWritingSettingsSection() {
resolvedSourceControlWriterSelection === settings.textGenerationModelSelection
? defaultModelSelection
: resolvedSourceControlWriterSelection;
- const instanceEntries = sortProviderInstanceEntries(
- applyProviderInstanceSettings(deriveProviderInstanceEntries(serverProviders), settings),
+ const instanceEntries = filterTextGenerationProviderInstanceEntries(
+ sortProviderInstanceEntries(
+ applyProviderInstanceSettings(deriveProviderInstanceEntries(serverProviders), settings),
+ ),
);
+ const canUseDedicatedModel = hasUsableSourceControlWriterModel(instanceEntries);
+ const dedicatedWriterToggle = sourceControlWriterToggleState({
+ hasOverride: usesDedicatedModel,
+ hasSupportedModel: canUseDedicatedModel,
+ });
+ const dedicatedWriterUnavailableMessage = sourceControlWriterUnavailableMessage({
+ hasOverride: usesDedicatedModel,
+ hasSupportedModel: canUseDedicatedModel,
+ });
const modelOptionsByInstance = getCustomModelOptionsByInstance(
settings,
serverProviders,
@@ -170,10 +214,13 @@ export function SourceControlWritingSettingsSection() {
- {usesDedicatedModel ? (
+ {usesDedicatedModel && canUseDedicatedModel ? (
) : null}
updateSettings({
sourceControlWriterModelSelection: checked
diff --git a/apps/web/src/components/settings/providerDriverMeta.ts b/apps/web/src/components/settings/providerDriverMeta.ts
index bfee6a8d6807..355514eab755 100644
--- a/apps/web/src/components/settings/providerDriverMeta.ts
+++ b/apps/web/src/components/settings/providerDriverMeta.ts
@@ -1,5 +1,6 @@
import {
ClaudeSettings,
+ ClineSettings,
CodexSettings,
CursorSettings,
GrokSettings,
@@ -7,7 +8,15 @@ import {
ProviderDriverKind,
} from "@t3tools/contracts";
import type * as Schema from "effect/Schema";
-import { ClaudeAI, CursorIcon, GrokIcon, type Icon, OpenAI, OpenCodeIcon } from "../Icons";
+import {
+ ClaudeAI,
+ ClineIcon,
+ CursorIcon,
+ GrokIcon,
+ type Icon,
+ OpenAI,
+ OpenCodeIcon,
+} from "../Icons";
type ProviderSettingsSchema = {
readonly fields: Readonly>;
@@ -32,6 +41,8 @@ export interface ProviderClientDefinition {
* built-in default or custom — advertises the same marker.
*/
readonly badgeLabel?: string;
+ /** Whether Settings may author model IDs not advertised by the provider. */
+ readonly supportsCustomModels?: boolean;
}
export const PROVIDER_CLIENT_DEFINITIONS: readonly ProviderClientDefinition[] = [
@@ -61,6 +72,14 @@ export const PROVIDER_CLIENT_DEFINITIONS: readonly ProviderClientDefinition[] =
badgeLabel: "Early Access",
settingsSchema: GrokSettings,
},
+ {
+ value: ProviderDriverKind.make("cline"),
+ label: "Cline",
+ icon: ClineIcon,
+ badgeLabel: "Early Access",
+ supportsCustomModels: false,
+ settingsSchema: ClineSettings,
+ },
{
value: ProviderDriverKind.make("opencode"),
label: "OpenCode",
diff --git a/apps/web/src/composerDraftStore.test.ts b/apps/web/src/composerDraftStore.test.ts
index 20c6603f773b..9a1ab984ffea 100644
--- a/apps/web/src/composerDraftStore.test.ts
+++ b/apps/web/src/composerDraftStore.test.ts
@@ -6,6 +6,7 @@ import {
} from "@t3tools/client-runtime/environment";
import * as Schema from "effect/Schema";
import {
+ DEFAULT_UNIFIED_SETTINGS,
defaultInstanceIdForDriver,
EnvironmentId,
ProjectId,
@@ -14,6 +15,7 @@ import {
ThreadId,
type ModelSelection,
type ProviderOptionSelection,
+ type ServerProvider,
} from "@t3tools/contracts";
import { createModelSelection } from "@t3tools/shared/model";
@@ -60,6 +62,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test"
import {
COMPOSER_DRAFT_STORAGE_KEY,
clearComposerDraftsEnvironment,
+ deriveEffectiveComposerModelState,
finalizePromotedDraftThreadByRef,
markPromotedDraftThread,
markPromotedDraftThreadByRef,
@@ -76,6 +79,10 @@ import {
type TerminalContextDraft,
} from "./lib/terminalContext";
import { createDebouncedStorage } from "./lib/storage";
+import {
+ deriveProviderInstanceEntries,
+ resolveComposerProviderInstanceEntry,
+} from "./providerInstances";
function makeImage(input: {
id: string;
@@ -1285,6 +1292,95 @@ describe("composerDraftStore modelSelection", () => {
resetComposerDraftStore();
});
+ it.each([
+ ["an empty ready catalog", "ready", "authenticated"],
+ ["a checking catalog", "warning", "unknown"],
+ ["an errored catalog", "error", "authenticated"],
+ ] as const)(
+ "does not borrow the default instance model when a custom Cline instance has %s",
+ (_label, status, authStatus) => {
+ const clineDriver = ProviderDriverKind.make("cline");
+ const defaultInstanceId = defaultInstanceIdForDriver(clineDriver);
+ const customInstanceId = ProviderInstanceId.make("cline_work");
+ const provider = (input: {
+ instanceId: ProviderInstanceId;
+ status: ServerProvider["status"];
+ authStatus: ServerProvider["auth"]["status"];
+ models: ServerProvider["models"];
+ }): ServerProvider => ({
+ instanceId: input.instanceId,
+ driver: clineDriver,
+ displayName: input.instanceId === defaultInstanceId ? "Cline" : "Cline Work",
+ enabled: true,
+ installed: true,
+ version: "3.0.57",
+ status: input.status,
+ auth: { status: input.authStatus },
+ checkedAt: "2026-08-23T00:00:00.000Z",
+ models: input.models,
+ slashCommands: [],
+ skills: [],
+ });
+ const providers = [
+ provider({
+ instanceId: defaultInstanceId,
+ status: "ready",
+ authStatus: "authenticated",
+ models: [
+ {
+ slug: "default-account-model",
+ name: "Default account model",
+ isCustom: false,
+ isDefault: true,
+ capabilities: {},
+ },
+ ],
+ }),
+ provider({
+ instanceId: customInstanceId,
+ status,
+ authStatus,
+ models: [],
+ }),
+ ];
+ const selectedEntry = resolveComposerProviderInstanceEntry({
+ entries: deriveProviderInstanceEntries(providers),
+ candidateInstanceIds: [customInstanceId],
+ requestedDriverKind: clineDriver,
+ lockedProvider: null,
+ lockedContinuationGroupKey: null,
+ });
+ const customSelection = createModelSelection(customInstanceId, "retired-custom-model");
+ const draft = {
+ activeProvider: customInstanceId,
+ modelSelectionByProvider: {
+ [defaultInstanceId]: createModelSelection(defaultInstanceId, "default-account-model"),
+ [customInstanceId]: customSelection,
+ },
+ };
+
+ expect(selectedEntry?.instanceId).toBe(customInstanceId);
+ expect(
+ deriveEffectiveComposerModelState({
+ draft,
+ providers,
+ selectedProvider: clineDriver,
+ selectedInstanceId: selectedEntry?.instanceId,
+ threadModelSelection: customSelection,
+ projectModelSelection: null,
+ settings: DEFAULT_UNIFIED_SETTINGS,
+ }).selectedModel,
+ ).toBe("");
+ expect(draft).toEqual({
+ activeProvider: customInstanceId,
+ modelSelectionByProvider: {
+ [defaultInstanceId]: createModelSelection(defaultInstanceId, "default-account-model"),
+ [customInstanceId]: customSelection,
+ },
+ });
+ },
+ );
+
it("stores a model selection in the draft", () => {
const store = useComposerDraftStore.getState();
store.setModelSelection(
diff --git a/apps/web/src/composerDraftStore.ts b/apps/web/src/composerDraftStore.ts
index f20385ee04f4..b0f8d3e076ed 100644
--- a/apps/web/src/composerDraftStore.ts
+++ b/apps/web/src/composerDraftStore.ts
@@ -1014,23 +1014,26 @@ export function deriveEffectiveComposerModelState(input: {
}): EffectiveComposerModelState {
const baseModelCandidate =
input.threadModelSelection?.model ?? input.projectModelSelection?.model ?? null;
- const baseModel =
- (input.selectedInstanceId
- ? resolveAppModelSelectionForInstance(
- input.selectedInstanceId,
- input.settings,
- input.providers,
- baseModelCandidate,
- )
- : null) ??
- resolveAppModelSelection(
- input.selectedProvider,
- input.settings,
- input.providers,
- baseModelCandidate,
- ) ??
- normalizeModelSlug(baseModelCandidate, input.selectedProvider) ??
- getDefaultServerModel(input.providers, input.selectedProvider);
+ const selectedInstanceId = input.selectedInstanceId
+ ? input.providers.find((provider) => provider.instanceId === input.selectedInstanceId)
+ ?.instanceId
+ : undefined;
+ const selectedInstanceExists = selectedInstanceId !== undefined;
+ const baseModel = selectedInstanceExists
+ ? (resolveAppModelSelectionForInstance(
+ selectedInstanceId,
+ input.settings,
+ input.providers,
+ baseModelCandidate,
+ ) ?? "")
+ : (resolveAppModelSelection(
+ input.selectedProvider,
+ input.settings,
+ input.providers,
+ baseModelCandidate,
+ ) ??
+ normalizeModelSlug(baseModelCandidate, input.selectedProvider) ??
+ getDefaultServerModel(input.providers, input.selectedProvider));
// Look up the instance's saved selection first; fall back to the
// driver-kind bucket so legacy kind-keyed drafts still resolve. Every
// `ProviderDriverKind` literal is a valid `ProviderInstanceId` slug, so the
@@ -1038,25 +1041,33 @@ export function deriveEffectiveComposerModelState(input: {
const instanceSelection = input.selectedInstanceId
? input.draft?.modelSelectionByProvider?.[input.selectedInstanceId]
: undefined;
- const legacySelection =
- input.draft?.modelSelectionByProvider?.[ProviderInstanceId.make(input.selectedProvider)];
+ const legacySelection = selectedInstanceExists
+ ? undefined
+ : input.draft?.modelSelectionByProvider?.[ProviderInstanceId.make(input.selectedProvider)];
const activeSelection = instanceSelection ?? legacySelection;
const activeSelectionInstanceId = instanceSelection
? (input.selectedInstanceId ?? ProviderInstanceId.make(input.selectedProvider))
: ProviderInstanceId.make(input.selectedProvider);
const selectedModel = activeSelection?.model
- ? (resolveAppModelSelectionForInstance(
- activeSelectionInstanceId,
- input.settings,
- input.providers,
- activeSelection.model,
- ) ??
- resolveAppModelSelection(
- input.selectedProvider,
- input.settings,
- input.providers,
- activeSelection.model,
- ))
+ ? selectedInstanceExists
+ ? (resolveAppModelSelectionForInstance(
+ activeSelectionInstanceId,
+ input.settings,
+ input.providers,
+ activeSelection.model,
+ ) ?? "")
+ : (resolveAppModelSelectionForInstance(
+ activeSelectionInstanceId,
+ input.settings,
+ input.providers,
+ activeSelection.model,
+ ) ??
+ resolveAppModelSelection(
+ input.selectedProvider,
+ input.settings,
+ input.providers,
+ activeSelection.model,
+ ))
: baseModel;
const modelOptions =
modelSelectionByProviderToOptions(input.draft?.modelSelectionByProvider) ??
diff --git a/apps/web/src/lib/contextWindow.ts b/apps/web/src/lib/contextWindow.ts
index 80f7d31cf2f9..bd422459c8b7 100644
--- a/apps/web/src/lib/contextWindow.ts
+++ b/apps/web/src/lib/contextWindow.ts
@@ -38,6 +38,8 @@ export function formatProviderDisplayName(provider: string | null | undefined):
return "Cursor";
case "opencode":
return "OpenCode";
+ case "cline":
+ return "Cline";
default: {
// Title-case unknown driver kinds so they read reasonably.
const trimmed = provider.replace(/Agent$/i, "").trim();
diff --git a/apps/web/src/modelSelection.test.ts b/apps/web/src/modelSelection.test.ts
index 405366d9fcbe..56ed38b41c82 100644
--- a/apps/web/src/modelSelection.test.ts
+++ b/apps/web/src/modelSelection.test.ts
@@ -3,7 +3,9 @@ import { DEFAULT_UNIFIED_SETTINGS, type UnifiedSettings } from "@t3tools/contrac
import { describe, expect, it } from "vite-plus/test";
import { createModelSelection } from "@t3tools/shared/model";
import { deriveProviderInstanceEntries } from "./providerInstances";
+import { getDefaultServerModel } from "./providerModels";
import {
+ getAppModelOptions,
getAppModelOptionsForInstance,
resolveAppModelSelectionForInstance,
resolveAppModelSelectionState,
@@ -15,6 +17,9 @@ function provider(input: {
provider?: ProviderDriverKind;
instanceId: string;
models?: ReadonlyArray;
+ enabled?: boolean;
+ availability?: ServerProvider["availability"];
+ status?: ServerProvider["status"];
}): ServerProvider {
const driver =
input.provider ??
@@ -24,10 +29,11 @@ function provider(input: {
return {
instanceId: ProviderInstanceId.make(input.instanceId),
driver,
- enabled: true,
+ enabled: input.enabled ?? true,
installed: true,
version: null,
- status: "ready",
+ status: input.status ?? "ready",
+ ...(input.availability ? { availability: input.availability } : {}),
auth: { status: "authenticated" },
checkedAt: "2026-01-01T00:00:00.000Z",
models: (input.models ?? []).map((slug) => ({
@@ -58,6 +64,44 @@ function settingsWithProviderInstances(): UnifiedSettings {
}
describe("instance-scoped model selection", () => {
+ it("does not synthesize Codex's default for an empty Cline catalog", () => {
+ const cline = ProviderDriverKind.make("cline");
+ expect(
+ getDefaultServerModel(
+ [provider({ provider: cline, instanceId: "cline", models: [] })],
+ cline,
+ ),
+ ).toBe("");
+
+ expect(
+ resolveAppModelSelectionState(DEFAULT_UNIFIED_SETTINGS, [
+ provider({ provider: cline, instanceId: "cline", models: [] }),
+ ]),
+ ).toEqual({ instanceId: "t3code_no_provider", model: "" });
+ });
+
+ it("ignores authored Cline model IDs that ACP did not advertise", () => {
+ const cline = ProviderDriverKind.make("cline");
+ const providers = [provider({ provider: cline, instanceId: "cline", models: ["advertised"] })];
+ const settings: UnifiedSettings = {
+ ...DEFAULT_UNIFIED_SETTINGS,
+ providerInstances: {
+ [ProviderInstanceId.make("cline")]: {
+ driver: cline,
+ config: { customModels: ["unadvertised"] },
+ },
+ },
+ };
+ const entry = deriveProviderInstanceEntries(providers)[0]!;
+
+ expect(getAppModelOptions(settings, providers, cline).map((option) => option.slug)).toEqual([
+ "advertised",
+ ]);
+ expect(getAppModelOptionsForInstance(settings, entry).map((option) => option.slug)).toEqual([
+ "advertised",
+ ]);
+ });
+
it("preserves server-provided legacy model metadata", () => {
const baseProvider = provider({
instanceId: "claudeAgent",
@@ -323,6 +367,76 @@ describe("instance-scoped model selection", () => {
model: "openai/gpt-5.5",
});
});
+
+ it("returns no background selection when Cline is the only usable provider", () => {
+ const providers = [
+ provider({
+ provider: ProviderDriverKind.make("cline"),
+ instanceId: "cline",
+ models: ["advertised-interactive-model"],
+ }),
+ ];
+ const settings: UnifiedSettings = {
+ ...settingsWithProviderInstances(),
+ providerInstances: {
+ [ProviderInstanceId.make("cline")]: {
+ driver: ProviderDriverKind.make("cline"),
+ enabled: true,
+ config: {},
+ },
+ },
+ textGenerationModelSelection: {
+ instanceId: ProviderInstanceId.make("cline"),
+ model: "advertised-interactive-model",
+ },
+ };
+
+ expect(resolveAppModelSelectionState(settings, providers)).toEqual({
+ instanceId: "t3code_no_provider",
+ model: "",
+ });
+ });
+
+ it("returns no background selection when non-Cline snapshots are all unusable", () => {
+ const providers = [
+ provider({
+ instanceId: "codex",
+ models: ["gpt-5.4"],
+ enabled: false,
+ }),
+ provider({
+ provider: ProviderDriverKind.make("claudeAgent"),
+ instanceId: "claudeAgent",
+ models: ["claude-sonnet-4-6"],
+ availability: "unavailable",
+ }),
+ ];
+
+ expect(resolveAppModelSelectionState(DEFAULT_UNIFIED_SETTINGS, providers)).toEqual({
+ instanceId: "t3code_no_provider",
+ model: "",
+ });
+ });
+
+ it("returns no background selection for errored or empty provider catalogs", () => {
+ const providers = [
+ provider({
+ instanceId: "codex",
+ models: ["gpt-5.4"],
+ status: "error",
+ }),
+ provider({
+ provider: ProviderDriverKind.make("claudeAgent"),
+ instanceId: "claudeAgent",
+ models: [],
+ }),
+ ];
+
+ expect(resolveAppModelSelectionState(DEFAULT_UNIFIED_SETTINGS, providers)).toEqual({
+ instanceId: "t3code_no_provider",
+ model: "",
+ });
+ });
});
describe("withoutPlanAgentSelection", () => {
diff --git a/apps/web/src/modelSelection.ts b/apps/web/src/modelSelection.ts
index ccdffdda1004..4926230a79b1 100644
--- a/apps/web/src/modelSelection.ts
+++ b/apps/web/src/modelSelection.ts
@@ -23,7 +23,12 @@ import {
resolveSelectableProvider,
} from "./providerModels";
import { ModelEsque } from "./components/chat/providerIconUtils";
-import { type ProviderInstanceEntry, deriveProviderInstanceEntries } from "./providerInstances";
+import {
+ type ProviderInstanceEntry,
+ deriveProviderInstanceEntries,
+ isProviderInstancePickerReady,
+ NO_PROVIDER_MODEL_SELECTION,
+} from "./providerInstances";
import { sortModelsForProviderInstance } from "./modelOrdering";
const MAX_CUSTOM_MODEL_COUNT = 32;
@@ -166,7 +171,8 @@ export function getAppModelOptions(
// settings and the initial render before the first write both still
// see the user's authored custom models.
const defaultInstanceId = defaultInstanceIdForDriver(provider);
- const customModels = readInstanceCustomModels(settings, defaultInstanceId, provider);
+ const customModels =
+ provider === "cline" ? [] : readInstanceCustomModels(settings, defaultInstanceId, provider);
for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs)) {
if (seen.has(slug)) {
continue;
@@ -209,7 +215,10 @@ export function getAppModelOptionsForInstance(
),
);
- const customModels = readInstanceCustomModels(settings, entry.instanceId, entry.driverKind);
+ const customModels =
+ entry.driverKind === "cline"
+ ? []
+ : readInstanceCustomModels(settings, entry.instanceId, entry.driverKind);
for (const slug of normalizeCustomModelSlugs(customModels, builtInModelSlugs)) {
if (seen.has(slug)) {
continue;
@@ -331,49 +340,38 @@ export function resolveAppModelSelectionState(
instanceId: DEFAULT_TEXT_GENERATION_INSTANCE_ID,
model: DEFAULT_TEXT_GENERATION_MODEL,
};
- const entries = deriveProviderInstanceEntries(providers);
+ const entries = deriveProviderInstanceEntries(providers).filter(
+ (entry) => entry.driverKind !== "cline",
+ );
+ const supportsBackgroundSelection = (entry: ProviderInstanceEntry) =>
+ isProviderInstancePickerReady(entry) && entry.models.length > 0;
const selectedEntry = entries.find(
- (entry) => entry.instanceId === selection.instanceId && entry.enabled && entry.isAvailable,
+ (entry) => entry.instanceId === selection.instanceId && supportsBackgroundSelection(entry),
);
- const entry =
- selectedEntry ?? entries.find((candidate) => candidate.enabled && candidate.isAvailable);
- if (entry) {
- // When the instance changed due to fallback (e.g. selected instance was disabled),
- // don't carry over the old instance's model — use the fallback instance's default.
- const selectedModel = selectedEntry ? selection.model : null;
- const model =
- resolveAppModelSelectionForInstance(entry.instanceId, settings, providers, selectedModel) ??
- entry.models[0]?.slug ??
- DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[entry.driverKind];
- if (!model) {
- return createModelSelection(entry.instanceId, "", []);
- }
- const provider = entry.driverKind;
- const { modelOptionsForDispatch } = getComposerProviderState({
- provider,
- model,
- models: entry.models,
- modelOptions: selectedEntry ? selection.options : undefined,
- planModeEnabled: settings.planModeEnabled,
- });
+ const entry = selectedEntry ?? entries.find(supportsBackgroundSelection);
+ // Snapshots can remain present while an instance is disabled or unavailable.
+ // Background text generation must fail closed instead of synthesizing a
+ // Codex selection from those unusable rows.
+ if (!entry) return NO_PROVIDER_MODEL_SELECTION;
- return createModelSelection(entry.instanceId, model, modelOptionsForDispatch);
+ // When the instance changed due to fallback (e.g. selected instance was disabled),
+ // don't carry over the old instance's model — use the fallback instance's default.
+ const selectedModel = selectedEntry ? selection.model : null;
+ const model =
+ resolveAppModelSelectionForInstance(entry.instanceId, settings, providers, selectedModel) ??
+ entry.models[0]?.slug ??
+ DEFAULT_TEXT_GENERATION_MODEL_BY_PROVIDER[entry.driverKind];
+ if (!model) {
+ return createModelSelection(entry.instanceId, "", []);
}
-
- const provider = resolveSelectableProvider(providers, null);
- const keptSelectedProvider = false;
-
- // When the provider changed due to fallback (e.g. selected provider was disabled),
- // don't carry over the old provider's model — use the fallback provider's default.
- const selectedModel = keptSelectedProvider ? selection.model : null;
- const model = resolveAppModelSelection(provider, settings, providers, selectedModel);
+ const provider = entry.driverKind;
const { modelOptionsForDispatch } = getComposerProviderState({
provider,
model,
- models: getProviderModels(providers, provider),
- modelOptions: keptSelectedProvider ? selection.options : undefined,
+ models: entry.models,
+ modelOptions: selectedEntry ? selection.options : undefined,
planModeEnabled: settings.planModeEnabled,
});
- return createModelSelection(defaultInstanceIdForDriver(provider), model, modelOptionsForDispatch);
+ return createModelSelection(entry.instanceId, model, modelOptionsForDispatch);
}
diff --git a/apps/web/src/providerInstances.test.ts b/apps/web/src/providerInstances.test.ts
index b64a5e25d508..423b8daf71f8 100644
--- a/apps/web/src/providerInstances.test.ts
+++ b/apps/web/src/providerInstances.test.ts
@@ -4,9 +4,11 @@ import {
applyProviderInstanceSettings,
deriveProviderEntriesByEnvironment,
deriveProviderInstanceEntries,
+ filterTextGenerationProviderInstanceEntries,
getDefaultProviderInstanceModel,
isProviderInstancePickerReady,
isProviderInstancePickerVisible,
+ resolveComposerProviderInstanceEntry,
resolveDefaultProviderModelSelection,
resolveSelectableProviderInstance,
resolveProviderDriverKindForInstanceSelection,
@@ -87,6 +89,20 @@ describe("isProviderInstancePickerVisible", () => {
});
});
+describe("filterTextGenerationProviderInstanceEntries", () => {
+ it("excludes built-in and custom Cline instances", () => {
+ const entries = deriveProviderInstanceEntries([
+ provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
+ provider({ provider: ProviderDriverKind.make("cline"), instanceId: "cline" }),
+ provider({ provider: ProviderDriverKind.make("cline"), instanceId: "cline_work" }),
+ ]);
+
+ expect(
+ filterTextGenerationProviderInstanceEntries(entries).map((entry) => entry.instanceId),
+ ).toEqual(["codex"]);
+ });
+});
+
describe("applyProviderInstanceSettings", () => {
it("uses settings when a streamed snapshot still reports a disabled default as enabled", () => {
const entries = deriveProviderInstanceEntries([
@@ -291,6 +307,46 @@ describe("resolveSelectableProviderInstance", () => {
});
});
+describe("resolveComposerProviderInstanceEntry", () => {
+ it("falls back from a disabled draft selection to the same ready instance used for dispatch", () => {
+ const entries = deriveProviderInstanceEntries([
+ provider({
+ provider: ProviderDriverKind.make("cline"),
+ instanceId: "cline",
+ enabled: false,
+ }),
+ provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
+ ]);
+
+ expect(
+ resolveComposerProviderInstanceEntry({
+ entries,
+ candidateInstanceIds: ["cline"],
+ requestedDriverKind: ProviderDriverKind.make("cline"),
+ lockedProvider: null,
+ lockedContinuationGroupKey: null,
+ })?.instanceId,
+ ).toBe("codex");
+ });
+
+ it("uses the exact selected custom instance instead of its driver's default snapshot", () => {
+ const entries = deriveProviderInstanceEntries([
+ provider({ provider: ProviderDriverKind.make("cline"), instanceId: "cline" }),
+ provider({ provider: ProviderDriverKind.make("cline"), instanceId: "cline_work" }),
+ ]);
+
+ expect(
+ resolveComposerProviderInstanceEntry({
+ entries,
+ candidateInstanceIds: ["cline_work", "cline"],
+ requestedDriverKind: ProviderDriverKind.make("cline"),
+ lockedProvider: null,
+ lockedContinuationGroupKey: null,
+ })?.instanceId,
+ ).toBe("cline_work");
+ });
+});
+
describe("resolveProviderDriverKindForInstanceSelection", () => {
it("maps custom provider instance ids back to their driver kind", () => {
const providers = [
@@ -420,6 +476,42 @@ describe("resolveDefaultProviderModelSelection", () => {
expect(resolveDefaultProviderModelSelection(providers, stored)).toBe(stored);
});
+ it("heals a stale Cline model against the current advertised catalog", () => {
+ const providers = [
+ provider({
+ provider: ProviderDriverKind.make("cline"),
+ instanceId: "cline",
+ models: [model("current-account-model", false, true)],
+ }),
+ ];
+
+ expect(
+ resolveDefaultProviderModelSelection(providers, {
+ instanceId: ProviderInstanceId.make("cline"),
+ model: "retired-account-model",
+ options: [{ id: "unused", value: "stale" }],
+ }),
+ ).toEqual({ instanceId: "cline", model: "current-account-model" });
+ });
+
+ it("returns no project selection for a Cline instance with an empty catalog", () => {
+ const providers = [
+ provider({
+ provider: ProviderDriverKind.make("cline"),
+ instanceId: "cline",
+ status: "error",
+ models: [],
+ }),
+ ];
+
+ expect(
+ resolveDefaultProviderModelSelection(providers, {
+ instanceId: ProviderInstanceId.make("cline"),
+ model: "retired-account-model",
+ }),
+ ).toBeNull();
+ });
+
it("replaces a stale stored instance with the first ready instance and its model", () => {
const providers = [
provider({
diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.ts
index ef60d554dd78..6bd1b2b1019a 100644
--- a/apps/web/src/providerInstances.ts
+++ b/apps/web/src/providerInstances.ts
@@ -288,6 +288,13 @@ export function sortProviderInstanceEntries(
return sorted;
}
+/** Background text generation must not offer drivers without a safe backend. */
+export function filterTextGenerationProviderInstanceEntries(
+ entries: ReadonlyArray,
+): ReadonlyArray {
+ return entries.filter((entry) => entry.driverKind !== "cline");
+}
+
/**
* Look up a single instance entry by exact `instanceId`. Missing snapshots
* are not inferred from driver kind in UI routing code.
@@ -357,6 +364,46 @@ export function resolveSelectableProviderInstanceEntry(
);
}
+/**
+ * Resolve the provider instance targeted by a composer draft.
+ *
+ * ChatView and ChatComposer both consume this result: the former derives
+ * capability banners and send restrictions, while the latter builds the
+ * actual turn selection. Keeping the candidate and fallback rules here
+ * prevents those two surfaces from disagreeing after an instance is disabled,
+ * becomes unavailable, or is constrained by a started thread.
+ */
+export function resolveComposerProviderInstanceEntry(input: {
+ readonly entries: ReadonlyArray;
+ readonly candidateInstanceIds: ReadonlyArray;
+ readonly requestedDriverKind: ProviderDriverKind;
+ readonly lockedProvider: ProviderDriverKind | null;
+ readonly lockedContinuationGroupKey: string | null;
+}): ProviderInstanceEntry | undefined {
+ const isCompatible = (entry: ProviderInstanceEntry) =>
+ (!input.lockedProvider || entry.driverKind === input.lockedProvider) &&
+ (!input.lockedContinuationGroupKey ||
+ entry.continuationGroupKey === input.lockedContinuationGroupKey);
+
+ for (const candidate of input.candidateInstanceIds) {
+ if (!candidate) continue;
+ const match = input.entries.find(
+ (entry) =>
+ entry.instanceId === candidate && entry.enabled && entry.isAvailable && isCompatible(entry),
+ );
+ if (match) return match;
+ }
+
+ const compatibleEntries = input.entries.filter(isCompatible);
+ const requestedDriverEntries = compatibleEntries.filter(
+ (entry) => entry.driverKind === input.requestedDriverKind,
+ );
+ return (
+ resolveSelectableProviderInstanceEntry(requestedDriverEntries, undefined) ??
+ resolveSelectableProviderInstanceEntry(compatibleEntries, undefined)
+ );
+}
+
/**
* Resolve the routing key for a selection that may reference an instance
* id that no longer exists (e.g. a persisted thread selection after the
@@ -383,7 +430,17 @@ export function resolveDefaultProviderModelSelection(
): ModelSelection | null {
const instanceId = resolveSelectableProviderInstance(providers, selection?.instanceId);
if (instanceId === undefined) return null;
- if (selection?.instanceId === instanceId) return selection;
+ if (selection?.instanceId === instanceId) {
+ const entry = deriveProviderInstanceEntries(providers).find(
+ (candidate) => candidate.instanceId === instanceId,
+ );
+ if (
+ entry?.driverKind !== "cline" ||
+ entry.models.some((model) => model.slug === selection.model)
+ ) {
+ return selection;
+ }
+ }
const model = getDefaultProviderInstanceModel(providers, instanceId);
return model ? { instanceId, model } : null;
}
diff --git a/apps/web/src/providerModels.test.ts b/apps/web/src/providerModels.test.ts
new file mode 100644
index 000000000000..707bf341136b
--- /dev/null
+++ b/apps/web/src/providerModels.test.ts
@@ -0,0 +1,92 @@
+import { ProviderDriverKind, ProviderInstanceId, type ServerProvider } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import {
+ canUseProviderInteractionModeShortcut,
+ getUnsupportedProviderAttachmentReason,
+ getProviderSupportedRuntimeModes,
+ getUnsupportedProviderModeReason,
+} from "./providerModels";
+
+const provider = (overrides: Partial = {}): ServerProvider => ({
+ instanceId: ProviderInstanceId.make("cline"),
+ driver: ProviderDriverKind.make("cline"),
+ displayName: "Cline",
+ enabled: true,
+ installed: true,
+ version: "1.0.0",
+ status: "ready",
+ auth: { status: "authenticated" },
+ checkedAt: "2026-08-23T00:00:00.000Z",
+ models: [],
+ slashCommands: [],
+ skills: [],
+ ...overrides,
+});
+
+describe("provider mode capabilities", () => {
+ it("keeps legacy providers compatible when runtime modes are absent", () => {
+ expect(getProviderSupportedRuntimeModes(provider())).toEqual([
+ "approval-required",
+ "auto-accept-edits",
+ "auto",
+ "full-access",
+ ]);
+ });
+
+ it("requires an explicit safe mode change for restricted providers", () => {
+ const cline = provider({
+ showInteractionModeToggle: false,
+ supportedRuntimeModes: ["full-access"],
+ });
+
+ expect(
+ getUnsupportedProviderModeReason({
+ provider: cline,
+ runtimeMode: "approval-required",
+ interactionMode: "default",
+ }),
+ ).toContain("Choose Full access");
+ expect(
+ getUnsupportedProviderModeReason({
+ provider: cline,
+ runtimeMode: "full-access",
+ interactionMode: "plan",
+ }),
+ ).toContain("Choose Build");
+ expect(
+ getUnsupportedProviderModeReason({
+ provider: cline,
+ runtimeMode: "full-access",
+ interactionMode: "default",
+ }),
+ ).toBeNull();
+ });
+
+ it("blocks entering Plan by shortcut but preserves the Build escape", () => {
+ expect(
+ canUseProviderInteractionModeShortcut({
+ planModeUiEnabled: true,
+ showInteractionModeToggle: false,
+ interactionMode: "default",
+ }),
+ ).toBe(false);
+ expect(
+ canUseProviderInteractionModeShortcut({
+ planModeUiEnabled: true,
+ showInteractionModeToggle: false,
+ interactionMode: "plan",
+ }),
+ ).toBe(true);
+ });
+
+ it("rejects carried images only when the provider explicitly disallows them", () => {
+ expect(
+ getUnsupportedProviderAttachmentReason(provider({ supportsImageAttachments: false }), 1),
+ ).toContain("Remove the images");
+ expect(getUnsupportedProviderAttachmentReason(provider(), 1)).toBeNull();
+ expect(
+ getUnsupportedProviderAttachmentReason(provider({ supportsImageAttachments: false }), 0),
+ ).toBeNull();
+ });
+});
diff --git a/apps/web/src/providerModels.ts b/apps/web/src/providerModels.ts
index 6fc8b5e122a9..5fe8e6381cf4 100644
--- a/apps/web/src/providerModels.ts
+++ b/apps/web/src/providerModels.ts
@@ -5,6 +5,7 @@ import {
ProviderDriverKind,
type ModelCapabilities,
type ProviderInstanceId,
+ type RuntimeMode,
type ServerProvider,
type ServerProviderModel,
} from "@t3tools/contracts";
@@ -14,6 +15,12 @@ const EMPTY_CAPABILITIES: ModelCapabilities = createModelCapabilities({
optionDescriptors: [],
});
const DEFAULT_DRIVER_KIND = ProviderDriverKind.make("codex");
+export const ALL_RUNTIME_MODES: ReadonlyArray = [
+ "approval-required",
+ "auto-accept-edits",
+ "auto",
+ "full-access",
+];
export function formatProviderDriverKindLabel(provider: ProviderDriverKind): string {
return provider
@@ -53,6 +60,50 @@ export function getProviderInteractionModeToggle(
return getProviderSnapshot(providers, provider)?.showInteractionModeToggle ?? true;
}
+export function getProviderSupportedRuntimeModes(
+ provider: ServerProvider | null | undefined,
+): ReadonlyArray {
+ return provider?.supportedRuntimeModes ?? ALL_RUNTIME_MODES;
+}
+
+export function getUnsupportedProviderModeReason(input: {
+ readonly provider: ServerProvider | null | undefined;
+ readonly runtimeMode: RuntimeMode;
+ readonly interactionMode: "default" | "plan";
+}): string | null {
+ const label =
+ input.provider?.displayName?.trim() ||
+ (input.provider ? formatProviderDriverKindLabel(input.provider.driver) : "This provider");
+ if (!getProviderSupportedRuntimeModes(input.provider).includes(input.runtimeMode)) {
+ return `${label} does not support the selected access mode. Choose Full access to continue.`;
+ }
+ if (input.interactionMode === "plan" && input.provider?.showInteractionModeToggle === false) {
+ return `${label} does not support Plan mode. Choose Build to continue.`;
+ }
+ return null;
+}
+
+export function canUseProviderInteractionModeShortcut(input: {
+ readonly planModeUiEnabled: boolean;
+ readonly showInteractionModeToggle: boolean;
+ readonly interactionMode: "default" | "plan";
+}): boolean {
+ return (
+ input.planModeUiEnabled && (input.showInteractionModeToggle || input.interactionMode === "plan")
+ );
+}
+
+export function getUnsupportedProviderAttachmentReason(
+ provider: ServerProvider | null | undefined,
+ attachmentCount: number,
+): string | null {
+ if (attachmentCount === 0 || provider?.supportsImageAttachments !== false) {
+ return null;
+ }
+ const label = provider.displayName?.trim() || formatProviderDriverKindLabel(provider.driver);
+ return `${label} does not support image attachments. Remove the images to continue.`;
+}
+
export function isProviderEnabled(
providers: ReadonlyArray,
provider: ProviderDriverKind,
@@ -122,6 +173,11 @@ export function getDefaultServerModel(
provider: ProviderDriverKind,
): string {
const models = getProviderModels(providers, provider);
+ if (provider === "cline" && models.length === 0) {
+ // Cline's model catalog is account-scoped. An empty catalog is an
+ // actionable provider error, not a reason to synthesize a Codex model.
+ return "";
+ }
return (
models.find((model) => model.isDefault && !model.isCustom)?.slug ??
models.find((model) => !model.isCustom)?.slug ??
diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.ts
index 4824258422fb..bc849f82da8b 100644
--- a/apps/web/src/session-logic.ts
+++ b/apps/web/src/session-logic.ts
@@ -52,6 +52,12 @@ export const PROVIDER_OPTIONS: Array<{
available: true,
pickerSidebarBadge: "new",
},
+ {
+ value: ProviderDriverKind.make("cline"),
+ label: "Cline",
+ available: true,
+ pickerSidebarBadge: "new",
+ },
];
export type WorkLogToolLifecycleStatus =
diff --git a/docs/internals/glossary.md b/docs/internals/glossary.md
index da16f74d339f..bc6f6273289f 100644
--- a/docs/internals/glossary.md
+++ b/docs/internals/glossary.md
@@ -94,7 +94,7 @@ The live backend agent implementation and its event stream. The main service is
#### Provider
-The backend agent runtime that actually performs work. Five drivers ship built in: Codex, Claude, Cursor, Grok, and OpenCode. See [ProviderService.ts][14], [ProviderAdapter.ts][15], and [CodexAdapter.ts][17] as a representative adapter.
+The backend agent runtime that actually performs work. Six drivers ship built in: Codex, Claude, Cline, Cursor, Grok, and OpenCode. See [ProviderService.ts][14], [ProviderAdapter.ts][15], and [CodexAdapter.ts][17] as a representative adapter.
#### Session
diff --git a/docs/internals/overview.md b/docs/internals/overview.md
index b9454f7b58d0..7c36eaeaf5f8 100644
--- a/docs/internals/overview.md
+++ b/docs/internals/overview.md
@@ -18,13 +18,13 @@ there, never in the client.
┌──────────────────▼─────────────────────────────┐
│ apps/server │
│ orchestration engine (event-sourced) │
-│ provider driver registry (5 built-in drivers) │
+│ provider driver registry (6 built-in drivers) │
│ checkpointing, VCS, terminals, filesystem │
└──────────────────┬─────────────────────────────┘
│ per-driver transport
┌──────────────────▼─────────────────────────────┐
-│ Agent CLIs: Codex, Claude, Cursor, Grok, │
-│ OpenCode │
+│ Agent CLIs: Codex, Claude, Cline, Cursor, │
+│ Grok, OpenCode │
└────────────────────────────────────────────────┘
```
@@ -106,8 +106,8 @@ build production behavior on receipts.
## Provider drivers
-Five drivers ship built in, registered in [`builtInDrivers.ts`][drivers] as `BUILT_IN_DRIVERS`:
-Codex, Claude, Cursor, Grok, and OpenCode. A driver declares its kind and config schema and creates a
+Six drivers ship built in, registered in [`builtInDrivers.ts`][drivers] as `BUILT_IN_DRIVERS`:
+Codex, Claude, Cline, Cursor, Grok, and OpenCode. A driver declares its kind and config schema and creates a
scoped adapter; `ProviderInstanceRegistry` owns live instances and `ProviderAdapterRegistry` resolves
an instance to its adapter, so `ProviderService` routes session and turn operations without knowing
which agent is behind them. See [providers.md](./providers.md).
diff --git a/docs/internals/providers.md b/docs/internals/providers.md
index a309d70f03de..b7bfb6b0e11f 100644
--- a/docs/internals/providers.md
+++ b/docs/internals/providers.md
@@ -7,12 +7,13 @@ orchestration layer does not know which one is behind a thread.
## Built-in drivers
-[`builtInDrivers.ts`][drivers] exports `BUILT_IN_DRIVERS` with five entries:
+[`builtInDrivers.ts`][drivers] exports `BUILT_IN_DRIVERS` with six entries:
| Driver kind | Driver source |
| ------------- | --------------------------------------- |
| `codex` | [`Drivers/CodexDriver.ts`][codex] |
| `claudeAgent` | [`Drivers/ClaudeDriver.ts`][claude] |
+| `cline` | [`Drivers/ClineDriver.ts`][cline] |
| `cursor` | [`Drivers/CursorDriver.ts`][cursor] |
| `grok` | [`Drivers/GrokDriver.ts`][grok] |
| `opencode` | [`Drivers/OpenCodeDriver.ts`][opencode] |
@@ -39,6 +40,24 @@ directory to route session and turn operations for a thread, so callers name a t
Adding a driver means writing the driver plus adapter and adding it to `BUILT_IN_DRIVERS`. No
orchestration, contract, or client change is required for the common case.
+### Current Cline ACP limitations
+
+Cline ACP accepts per-session `mcpServers` during setup but does not currently consume them. The
+provider service therefore withholds T3 MCP credentials for Cline, and agent browser/preview tools
+are unsupported in Cline sessions. Do not work around this by writing Cline's global configuration:
+provider processes may run on remote hosts and multiple configured instances may share that state.
+
+Cline also omits the optional `ProviderInstance.textGeneration` capability. Current ACP creates its
+normal local runtime with default config extensions, which can execute project/account lifecycle
+hooks before any ACP tool-permission request. Until ACP exposes a verified extension-disable
+boundary, server settings must never select Cline for background title, branch, commit, or pull
+request text generation.
+
+The same extension boundary means only `full-access` interactive sessions are currently truthful.
+`ClineAdapter` rejects every narrower runtime mode before spawning the CLI, and the provider
+snapshot does not advertise the plan/build interaction toggle. Do not describe ACP permission
+responses as supervising workspace/account hooks; they are separate execution paths.
+
## How provider work is requested
Clients never call a provider directly. They dispatch orchestration commands over the RPC method
@@ -78,6 +97,7 @@ when a request opens (approval) or user input is requested, via
[drivers]: ../../apps/server/src/provider/builtInDrivers.ts
[codex]: ../../apps/server/src/provider/Drivers/CodexDriver.ts
[claude]: ../../apps/server/src/provider/Drivers/ClaudeDriver.ts
+[cline]: ../../apps/server/src/provider/Drivers/ClineDriver.ts
[cursor]: ../../apps/server/src/provider/Drivers/CursorDriver.ts
[grok]: ../../apps/server/src/provider/Drivers/GrokDriver.ts
[opencode]: ../../apps/server/src/provider/Drivers/OpenCodeDriver.ts
diff --git a/docs/user/install.md b/docs/user/install.md
index 15f96e00d4f3..4d2ccd172617 100644
--- a/docs/user/install.md
+++ b/docs/user/install.md
@@ -54,20 +54,38 @@ yay -S t3code-nightly-bin
T3 Code drives provider CLIs; it does not ship them. Install the CLI for each provider you want
to use, then authenticate it.
-| Provider | CLI | Default binary | Log in with |
-| ---------- | ----------------------------------------------------- | -------------- | --------------------- |
-| Codex | [Codex CLI](https://developers.openai.com/codex/cli) | `codex` | `codex login` |
-| Claude | [Claude Code](https://claude.com/product/claude-code) | `claude` | `claude auth login` |
-| Cursor | [Cursor CLI](https://cursor.com/cli) | `cursor-agent` | `agent login` |
-| Grok Build | [Grok Build CLI](https://x.ai/cli) | `grok` | `grok login` |
-| OpenCode | [OpenCode](https://opencode.ai) | `opencode` | `opencode auth login` |
-
-Codex and Claude are on by default. Cursor, Grok Build, and OpenCode are off by default; turn
-them on in **Settings** → the provider's card when you want to use them.
+| Provider | CLI | Default binary | Log in with |
+| ---------- | ------------------------------------------------------ | -------------- | --------------------- |
+| Codex | [Codex CLI](https://developers.openai.com/codex/cli) | `codex` | `codex login` |
+| Claude | [Claude Code](https://claude.com/product/claude-code) | `claude` | `claude auth login` |
+| Cline | [Cline CLI](https://docs.cline.bot/usage/cli-overview) | `cline` | `cline auth` |
+| Cursor | [Cursor CLI](https://cursor.com/cli) | `cursor-agent` | `agent login` |
+| Grok Build | [Grok Build CLI](https://x.ai/cli) | `grok` | `grok login` |
+| OpenCode | [OpenCode](https://opencode.ai) | `opencode` | `opencode auth login` |
+
+Codex, Claude, and Cursor are on by default. Grok Build, OpenCode, and Cline are off by default;
+turn them on in **Settings** → the provider's card when you want to use them.
Cursor is the one to watch: install Cursor CLI, which provides the `cursor-agent` binary that
T3 Code looks for, but authenticate with `agent login`, not `cursor-agent login`.
+Cline reuses credentials saved by `cline auth`. T3 Code does not launch Cline's interactive ACP
+sign-in flow, so authenticate it on the server machine before enabling it.
+
+Image attachments are currently unavailable with Cline. T3 Code rejects Cline turns that contain
+images because the current Cline CLI drops image input over ACP instead of sending it to the model.
+
+T3 Code's agent browser and preview tools are also unavailable in Cline sessions. Current Cline ACP
+does not consume per-session MCP servers, so T3 Code withholds the otherwise unused MCP credential.
+
+Cline is not used for T3 Code's background title, branch, commit, or pull-request text generation.
+Current Cline ACP loads workspace and account extensions, including executable lifecycle hooks, and
+does not expose a way for T3 Code to disable them for non-interactive metadata generation.
+
+Cline sessions currently require **Full access**. Supervised and auto-accept modes cannot cover
+extensions that run outside ACP tool-permission requests, so T3 Code rejects those modes before it
+starts Cline. Plan mode is not advertised for the same reason.
+
Run the login command on the machine running the T3 Code server, not on the device you browse
from.
diff --git a/packages/contracts/src/model.ts b/packages/contracts/src/model.ts
index 9fcd0d266dd6..b8d7df918817 100644
--- a/packages/contracts/src/model.ts
+++ b/packages/contracts/src/model.ts
@@ -132,6 +132,7 @@ const CLAUDE_DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
const CURSOR_DRIVER_KIND = ProviderDriverKind.make("cursor");
const GROK_DRIVER_KIND = ProviderDriverKind.make("grok");
const OPENCODE_DRIVER_KIND = ProviderDriverKind.make("opencode");
+const CLINE_DRIVER_KIND = ProviderDriverKind.make("cline");
export const DEFAULT_MODEL = "gpt-5.6-sol";
@@ -146,7 +147,6 @@ export const PREFERRED_DEFAULT_CODEX_MODELS: ReadonlyArray = [
];
export const DEFAULT_TEXT_GENERATION_MODEL = "gpt-5.6-luna";
export const DEFAULT_TEXT_GENERATION_REASONING_EFFORT = "low";
-
export const DEFAULT_MODEL_BY_PROVIDER: Partial> = {
[CODEX_DRIVER_KIND]: DEFAULT_MODEL,
[CLAUDE_DRIVER_KIND]: "claude-sonnet-5",
@@ -222,4 +222,5 @@ export const PROVIDER_DISPLAY_NAMES: Partial>
[CURSOR_DRIVER_KIND]: "Cursor",
[GROK_DRIVER_KIND]: "Grok",
[OPENCODE_DRIVER_KIND]: "OpenCode",
+ [CLINE_DRIVER_KIND]: "Cline",
};
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index 9791a4f62185..b6da649cc9f9 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -19,6 +19,7 @@ import {
} from "./keybindings.ts";
import { EditorId, RemoteOpenTarget } from "./editor.ts";
import { ModelCapabilities } from "./model.ts";
+import { RuntimeMode } from "./orchestration.ts";
import { ProviderDriverKind, ProviderInstanceId } from "./providerInstance.ts";
import { ServerSettings } from "./settings.ts";
@@ -170,6 +171,12 @@ export const ServerProvider = Schema.Struct({
badgeLabel: Schema.optional(TrimmedNonEmptyString),
continuation: Schema.optional(ServerProviderContinuation),
showInteractionModeToggle: Schema.optional(Schema.Boolean),
+ // Optional for backward compatibility. An absent list means every runtime
+ // mode is supported; providers with stricter boundaries advertise them.
+ supportedRuntimeModes: Schema.optional(Schema.Array(RuntimeMode)),
+ // Optional for backward compatibility. An absent value keeps the legacy
+ // behavior where clients allow image attachments.
+ supportsImageAttachments: Schema.optional(Schema.Boolean),
requiresNewThreadForModelChange: Schema.optional(Schema.Boolean),
enabled: Schema.Boolean,
installed: Schema.Boolean,
diff --git a/packages/contracts/src/settings.test.ts b/packages/contracts/src/settings.test.ts
index 55023bcc48e7..deb9cbc3e4c7 100644
--- a/packages/contracts/src/settings.test.ts
+++ b/packages/contracts/src/settings.test.ts
@@ -203,12 +203,14 @@ describe("provider enabled defaults", () => {
expect(decoded.providers.cursor.enabled).toBe(true);
expect(decoded.providers.grok.enabled).toBe(false);
expect(decoded.providers.opencode.enabled).toBe(false);
+ expect(decoded.providers.cline.enabled).toBe(false);
});
it("derives per-driver defaults from the settings schemas", () => {
expect(defaultEnabledForDriver(ProviderDriverKind.make("codex"))).toBe(true);
expect(defaultEnabledForDriver(ProviderDriverKind.make("cursor"))).toBe(true);
expect(defaultEnabledForDriver(ProviderDriverKind.make("grok"))).toBe(false);
+ expect(defaultEnabledForDriver(ProviderDriverKind.make("cline"))).toBe(false);
// Unknown fork drivers stay enabled; their own build decides otherwise.
expect(defaultEnabledForDriver(ProviderDriverKind.make("ollama"))).toBe(true);
});
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 80e03b8c879e..5b5715fa8200 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -455,7 +455,7 @@ export type CursorSettings = typeof CursorSettings.Type;
export const GrokSettings = makeProviderSettingsSchema(
{
- // Off by default (like Cursor and OpenCode): the binding is not yet
+ // Off by default (like OpenCode and Cline): the binding is not yet
// stable enough to probe on every install. Users opt in from Settings.
enabled: Schema.Boolean.pipe(
Schema.withDecodingDefault(Effect.succeed(false)),
@@ -481,7 +481,7 @@ export type GrokSettings = typeof GrokSettings.Type;
export const OpenCodeSettings = makeProviderSettingsSchema(
{
- // Off by default (like Cursor and Grok): the binding is not yet stable
+ // Off by default (like Grok and Cline): the binding is not yet stable
// enough to probe on every install. Users opt in from Settings.
enabled: Schema.Boolean.pipe(
Schema.withDecodingDefault(Effect.succeed(false)),
@@ -531,6 +531,32 @@ export const OpenCodeSettings = makeProviderSettingsSchema(
);
export type OpenCodeSettings = typeof OpenCodeSettings.Type;
+export const ClineSettings = makeProviderSettingsSchema(
+ {
+ // Off by default (like Grok and OpenCode): the binding is not yet stable
+ // enough to probe on every install. Users opt in from Settings.
+ enabled: Schema.Boolean.pipe(
+ Schema.withDecodingDefault(Effect.succeed(false)),
+ Schema.annotateKey({ providerSettingsForm: { hidden: true } }),
+ ),
+ binaryPath: makeBinaryPathSetting("cline").pipe(
+ Schema.annotateKey({
+ title: "Binary path",
+ description: "Path to the Cline CLI binary.",
+ providerSettingsForm: { placeholder: "cline", clearWhenEmpty: "omit" },
+ }),
+ ),
+ customModels: Schema.Array(Schema.String).pipe(
+ Schema.withDecodingDefault(Effect.succeed([])),
+ Schema.annotateKey({ providerSettingsForm: { hidden: true } }),
+ ),
+ },
+ {
+ order: ["binaryPath"],
+ },
+);
+export type ClineSettings = typeof ClineSettings.Type;
+
export const ObservabilitySettings = Schema.Struct({
otlpTracesUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
otlpMetricsUrl: TrimmedString.pipe(Schema.withDecodingDefault(Effect.succeed(""))),
@@ -673,6 +699,7 @@ export const ServerSettings = Schema.Struct({
cursor: CursorSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
grok: GrokSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
opencode: OpenCodeSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
+ cline: ClineSettings.pipe(Schema.withDecodingDefault(Effect.succeed({}))),
}).pipe(Schema.withDecodingDefault(Effect.succeed({}))),
// New driver-agnostic instance map. Keyed by `ProviderInstanceId`; values
// are `ProviderInstanceConfig` envelopes. The driver-specific config blob
@@ -820,6 +847,12 @@ const OpenCodeSettingsPatch = Schema.Struct({
customModels: Schema.optionalKey(Schema.Array(Schema.String)),
});
+const ClineSettingsPatch = Schema.Struct({
+ enabled: Schema.optionalKey(Schema.Boolean),
+ binaryPath: Schema.optionalKey(TrimmedString),
+ customModels: Schema.optionalKey(Schema.Array(Schema.String)),
+});
+
export const ServerSettingsPatch = Schema.Struct({
// Server settings
enableLegacyTokenStreaming: Schema.optionalKey(Schema.Boolean),
@@ -861,6 +894,7 @@ export const ServerSettingsPatch = Schema.Struct({
cursor: Schema.optionalKey(CursorSettingsPatch),
grok: Schema.optionalKey(GrokSettingsPatch),
opencode: Schema.optionalKey(OpenCodeSettingsPatch),
+ cline: Schema.optionalKey(ClineSettingsPatch),
}),
),
// Whole-map replacement for the new instance config. Patching individual
diff --git a/packages/shared/src/serverSettings.test.ts b/packages/shared/src/serverSettings.test.ts
index baa84a4e1aa8..c8b5ee8fb3d1 100644
--- a/packages/shared/src/serverSettings.test.ts
+++ b/packages/shared/src/serverSettings.test.ts
@@ -264,6 +264,36 @@ describe("serverSettings helpers", () => {
expect(settings.sourceControlWriterModelSelection).toBe(sourceControlWriterModelSelection);
});
+ it("falls back from built-in and custom Cline source control writer selections", () => {
+ const customClineId = ProviderInstanceId.make("cline_work");
+ const settings = {
+ ...DEFAULT_SERVER_SETTINGS,
+ providers: {
+ ...DEFAULT_SERVER_SETTINGS.providers,
+ cline: { ...DEFAULT_SERVER_SETTINGS.providers.cline, enabled: true },
+ },
+ providerInstances: {
+ [customClineId]: {
+ driver: ProviderDriverKind.make("cline"),
+ enabled: true,
+ config: {},
+ },
+ },
+ };
+
+ for (const instanceId of [ProviderInstanceId.make("cline"), customClineId]) {
+ expect(
+ resolveSourceControlWriterModelSelection({
+ ...settings,
+ sourceControlWriterModelSelection: createModelSelection(
+ instanceId,
+ "advertised-interactive-model",
+ ),
+ }),
+ ).toBe(settings.textGenerationModelSelection);
+ }
+ });
+
it("replaces providerInstances maps so omitted instance fields are cleared", () => {
const codexId = ProviderInstanceId.make("codex");
const current = {
diff --git a/packages/shared/src/serverSettings.ts b/packages/shared/src/serverSettings.ts
index 69fc9eaacbcc..0024b117cb92 100644
--- a/packages/shared/src/serverSettings.ts
+++ b/packages/shared/src/serverSettings.ts
@@ -46,12 +46,24 @@ export function isModelSelectionProviderEnabled(
);
}
+function isTextGenerationModelSelectionSupported(
+ settings: ServerSettings,
+ selection: ModelSelection,
+): boolean {
+ const driver = settings.providerInstances[selection.instanceId]?.driver ?? selection.instanceId;
+ return driver !== "cline";
+}
+
export function resolveSourceControlWriterModelSelection(
settings: ServerSettings,
providers?: ReadonlyArray,
): ModelSelection {
const selection = settings.sourceControlWriterModelSelection;
- if (!selection || !isModelSelectionProviderEnabled(settings, selection)) {
+ if (
+ !selection ||
+ !isModelSelectionProviderEnabled(settings, selection) ||
+ !isTextGenerationModelSelectionSupported(settings, selection)
+ ) {
return settings.textGenerationModelSelection;
}
if (providers === undefined) {
