@makefinks/daemon 0.9.1 → 0.11.0

package/src/ai/daemon-ai.ts

@@ -4,97 +4,33 @@
  */
 
 import { createOpenAI } from "@ai-sdk/openai";
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
-import {
-	type ModelMessage,
-	ToolLoopAgent,
-	generateText,
-	stepCountIs,
-	experimental_transcribe as transcribe,
-} from "ai";
+import { type ModelMessage, experimental_transcribe as transcribe } from "ai";
 import { getDaemonManager } from "../state/daemon-state";
-import { getRuntimeContext } from "../state/runtime-context";
 import type {
 	MemoryToastOperation,
 	MemoryToastPreview,
 	ReasoningEffort,
 	StreamCallbacks,
-	TokenUsage,
-	ToolApprovalRequest,
-	ToolApprovalResponse,
 	TranscriptionResult,
 } from "../types";
-import { debug, toolDebug } from "../utils/debug-logger";
-import { getOpenRouterReportedCost } from "../utils/openrouter-reported-cost";
-import { getWorkspacePath } from "../utils/workspace-manager";
+import { debug } from "../utils/debug-logger";
 import { buildMemoryInjection, getMemoryManager, isMemoryAvailable } from "./memory";
-import { extractFinalAssistantText } from "./message-utils";
-import { TRANSCRIPTION_MODEL, buildOpenRouterChatSettings, getResponseModel } from "./model-config";
-import { sanitizeMessagesForInput } from "./sanitize-messages";
-import { type InteractionMode, buildDaemonSystemPrompt } from "./system-prompt";
-import { coordinateToolApprovals } from "./tool-approval-coordinator";
-import { getCachedToolAvailability, getDaemonTools } from "./tools/index";
+import { TRANSCRIPTION_MODEL } from "./model-config";
+import { getProviderAdapter } from "./providers/registry";
+import { type InteractionMode } from "./system-prompt";
 import { setSubagentProgressEmitter } from "./tools/subagents";
-import { createToolAvailabilitySnapshot, resolveToolAvailability } from "./tools/tool-registry";
 
-// Re-export ModelMessage from AI SDK since it's commonly needed by consumers
 export type { ModelMessage } from "ai";
 
-// OpenRouter client for AI SDK (response generation)
-const openrouter = createOpenRouter();
-
-// OpenAI client for transcription (OpenRouter doesn't support transcription)
 const openai = createOpenAI({});
 
