@makefinks/daemon 0.9.1 → 0.11.0

package/src/ai/providers/openrouter-provider.ts

@@ -0,0 +1,217 @@
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { type ModelMessage, ToolLoopAgent, generateText, stepCountIs } from "ai";
+import { getDaemonManager } from "../../state/daemon-state";
+import { getRuntimeContext } from "../../state/runtime-context";
+import type { ReasoningEffort, ToolApprovalRequest } from "../../types";
+import { debug, toolDebug } from "../../utils/debug-logger";
+import { getOpenRouterReportedCost } from "../../utils/openrouter-reported-cost";
+import { getWorkspacePath } from "../../utils/workspace-manager";
+import { extractFinalAssistantText } from "../message-utils";
+import { buildOpenRouterChatSettings, getResponseModel } from "../model-config";
+import { sanitizeMessagesForInput } from "../sanitize-messages";
+import { buildDaemonSystemPrompt } from "../system-prompt";
+import { coordinateToolApprovals } from "../tool-approval-coordinator";
+import { getCachedToolAvailability, getDaemonTools } from "../tools/index";
+import { createToolAvailabilitySnapshot, resolveToolAvailability } from "../tools/tool-registry";
+import { getProviderCapabilities } from "./capabilities";
+import type { LlmProviderAdapter, ProviderStreamRequest, ProviderStreamResult } from "./types";
+
+const openrouter = createOpenRouter();
+const MAX_AGENT_STEPS = 100;
+
+function normalizeStreamError(error: unknown): Error {
+	if (error instanceof Error) return error;
+	if (error && typeof error === "object" && "message" in error) {
+		const message = (error as { message?: unknown }).message;
+		if (typeof message === "string") return new Error(message);
+	}
+	return new Error(String(error));
+}
+
+async function createDaemonAgent(
+	interactionMode: ProviderStreamRequest["interactionMode"] = "text",
+	reasoningEffort?: ReasoningEffort,
+	memoryInjection?: string
+) {
+	const openRouterReasoningEffort = reasoningEffort === "xhigh" ? "high" : reasoningEffort;
+	const modelConfig = buildOpenRouterChatSettings(
+		openRouterReasoningEffort ? { reasoning: { effort: openRouterReasoningEffort } } : undefined
+	);
+
+	const { sessionId } = getRuntimeContext();
+	const tools = await getDaemonTools();
+	const toolAvailability =
+		getCachedToolAvailability() ?? (await resolveToolAvailability(getDaemonManager().toolToggles));
+
+	const workspacePath = sessionId ? getWorkspacePath(sessionId) : undefined;
+
+	return new ToolLoopAgent({
+		model: openrouter.chat(getResponseModel(), modelConfig),
+		instructions: buildDaemonSystemPrompt({
+			mode: interactionMode,
+			toolAvailability: createToolAvailabilitySnapshot(toolAvailability),
+			workspacePath,
+			memoryInjection,
+		}),
+		tools,
+		stopWhen: stepCountIs(MAX_AGENT_STEPS),
+		prepareStep: async ({ messages }) => ({
+			messages: sanitizeMessagesForInput(messages),
+		}),
+	});
+}
+
+async function streamOpenRouterResponse(
+	request: ProviderStreamRequest
+): Promise<ProviderStreamResult | null> {
+	const {
+		userMessage,
+		callbacks,
+		conversationHistory,
+		interactionMode,
+		abortSignal,
+		reasoningEffort,
+		memoryInjection,
+	} = request;
+
+	const messages: ModelMessage[] = [...conversationHistory];
+	messages.push({ role: "user" as const, content: userMessage });
+
+	const agent = await createDaemonAgent(interactionMode, reasoningEffort, memoryInjection);
+
+	let currentMessages = messages;
+	let fullText = "";
+	let streamError: Error | null = null;
+	let allResponseMessages: ModelMessage[] = [];
+
+	while (true) {
+		const stream = await agent.stream({
+			messages: currentMessages,
+		});
+
+		const pendingApprovals: ToolApprovalRequest[] = [];
+
+		for await (const part of stream.fullStream) {
+			if (abortSignal?.aborted) {
+				return null;
+			}
+
+			if (part.type === "error") {
+				const err = normalizeStreamError(part.error);
+				streamError = err;
+				debug.error("agent-stream-error", {
+					message: err.message,
+					error: part.error,
+				});
+				callbacks.onError?.(err);
+			} else if (part.type === "abort") {
+				return null;
+			} else if (part.type === "reasoning-delta") {
+				callbacks.onReasoningToken?.(part.text);
+			} else if (part.type === "text-delta") {
+				fullText += part.text;
+				callbacks.onToken?.(part.text);
+			} else if (part.type === "tool-input-start") {
+				callbacks.onToolCallStart?.(part.toolName, part.id);
+			} else if (part.type === "tool-call") {
+				callbacks.onToolCall?.(part.toolName, part.input, part.toolCallId);
+			} else if (part.type === "tool-result") {
+				callbacks.onToolResult?.(part.toolName, part.output, part.toolCallId);
+			} else if (part.type === "tool-error") {
+				const errorMessage = part.error instanceof Error ? part.error.message : String(part.error);
+				toolDebug.error("tool-error", {
+					toolName: part.toolName,
+					toolCallId: part.toolCallId,
+					input: part.input,
+					error: errorMessage,
+				});
+				callbacks.onToolResult?.(part.toolName, { error: errorMessage, input: part.input }, part.toolCallId);
+			} else if (part.type === "tool-approval-request") {
+				const approvalRequest: ToolApprovalRequest = {
+					approvalId: part.approvalId,
+					toolName: part.toolCall.toolName,
+					toolCallId: part.toolCall.toolCallId,
+					input: part.toolCall.input,
+				};
+				pendingApprovals.push(approvalRequest);
+				callbacks.onToolApprovalRequest?.(approvalRequest);
+			} else if (part.type === "finish-step") {
+				if (part.usage && callbacks.onStepUsage) {
+					const reportedCost = getOpenRouterReportedCost(part.providerMetadata);
+
+					callbacks.onStepUsage({
+						promptTokens: part.usage.inputTokens ?? 0,
+						completionTokens: part.usage.outputTokens ?? 0,
+						totalTokens: part.usage.totalTokens ?? 0,
+						reasoningTokens: part.usage.outputTokenDetails?.reasoningTokens ?? 0,
+						cachedInputTokens: part.usage.inputTokenDetails?.cacheReadTokens ?? 0,
+						cost: reportedCost,
+					});
+				}
+			}
+		}
+
+		if (streamError) {
+			return null;
+		}
+
+		const rawResponseMessages = await stream.response.then((response) => response.messages);
+		const responseMessages = sanitizeMessagesForInput(rawResponseMessages);
+		allResponseMessages = [...allResponseMessages, ...responseMessages];
+		currentMessages = [...currentMessages, ...responseMessages];
+
+		if (pendingApprovals.length > 0 && callbacks.onAwaitingApprovals) {
+			const { toolMessage } = await coordinateToolApprovals({
+				pendingApprovals,
+				requestApprovals: callbacks.onAwaitingApprovals,
+			});
+
+			if (toolMessage) {
+				currentMessages = [...currentMessages, toolMessage];
+			}
+
+			continue;
+		}
+
+		break;
+	}
+
+	if (streamError) {
+		return null;
+	}
+
+	const finalText = extractFinalAssistantText(allResponseMessages);
+	if (!fullText && allResponseMessages.length === 0) {
+		callbacks.onError?.(new Error("Model returned empty response. Check API key and model availability."));
+		return null;
+	}
+
+	return {
+		fullText,
+		responseMessages: allResponseMessages,
+		finalText,
+	};
+}
+
+async function generateOpenRouterSessionTitle(firstMessage: string): Promise<string> {
+	const result = await generateText({
+		model: openrouter.chat(getResponseModel(), buildOpenRouterChatSettings()),
+		system:
+			'You are a title generator. Generate a very short, descriptive title (3-6 words) for a conversation based on the user\'s first message. The title should capture the main topic or intent. Do not use quotes, punctuation, or prefixes like "Title:". Just output the title text directly.',
+		messages: [
+			{
+				role: "user",
+				content: `Generate a short descriptive title for the following message <message>${firstMessage}</message>`,
+			},
+		],
+	});
+
+	return result.text.trim() || "New Session";
+}
+
+export const openRouterProviderAdapter: LlmProviderAdapter = {
+	id: "openrouter",
+	capabilities: getProviderCapabilities("openrouter"),
+	streamResponse: streamOpenRouterResponse,
+	generateSessionTitle: generateOpenRouterSessionTitle,
+};

