@makefinks/daemon 0.9.1 → 0.11.0

package/src/hooks/keyboard-handlers.ts

@@ -1,16 +1,19 @@
 import type { KeyEvent } from "@opentui/core";
-import { setResponseModel } from "../ai/model-config";
+import { getResponseModelForProvider, setModelProvider, setResponseModel } from "../ai/model-config";
+import { invalidateDaemonToolsCache } from "../ai/tools";
+import { invalidateSubagentToolsCache } from "../ai/tools/subagents";
 import type {
 	AppPreferences,
 	AudioDevice,
 	BashApprovalLevel,
+	LlmProvider,
 	ModelOption,
 	OnboardingStep,
 	ReasoningEffort,
 	SpeechSpeed,
 	VoiceInteractionType,
 } from "../types";
-import { BASH_APPROVAL_LEVELS, REASONING_EFFORT_LEVELS } from "../types";
+import { BASH_APPROVAL_LEVELS, getReasoningEffortLevels } from "../types";
 import { openUrlInBrowser } from "../utils/preferences";
 import { setAudioDevice } from "../voice/audio-recorder";
 import { isNavigateDownKey, isNavigateUpKey } from "./menu-navigation";
@@ -18,6 +21,7 @@ import { isNavigateDownKey, isNavigateUpKey } from "./menu-navigation";
 export type KeyHandler = (key: KeyEvent) => boolean;
 
 const API_KEY_URLS: Record<string, string> = {
+	copilot_auth: "https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli",
 	openrouter_key: "https://openrouter.ai/keys",
 	openai_key: "https://platform.openai.com/api-keys",
 	exa_key: "https://dashboard.exa.ai/api-keys",
@@ -25,13 +29,18 @@ const API_KEY_URLS: Record<string, string> = {
 
 interface OnboardingContext {
 	step: OnboardingStep;
+	selectedProviderIdx: number;
 	devices: AudioDevice[];
 	models: ModelOption[];
 	selectedDeviceIdx: number;
 	selectedModelIdx: number;
+	currentModelProvider: LlmProvider;
+	copilotAuthenticated: boolean;
 	preferences: AppPreferences | null;
+	setSelectedProviderIdx: (fn: (prev: number) => number) => void;
 	setSelectedDeviceIdx: (fn: (prev: number) => number) => void;
 	setSelectedModelIdx: (fn: (prev: number) => number) => void;
+	setCurrentModelProvider: (provider: LlmProvider) => void;
 	setCurrentDevice: (device: string) => void;
 	setCurrentOutputDevice: (device: string) => void;
 	setCurrentModelId: (modelId: string) => void;
@@ -49,28 +58,19 @@ export function getApiKeyUrl(step: OnboardingStep): string | null {
 }
 
 export function isApiKeyStep(step: OnboardingStep): boolean {
-	return step === "openrouter_key" || step === "openai_key" || step === "exa_key";
+	return step === "openrouter_key" || step === "copilot_auth" || step === "openai_key" || step === "exa_key";
 }
 
-type StepCondition = {
-	step: OnboardingStep;
-	check: (prefs: AppPreferences | null) => boolean;
-	/** If true, this step is only shown during initial onboarding, not when re-prompting */
-	onboardingOnly?: boolean;
-};
-
-const STEP_CONDITIONS: StepCondition[] = [
-	{ step: "openrouter_key", check: () => !process.env.OPENROUTER_API_KEY },
-	{ step: "openai_key", check: () => !process.env.OPENAI_API_KEY },
-	{ step: "exa_key", check: () => !process.env.EXA_API_KEY },
-	{ step: "device", check: (prefs) => !prefs?.audioDeviceName, onboardingOnly: true },
-	{ step: "model", check: (prefs) => !prefs?.modelId, onboardingOnly: true },
-	{ step: "settings", check: () => true, onboardingOnly: true },
-];
+export interface DetermineNextStepOptions {
+	currentProvider?: LlmProvider;
+	copilotAuthenticated?: boolean;
+}
 
 const STEP_ORDER: OnboardingStep[] = [
 	"intro",
+	"provider",
 	"openrouter_key",
+	"copilot_auth",
 	"openai_key",
 	"exa_key",
 	"device",
@@ -81,18 +81,36 @@ const STEP_ORDER: OnboardingStep[] = [
 
 export function determineNextStep(
 	currentStep: OnboardingStep,
-	preferences: AppPreferences | null
+	preferences: AppPreferences | null,
+	options: DetermineNextStepOptions = {}
 ): OnboardingStep {
 	const currentIndex = STEP_ORDER.indexOf(currentStep);
 	if (currentIndex === -1 || currentStep === "complete") return "complete";
 
 	const isReprompt = preferences?.onboardingCompleted === true;
-
-	for (const condition of STEP_CONDITIONS) {
+	const provider: LlmProvider = options.currentProvider ?? preferences?.modelProvider ?? "openrouter";
+	const hasCopilotAuth = Boolean(options.copilotAuthenticated);
+
+	const conditions: Array<{
+		step: OnboardingStep;
+		enabled: boolean;
+		onboardingOnly?: boolean;
+	}> = [
+		{ step: "provider", enabled: true, onboardingOnly: true },
+		{ step: "openrouter_key", enabled: provider === "openrouter" && !process.env.OPENROUTER_API_KEY },
+		{ step: "copilot_auth", enabled: provider === "copilot" && !hasCopilotAuth },
+		{ step: "openai_key", enabled: !process.env.OPENAI_API_KEY },
+		{ step: "exa_key", enabled: !process.env.EXA_API_KEY },
+		{ step: "device", enabled: !preferences?.audioDeviceName, onboardingOnly: true },
+		{ step: "model", enabled: !preferences?.modelId, onboardingOnly: true },
+		{ step: "settings", enabled: true, onboardingOnly: true },
+	];
+
+	for (const condition of conditions) {
 		if (isReprompt && condition.onboardingOnly) continue;
 
 		const conditionIndex = STEP_ORDER.indexOf(condition.step);
-		if (conditionIndex > currentIndex && condition.check(preferences)) {
+		if (conditionIndex > currentIndex && condition.enabled) {
 			return condition.step;
 		}
 	}
@@ -104,9 +122,14 @@ type EscapeHandler = (ctx: OnboardingContext) => void;
 
 const ESCAPE_HANDLERS: Partial<Record<OnboardingStep, EscapeHandler>> = {
 	intro: () => {},
+	provider: () => {},
 	openrouter_key: () => {},
+	copilot_auth: () => {},
 	openai_key: (ctx) => {
-		const nextStep = determineNextStep("openai_key", ctx.preferences);
+		const nextStep = determineNextStep("openai_key", ctx.preferences, {
+			currentProvider: ctx.currentModelProvider,
+			copilotAuthenticated: ctx.copilotAuthenticated,
+		});
 		if (nextStep === "complete") {
 			ctx.persistPreferences({ onboardingCompleted: true });
 			ctx.completeOnboarding();
@@ -115,7 +138,10 @@ const ESCAPE_HANDLERS: Partial<Record<OnboardingStep, EscapeHandler>> = {
 		}
 	},
 	exa_key: (ctx) => {
-		const nextStep = determineNextStep("exa_key", ctx.preferences);
+		const nextStep = determineNextStep("exa_key", ctx.preferences, {
+			currentProvider: ctx.currentModelProvider,
+			copilotAuthenticated: ctx.copilotAuthenticated,
+		});
 		if (nextStep === "complete") {
 			ctx.persistPreferences({ onboardingCompleted: true });
 			ctx.completeOnboarding();
@@ -156,11 +182,54 @@ export function handleOnboardingKey(key: KeyEvent, ctx: OnboardingContext): bool
 
 	if (step === "intro") {
 		if (key.name === "return") {
-			ctx.setOnboardingStep(determineNextStep(step, ctx.preferences));
+			ctx.setOnboardingStep(
+				determineNextStep(step, ctx.preferences, {
+					currentProvider: ctx.currentModelProvider,
+					copilotAuthenticated: ctx.copilotAuthenticated,
+				})
+			);
 		}
 		return true;
 	}
 
+	if (step === "provider") {
+		const providers: LlmProvider[] = ctx.copilotAuthenticated ? ["openrouter", "copilot"] : ["openrouter"];
+
+		if (isNavigateUpKey(key) || isNavigateDownKey(key)) {
+			ctx.setSelectedProviderIdx((prev) => {
+				if (isNavigateUpKey(key)) {
+					return prev > 0 ? prev - 1 : providers.length - 1;
+				}
+				return prev < providers.length - 1 ? prev + 1 : 0;
+			});
+			return true;
+		}
+
+		if (key.name === "return") {
+			const selectedProvider = providers[ctx.selectedProviderIdx] ?? "openrouter";
+			setModelProvider(selectedProvider);
+			invalidateDaemonToolsCache();
+			invalidateSubagentToolsCache();
+			ctx.setCurrentModelProvider(selectedProvider);
+
+			const defaultModelId = getResponseModelForProvider(selectedProvider);
+
+			ctx.persistPreferences({
+				modelProvider: selectedProvider,
+				modelId: defaultModelId,
+			});
+
+			ctx.setOnboardingStep(
+				determineNextStep("provider", ctx.preferences, {
+					currentProvider: selectedProvider,
+					copilotAuthenticated: ctx.copilotAuthenticated,
+				})
+			);
+		}
+
+		return true;
+	}
+
 	if (isApiKeyStep(step)) {
 		return false;
 	}
@@ -224,6 +293,7 @@ export function handleOnboardingKey(key: KeyEvent, ctx: OnboardingContext): bool
 				setResponseModel(selectedModel.id);
 				ctx.setCurrentModelId(selectedModel.id);
 				ctx.persistPreferences({
+					modelProvider: ctx.currentModelProvider,
 					modelId: selectedModel.id,
 					openRouterProviderTag: undefined,
 				});
@@ -248,17 +318,20 @@ interface SettingsMenuContext {
 	selectedIdx: number;
 	menuItemCount: number;
 	interactionMode: "text" | "voice";
+	modelProvider: LlmProvider;
 	voiceInteractionType: VoiceInteractionType;
 	speechSpeed: SpeechSpeed;
 	reasoningEffort: ReasoningEffort;
 	bashApprovalLevel: BashApprovalLevel;
 	supportsReasoning: boolean;
+	supportsReasoningXHigh: boolean;
 	canEnableVoiceOutput: boolean;
 	showFullReasoning: boolean;
 	showToolOutput: boolean;
 	memoryEnabled: boolean;
 	setSelectedIdx: (fn: (prev: number) => number) => void;
 	toggleInteractionMode: () => void;
+	cycleModelProvider: () => void;
 	setVoiceInteractionType: (type: VoiceInteractionType) => void;
 	setSpeechSpeed: (speed: SpeechSpeed) => void;
 	setReasoningEffort: (effort: ReasoningEffort) => void;
@@ -316,6 +389,13 @@ export function handleSettingsMenuKey(key: KeyEvent, ctx: SettingsMenuContext):
 		}
 		settingIdx++;
 
+		if (ctx.selectedIdx === settingIdx) {
+			ctx.cycleModelProvider();
+			key.preventDefault();
+			return true;
+		}
+		settingIdx++;
+
 		if (ctx.selectedIdx === settingIdx) {
 			const current = ctx.manager.voiceInteractionType;
 			const next = current === "direct" ? "review" : "direct";
@@ -329,10 +409,11 @@ export function handleSettingsMenuKey(key: KeyEvent, ctx: SettingsMenuContext):
 
 		if (ctx.selectedIdx === settingIdx) {
 			if (ctx.supportsReasoning) {
+				const effortLevels = getReasoningEffortLevels(ctx.supportsReasoningXHigh);
 				const currentEffort = ctx.manager.reasoningEffort;
-				const currentIndex = REASONING_EFFORT_LEVELS.indexOf(currentEffort);
-				const nextIndex = (currentIndex + 1) % REASONING_EFFORT_LEVELS.length;
-				const nextEffort = REASONING_EFFORT_LEVELS[nextIndex] ?? "medium";
+				const currentIndex = effortLevels.indexOf(currentEffort);
+				const nextIndex = (currentIndex + 1) % effortLevels.length;
+				const nextEffort = effortLevels[nextIndex] ?? "medium";
 				ctx.manager.reasoningEffort = nextEffort;
 				ctx.setReasoningEffort(nextEffort);
 				ctx.persistPreferences({ reasoningEffort: nextEffort });

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

@@ -1,10 +1,21 @@
 import { useCallback } from "react";
-import { setOpenRouterProviderTag, setResponseModel } from "../ai/model-config";
+import { toast } from "@opentui-ui/toast/react";
+import {
+	getResponseModelForProvider,
+	setModelProvider,
+	setOpenRouterProviderTag,
+	setResponseModel,
+	setResponseModelForProvider,
+} from "../ai/model-config";
+import { invalidateDaemonToolsCache } from "../ai/tools";
+import { invalidateSubagentToolsCache } from "../ai/tools/subagents";
+import { getCopilotAuthStatusSafe, resetCopilotClient } from "../ai/copilot-client";
 import { setAudioDevice } from "../voice/audio-recorder";
 import { getDaemonManager } from "../state/daemon-state";
 import type {
 	AppPreferences,
 	AudioDevice,
+	LlmProvider,
 	ModelOption,
 	OnboardingStep,
 	ReasoningEffort,
@@ -14,8 +25,11 @@ import type {
 import { determineNextStep } from "./keyboard-handlers";
 
 export interface UseAppCallbacksParams {
+	currentModelProvider: LlmProvider;
+	setCurrentModelProvider: (provider: LlmProvider) => void;
 	currentModelId: string;
 	setCurrentModelId: (modelId: string) => void;
+	setCurrentModelForProvider: (provider: LlmProvider, modelId: string) => void;
 	setCurrentDevice: (deviceName: string | undefined) => void;
 	setCurrentOutputDevice: (deviceName: string | undefined) => void;
 	setCurrentOpenRouterProviderTag: (tag: string | undefined) => void;
@@ -26,7 +40,9 @@ export interface UseAppCallbacksParams {
 	persistPreferences: (updates: Partial<AppPreferences>) => void;
 	loadedPreferences: AppPreferences | null;
 	onboardingStep: OnboardingStep;
+	copilotAuthenticated: boolean;
 	setOnboardingStep: (step: OnboardingStep) => void;
+	setCopilotAuthenticated: (authenticated: boolean) => void;
 	apiKeyTextareaRef: React.RefObject<{ plainText?: string; setText: (v: string) => void } | null>;
 	setShowDeviceMenu: (show: boolean) => void;
 	setShowModelMenu: (show: boolean) => void;
@@ -40,6 +56,7 @@ export interface UseAppCallbacksReturn {
 	handleDeviceSelect: (device: AudioDevice) => void;
 	handleOutputDeviceSelect: (device: AudioDevice) => void;
 	handleModelSelect: (model: ModelOption) => void;
+	cycleModelProvider: () => void;
 	handleProviderSelect: (providerTag: string | undefined) => void;
 	toggleInteractionMode: () => void;
 	completeOnboarding: () => void;
@@ -48,8 +65,11 @@ export interface UseAppCallbacksReturn {
 
 export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksReturn {
 	const {
+		currentModelProvider,
+		setCurrentModelProvider,
 		currentModelId,
 		setCurrentModelId,
+		setCurrentModelForProvider,
 		setCurrentDevice,
 		setCurrentOutputDevice,
 		setCurrentOpenRouterProviderTag,
@@ -60,7 +80,9 @@ export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksR
 		persistPreferences,
 		loadedPreferences,
 		onboardingStep,
+		copilotAuthenticated,
 		setOnboardingStep,
+		setCopilotAuthenticated,
 		apiKeyTextareaRef,
 		setShowDeviceMenu,
 		setShowModelMenu,
@@ -92,19 +114,61 @@ export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksR
 	const handleModelSelect = useCallback(
 		(model: ModelOption) => {
 			if (model.id !== currentModelId) {
-				setResponseModel(model.id);
-				setOpenRouterProviderTag(undefined);
+				setResponseModelForProvider(currentModelProvider, model.id);
 				setCurrentModelId(model.id);
-				setCurrentOpenRouterProviderTag(undefined);
-				persistPreferences({
-					modelId: model.id,
-					openRouterProviderTag: undefined,
-				});
+				if (currentModelProvider === "openrouter") {
+					setOpenRouterProviderTag(undefined);
+					setCurrentOpenRouterProviderTag(undefined);
+					persistPreferences({
+						modelProvider: currentModelProvider,
+						modelId: model.id,
+						openRouterProviderTag: undefined,
+					});
+				} else {
+					persistPreferences({
+						modelProvider: currentModelProvider,
+						modelId: model.id,
+					});
+				}
 			}
 		},
-		[currentModelId, setCurrentModelId, setCurrentOpenRouterProviderTag, persistPreferences]
+		[
+			currentModelProvider,
+			currentModelId,
+			setCurrentModelId,
+			setCurrentOpenRouterProviderTag,
+			persistPreferences,
+		]
 	);
 
+	const cycleModelProvider = useCallback(() => {
+		const nextProvider: LlmProvider = currentModelProvider === "openrouter" ? "copilot" : "openrouter";
+		if (nextProvider === "copilot" && !copilotAuthenticated) {
+			toast.error("COPILOT LOGIN REQUIRED", {
+				description: "Run `gh auth login` and `copilot login` to enable the Copilot provider.",
+			});
+			return;
+		}
+		const nextModelId = getResponseModelForProvider(nextProvider);
+
+		setModelProvider(nextProvider);
+		invalidateDaemonToolsCache();
+		invalidateSubagentToolsCache();
+		setCurrentModelProvider(nextProvider);
+		setCurrentModelForProvider(nextProvider, nextModelId);
+
+		persistPreferences({
+			modelProvider: nextProvider,
+			modelId: nextModelId,
+		});
+	}, [
+		currentModelProvider,
+		copilotAuthenticated,
+		setCurrentModelProvider,
+		setCurrentModelForProvider,
+		persistPreferences,
+	]);
+
 	const handleProviderSelect = useCallback(
 		(providerTag: string | undefined) => {
 			setOpenRouterProviderTag(providerTag);
@@ -145,48 +209,81 @@ export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksR
 	]);
 
 	const handleApiKeySubmit = useCallback(() => {
-		const key = (apiKeyTextareaRef.current?.plainText ?? "").trim();
-		if (!key) return;
-
-		if (onboardingStep === "openrouter_key") {
-			process.env.OPENROUTER_API_KEY = key;
-			persistPreferences({ openRouterApiKey: key });
-			const nextStep = determineNextStep("openrouter_key", loadedPreferences);
-			if (nextStep === "complete") {
-				persistPreferences({ onboardingCompleted: true });
-				completeOnboarding();
-			} else {
-				setOnboardingStep(nextStep);
-			}
-		} else if (onboardingStep === "openai_key") {
-			process.env.OPENAI_API_KEY = key;
-			persistPreferences({ openAiApiKey: key });
-			const nextStep = determineNextStep("openai_key", loadedPreferences);
-			if (nextStep === "complete") {
-				persistPreferences({ onboardingCompleted: true });
-				completeOnboarding();
-			} else {
-				setOnboardingStep(nextStep);
-			}
-		} else if (onboardingStep === "exa_key") {
-			process.env.EXA_API_KEY = key;
-			persistPreferences({ exaApiKey: key });
-			const nextStep = determineNextStep("exa_key", loadedPreferences);
-			if (nextStep === "complete") {
-				persistPreferences({ onboardingCompleted: true });
-				completeOnboarding();
-			} else {
-				setOnboardingStep(nextStep);
+		void (async () => {
+			const key = (apiKeyTextareaRef.current?.plainText ?? "").trim();
+
+			if (onboardingStep !== "copilot_auth" && !key) return;
+
+			if (onboardingStep === "openrouter_key") {
+				process.env.OPENROUTER_API_KEY = key;
+				persistPreferences({ openRouterApiKey: key });
+				const nextStep = determineNextStep("openrouter_key", loadedPreferences, {
+					currentProvider: currentModelProvider,
+				});
+				if (nextStep === "complete") {
+					persistPreferences({ onboardingCompleted: true });
+					completeOnboarding();
+				} else {
+					setOnboardingStep(nextStep);
+				}
+			} else if (onboardingStep === "copilot_auth") {
+				await resetCopilotClient();
+				const authStatus = await getCopilotAuthStatusSafe();
+				setCopilotAuthenticated(authStatus.isAuthenticated);
+				if (!authStatus.isAuthenticated) {
+					toast.error("COPILOT AUTH REQUIRED", {
+						description: "Run `gh auth login` and `copilot login`, then press ENTER to retry.",
+					});
+					return;
+				}
+
+				const nextStep = determineNextStep("copilot_auth", loadedPreferences, {
+					currentProvider: currentModelProvider,
+					copilotAuthenticated: true,
+				});
+				if (nextStep === "complete") {
+					persistPreferences({ onboardingCompleted: true });
+					completeOnboarding();
+				} else {
+					setOnboardingStep(nextStep);
+				}
+			} else if (onboardingStep === "openai_key") {
+				process.env.OPENAI_API_KEY = key;
+				persistPreferences({ openAiApiKey: key });
+				const nextStep = determineNextStep("openai_key", loadedPreferences, {
+					currentProvider: currentModelProvider,
+				});
+				if (nextStep === "complete") {
+					persistPreferences({ onboardingCompleted: true });
+					completeOnboarding();
+				} else {
+					setOnboardingStep(nextStep);
+				}
+			} else if (onboardingStep === "exa_key") {
+				process.env.EXA_API_KEY = key;
+				persistPreferences({ exaApiKey: key });
+				const nextStep = determineNextStep("exa_key", loadedPreferences, {
+					currentProvider: currentModelProvider,
+				});
+				if (nextStep === "complete") {
+					persistPreferences({ onboardingCompleted: true });
+					completeOnboarding();
+				} else {
+					setOnboardingStep(nextStep);
+				}
 			}
-		}
 
-		apiKeyTextareaRef.current?.setText("");
+			apiKeyTextareaRef.current?.setText("");
+		})();
 	}, [
 		onboardingStep,
 		persistPreferences,
 		loadedPreferences,
+		currentModelProvider,
+		copilotAuthenticated,
 		completeOnboarding,
 		setOnboardingStep,
+		setCopilotAuthenticated,
 		apiKeyTextareaRef,
 	]);
 
@@ -194,6 +291,7 @@ export function useAppCallbacks(params: UseAppCallbacksParams): UseAppCallbacksR
 		handleDeviceSelect,
 		handleOutputDeviceSelect,
 		handleModelSelect,
+		cycleModelProvider,
 		handleProviderSelect,
 		toggleInteractionMode,
 		completeOnboarding,

package/src/hooks/use-app-context-builder.ts

@@ -15,6 +15,7 @@ import type {
 	AudioDevice,
 	BashApprovalLevel,
 	GroundingMap,
+	LlmProvider,
 	ModelOption,
 	OnboardingStep,
 	ReasoningEffort,
@@ -65,6 +66,7 @@ export interface UseAppContextBuilderParams {
 		reasoningEffort: ReasoningEffort;
 		bashApprovalLevel: BashApprovalLevel;
 		supportsReasoning: boolean;
+		supportsReasoningXHigh: boolean;
 		canEnableVoiceOutput: boolean;
 		showFullReasoning: boolean;
 		setShowFullReasoning: (show: boolean) => void;
@@ -81,6 +83,8 @@ export interface UseAppContextBuilderParams {
 		openRouterModels: ModelOption[];
 		openRouterModelsLoading: boolean;
 		openRouterModelsUpdatedAt: number | null;
+		currentModelProvider: LlmProvider;
+		setCurrentModelProvider: (provider: LlmProvider) => void;
 		currentModelId: string;
 		setCurrentModelId: (modelId: string) => void;
 		providerMenuItems: ProviderMenuItem[];
@@ -102,6 +106,7 @@ export interface UseAppContextBuilderParams {
 	onboarding: {
 		onboardingActive: boolean;
 		onboardingStep: OnboardingStep;
+		copilotAuthenticated: boolean;
 		setOnboardingStep: (step: OnboardingStep) => void;
 		onboardingPreferences: AppPreferences | null;
 		apiKeyTextareaRef: MutableRefObject<TextareaRenderable | null>;