@makefinks/daemon 0.10.0 → 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/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

@@ -10,6 +10,7 @@ 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";
 
@@ -48,7 +49,7 @@ const TOOL_REGISTRY: ToolEntry[] = [
 	{ 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> {
@@ -67,6 +68,20 @@ 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,

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 && (