package/src/ai/providers/registry.ts

@@ -0,0 +1,14 @@
+import type { LlmProvider } from "../../types";
+import { getModelProvider } from "../model-config";
+import { copilotProviderAdapter } from "./copilot-provider";
+import { openRouterProviderAdapter } from "./openrouter-provider";
+import type { LlmProviderAdapter } from "./types";
+
+const PROVIDER_ADAPTERS: Record<LlmProvider, LlmProviderAdapter> = {
+	openrouter: openRouterProviderAdapter,
+	copilot: copilotProviderAdapter,
+};
+
+export function getProviderAdapter(provider: LlmProvider = getModelProvider()): LlmProviderAdapter {
+	return PROVIDER_ADAPTERS[provider];
+}

package/src/ai/providers/types.ts

@@ -0,0 +1,31 @@
+import type { ModelMessage } from "ai";
+import type { LlmProvider, ReasoningEffort, StreamCallbacks, TokenUsage } from "../../types";
+import type { InteractionMode } from "../system-prompt";
+
+export interface ProviderCapabilities {
+	supportsSubagentTool: boolean;
+}
+
+export interface ProviderStreamRequest {
+	userMessage: string;
+	callbacks: StreamCallbacks;
+	conversationHistory: ModelMessage[];
+	interactionMode: InteractionMode;
+	abortSignal?: AbortSignal;
+	reasoningEffort?: ReasoningEffort;
+	memoryInjection?: string;
+}
+
+export interface ProviderStreamResult {
+	fullText: string;
+	responseMessages: ModelMessage[];
+	usage?: TokenUsage;
+	finalText?: string;
+}
+
+export interface LlmProviderAdapter {
+	id: LlmProvider;
+	capabilities: ProviderCapabilities;
+	streamResponse: (request: ProviderStreamRequest) => Promise<ProviderStreamResult | null>;
+	generateSessionTitle: (firstMessage: string) => Promise<string>;
+}