-// Maximum steps for the agent loop to prevent infinite loops
-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);
+async function buildMemoryInjectionForPrompt(userMessage: string): Promise<string | undefined> {
+	if (!getDaemonManager().memoryEnabled || !isMemoryAvailable()) {
+		return undefined;
 	}
-	return new Error(String(error));
-}
-
-/**
- * The DAEMON agent instance.
- * Handles the agent loop internally, allowing for multi-step tool usage.
- * Created dynamically to use the current model selection and reasoning effort.
- * @param interactionMode - "text" for terminal output, "voice" for speech-optimized
- * @param reasoningEffort - Optional reasoning effort level for models that support it
- */
-async function createDaemonAgent(
-	interactionMode: InteractionMode = "text",
-	reasoningEffort?: ReasoningEffort,
-	memoryInjection?: string
-) {
-	const modelConfig = buildOpenRouterChatSettings(
-		reasoningEffort ? { reasoning: { effort: reasoningEffort } } : 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),
-		}),
-	});
+	const injection = await buildMemoryInjection(userMessage);
+	return injection || undefined;
 }
 
 /**
@@ -118,9 +54,8 @@ export async function transcribeAudio(
 			text: result.text,
 		};
 	} catch (error) {
-		// Check if this was an abort
 		if (error instanceof Error && error.name === "AbortError") {
-			throw error; // Re-throw abort errors as-is
+			throw error;
 		}
 		const err = error instanceof Error ? error : new Error(String(error));
 		throw new Error(`Transcription failed: ${err.message}`);
@@ -128,15 +63,8 @@ export async function transcribeAudio(
 }
 
 /**
- * Generate a streaming response from DAEMON using the Agent class.
- * The agent handles the tool loop internally.
- *
- * @param userMessage - The transcribed user message
- * @param callbacks - Callbacks for streaming tokens, tool calls, and completion
- * @param conversationHistory - Previous AI SDK messages for context
- * @param interactionMode - "text" for terminal output, "voice" for speech-optimized
- * @param abortSignal - Optional abort signal to cancel the request
- * @param reasoningEffort - Optional reasoning effort level for models that support it
+ * Generate a streaming response from DAEMON.
+ * Delegates provider-specific execution to the active provider adapter.
  */
 export async function generateResponse(
 	userMessage: string,
@@ -146,7 +74,6 @@ export async function generateResponse(
 	abortSignal?: AbortSignal,
 	reasoningEffort?: ReasoningEffort
 ): Promise<void> {
-	// Set up subagent progress emitter to forward events to callbacks
 	setSubagentProgressEmitter({
 		onSubagentToolCall: (toolCallId: string, toolName: string, input?: unknown) => {
 			callbacks.onSubagentToolCall?.(toolCallId, toolName, input);
@@ -163,146 +90,30 @@ export async function generateResponse(
 	});
 
 	try {
-		// Build messages array with history and new user message
-		const messages: ModelMessage[] = [...conversationHistory];
-
-		// Include relevant memories in the system prompt if available
-		let memoryInjection: string | undefined;
-		if (getDaemonManager().memoryEnabled && isMemoryAvailable()) {
-			const injection = await buildMemoryInjection(userMessage);
-			if (injection) {
-				memoryInjection = injection;
-			}
-		}
-
-		// Add the user message
-		messages.push({ role: "user" as const, content: userMessage });
-
-		// Stream response from the agent with mode-specific system prompt
-		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;
-				}
-
-				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;
-				} 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);
-
-						// reportedCost may be undefined when provider doesn't supply it
-
-						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;
-			}
-
-			const rawResponseMessages = await stream.response.then((r) => r.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;
-		}
-
-		const finalText = extractFinalAssistantText(allResponseMessages);
+		const memoryInjection = await buildMemoryInjectionForPrompt(userMessage);
+		const provider = getProviderAdapter();
+		const result = await provider.streamResponse({
+			userMessage,
+			callbacks,
+			conversationHistory,
+			interactionMode,
+			abortSignal,
+			reasoningEffort,
+			memoryInjection,
+		});
 
-		if (!fullText && allResponseMessages.length === 0) {
-			callbacks.onError?.(new Error("Model returned empty response. Check API key and model availability."));
+		if (!result) {
 			return;
 		}
 
-		callbacks.onComplete?.(fullText, allResponseMessages, undefined, finalText);
+		callbacks.onComplete?.(result.fullText, result.responseMessages, result.usage, result.finalText);
 
-		void persistConversationMemory(userMessage, finalText ?? fullText).then((preview) => {
+		const assistantTextForMemory = result.finalText ?? result.fullText;
+		void persistConversationMemory(userMessage, assistantTextForMemory).then((preview) => {
 			if (!preview) return;
 			callbacks.onMemorySaved?.(preview);
 		});
 	} catch (error) {
-		// Check if this was an abort - don't treat as error
 		if (abortSignal?.aborted) {
 			return;
 		}
@@ -310,10 +121,8 @@ export async function generateResponse(
 			return;
 		}
 		const err = error instanceof Error ? error : new Error(String(error));
-		let errorMessage = err.message;
-		callbacks.onError?.(new Error(errorMessage));
+		callbacks.onError?.(new Error(err.message));
 	} finally {
-		// Clean up the subagent progress emitter
 		setSubagentProgressEmitter(null);
 	}
 }
@@ -386,23 +195,12 @@ function truncatePreview(text: string, maxChars: number): string {
 
 /**
  * Generate a short descriptive title for a session based on the first user message.
- * Uses the currently selected model.
- * @param firstMessage - The first user message in the session
- * @returns A short title (3-6 words) describing the session topic
  */
 export async function generateSessionTitle(firstMessage: string): Promise<string> {
 	try {
-		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";
+		const provider = getProviderAdapter();
+		const title = await provider.generateSessionTitle(firstMessage);
+		return title.trim() || "New Session";
 	} catch (error) {
 		const err = error instanceof Error ? error : new Error(String(error));
 		debug.error("session-title-generation-failed", { message: err.message });

package/src/ai/model-config.ts

@@ -3,35 +3,66 @@
  */
 
 import type { OpenRouterChatSettings } from "@openrouter/ai-sdk-provider";
-import type { ModelOption } from "../types";
+import type { LlmProvider, ModelOption } from "../types";
 import { loadManualConfig } from "../utils/config";
 
 // Available models for selection (OpenRouter format)
-export const AVAILABLE_MODELS: ModelOption[] = [
+export const AVAILABLE_OPENROUTER_MODELS: ModelOption[] = [
 	{ id: "x-ai/grok-4.1-fast", name: "Grok 4.1 Fast" },
+	{ id: "arcee-ai/trinity-large-preview:free", name: "Trinity Large Preview" },
 	{ id: "z-ai/glm-4.7", name: "GLM 4.7" },
 	{ id: "minimax/minimax-m2.1", name: "Minimax M2.1" },
 	{ id: "google/gemini-3-flash-preview", name: "Gemini 3 Flash" },
 	{ id: "google/gemini-3-pro-preview", name: "Gemini 3 Pro" },
 	{ id: "openai/gpt-5.2", name: "GPT 5.2" },
-	{ id: "moonshotai/kimi-k2-thinking", name: "Kimi K2 Thinking" },
+	{ id: "moonshotai/kimi-k2.5", name: "Kimi K2.5" },
 	{ id: "openai/gpt-oss-120b:exacto", name: "GPT-OSS-120" },
-	{ id: "mistralai/devstral-2512:free", name: "Mistral Devstral" },
 	{ id: "nvidia/nemotron-3-nano-30b-a3b:free", name: "Nemotron 3 Nano" },
 ];
 
-// Default model ID
-export const DEFAULT_MODEL_ID = "z-ai/glm-4.7";
+// Default model IDs
+export const DEFAULT_OPENROUTER_MODEL_ID = "z-ai/glm-4.7";
+export const DEFAULT_COPILOT_MODEL_ID = "claude-sonnet-4.5";
+export const DEFAULT_MODEL_ID = DEFAULT_OPENROUTER_MODEL_ID;
+export const DEFAULT_MODEL_PROVIDER: LlmProvider = "openrouter";
 
-// Current selected model (mutable)
-let currentModelId = DEFAULT_MODEL_ID;
+// Backward-compatible alias used by existing OpenRouter pricing loaders.
+export const AVAILABLE_MODELS = AVAILABLE_OPENROUTER_MODELS;
+
+// Current selected provider + model IDs (mutable)
+let currentModelProvider: LlmProvider = DEFAULT_MODEL_PROVIDER;
+const currentModelIdByProvider: Record<LlmProvider, string> = {
+	openrouter: DEFAULT_OPENROUTER_MODEL_ID,
+	copilot: DEFAULT_COPILOT_MODEL_ID,
+};
 let currentOpenRouterProviderTag: string | undefined;
 
 /**
  * Get the current response model ID.
  */
 export function getResponseModel(): string {
-	return currentModelId;
+	return currentModelIdByProvider[currentModelProvider];
+}
+
+/**
+ * Get selected model ID for a specific provider.
+ */
+export function getResponseModelForProvider(provider: LlmProvider): string {
+	return currentModelIdByProvider[provider];
+}
+
+/**
+ * Get the currently selected LLM provider.
+ */
+export function getModelProvider(): LlmProvider {
+	return currentModelProvider;
+}
+
+/**
+ * Set the currently selected LLM provider.
+ */
+export function setModelProvider(provider: LlmProvider): void {
+	currentModelProvider = provider;
 }
 
 /**
@@ -57,10 +88,20 @@ export function setOpenRouterProviderTag(providerTag: string | undefined): void
  */
 export function setResponseModel(modelId: string): void {
 	if (!modelId) return;
-	if (modelId !== currentModelId) {
-		currentModelId = modelId;
-		// Always reset provider when switching to a DIFFERENT model
-		currentOpenRouterProviderTag = undefined;
+	setResponseModelForProvider(currentModelProvider, modelId);
+}
+
+/**
+ * Set model ID for a specific provider.
+ */
+export function setResponseModelForProvider(provider: LlmProvider, modelId: string): void {
+	if (!modelId) return;
+	if (modelId !== currentModelIdByProvider[provider]) {
+		currentModelIdByProvider[provider] = modelId;
+		// Reset OpenRouter routing provider when switching OpenRouter models.
+		if (provider === "openrouter") {
+			currentOpenRouterProviderTag = undefined;
+		}
 	}
 }
 
@@ -68,7 +109,7 @@ export function setResponseModel(modelId: string): void {
  * Get the current subagent model ID (same as main agent).
  */
 export function getSubagentModel(): string {
-	return currentModelId;
+	return getResponseModel();
 }
 
 /**

package/src/ai/providers/capabilities.ts

@@ -0,0 +1,16 @@
+import type { LlmProvider } from "../../types";
+import { getModelProvider } from "../model-config";
+import type { ProviderCapabilities } from "./types";
+
+const PROVIDER_CAPABILITIES: Record<LlmProvider, ProviderCapabilities> = {
+	openrouter: {
+		supportsSubagentTool: true,
+	},
+	copilot: {
+		supportsSubagentTool: false,
+	},
+};
+
+export function getProviderCapabilities(provider: LlmProvider = getModelProvider()): ProviderCapabilities {
+	return PROVIDER_CAPABILITIES[provider];
+}