@makefinks/daemon 0.9.1 → 0.11.0

package/src/hooks/use-app-controller.ts

@@ -123,8 +123,13 @@ export function useAppController({
 		showProviderMenu,
 	});
 	const {
+		currentModelProvider,
+		setCurrentModelProvider,
 		currentModelId,
+		currentModelSupportsReasoning,
+		currentModelSupportsReasoningXHigh,
 		setCurrentModelId,
+		setCurrentModelForProvider,
 		currentOpenRouterProviderTag,
 		setCurrentOpenRouterProviderTag,
 		modelsWithPricing,
@@ -154,6 +159,7 @@ export function useAppController({
 	}, [onboardingComplete]);
 
 	const daemon = useDaemonRuntimeController({
+		currentModelProvider,
 		currentModelId,
 		preferencesLoaded,
 		sessionId: session.currentSessionId,
@@ -166,12 +172,18 @@ export function useAppController({
 	const [apiKeyMissingError, setApiKeyMissingError] = useState<string>("");
 	const [escPendingCancel, setEscPendingCancel] = useState(false);
 
-	const supportsReasoning = daemon.modelMetadata?.supportsReasoning ?? false;
+	const supportsReasoning =
+		currentModelProvider === "copilot"
+			? currentModelSupportsReasoning
+			: (daemon.modelMetadata?.supportsReasoning ?? false);
+	const supportsReasoningXHigh =
+		currentModelProvider === "copilot" ? currentModelSupportsReasoningXHigh : false;
 
 	// Preferences bootstrap (hook): returns a stable persist callback.
 	const { persistPreferences } = useAppPreferencesBootstrap({
 		manager,
-		setCurrentModelId,
+		setCurrentModelProvider,
+		setCurrentModelForProvider,
 		setCurrentOpenRouterProviderTag,
 		setCurrentDevice: bootstrap.setCurrentDevice,
 		setCurrentOutputDevice: bootstrap.setCurrentOutputDevice,
@@ -186,6 +198,7 @@ export function useAppController({
 		setLoadedPreferences: bootstrap.setLoadedPreferences,
 		setOnboardingActive: bootstrap.setOnboardingActive,
 		setOnboardingStep: bootstrap.setOnboardingStep,
+		setCopilotAuthenticated: bootstrap.setCopilotAuthenticated,
 		setPreferencesLoaded,
 	});
 
@@ -218,13 +231,17 @@ export function useAppController({
 		handleDeviceSelect,
 		handleOutputDeviceSelect,
 		handleModelSelect,
+		cycleModelProvider,
 		handleProviderSelect,
 		toggleInteractionMode,
 		completeOnboarding,
 		handleApiKeySubmit,
 	} = useAppCallbacks({
+		currentModelProvider,
+		setCurrentModelProvider,
 		currentModelId,
 		setCurrentModelId,
+		setCurrentModelForProvider,
 		setCurrentDevice: bootstrap.setCurrentDevice,
 		setCurrentOutputDevice: bootstrap.setCurrentOutputDevice,
 		setCurrentOpenRouterProviderTag,
@@ -235,7 +252,9 @@ export function useAppController({
 		persistPreferences,
 		loadedPreferences: bootstrap.loadedPreferences,
 		onboardingStep: bootstrap.onboardingStep,
+		copilotAuthenticated: bootstrap.copilotAuthenticated,
 		setOnboardingStep: bootstrap.setOnboardingStep,
+		setCopilotAuthenticated: bootstrap.setCopilotAuthenticated,
 		apiKeyTextareaRef: bootstrap.apiKeyTextareaRef,
 		setShowDeviceMenu,
 		setShowModelMenu,
@@ -367,6 +386,7 @@ export function useAppController({
 			hasGrounding: session.hasGrounding,
 			showFullReasoning,
 			showToolOutput,
+			currentModelProvider,
 		},
 		keyboardActions
 	);
@@ -379,8 +399,11 @@ export function useAppController({
 		reasoningQueue: daemon.reasoning.reasoningQueue,
 		responseElapsedMs: daemon.responseElapsedMs,
 		hasInteracted: daemon.hasInteracted,
+		currentModelProvider,
 		currentModelId,
 		modelMetadata: daemon.modelMetadata,
+		curatedModels: modelsWithPricing,
+		availableModels: openRouterModels,
 		preferencesLoaded,
 		currentSessionId: session.currentSessionId,
 		sessionMenuItems: session.sessionMenuItems,
@@ -466,6 +489,7 @@ export function useAppController({
 			reasoningEffort,
 			bashApprovalLevel,
 			supportsReasoning,
+			supportsReasoningXHigh,
 			canEnableVoiceOutput,
 			showFullReasoning,
 			setShowFullReasoning,
@@ -481,6 +505,8 @@ export function useAppController({
 			openRouterModels,
 			openRouterModelsLoading,
 			openRouterModelsUpdatedAt,
+			currentModelProvider,
+			setCurrentModelProvider,
 			currentModelId,
 			setCurrentModelId,
 			providerMenuItems,
@@ -499,6 +525,7 @@ export function useAppController({
 		onboarding: {
 			onboardingActive: bootstrap.onboardingActive,
 			onboardingStep: bootstrap.onboardingStep,
+			copilotAuthenticated: bootstrap.copilotAuthenticated,
 			setOnboardingStep: bootstrap.setOnboardingStep,
 			onboardingPreferences: bootstrap.loadedPreferences,
 			apiKeyTextareaRef: bootstrap.apiKeyTextareaRef,
@@ -509,6 +536,7 @@ export function useAppController({
 		},
 		settingsCallbacks: {
 			onToggleInteractionMode: toggleInteractionMode,
+			onCycleModelProvider: cycleModelProvider,
 			onSetVoiceInteractionType: setVoiceInteractionType,
 			onSetSpeechSpeed: setSpeechSpeed,
 			onSetReasoningEffort: setReasoningEffort,
@@ -590,6 +618,7 @@ export function useAppController({
 			},
 			sessionUsage: daemon.sessionUsage,
 			modelMetadata: daemon.modelMetadata,
+			currentModelProvider,
 			hasInteracted: daemon.hasInteracted,
 			frostColor,
 			initialStatusTop,

package/src/hooks/use-app-copilot-models-loader.ts

@@ -0,0 +1,45 @@
+import { useCallback, useEffect } from "react";
+import type { ModelOption } from "../types";
+import { getCopilotModels } from "../utils/copilot-models";
+
+export interface UseAppCopilotModelsLoaderParams {
+	preferencesLoaded: boolean;
+	enabled?: boolean;
+	setModels: React.Dispatch<React.SetStateAction<ModelOption[]>>;
+	setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+	setUpdatedAt: React.Dispatch<React.SetStateAction<number | null>>;
+}
+
+export interface UseAppCopilotModelsLoaderResult {
+	refresh: () => Promise<void>;
+}
+
+export function useAppCopilotModelsLoader(
+	params: UseAppCopilotModelsLoaderParams
+): UseAppCopilotModelsLoaderResult {
+	const { preferencesLoaded, enabled = true, setModels, setLoading, setUpdatedAt } = params;
+
+	const refresh = useCallback(
+		async (forceRefresh = false) => {
+			if (!preferencesLoaded || !enabled) return;
+			setLoading(true);
+			try {
+				const result = await getCopilotModels({ forceRefresh });
+				setModels(result.models);
+				setUpdatedAt(result.timestamp);
+			} finally {
+				setLoading(false);
+			}
+		},
+		[enabled, preferencesLoaded, setLoading, setModels, setUpdatedAt]
+	);
+
+	useEffect(() => {
+		if (!preferencesLoaded || !enabled) return;
+		void refresh(false);
+	}, [enabled, preferencesLoaded, refresh]);
+
+	return {
+		refresh: () => refresh(true),
+	};
+}

package/src/hooks/use-app-display-state.ts

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import { DaemonState } from "../types";
-import type { ContentBlock, SessionInfo } from "../types";
+import type { ContentBlock, LlmProvider, ModelOption, SessionInfo } from "../types";
 import { COLORS, STATE_COLOR_HEX, STATUS_TEXT } from "../ui/constants";
 import { formatElapsedTime } from "../utils/formatters";
 import type { ModelMetadata } from "../utils/model-metadata";
@@ -14,8 +14,11 @@ export interface UseAppDisplayStateParams {
 	responseElapsedMs: number;
 	hasInteracted: boolean;
 
+	currentModelProvider: LlmProvider;
 	currentModelId: string;
 	modelMetadata: ModelMetadata | null;
+	curatedModels: ModelOption[];
+	availableModels: ModelOption[];
 	preferencesLoaded: boolean;
 
 	currentSessionId: string | null;
@@ -57,8 +60,11 @@ export function useAppDisplayState(params: UseAppDisplayStateParams): UseAppDisp
 		reasoningQueue,
 		responseElapsedMs,
 		hasInteracted,
+		currentModelProvider,
 		currentModelId,
 		modelMetadata,
+		curatedModels,
+		availableModels,
 		preferencesLoaded,
 		currentSessionId,
 		sessionMenuItems,
@@ -113,8 +119,24 @@ export function useAppDisplayState(params: UseAppDisplayStateParams): UseAppDisp
 		if (modelMetadata?.name && modelMetadata.id === currentModelId) {
 			return modelMetadata.name;
 		}
+		const selectedModel =
+			availableModels.find((model) => model.id === currentModelId) ??
+			curatedModels.find((model) => model.id === currentModelId);
+		if (selectedModel?.name) {
+			return currentModelProvider === "copilot" ? `Copilot: ${selectedModel.name}` : selectedModel.name;
+		}
+		if (currentModelProvider === "copilot") {
+			return `Copilot: ${currentModelId}`;
+		}
 		return undefined;
-	}, [modelMetadata, currentModelId, preferencesLoaded]);
+	}, [
+		availableModels,
+		curatedModels,
+		currentModelProvider,
+		modelMetadata,
+		currentModelId,
+		preferencesLoaded,
+	]);
 
 	const sessionTitle = useMemo(() => {
 		if (!currentSessionId) return undefined;

package/src/hooks/use-app-model.ts

@@ -1,12 +1,18 @@
-import { useMemo, useState } from "react";
-import { AVAILABLE_MODELS, DEFAULT_MODEL_ID } from "../ai/model-config";
+import { useCallback, useMemo, useState } from "react";
+import {
+	AVAILABLE_MODELS,
+	DEFAULT_COPILOT_MODEL_ID,
+	DEFAULT_MODEL_ID,
+	DEFAULT_MODEL_PROVIDER,
+} from "../ai/model-config";
+import type { ProviderMenuItem } from "../components/ProviderMenu";
+import type { LlmProvider, ModelOption } from "../types";
+import type { OpenRouterInferenceProvider } from "../utils/openrouter-endpoints";
 import { mergePricingAverages } from "../utils/openrouter-pricing";
+import { useAppCopilotModelsLoader } from "./use-app-copilot-models-loader";
 import { useAppModelPricingLoader } from "./use-app-model-pricing-loader";
 import { useAppOpenRouterModelsLoader } from "./use-app-openrouter-models-loader";
 import { useAppOpenRouterProviderLoader } from "./use-app-openrouter-provider-loader";
-import type { ModelOption } from "../types";
-import type { ProviderMenuItem } from "../components/ProviderMenu";
-import type { OpenRouterInferenceProvider } from "../utils/openrouter-endpoints";
 
 export interface UseAppModelParams {
 	preferencesLoaded: boolean;
@@ -14,8 +20,14 @@ export interface UseAppModelParams {
 }
 
 export interface UseAppModelReturn {
+	currentModelProvider: LlmProvider;
+	setCurrentModelProvider: React.Dispatch<React.SetStateAction<LlmProvider>>;
+
 	currentModelId: string;
-	setCurrentModelId: React.Dispatch<React.SetStateAction<string>>;
+	currentModelSupportsReasoning: boolean;
+	currentModelSupportsReasoningXHigh: boolean;
+	setCurrentModelId: (modelId: string) => void;
+	setCurrentModelForProvider: (provider: LlmProvider, modelId: string) => void;
 
 	currentOpenRouterProviderTag: string | undefined;
 	setCurrentOpenRouterProviderTag: React.Dispatch<React.SetStateAction<string | undefined>>;
@@ -27,41 +39,59 @@ export interface UseAppModelReturn {
 
 	providerMenuItems: ProviderMenuItem[];
 
-	refreshOpenRouterModels: () => void;
+	refreshOpenRouterModels: () => Promise<void>;
 }
 
 export function useAppModel(params: UseAppModelParams): UseAppModelReturn {
 	const { preferencesLoaded, showProviderMenu } = params;
 
-	const [currentModelId, setCurrentModelId] = useState(DEFAULT_MODEL_ID);
+	const [currentModelProvider, setCurrentModelProvider] = useState<LlmProvider>(DEFAULT_MODEL_PROVIDER);
+	const [openRouterModelId, setOpenRouterModelId] = useState(DEFAULT_MODEL_ID);
+	const [copilotModelId, setCopilotModelId] = useState(DEFAULT_COPILOT_MODEL_ID);
+
 	const [currentOpenRouterProviderTag, setCurrentOpenRouterProviderTag] = useState<string | undefined>(
 		undefined
 	);
-	const [modelsWithPricing, setModelsWithPricing] = useState<ModelOption[]>(AVAILABLE_MODELS);
+
+	const [openRouterModelsWithPricing, setOpenRouterModelsWithPricing] =
+		useState<ModelOption[]>(AVAILABLE_MODELS);
 	const [openRouterModels, setOpenRouterModels] = useState<ModelOption[]>([]);
 	const [openRouterModelsLoading, setOpenRouterModelsLoading] = useState(false);
 	const [openRouterModelsUpdatedAt, setOpenRouterModelsUpdatedAt] = useState<number | null>(null);
 	const [openRouterProviders, setOpenRouterProviders] = useState<OpenRouterInferenceProvider[]>([]);
 
+	const [copilotModels, setCopilotModels] = useState<ModelOption[]>([]);
+	const [copilotModelsLoading, setCopilotModelsLoading] = useState(false);
+	const [copilotModelsUpdatedAt, setCopilotModelsUpdatedAt] = useState<number | null>(null);
+
+	const currentModelId = currentModelProvider === "openrouter" ? openRouterModelId : copilotModelId;
+
 	useAppModelPricingLoader({
 		preferencesLoaded,
-		setModelsWithPricing,
+		setModelsWithPricing: setOpenRouterModelsWithPricing,
 	});
 
 	useAppOpenRouterProviderLoader({
 		preferencesLoaded,
-		showProviderMenu,
-		modelId: currentModelId,
+		showProviderMenu: showProviderMenu && currentModelProvider === "openrouter",
+		modelId: openRouterModelId,
 		setProviders: setOpenRouterProviders,
 	});
 
-	const { refresh: refreshOpenRouterModels } = useAppOpenRouterModelsLoader({
+	const { refresh: refreshOpenRouterModelsRaw } = useAppOpenRouterModelsLoader({
 		preferencesLoaded,
 		setModels: setOpenRouterModels,
 		setLoading: setOpenRouterModelsLoading,
 		setUpdatedAt: setOpenRouterModelsUpdatedAt,
 	});
 
+	const { refresh: refreshCopilotModels } = useAppCopilotModelsLoader({
+		preferencesLoaded,
+		setModels: setCopilotModels,
+		setLoading: setCopilotModelsLoading,
+		setUpdatedAt: setCopilotModelsUpdatedAt,
+	});
+
 	const providerMenuItems: ProviderMenuItem[] = useMemo(() => {
 		const pricingCandidates = openRouterProviders
 			.map((p) => p.pricing)
@@ -108,16 +138,72 @@ export function useAppModel(params: UseAppModelParams): UseAppModelReturn {
 		return items;
 	}, [openRouterProviders, currentOpenRouterProviderTag]);
 
+	const modelsWithPricing =
+		currentModelProvider === "openrouter" ? openRouterModelsWithPricing : copilotModels;
+	const modelsForMenu = currentModelProvider === "openrouter" ? openRouterModels : copilotModels;
+	const modelsLoading =
+		currentModelProvider === "openrouter" ? openRouterModelsLoading : copilotModelsLoading;
+	const modelsUpdatedAt =
+		currentModelProvider === "openrouter" ? openRouterModelsUpdatedAt : copilotModelsUpdatedAt;
+	const currentModelSupportsReasoning = useMemo(() => {
+		if (currentModelProvider !== "copilot") {
+			return false;
+		}
+		const selected = copilotModels.find((model) => model.id === copilotModelId);
+		return selected?.supportsReasoningEffort === true;
+	}, [copilotModelId, copilotModels, currentModelProvider]);
+	const currentModelSupportsReasoningXHigh = useMemo(() => {
+		if (currentModelProvider !== "copilot") {
+			return false;
+		}
+		const selected = copilotModels.find((model) => model.id === copilotModelId);
+		return selected?.supportsReasoningEffortXHigh === true;
+	}, [copilotModelId, copilotModels, currentModelProvider]);
+
+	const setCurrentModelId = useCallback(
+		(modelId: string) => {
+			if (!modelId) return;
+			if (currentModelProvider === "openrouter") {
+				setOpenRouterModelId(modelId);
+				return;
+			}
+			setCopilotModelId(modelId);
+		},
+		[currentModelProvider]
+	);
+
+	const setCurrentModelForProvider = useCallback((provider: LlmProvider, modelId: string) => {
+		if (!modelId) return;
+		if (provider === "openrouter") {
+			setOpenRouterModelId(modelId);
+			return;
+		}
+		setCopilotModelId(modelId);
+	}, []);
+
+	const refreshOpenRouterModels = useCallback(async () => {
+		if (currentModelProvider === "openrouter") {
+			await refreshOpenRouterModelsRaw();
+			return;
+		}
+		await refreshCopilotModels();
+	}, [currentModelProvider, refreshOpenRouterModelsRaw, refreshCopilotModels]);
+
 	return {
+		currentModelProvider,
+		setCurrentModelProvider,
 		currentModelId,
+		currentModelSupportsReasoning,
+		currentModelSupportsReasoningXHigh,
 		setCurrentModelId,
+		setCurrentModelForProvider,
 		currentOpenRouterProviderTag,
 		setCurrentOpenRouterProviderTag,
 		modelsWithPricing,
-		openRouterModels,
-		openRouterModelsLoading,
-		openRouterModelsUpdatedAt,
-		providerMenuItems,
+		openRouterModels: modelsForMenu,
+		openRouterModelsLoading: modelsLoading,
+		openRouterModelsUpdatedAt: modelsUpdatedAt,
+		providerMenuItems: currentModelProvider === "openrouter" ? providerMenuItems : [],
 		refreshOpenRouterModels,
 	};
 }

package/src/hooks/use-app-preferences-bootstrap.ts

@@ -1,9 +1,19 @@
 import { useCallback, useEffect, useRef } from "react";
 import { startMcpManager } from "../ai/mcp/mcp-manager";
-import { setOpenRouterProviderTag, setResponseModel } from "../ai/model-config";
+import { hasCopilotCliAuthSafe } from "../ai/copilot-client";
+import {
+	getModelProvider,
+	getResponseModelForProvider,
+	setModelProvider,
+	setOpenRouterProviderTag,
+	setResponseModelForProvider,
+} from "../ai/model-config";
+import { invalidateDaemonToolsCache } from "../ai/tools";
+import { invalidateSubagentToolsCache } from "../ai/tools/subagents";
 import type {
 	AppPreferences,
 	BashApprovalLevel,
+	LlmProvider,
 	OnboardingStep,
 	ReasoningEffort,
 	SpeechSpeed,
@@ -26,7 +36,8 @@ export interface UseAppPreferencesBootstrapParams {
 		audioDeviceName?: string;
 		outputDeviceName?: string;
 	};
-	setCurrentModelId: (modelId: string) => void;
+	setCurrentModelProvider: (provider: LlmProvider) => void;
+	setCurrentModelForProvider: (provider: LlmProvider, modelId: string) => void;
 	setCurrentOpenRouterProviderTag: (providerTag: string | undefined) => void;
 	setCurrentDevice: (deviceName: string | undefined) => void;
 	setCurrentOutputDevice: (deviceName: string | undefined) => void;
@@ -41,6 +52,7 @@ export interface UseAppPreferencesBootstrapParams {
 	setLoadedPreferences: (prefs: AppPreferences | null) => void;
 	setOnboardingActive: (active: boolean) => void;
 	setOnboardingStep: (step: OnboardingStep) => void;
+	setCopilotAuthenticated: (authenticated: boolean) => void;
 	setPreferencesLoaded: (loaded: boolean) => void;
 }
 
@@ -53,7 +65,8 @@ export function useAppPreferencesBootstrap(
 ): UseAppPreferencesBootstrapReturn {
 	const {
 		manager,
-		setCurrentModelId,
+		setCurrentModelProvider,
+		setCurrentModelForProvider,
 		setCurrentOpenRouterProviderTag,
 		setCurrentDevice,
 		setCurrentOutputDevice,
@@ -68,6 +81,7 @@ export function useAppPreferencesBootstrap(
 		setLoadedPreferences,
 		setOnboardingActive,
 		setOnboardingStep,
+		setCopilotAuthenticated,
 		setPreferencesLoaded,
 	} = params;
 
@@ -82,6 +96,7 @@ export function useAppPreferencesBootstrap(
 
 	useEffect(() => {
 		let cancelled = false;
+		let copilotAuthCheckTimer: ReturnType<typeof setTimeout> | null = null;
 
 		(async () => {
 			const prefs = await loadPreferences();
@@ -100,9 +115,18 @@ export function useAppPreferencesBootstrap(
 			// Start MCP discovery in the background (non-blocking)
 			startMcpManager();
 
+			const modelProvider: LlmProvider = prefs?.modelProvider ?? "openrouter";
+			setModelProvider(modelProvider);
+			invalidateDaemonToolsCache();
+			invalidateSubagentToolsCache();
+			setCurrentModelProvider(modelProvider);
+
 			if (prefs?.modelId) {
-				setResponseModel(prefs.modelId);
-				setCurrentModelId(prefs.modelId);
+				setResponseModelForProvider(modelProvider, prefs.modelId);
+				setCurrentModelForProvider(modelProvider, prefs.modelId);
+			} else {
+				const fallbackModelId = getResponseModelForProvider(modelProvider);
+				setCurrentModelForProvider(modelProvider, fallbackModelId);
 			}
 
 			if (prefs?.openRouterProviderTag) {
@@ -169,20 +193,35 @@ export function useAppPreferencesBootstrap(
 			const hasOpenRouterKey = Boolean(process.env.OPENROUTER_API_KEY);
 			const hasOpenAiKey = Boolean(process.env.OPENAI_API_KEY);
 			const hasExaKey = Boolean(process.env.EXA_API_KEY);
+			const usingCopilotProvider = modelProvider === "copilot";
+			const hasCopilotAuth = usingCopilotProvider;
+			setCopilotAuthenticated(hasCopilotAuth);
+			copilotAuthCheckTimer = setTimeout(() => {
+				void (async () => {
+					const authenticated = await hasCopilotCliAuthSafe();
+					if (cancelled) return;
+					setCopilotAuthenticated(authenticated);
+					if (!authenticated && getModelProvider() === "copilot") {
+						setOnboardingStep("copilot_auth");
+						setOnboardingActive(true);
+					}
+				})();
+			}, 0);
 			const hasCoreSettings = Boolean(prefs?.audioDeviceName && prefs?.modelId);
 
 			setLoadedPreferences(prefs);
 
 			const isFreshLaunch = prefs === null;
-			const needsOnboarding = !hasOpenRouterKey || !hasOpenAiKey || !hasExaKey;
+			const hasProviderAuth = modelProvider === "openrouter" ? hasOpenRouterKey : hasCopilotAuth;
+			const needsOnboarding = !hasProviderAuth || !hasOpenAiKey || !hasExaKey;
 
 			if (isFreshLaunch) {
 				setOnboardingStep("intro");
 				setOnboardingActive(true);
 			} else if (needsOnboarding) {
-				let startStep: OnboardingStep = "intro";
-				if (!hasOpenRouterKey) {
-					startStep = "openrouter_key";
+				let startStep: OnboardingStep = "provider";
+				if (!hasProviderAuth) {
+					startStep = modelProvider === "openrouter" ? "openrouter_key" : "copilot_auth";
 				} else if (!hasOpenAiKey) {
 					startStep = "openai_key";
 				} else if (!hasExaKey) {
@@ -203,10 +242,14 @@ export function useAppPreferencesBootstrap(
 
 		return () => {
 			cancelled = true;
+			if (copilotAuthCheckTimer) {
+				clearTimeout(copilotAuthCheckTimer);
+			}
 		};
 	}, [
 		manager,
-		setCurrentModelId,
+		setCurrentModelProvider,
+		setCurrentModelForProvider,
 		setCurrentOpenRouterProviderTag,
 		setCurrentDevice,
 		setCurrentOutputDevice,
@@ -220,6 +263,7 @@ export function useAppPreferencesBootstrap(
 		setLoadedPreferences,
 		setOnboardingActive,
 		setOnboardingStep,
+		setCopilotAuthenticated,
 		setPreferencesLoaded,
 	]);
 

package/src/hooks/use-bootstrap-controller.ts

@@ -15,6 +15,8 @@ export interface BootstrapControllerResult {
 
 	onboardingStep: OnboardingStep;
 	setOnboardingStep: (step: OnboardingStep) => void;
+	copilotAuthenticated: boolean;
+	setCopilotAuthenticated: (authenticated: boolean) => void;
 
 	loadedPreferences: AppPreferences | null;
 	setLoadedPreferences: (prefs: AppPreferences | null) => void;
@@ -50,6 +52,7 @@ export function useBootstrapController({
 
 	const [loadedPreferences, setLoadedPreferences] = useState<AppPreferences | null>(null);
 	const [onboardingStep, setOnboardingStep] = useState<OnboardingStep>("intro");
+	const [copilotAuthenticated, setCopilotAuthenticated] = useState(false);
 
 	const [devices, setDevices] = useState<AudioDevice[]>([]);
 	const [currentDevice, setCurrentDevice] = useState<string | undefined>(undefined);
@@ -75,6 +78,8 @@ export function useBootstrapController({
 		setOnboardingActive,
 		onboardingStep,
 		setOnboardingStep,
+		copilotAuthenticated,
+		setCopilotAuthenticated,
 		loadedPreferences,
 		setLoadedPreferences,
 		devices,

package/src/hooks/use-daemon-events.ts

@@ -9,7 +9,7 @@ import { daemonEvents } from "../state/daemon-events";
 import { getDaemonManager } from "../state/daemon-state";
 import { buildModelHistoryFromConversation } from "../state/session-store";
 import { DaemonState } from "../types";
-import type { ContentBlock, ConversationMessage, TokenUsage, ToolCall } from "../types";
+import type { ContentBlock, ConversationMessage, LlmProvider, TokenUsage, ToolCall } from "../types";
 import { REASONING_COLORS, STATE_COLORS } from "../types/theme";
 import { REASONING_ANIMATION } from "../ui/constants";
 import { type ModelMetadata, getModelMetadata } from "../utils/model-metadata";
@@ -41,6 +41,7 @@ import {
 } from "./daemon-event-handlers";
 
 export interface UseDaemonEventsParams {
+	currentModelProvider: LlmProvider;
 	currentModelId: string;
 	preferencesLoaded: boolean;
 	setReasoningQueue: (queue: string | ((prev: string) => string)) => void;
@@ -79,6 +80,7 @@ export interface UseDaemonEventsReturn {
 
 export function useDaemonEvents(params: UseDaemonEventsParams): UseDaemonEventsReturn {
 	const {
+		currentModelProvider,
 		currentModelId,
 		preferencesLoaded,
 		setReasoningQueue,
@@ -117,6 +119,10 @@ export function useDaemonEvents(params: UseDaemonEventsParams): UseDaemonEventsR
 
 	useEffect(() => {
 		if (!preferencesLoaded) return;
+		if (currentModelProvider !== "openrouter") {
+			setModelMetadata(null);
+			return;
+		}
 		let cancelled = false;
 		getModelMetadata(currentModelId).then((metadata) => {
 			if (!cancelled) setModelMetadata(metadata);
@@ -124,7 +130,7 @@ export function useDaemonEvents(params: UseDaemonEventsParams): UseDaemonEventsR
 		return () => {
 			cancelled = true;
 		};
-	}, [currentModelId, preferencesLoaded]);
+	}, [currentModelId, currentModelProvider, preferencesLoaded]);
 
 	useEffect(() => {
 		clearFetchCache();