@makefinks/daemon 0.10.0 → 0.11.0

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

@@ -4,7 +4,7 @@ import type { ScrollBoxRenderable } from "@opentui/core";
 import { useKeyboard } from "@opentui/react";
 import { useCallback } from "react";
 import { getDaemonManager } from "../state/daemon-state";
-import { type AppPreferences, DaemonState } from "../types";
+import { type AppPreferences, type LlmProvider, DaemonState } from "../types";
 import { COLORS } from "../ui/constants";
 export interface KeyboardHandlerState {
 	isOverlayOpen: boolean;
@@ -13,6 +13,7 @@ export interface KeyboardHandlerState {
 	hasGrounding: boolean;
 	showFullReasoning: boolean;
 	showToolOutput: boolean;
+	currentModelProvider: LlmProvider;
 }
 
 export interface KeyboardHandlerActions {
@@ -43,7 +44,14 @@ export interface KeyboardHandlerActions {
 
 export function useDaemonKeyboard(state: KeyboardHandlerState, actions: KeyboardHandlerActions) {
 	const manager = getDaemonManager();
-	const { isOverlayOpen, escPendingCancel, hasInteracted, hasGrounding, showFullReasoning } = state;
+	const {
+		isOverlayOpen,
+		escPendingCancel,
+		hasInteracted,
+		hasGrounding,
+		showFullReasoning,
+		currentModelProvider,
+	} = state;
 
 	const closeAllMenus = useCallback(() => {
 		actions.setShowDeviceMenu(false);
@@ -161,6 +169,10 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				key.eventType === "press" &&
 				(currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING)
 			) {
+				if (currentModelProvider !== "openrouter") {
+					key.preventDefault();
+					return;
+				}
 				closeAllMenus();
 				actions.setShowProviderMenu(true);
 				key.preventDefault();
@@ -310,8 +322,8 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 				currentState !== DaemonState.TYPING
 			) {
 				if (currentState === DaemonState.IDLE || currentState === DaemonState.SPEAKING) {
-					// Check for OpenRouter API key first (needed for any AI response)
-					if (!process.env.OPENROUTER_API_KEY) {
+					// OpenRouter provider requires OPENROUTER_API_KEY for model responses.
+					if (currentModelProvider === "openrouter" && !process.env.OPENROUTER_API_KEY) {
 						actions.setApiKeyMissingError(
 							"OPENROUTER_API_KEY not found · Set via environment variable or enter in onboarding"
 						);
@@ -340,8 +352,8 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 			// Shift+Tab for typing mode
 			if (key.name === "tab" && key.shift && key.eventType === "press") {
 				if (currentState === DaemonState.IDLE) {
-					// Check for OpenRouter API key (needed for any AI response)
-					if (!process.env.OPENROUTER_API_KEY) {
+					// OpenRouter provider requires OPENROUTER_API_KEY for model responses.
+					if (currentModelProvider === "openrouter" && !process.env.OPENROUTER_API_KEY) {
 						actions.setApiKeyMissingError(
 							"OPENROUTER_API_KEY not found · Set via environment variable or enter in onboarding"
 						);
@@ -411,6 +423,7 @@ export function useDaemonKeyboard(state: KeyboardHandlerState, actions: Keyboard
 			hasGrounding,
 			showFullReasoning,
 			state.showToolOutput,
+			currentModelProvider,
 			actions,
 		]
 	);

package/src/hooks/use-daemon-runtime-controller.ts

@@ -9,6 +9,7 @@ import { useResponseTimer } from "./use-response-timer";
 import { useTypingMode } from "./use-typing-mode";
 
 import { daemonEvents } from "../state/daemon-events";
+import type { LlmProvider } from "../types";
 
 export interface DaemonRuntimeControllerResult {
 	reasoning: ReturnType<typeof useReasoningAnimation>;
@@ -41,6 +42,7 @@ export interface DaemonRuntimeControllerResult {
 }
 
 export function useDaemonRuntimeController({
+	currentModelProvider,
 	currentModelId,
 	preferencesLoaded,
 	sessionId,
@@ -48,6 +50,7 @@ export function useDaemonRuntimeController({
 	ensureSessionId,
 	onFirstMessage,
 }: {
+	currentModelProvider: LlmProvider;
 	currentModelId: string;
 	preferencesLoaded: boolean;
 	sessionId: string | null;
@@ -77,6 +80,7 @@ export function useDaemonRuntimeController({
 		setSessionUsage,
 		applyAvatarForState,
 	} = useDaemonEvents({
+		currentModelProvider,
 		currentModelId,
 		preferencesLoaded,
 		setReasoningQueue: reasoning.setReasoningQueue,

package/src/hooks/use-menu-keyboard.ts

@@ -12,6 +12,7 @@ interface UseMenuKeyboardParams {
 	enableViKeys?: boolean;
 	closeOnSelect?: boolean;
 	ignoreEscape?: boolean;
+	disabled?: boolean;
 }
 
 interface UseMenuKeyboardReturn {
@@ -27,6 +28,7 @@ export function useMenuKeyboard({
 	enableViKeys = true,
 	closeOnSelect = true,
 	ignoreEscape = false,
+	disabled = false,
 }: UseMenuKeyboardParams): UseMenuKeyboardReturn {
 	const [selectedIndex, setSelectedIndex] = useState(initialIndex);
 
@@ -49,6 +51,9 @@ export function useMenuKeyboard({
 	const handleKeyPress = useCallback(
 		(key: KeyEvent) => {
 			if (key.eventType !== "press") return;
+			if (disabled) {
+				return;
+			}
 			if (ignoreEscape && key.name === "escape") {
 				return;
 			}
@@ -84,7 +89,7 @@ export function useMenuKeyboard({
 
 			key.preventDefault();
 		},
-		[itemCount, selectedIndex, onClose, onSelect, enableViKeys, closeOnSelect]
+		[itemCount, selectedIndex, onClose, onSelect, enableViKeys, closeOnSelect, ignoreEscape, disabled]
 	);
 
 	useKeyboard(handleKeyPress);

package/src/state/app-context.tsx

@@ -6,6 +6,7 @@ import type {
 	AudioDevice,
 	BashApprovalLevel,
 	GroundingMap,
+	LlmProvider,
 	ModelOption,
 	OnboardingStep,
 	ReasoningEffort,
@@ -55,6 +56,7 @@ export interface SettingsState {
 	reasoningEffort: ReasoningEffort;
 	bashApprovalLevel: BashApprovalLevel;
 	supportsReasoning: boolean;
+	supportsReasoningXHigh: boolean;
 	canEnableVoiceOutput: boolean;
 	showFullReasoning: boolean;
 	setShowFullReasoning: (show: boolean) => void;
@@ -71,6 +73,8 @@ export interface ModelState {
 	openRouterModels: ModelOption[];
 	openRouterModelsLoading: boolean;
 	openRouterModelsUpdatedAt: number | null;
+	currentModelProvider: LlmProvider;
+	setCurrentModelProvider: (provider: LlmProvider) => void;
 	currentModelId: string;
 	setCurrentModelId: (modelId: string) => void;
 	providerMenuItems: ProviderMenuItem[];
@@ -92,6 +96,7 @@ export interface GroundingState {
 export interface OnboardingState {
 	onboardingActive: boolean;
 	onboardingStep: OnboardingStep;
+	copilotAuthenticated: boolean;
 	setOnboardingStep: (step: OnboardingStep) => void;
 	onboardingPreferences: AppPreferences | null;
 	apiKeyTextareaRef: MutableRefObject<TextareaRenderable | null>;
@@ -104,6 +109,7 @@ export interface DeviceCallbacks {
 
 export interface SettingsCallbacks {
 	onToggleInteractionMode: () => void;
+	onCycleModelProvider: () => void;
 	onSetVoiceInteractionType: (type: VoiceInteractionType) => void;
 	onSetSpeechSpeed: (speed: SpeechSpeed) => void;
 	onSetReasoningEffort: (effort: ReasoningEffort) => void;

package/src/types/index.ts

@@ -150,6 +150,11 @@ export interface TranscriptionResult {
 	text: string;
 }
 
+/**
+ * LLM backend provider used for agent responses.
+ */
+export type LlmProvider = "openrouter" | "copilot";
+
 /**
  * Callbacks for streaming AI responses
  */
@@ -213,18 +218,25 @@ export type SpeechSpeed = 1.0 | 1.25 | 1.5 | 1.75 | 2.0;
  * - "low": SURFACE - minimal reasoning
  * - "medium": DEEP - moderate reasoning (default)
  * - "high": ABYSSAL - maximum reasoning depth
+ * - "xhigh": EXTREME - extended deep reasoning (model-dependent)
  */
-export type ReasoningEffort = "low" | "medium" | "high";
+export type ReasoningEffort = "low" | "medium" | "high" | "xhigh";
 
 /** Display labels for reasoning effort levels */
 export const REASONING_EFFORT_LABELS: Record<ReasoningEffort, string> = {
 	low: "LOW",
 	medium: "MEDIUM",
 	high: "HIGH",
+	xhigh: "XHIGH",
 };
 
 /** Ordered list of reasoning effort levels for cycling */
 export const REASONING_EFFORT_LEVELS: ReasoningEffort[] = ["low", "medium", "high"];
+export const REASONING_EFFORT_LEVELS_WITH_XHIGH: ReasoningEffort[] = ["low", "medium", "high", "xhigh"];
+
+export function getReasoningEffortLevels(includeXHigh: boolean): ReasoningEffort[] {
+	return includeXHigh ? REASONING_EFFORT_LEVELS_WITH_XHIGH : REASONING_EFFORT_LEVELS;
+}
 
 /**
  * Bash tool approval level settings.
@@ -248,7 +260,9 @@ export const BASH_APPROVAL_LEVELS: BashApprovalLevel[] = ["none", "dangerous", "
 /**
  * Onboarding flow steps.
  * - intro: Welcome screen
+ * - provider: Select backend provider
  * - openrouter_key: OpenRouter API key input (for AI models)
+ * - copilot_auth: GitHub Copilot authentication
  * - openai_key: OpenAI API key input (for transcription)
  * - exa_key: Exa API key input (for web search)
  * - device: Audio device selection
@@ -257,7 +271,9 @@ export const BASH_APPROVAL_LEVELS: BashApprovalLevel[] = ["none", "dangerous", "
  */
 export type OnboardingStep =
 	| "intro"
+	| "provider"
 	| "openrouter_key"
+	| "copilot_auth"
 	| "openai_key"
 	| "exa_key"
 	| "device"
@@ -302,6 +318,7 @@ export interface AppPreferences {
 	onboardingCompleted: boolean;
 	audioDeviceName?: string;
 	audioOutputDeviceName?: string;
+	modelProvider?: LlmProvider;
 	modelId?: string;
 	/**
 	 * OpenRouter inference provider slug (aka `provider` routing tag), e.g. "openai".
@@ -359,6 +376,10 @@ export interface ModelOption {
 	pricing?: ModelPricing;
 	contextLength?: number;
 	supportsCaching?: boolean;
+	/** Per-model support for reasoning effort controls (currently used by Copilot). */
+	supportsReasoningEffort?: boolean;
+	/** Whether this model supports Copilot's `xhigh` reasoning effort tier. */
+	supportsReasoningEffortXHigh?: boolean;
 }
 
 /**

package/src/utils/copilot-models.ts

@@ -0,0 +1,77 @@
+import type { ModelOption } from "../types";
+import { listCopilotModelsSafe } from "../ai/copilot-client";
+import { debug } from "./debug-logger";
+
+let inMemoryCache: { timestamp: number; models: ModelOption[] } | null = null;
+function supportsXHighReasoning(modelId: string): boolean {
+	const normalized = modelId.trim().toLowerCase();
+	return normalized.includes("5.1") || normalized.includes("5.2") || normalized.includes("codex");
+}
+
+function normalizeCopilotModels(
+	items: Array<{
+		id: string;
+		name: string;
+		capabilities?: {
+			supports?: {
+				reasoningEffort?: boolean;
+			};
+			limits?: {
+				max_context_window_tokens?: number;
+			};
+		};
+	}>
+): ModelOption[] {
+	return items
+		.filter((item) => typeof item.id === "string" && item.id.trim().length > 0)
+		.map((item) => ({
+			id: item.id.trim(),
+			name: typeof item.name === "string" && item.name.trim().length > 0 ? item.name.trim() : item.id.trim(),
+			contextLength: item.capabilities?.limits?.max_context_window_tokens,
+			supportsReasoningEffort: item.capabilities?.supports?.reasoningEffort === true,
+			supportsReasoningEffortXHigh: supportsXHighReasoning(item.id.trim()),
+		}))
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function getCopilotModels(options: { forceRefresh?: boolean } = {}): Promise<{
+	models: ModelOption[];
+	timestamp: number | null;
+	fromCache: boolean;
+}> {
+	const now = Date.now();
+	const forceRefresh = options.forceRefresh === true;
+
+	if (!forceRefresh && inMemoryCache) {
+		return {
+			models: inMemoryCache.models,
+			timestamp: inMemoryCache.timestamp,
+			fromCache: true,
+		};
+	}
+
+	try {
+		const modelInfo = await listCopilotModelsSafe();
+		const models = normalizeCopilotModels(modelInfo);
+		if (models.length > 0) {
+			inMemoryCache = {
+				timestamp: now,
+				models,
+			};
+			return {
+				models,
+				timestamp: now,
+				fromCache: false,
+			};
+		}
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		debug.error("Failed to fetch Copilot models:", err);
+	}
+
+	return {
+		models: inMemoryCache?.models ?? [],
+		timestamp: inMemoryCache?.timestamp ?? null,
+		fromCache: Boolean(inMemoryCache),
+	};
+}

package/src/utils/preferences.ts

@@ -74,6 +74,9 @@ export function parsePreferences(raw: unknown): AppPreferences | null {
 	if (typeof raw.modelId === "string") {
 		prefs.modelId = raw.modelId;
 	}
+	if (raw.modelProvider === "openrouter" || raw.modelProvider === "copilot") {
+		prefs.modelProvider = raw.modelProvider;
+	}
 	if (typeof raw.openRouterProviderTag === "string") {
 		prefs.openRouterProviderTag = raw.openRouterProviderTag;
 	}