package/src/ai/system-prompt.ts

@@ -9,6 +9,7 @@ export type InteractionMode = "text" | "voice";
 
 export interface ToolAvailability {
 	readFile: boolean;
+	writeFile: boolean;
 	runBash: boolean;
 	webSearch: boolean;
 	fetchUrls: boolean;
@@ -64,6 +65,7 @@ export function buildDaemonSystemPrompt(options: SystemPromptOptions = {}): stri
 function normalizeToolAvailability(toolAvailability?: Partial<ToolAvailability>): ToolAvailability {
 	return {
 		readFile: toolAvailability?.readFile ?? true,
+		writeFile: toolAvailability?.writeFile ?? true,
 		runBash: toolAvailability?.runBash ?? true,
 		webSearch: toolAvailability?.webSearch ?? true,
 		fetchUrls: toolAvailability?.fetchUrls ?? true,
@@ -243,6 +245,19 @@ Fetch multiple URLs in one call:
   By default it reads up to 2000 lines from the start when no offset/limit are provided.
   For partial reads, you must provide both a 0-based line offset and a line limit.
 `,
+	writeFile: `
+  ### 'writeFile' (local file writer)
+  Use this to write content to files. Creates new files or overwrites existing ones.
+  Automatically creates parent directories if they don't exist.
+
+  **CRITICAL: Always report the correct file location to the user**
+  - When you write a file, explicitly tell the user the full path where it was saved
+  - If the file is in the workspace, say "I have saved it to my workspace at: [full path]"
+  - If the file is in the current working directory, say "I have saved it to: [path]"
+  - Do NOT give commands like "cat filename" or "open filename" unless the file is actually in the current working directory
+  - For files in the workspace, give the full path: "cat /full/path/to/file" or tell the user to navigate there first
+`,
+
 	subagent: `
   ### 'subagent'
   Call this tool to spawn subagents for specific tasks.
@@ -260,6 +275,7 @@ function buildToolDefinitions(availability: ToolAvailability): string {
 	if (availability.groundingManager) blocks.push(TOOL_SECTIONS.groundingManager);
 	if (availability.runBash) blocks.push(TOOL_SECTIONS.runBash);
 	if (availability.readFile) blocks.push(TOOL_SECTIONS.readFile);
+	if (availability.writeFile) blocks.push(TOOL_SECTIONS.writeFile);
 	if (availability.subagent) blocks.push(TOOL_SECTIONS.subagent);
 
 	const webNote =

package/src/ai/tools/subagents.ts

@@ -14,7 +14,6 @@ import { getOpenRouterReportedCost } from "../../utils/openrouter-reported-cost"
 import { getMcpManager } from "../mcp/mcp-manager";
 import { extractFinalAssistantText } from "../message-utils";
 import { buildOpenRouterChatSettings, getSubagentModel } from "../model-config";
-import { buildToolSet } from "./tool-registry";
 
 // OpenRouter client for subagents
 const openrouter = createOpenRouter();
@@ -33,6 +32,7 @@ async function getSubagentTools(): Promise<ToolSet> {
 	if (!cachedSubagentBaseTools) {
 		cachedSubagentBaseTools = (async () => {
 			const toggles = getDaemonManager().toolToggles;
+			const { buildToolSet } = await import("./tool-registry");
 			const { tools } = await buildToolSet(toggles, {
 				omit: ["groundingManager", "subagent"],
 			});

package/src/ai/tools/tool-registry.ts

@@ -8,7 +8,9 @@ import { runBash } from "./run-bash";
 import { subagent } from "./subagents";
 import { todoManager } from "./todo-manager";
 import { webSearch } from "./web-search";
+import { writeFile } from "./write-file";
 
+import { getProviderCapabilities } from "../providers/capabilities";
 import type { ToolToggleId, ToolToggles } from "../../types";
 import { detectLocalPlaywrightChromium } from "../../utils/js-rendering";
 
@@ -40,13 +42,14 @@ type ToolGateResult = {
 
 const TOOL_REGISTRY: ToolEntry[] = [
 	{ id: "readFile", toggleKey: "readFile", tool: readFile },
+	{ id: "writeFile", toggleKey: "writeFile", tool: writeFile },
 	{ id: "runBash", toggleKey: "runBash", tool: runBash },
 	{ id: "webSearch", toggleKey: "webSearch", tool: webSearch, gate: gateExa },
 	{ id: "fetchUrls", toggleKey: "fetchUrls", tool: fetchUrls, gate: gateExa },
 	{ id: "renderUrl", toggleKey: "renderUrl", tool: renderUrl, gate: gateRenderUrl },
 	{ id: "todoManager", toggleKey: "todoManager", tool: todoManager },
 	{ id: "groundingManager", toggleKey: "groundingManager", tool: groundingManager },
-	{ id: "subagent", toggleKey: "subagent", tool: subagent },
+	{ id: "subagent", toggleKey: "subagent", tool: subagent, gate: gateSubagent },
 ];
 
 function gateExa(): Promise<ToolGateResult> {
@@ -65,9 +68,24 @@ async function gateRenderUrl(): Promise<ToolGateResult> {
 	};
 }
 
+function gateSubagent(): Promise<ToolGateResult> {
+	const capabilities = getProviderCapabilities();
+	if (!capabilities.supportsSubagentTool) {
+		return Promise.resolve({
+			envAvailable: false,
+			disabledReason: "Subagent tool is unavailable for the current model provider.",
+		});
+	}
+
+	return Promise.resolve({
+		envAvailable: true,
+	});
+}
+
 function normalizeToggles(toggles?: ToolToggles): ToolToggles {
 	return {
 		readFile: toggles?.readFile ?? true,
+		writeFile: toggles?.writeFile ?? true,
 		runBash: toggles?.runBash ?? true,
 		webSearch: toggles?.webSearch ?? true,
 		fetchUrls: toggles?.fetchUrls ?? true,
@@ -166,6 +184,7 @@ export async function buildToolSet(
 export function getToolLabels(): Record<ToolId, string> {
 	return {
 		readFile: "readFile",
+		writeFile: "writeFile",
 		runBash: "runBash",
 		webSearch: "webSearch",
 		fetchUrls: "fetchUrls",
@@ -179,6 +198,7 @@ export function getToolLabels(): Record<ToolId, string> {
 export function getDefaultToolOrder(): ToolId[] {
 	return [
 		"readFile",
+		"writeFile",
 		"runBash",
 		"webSearch",
 		"fetchUrls",
@@ -192,6 +212,7 @@ export function getDefaultToolOrder(): ToolId[] {
 export function createToolAvailabilitySnapshot(availability: ToolAvailabilityMap): Record<ToolId, boolean> {
 	return {
 		readFile: availability.readFile?.enabled ?? false,
+		writeFile: availability.writeFile?.enabled ?? false,
 		runBash: availability.runBash?.enabled ?? false,
 		webSearch: availability.webSearch?.enabled ?? false,
 		fetchUrls: availability.fetchUrls?.enabled ?? false,

package/src/ai/tools/write-file.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+
+export const writeFile = tool({
+	description:
+		"Write content to a file. Creates the file if it doesn't exist, or overwrites it if it does. Supports append mode to add content to existing files. Use this to create scripts, save outputs, write configuration files, or generate any text-based file.",
+	inputSchema: z.object({
+		path: z
+			.string()
+			.describe("Path to the file to write. Can be absolute or relative to the current working directory."),
+		content: z.string().describe("The content to write to the file."),
+		append: z
+			.boolean()
+			.optional()
+			.default(false)
+			.describe("If true, append to the file instead of overwriting. Creates the file if it doesn't exist."),
+	}),
+	execute: async ({ path: filePath, content, append }) => {
+		try {
+			const resolvedPath = path.resolve(filePath);
+			const dir = path.dirname(resolvedPath);
+
+			// Create parent directories if they don't exist
+			if (!fs.existsSync(dir)) {
+				fs.mkdirSync(dir, { recursive: true });
+			}
+
+			// Write or append to the file
+			if (append) {
+				fs.appendFileSync(resolvedPath, content, "utf8");
+			} else {
+				fs.writeFileSync(resolvedPath, content, "utf8");
+			}
+
+			return {
+				success: true,
+				path: resolvedPath,
+				bytesWritten: Buffer.byteLength(content, "utf8"),
+			};
+		} catch (error: unknown) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			return {
+				success: false,
+				path: filePath,
+				error: err.message,
+			};
+		}
+	},
+});

package/src/app/components/AppOverlays.tsx

@@ -60,12 +60,16 @@ function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverl
 					reasoningEffort={settings.reasoningEffort}
 					bashApprovalLevel={settings.bashApprovalLevel}
 					supportsReasoning={settings.supportsReasoning}
+					supportsReasoningXHigh={settings.supportsReasoningXHigh}
+					modelProvider={model.currentModelProvider}
+					copilotAvailable={onboarding.copilotAuthenticated}
 					canEnableVoiceOutput={settings.canEnableVoiceOutput}
 					showFullReasoning={settings.showFullReasoning}
 					showToolOutput={settings.showToolOutput}
 					memoryEnabled={settings.memoryEnabled}
 					onClose={() => menus.setShowSettingsMenu(false)}
 					toggleInteractionMode={settingsCallbacks.onToggleInteractionMode}
+					cycleModelProvider={settingsCallbacks.onCycleModelProvider}
 					setVoiceInteractionType={settingsCallbacks.onSetVoiceInteractionType}
 					setSpeechSpeed={settingsCallbacks.onSetSpeechSpeed}
 					setReasoningEffort={settingsCallbacks.onSetReasoningEffort}
@@ -81,6 +85,7 @@ function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverl
 				<ModelMenu
 					curatedModels={model.curatedModels}
 					allModels={model.openRouterModels}
+					modelProvider={model.currentModelProvider}
 					allModelsLoading={model.openRouterModelsLoading}
 					allModelsUpdatedAt={model.openRouterModelsUpdatedAt}
 					currentModelId={model.currentModelId}
@@ -90,7 +95,7 @@ function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverl
 				/>
 			)}
 
-			{menus.showProviderMenu && (
+			{menus.showProviderMenu && model.currentModelProvider === "openrouter" && (
 				<ProviderMenu
 					items={model.providerMenuItems}
 					currentProviderTag={model.currentOpenRouterProviderTag}
@@ -141,10 +146,13 @@ function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverl
 					currentDevice={device.currentDevice}
 					currentOutputDevice={device.currentOutputDevice}
 					models={model.curatedModels}
+					currentModelProvider={model.currentModelProvider}
+					copilotAuthenticated={onboarding.copilotAuthenticated}
 					currentModelId={model.currentModelId}
 					deviceLoadTimedOut={device.deviceLoadTimedOut}
 					soxAvailable={device.soxAvailable}
 					soxInstallHint={device.soxInstallHint}
+					setCurrentModelProvider={model.setCurrentModelProvider}
 					setCurrentDevice={device.setCurrentDevice}
 					setCurrentOutputDevice={device.setCurrentOutputDevice}
 					setCurrentModelId={model.setCurrentModelId}

package/src/app/components/ConversationPane.tsx

@@ -12,7 +12,7 @@ import { InlineStatusIndicator } from "../../components/InlineStatusIndicator";
 import { StatusBar } from "../../components/StatusBar";
 import { TokenUsageDisplay } from "../../components/TokenUsageDisplay";
 import { TypingInputBar } from "../../components/TypingInputBar";
-import type { ContentBlock, ConversationMessage, TokenUsage } from "../../types";
+import type { ContentBlock, ConversationMessage, LlmProvider, TokenUsage } from "../../types";
 import { DaemonState } from "../../types";
 import { COLORS, REASONING_MARKDOWN_STYLE } from "../../ui/constants";
 import { renderReasoningTicker } from "../../ui/reasoning-ticker";
@@ -68,6 +68,7 @@ export interface ConversationPaneProps {
 	typing: TypingInputState;
 	sessionUsage: TokenUsage;
 	modelMetadata: ModelMetadata | null;
+	currentModelProvider: LlmProvider;
 	hasInteracted: boolean;
 	suppressStatusBar?: boolean;
 	frostColor: string;
@@ -89,6 +90,7 @@ function ConversationPaneImpl(props: ConversationPaneProps) {
 		typing,
 		sessionUsage,
 		modelMetadata,
+		currentModelProvider,
 		hasInteracted,
 		suppressStatusBar = false,
 		frostColor,
@@ -246,7 +248,11 @@ function ConversationPaneImpl(props: ConversationPaneProps) {
 				(sessionUsage.totalTokens > 0 ||
 					(sessionUsage.subagentTotalTokens ?? 0) > 0 ||
 					typeof sessionUsage.cost === "number") && (
-					<TokenUsageDisplay usage={sessionUsage} modelMetadata={modelMetadata} />
+					<TokenUsageDisplay
+						usage={sessionUsage}
+						modelMetadata={modelMetadata}
+						hideCost={currentModelProvider === "copilot"}
+					/>
 				)}
 
 			{hasInteracted && resetNotification && (