@makefinks/daemon 0.9.1 → 0.11.0

package/src/components/OnboardingOverlay.tsx

@@ -3,9 +3,10 @@ import { useKeyboard } from "@opentui/react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import type { RefObject } from "react";
 import { handleOnboardingKey } from "../hooks/keyboard-handlers";
-import type { AppPreferences, AudioDevice, ModelOption, OnboardingStep } from "../types";
+import type { AppPreferences, AudioDevice, LlmProvider, ModelOption, OnboardingStep } from "../types";
 import { COLORS } from "../ui/constants";
 import { formatContextWindowK, formatPrice } from "../utils/formatters";
+import { ApiKeyInput } from "./ApiKeyInput";
 import { ApiKeyStep } from "./ApiKeyStep";
 
 const MODEL_COL_WIDTH = {
@@ -25,6 +26,13 @@ const API_KEY_CONFIGS = {
 		keyUrl: "https://openrouter.ai/keys",
 		optional: false,
 	},
+	copilot_auth: {
+		title: "GITHUB COPILOT LOGIN REQUIRED",
+		description: "Authenticate with GitHub/Copilot CLI, then validate from here.",
+		envVarName: "COPILOT_CLI_LOGIN",
+		keyUrl: "https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli",
+		optional: false,
+	},
 	openai_key: {
 		title: "OPENAI API KEY (OPTIONAL)",
 		description: "OpenAI enables voice features (speech-to-text and text-to-speech).",
@@ -51,10 +59,13 @@ interface OnboardingOverlayProps {
 	currentDevice?: string;
 	currentOutputDevice?: string;
 	models: ModelOption[];
+	currentModelProvider: LlmProvider;
+	copilotAuthenticated: boolean;
 	currentModelId: string;
 	deviceLoadTimedOut?: boolean;
 	soxAvailable: boolean;
 	soxInstallHint: string;
+	setCurrentModelProvider: (provider: LlmProvider) => void;
 	setCurrentDevice: (deviceName: string | undefined) => void;
 	setCurrentOutputDevice: (deviceName: string | undefined) => void;
 	setCurrentModelId: (modelId: string) => void;
@@ -74,10 +85,13 @@ export function OnboardingOverlay({
 	currentDevice,
 	currentOutputDevice,
 	models,
+	currentModelProvider,
+	copilotAuthenticated,
 	currentModelId,
 	deviceLoadTimedOut,
 	soxAvailable,
 	soxInstallHint,
+	setCurrentModelProvider,
 	setCurrentDevice,
 	setCurrentOutputDevice,
 	setCurrentModelId,
@@ -87,9 +101,35 @@ export function OnboardingOverlay({
 	onKeySubmit,
 	apiKeyTextareaRef,
 }: OnboardingOverlayProps) {
+	const [selectedProviderIdx, setSelectedProviderIdx] = useState(0);
 	const [selectedDeviceIdx, setSelectedDeviceIdx] = useState(0);
 	const [selectedModelIdx, setSelectedModelIdx] = useState(0);
 
+	const providerOptions = useMemo(
+		() => [
+			{
+				id: "openrouter" as const,
+				label: "OpenRouter",
+				description: "API key based provider routing",
+			},
+			...(copilotAuthenticated
+				? ([
+						{
+							id: "copilot" as const,
+							label: "GitHub Copilot",
+							description: "GitHub auth + Copilot subscription",
+						},
+					] as const)
+				: []),
+		],
+		[copilotAuthenticated]
+	);
+
+	const initialProviderIdx = useMemo(() => {
+		const idx = providerOptions.findIndex((provider) => provider.id === currentModelProvider);
+		return idx >= 0 ? idx : 0;
+	}, [currentModelProvider, providerOptions]);
+
 	const initialDeviceIdx = useMemo(() => {
 		if (devices.length === 0) return 0;
 		const idx = currentDevice ? devices.findIndex((device) => device.name === currentDevice) : -1;
@@ -103,6 +143,11 @@ export function OnboardingOverlay({
 		return idx >= 0 ? idx : 0;
 	}, [models, currentModelId]);
 
+	useEffect(() => {
+		if (step !== "provider") return;
+		setSelectedProviderIdx(initialProviderIdx);
+	}, [step, initialProviderIdx]);
+
 	useEffect(() => {
 		if (step !== "device") return;
 		setSelectedDeviceIdx(initialDeviceIdx);
@@ -117,13 +162,18 @@ export function OnboardingOverlay({
 		(key: KeyEvent) => {
 			const handled = handleOnboardingKey(key, {
 				step,
+				selectedProviderIdx,
 				devices,
 				models,
 				selectedDeviceIdx,
 				selectedModelIdx,
+				currentModelProvider,
+				copilotAuthenticated,
 				preferences,
+				setSelectedProviderIdx,
 				setSelectedDeviceIdx,
 				setSelectedModelIdx,
+				setCurrentModelProvider,
 				setCurrentDevice,
 				setCurrentOutputDevice,
 				setCurrentModelId,
@@ -140,11 +190,15 @@ export function OnboardingOverlay({
 		},
 		[
 			step,
+			selectedProviderIdx,
 			devices,
 			models,
 			selectedDeviceIdx,
 			selectedModelIdx,
+			currentModelProvider,
+			copilotAuthenticated,
 			preferences,
+			setCurrentModelProvider,
 			setCurrentDevice,
 			setCurrentOutputDevice,
 			setCurrentModelId,
@@ -209,6 +263,61 @@ export function OnboardingOverlay({
 					</>
 				)}
 
+				{step === "provider" && (
+					<>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.DAEMON_LABEL}>[ SELECT MODEL PROVIDER ]</span>
+							</text>
+						</box>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.REASONING_DIM}>Choose where DAEMON should run agent responses.</span>
+							</text>
+						</box>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.USER_LABEL}>↑/↓ navigate, ENTER select</span>
+							</text>
+						</box>
+						<box flexDirection="column">
+							{providerOptions.map((provider, idx) => {
+								const isSelected = idx === selectedProviderIdx;
+								const isCurrent = currentModelProvider === provider.id;
+								return (
+									<box
+										key={provider.id}
+										backgroundColor={isSelected ? COLORS.MENU_SELECTED_BG : COLORS.MENU_BG}
+										paddingLeft={1}
+										paddingRight={1}
+										flexDirection="column"
+									>
+										<text>
+											<span fg={isSelected ? COLORS.DAEMON_LABEL : COLORS.MENU_TEXT}>
+												{isSelected ? "▶ " : "  "}
+												{provider.label}
+												{isCurrent ? " ●" : ""}
+											</span>
+										</text>
+										<text>
+											<span fg={COLORS.REASONING_DIM}> {provider.description}</span>
+										</text>
+									</box>
+								);
+							})}
+							{!copilotAuthenticated && (
+								<box marginTop={1}>
+									<text>
+										<span fg={COLORS.REASONING_DIM}>
+											Copilot appears after `gh auth login` and `copilot login`.
+										</span>
+									</text>
+								</box>
+							)}
+						</box>
+					</>
+				)}
+
 				{step === "openrouter_key" && (
 					<ApiKeyStep
 						{...API_KEY_CONFIGS.openrouter_key}
@@ -217,6 +326,43 @@ export function OnboardingOverlay({
 					/>
 				)}
 
+				{step === "copilot_auth" && (
+					<>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.DAEMON_LABEL}>[ {API_KEY_CONFIGS.copilot_auth.title} ]</span>
+							</text>
+						</box>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.MENU_TEXT}>
+									Run `gh auth login` and `copilot login`, then press ENTER to validate.
+								</span>
+							</text>
+						</box>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.REASONING_DIM}>
+									Copilot token auth is disabled in DAEMON; logged-in CLI session is required.
+								</span>
+							</text>
+						</box>
+						<box marginBottom={1}>
+							<text>
+								<span fg={COLORS.REASONING_DIM}>
+									Install/login guide: {API_KEY_CONFIGS.copilot_auth.keyUrl}
+								</span>
+								<span fg={COLORS.USER_LABEL}> · Shift+O to open</span>
+							</text>
+						</box>
+						<ApiKeyInput
+							onSubmit={onKeySubmit}
+							placeholder="Press ENTER to validate Copilot login..."
+							textareaRef={apiKeyTextareaRef}
+						/>
+					</>
+				)}
+
 				{step === "openai_key" && (
 					<ApiKeyStep
 						{...API_KEY_CONFIGS.openai_key}

package/src/components/SettingsMenu.tsx

@@ -4,6 +4,7 @@ import { useEffect, useState } from "react";
 import type {
 	AppPreferences,
 	InteractionMode,
+	LlmProvider,
 	VoiceInteractionType,
 	SpeechSpeed,
 	ReasoningEffort,
@@ -31,13 +32,17 @@ interface SettingsMenuProps {
 	speechSpeed: SpeechSpeed;
 	reasoningEffort: ReasoningEffort;
 	bashApprovalLevel: BashApprovalLevel;
+	modelProvider: LlmProvider;
 	supportsReasoning: boolean;
+	supportsReasoningXHigh: boolean;
+	copilotAvailable: boolean;
 	canEnableVoiceOutput: boolean;
 	showFullReasoning: boolean;
 	showToolOutput: boolean;
 	memoryEnabled: boolean;
 	onClose: () => void;
 	toggleInteractionMode: () => void;
+	cycleModelProvider: () => void;
 	setVoiceInteractionType: (type: VoiceInteractionType) => void;
 	setSpeechSpeed: (speed: SpeechSpeed) => void;
 	setReasoningEffort: (effort: ReasoningEffort) => void;
@@ -54,13 +59,17 @@ export function SettingsMenu({
 	speechSpeed,
 	reasoningEffort,
 	bashApprovalLevel,
+	modelProvider,
 	supportsReasoning,
+	supportsReasoningXHigh,
+	copilotAvailable,
 	canEnableVoiceOutput,
 	showFullReasoning,
 	showToolOutput,
 	memoryEnabled,
 	onClose,
 	toggleInteractionMode,
+	cycleModelProvider,
 	setVoiceInteractionType,
 	setSpeechSpeed,
 	setReasoningEffort,
@@ -93,6 +102,18 @@ export function SettingsMenu({
 			isToggle: true,
 			disabled: interactionModeLocked,
 		},
+		{
+			id: "model-provider",
+			label: "Model Provider",
+			value: modelProvider === "copilot" ? "COPILOT" : "OPENROUTER",
+			description:
+				!copilotAvailable && modelProvider === "openrouter"
+					? "OpenRouter API with provider routing (Copilot: run `gh auth login` + `copilot login`)"
+					: modelProvider === "copilot"
+						? "GitHub Copilot session runtime"
+						: "OpenRouter API with provider routing",
+			isToggle: true,
+		},
 		{
 			id: "voice-interaction-type",
 			label: "Voice Flow",
@@ -108,7 +129,9 @@ export function SettingsMenu({
 			label: "Reasoning Effort",
 			value: supportsReasoning ? REASONING_EFFORT_LABELS[reasoningEffort] : "N/A",
 			description: supportsReasoning
-				? "Depth of reasoning (LOW / MEDIUM / HIGH)"
+				? supportsReasoningXHigh
+					? "Depth of reasoning (LOW / MEDIUM / HIGH / XHIGH)"
+					: "Depth of reasoning (LOW / MEDIUM / HIGH)"
 				: "Not supported by current model",
 			isCyclic: supportsReasoning,
 		},
@@ -187,17 +210,20 @@ export function SettingsMenu({
 			selectedIdx,
 			menuItemCount: selectableCount,
 			interactionMode,
+			modelProvider,
 			voiceInteractionType,
 			speechSpeed,
 			reasoningEffort,
 			bashApprovalLevel,
 			supportsReasoning,
+			supportsReasoningXHigh,
 			canEnableVoiceOutput,
 			showFullReasoning,
 			showToolOutput,
 			memoryEnabled,
 			setSelectedIdx,
 			toggleInteractionMode,
+			cycleModelProvider,
 			setVoiceInteractionType,
 			setSpeechSpeed,
 			setReasoningEffort,

package/src/components/TokenUsageDisplay.tsx

@@ -10,15 +10,17 @@ import { type ModelMetadata, calculateCost, formatContextUsage, formatCost } fro
 interface TokenUsageDisplayProps {
 	usage: TokenUsage;
 	modelMetadata?: ModelMetadata | null;
+	hideCost?: boolean;
 }
 
-export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayProps) {
+export function TokenUsageDisplay({ usage, modelMetadata, hideCost = false }: TokenUsageDisplayProps) {
 	const mainPromptTokens = usage.promptTokens;
 	const mainCompletionTokens = usage.completionTokens;
 
 	// Calculate cost if we have pricing info
-	const cost =
-		typeof usage.cost === "number"
+	const cost = hideCost
+		? null
+		: typeof usage.cost === "number"
 			? usage.cost
 			: modelMetadata?.pricing
 				? calculateCost(

package/src/components/tool-layouts/layouts/index.ts

@@ -2,6 +2,7 @@ import "./bash";
 import "./web-search";
 import "./url-tools";
 import "./read-file";
+import "./write-file.tsx";
 import "./subagent";
 import "./todo";
 import "./system-info";

package/src/components/tool-layouts/layouts/write-file.tsx

@@ -0,0 +1,117 @@
+import { pathToFiletype } from "@opentui/core";
+import React from "react";
+import { COLORS, REASONING_MARKDOWN_STYLE } from "../../../ui/constants";
+import { registerToolLayout } from "../registry";
+import type { ToolHeader, ToolLayoutConfig, ToolLayoutRenderProps } from "../types";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function extractPath(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("path" in input && typeof input.path === "string") {
+		return input.path;
+	}
+	return null;
+}
+
+function extractContent(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("content" in input && typeof input.content === "string") {
+		return input.content;
+	}
+	return null;
+}
+
+function extractAppend(input: unknown): boolean {
+	if (!isRecord(input)) return false;
+	if ("append" in input && typeof input.append === "boolean") {
+		return input.append;
+	}
+	return false;
+}
+
+function WriteFileBody({ call, result }: ToolLayoutRenderProps) {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return (
+			<box paddingLeft={2}>
+				<text>
+					<span fg={COLORS.STATUS_FAILED}>{`error: ${result.error}`}</span>
+				</text>
+			</box>
+		);
+	}
+	if (result.success !== true) return null;
+
+	const content = extractContent(call.input) ?? "";
+	const path = extractPath(call.input) ?? "";
+
+	// Detect filetype from path for syntax highlighting
+	const filetype = pathToFiletype(path);
+
+	// Format content preview
+	let previewContent = "";
+	if (content.trim()) {
+		const MAX_LINES = 4;
+		const MAX_CHARS = 160;
+		const contentLines = content
+			.split("\n")
+			.slice(0, MAX_LINES)
+			.map((line) => (line.length > MAX_CHARS ? `${line.slice(0, MAX_CHARS - 1)}…` : line));
+
+		const totalLines = content.split("\n").length;
+		if (totalLines > MAX_LINES) {
+			contentLines.push(`... (${totalLines - MAX_LINES} more lines)`);
+		}
+		previewContent = contentLines.join("\n");
+	} else {
+		previewContent = "(empty file)";
+	}
+
+	return (
+		<box flexDirection="column" paddingLeft={2} marginTop={0}>
+			<box
+				borderStyle="single"
+				borderColor={COLORS.TOOL_INPUT_BORDER}
+				paddingLeft={1}
+				paddingRight={1}
+				paddingTop={0}
+				paddingBottom={0}
+			>
+				<code
+					content={previewContent}
+					filetype={filetype}
+					syntaxStyle={REASONING_MARKDOWN_STYLE}
+					conceal={true}
+					drawUnstyledText={false}
+				/>
+			</box>
+		</box>
+	);
+}
+
+export const writeFileLayout: ToolLayoutConfig = {
+	abbreviation: "write",
+
+	getHeader: (input): ToolHeader | null => {
+		const path = extractPath(input);
+		if (!path) return null;
+		const append = extractAppend(input);
+		const filetype = pathToFiletype(path);
+
+		const parts: string[] = [];
+		if (filetype) parts.push(filetype);
+		if (append) parts.push("append");
+
+		const secondary = parts.length > 0 ? parts.join(" · ") : undefined;
+		return { primary: path, secondary, secondaryStyle: "dim" };
+	},
+
+	renderBody: WriteFileBody,
+};
+
+registerToolLayout("writeFile", writeFileLayout);

package/src/hooks/daemon-event-handlers.ts

@@ -57,6 +57,31 @@ function clearAvatarToolEffects(avatar: DaemonAvatarRenderable | null): void {
 	avatar.setTypingMode(false);
 }
 
+function normalizeToolCallId(toolCallId: string | undefined): string | undefined {
+	if (typeof toolCallId !== "string") return undefined;
+	const trimmed = toolCallId.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function isInProgressToolCall(toolCall: ToolCall | undefined): boolean {
+	const status = toolCall?.status;
+	return status === "streaming" || status === "running" || status === "awaiting_approval";
+}
+
+function findExistingToolCall(
+	refs: EventHandlerRefs,
+	toolName: string,
+	toolCallId: string | undefined
+): ToolCall | undefined {
+	if (toolCallId) {
+		return refs.toolCallsByIdRef.current.get(toolCallId);
+	}
+
+	return [...refs.toolCallsRef.current]
+		.reverse()
+		.find((call) => call.name === toolName && isInProgressToolCall(call));
+}
+
 export function createMemorySavedHandler() {
 	return (preview: MemoryToastPreview) => {
 		const description = preview.description?.trim();
@@ -401,15 +426,27 @@ export function createToolInputStartHandler(
 			blocks.pop();
 		}
 
+		const normalizedToolCallId = normalizeToolCallId(toolCallId);
+		const existingToolCall = findExistingToolCall(refs, toolName, normalizedToolCallId);
+		if (existingToolCall) {
+			if (existingToolCall.status === undefined || existingToolCall.status === "streaming") {
+				existingToolCall.status = "streaming";
+			}
+			setters.setCurrentContentBlocks([...blocks]);
+			return;
+		}
+
 		const toolCall: ToolCall = {
 			name: toolName,
 			input: undefined,
-			toolCallId,
+			toolCallId: normalizedToolCallId,
 			status: "streaming",
 			subagentSteps: toolName === "subagent" ? [] : undefined,
 		};
 		refs.toolCallsRef.current.push(toolCall);
-		refs.toolCallsByIdRef.current.set(toolCallId, toolCall);
+		if (normalizedToolCallId) {
+			refs.toolCallsByIdRef.current.set(normalizedToolCallId, toolCall);
+		}
 
 		blocks.push({ type: "tool", call: toolCall });
 		setters.setCurrentContentBlocks([...blocks]);
@@ -437,18 +474,28 @@ export function createToolInvocationHandler(
 
 		const blocks = refs.contentBlocksRef.current;
 
-		const existingToolCall = toolCallId ? refs.toolCallsByIdRef.current.get(toolCallId) : undefined;
-		if (existingToolCall && existingToolCall.status === "streaming") {
+		const normalizedToolCallId = normalizeToolCallId(toolCallId);
+		const existingToolCall = findExistingToolCall(refs, toolName, normalizedToolCallId);
+		if (existingToolCall) {
+			const shouldActivateToolAnimation =
+				existingToolCall.status === undefined ||
+				existingToolCall.status === "streaming" ||
+				existingToolCall.status === "awaiting_approval";
+
 			existingToolCall.input = input;
-			existingToolCall.status = "running";
+			if (shouldActivateToolAnimation) {
+				existingToolCall.status = "running";
+			}
 			setters.setCurrentContentBlocks([...blocks]);
 
-			const avatar = refs.avatarRef.current;
-			if (avatar) {
-				const category = getToolCategory(toolName);
-				avatar.triggerToolFlash(category as ToolCategory | undefined);
-				if (category !== "fast") {
-					avatar.setToolActive(true, category as ToolCategory | undefined);
+			if (shouldActivateToolAnimation) {
+				const avatar = refs.avatarRef.current;
+				if (avatar) {
+					const category = getToolCategory(toolName);
+					avatar.triggerToolFlash(category as ToolCategory | undefined);
+					if (category !== "fast") {
+						avatar.setToolActive(true, category as ToolCategory | undefined);
+					}
 				}
 			}
 			return;
@@ -462,14 +509,14 @@ export function createToolInvocationHandler(
 		const toolCall: ToolCall = {
 			name: toolName,
 			input,
-			toolCallId,
+			toolCallId: normalizedToolCallId,
 			status: "running",
 			subagentSteps: toolName === "subagent" ? [] : undefined,
 		};
 		refs.toolCallsRef.current.push(toolCall);
 
-		if (toolCallId) {
-			refs.toolCallsByIdRef.current.set(toolCallId, toolCall);
+		if (normalizedToolCallId) {
+			refs.toolCallsByIdRef.current.set(normalizedToolCallId, toolCall);
 		}
 
 		blocks.push({ type: "tool", call: toolCall });