@eclipse-lyra/extension-ai-system 0.7.57 → 0.7.58

package/dist/ai-service-CQaQJORq.js

@@ -0,0 +1,1864 @@
+import { TOPIC_SETTINGS_CHANGED, appSettings, commandRegistry, contributionRegistry, createLogger, logger, persistenceService, publish, rootContext, subscribe } from "@eclipse-lyra/core";
+//#region src/core/constants.ts
+var TOPIC_AI_STREAM_STARTED = "events/aiservice/streamStarted";
+var TOPIC_AI_STREAM_CHUNK = "events/aiservice/streamChunk";
+var TOPIC_AI_STREAM_COMPLETE = "events/aiservice/streamComplete";
+var TOPIC_AI_STREAM_ERROR = "events/aiservice/streamError";
+var TOPIC_AICONFIG_CHANGED = "events/aiservice/aiConfigChanged";
+var TOPIC_AGENT_WORKFLOW_STARTED = "events/aiservice/agentWorkflowStarted";
+var TOPIC_AGENT_WORKFLOW_COMPLETE = "events/aiservice/agentWorkflowComplete";
+var TOPIC_AGENT_WORKFLOW_ERROR = "events/aiservice/agentWorkflowError";
+var CID_AGENTS = "aiservice.agents";
+var CID_CHAT_PROVIDERS = "aiservice.chatProviders";
+var CID_PROMPT_ENHANCERS = "aiservice.promptEnhancers";
+var KEY_AI_CONFIG = "aiConfig";
+var DEFAULT_AGENT_ROLE = "appsupport";
+var AI_CONFIG_TEMPLATE = {
+	"defaultProvider": "openai",
+	"providers": [],
+	"requireToolApproval": true
+};
+var MAX_TOOL_ITERATIONS = 10;
+var MAX_RECENT_TOOL_CALLS = 5;
+//#endregion
+//#region src/providers/streaming/stream-parser.ts
+var StreamParser = class {
+	constructor() {
+		this.decoder = new TextDecoder();
+		this.usage = null;
+	}
+	async *readLines(reader) {
+		let buffer = "";
+		this.usage = null;
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				buffer += this.decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) if (line.trim()) yield* this.processLine(line);
+			}
+			if (buffer.trim()) yield* this.processLine(buffer);
+			yield this.makeDoneChunk();
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	makeDoneChunk() {
+		const chunk = {
+			type: "done",
+			content: ""
+		};
+		if (this.usage) chunk.metadata = { usage: this.usage };
+		return chunk;
+	}
+};
+//#endregion
+//#region src/providers/streaming/sse-parser.ts
+var SSEParser = class extends StreamParser {
+	async *parse(reader) {
+		yield* this.readLines(reader);
+	}
+	async *processLine(line) {
+		if (!line.startsWith("data: ")) return;
+		const data = line.slice(6).trim();
+		if (data === "[DONE]") {
+			yield this.makeDoneChunk();
+			return;
+		}
+		try {
+			const json = JSON.parse(data);
+			if (json.error) {
+				yield {
+					type: "error",
+					content: json.error.message || "Unknown error",
+					metadata: json.error
+				};
+				return;
+			}
+			this.extractUsage(json);
+			const chunk = this.parseChunk(json);
+			if (chunk) yield chunk;
+		} catch {}
+	}
+	extractUsage(json) {
+		if (!json.usage) return;
+		const u = json.usage;
+		this.usage = {
+			promptTokens: u.prompt_tokens || 0,
+			completionTokens: u.completion_tokens || 0,
+			totalTokens: u.total_tokens || 0,
+			estimated: false
+		};
+	}
+	parseChunk(json) {
+		const delta = json.choices?.[0]?.delta;
+		const choice = json.choices?.[0];
+		if (delta?.content) return {
+			type: "token",
+			content: delta.content,
+			message: {
+				role: delta.role || "assistant",
+				content: choice?.message?.content || delta.content
+			}
+		};
+		if (choice?.message?.tool_calls) {
+			const toolCalls = this.parseToolCalls(choice.message.tool_calls, true);
+			if (toolCalls.length > 0) return {
+				type: "token",
+				content: "",
+				toolCalls
+			};
+		} else if (delta?.tool_calls || choice?.delta?.tool_calls) {
+			const toolCalls = this.parseToolCalls(delta?.tool_calls || choice?.delta?.tool_calls || [], false);
+			if (toolCalls.length > 0) return {
+				type: "token",
+				content: "",
+				toolCalls
+			};
+		}
+		return null;
+	}
+	parseToolCalls(toolCalls, isComplete) {
+		return toolCalls.filter((tc) => tc.function !== void 0).map((tc, idx) => ({
+			id: tc.id || `call_${tc.index !== void 0 ? tc.index : idx}_${Date.now()}`,
+			type: "function",
+			function: {
+				name: tc.function?.name || "",
+				arguments: tc.function?.arguments || (isComplete ? "{}" : "")
+			},
+			_index: tc.index !== void 0 ? tc.index : idx
+		}));
+	}
+};
+//#endregion
+//#region src/providers/streaming/ollama-parser.ts
+var OllamaParser = class extends StreamParser {
+	async *parse(reader) {
+		yield* this.readLines(reader);
+	}
+	async *processLine(line) {
+		try {
+			const json = JSON.parse(line);
+			if (json.error) {
+				yield {
+					type: "error",
+					content: json.error,
+					metadata: json
+				};
+				return;
+			}
+			if (json.done) {
+				this.extractUsage(json);
+				yield this.makeDoneChunk();
+				return;
+			}
+			const tokenChunk = this.parseToken(json);
+			if (tokenChunk) yield tokenChunk;
+		} catch {}
+	}
+	extractUsage(json) {
+		if (json.prompt_eval_count === void 0 && json.eval_count === void 0) return;
+		const promptTokens = json.prompt_eval_count || 0;
+		const completionTokens = json.eval_count || 0;
+		this.usage = {
+			promptTokens,
+			completionTokens,
+			totalTokens: promptTokens + completionTokens,
+			estimated: false
+		};
+	}
+	parseToken(json) {
+		if (json.message?.content) return {
+			type: "token",
+			content: json.message.content,
+			message: {
+				role: json.message.role || "assistant",
+				content: json.message.content
+			}
+		};
+		if (json.response) return {
+			type: "token",
+			content: json.response,
+			message: {
+				role: "assistant",
+				content: json.response
+			}
+		};
+		return null;
+	}
+};
+//#endregion
+//#region src/providers/provider-utils.ts
+async function streamToText(messages, chatConfig, providerFactory) {
+	let content = "";
+	const provider = providerFactory.getProvider(chatConfig);
+	for await (const chunk of provider.stream({
+		model: chatConfig.model,
+		messages,
+		chatConfig
+	})) if (chunk.type === "token") content += chunk.content;
+	return content;
+}
+function extractBaseUrl(endpoint) {
+	if (!endpoint) return null;
+	if (endpoint.includes("/v1/chat/completions")) return endpoint.replace("/v1/chat/completions", "");
+	if (endpoint.includes("/api/v1/chat/completions")) return endpoint.replace("/api/v1/chat/completions", "");
+	if (endpoint.includes("/api/chat/completion")) return endpoint.replace("/api/chat/completion", "");
+	try {
+		const url = new URL(endpoint);
+		return `${url.protocol}//${url.host}`;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/providers/base-provider.ts
+var BaseProvider = class {
+	createParser(contentType, endpoint) {
+		if (contentType.includes("text/event-stream") || endpoint.includes("openai")) return new SSEParser();
+		return new OllamaParser();
+	}
+	async getAvailableModels(chatProvider) {
+		if (!chatProvider.chatApiEndpoint) return [];
+		const baseUrl = extractBaseUrl(chatProvider.chatApiEndpoint);
+		if (!baseUrl) return [];
+		try {
+			const headers = { "Content-Type": "application/json" };
+			if (chatProvider.apiKey) headers["Authorization"] = `Bearer ${chatProvider.apiKey}`;
+			const response = await fetch(`${baseUrl}/v1/models`, {
+				method: "GET",
+				headers
+			});
+			if (!response.ok) return [];
+			return ((await response.json()).data || []).map((m) => ({
+				id: m.id,
+				name: m.name || m.id
+			}));
+		} catch {
+			return [];
+		}
+	}
+	async *stream(params) {
+		const requestBody = {
+			model: params.model,
+			stream: true,
+			messages: params.messages,
+			...params.chatConfig.parameters
+		};
+		if (params.tools && params.tools.length > 0) {
+			requestBody.tools = params.tools;
+			requestBody.tool_choice = "auto";
+		}
+		const response = await fetch(params.chatConfig.chatApiEndpoint, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${params.chatConfig.apiKey}`,
+				"Content-Type": "application/json",
+				"Accept": "text/event-stream"
+			},
+			body: JSON.stringify(requestBody),
+			signal: params.signal
+		});
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "Unknown error");
+			yield {
+				type: "error",
+				content: `HTTP ${response.status}: ${errorText}`,
+				metadata: { status: response.status }
+			};
+			return;
+		}
+		if (!response.body) {
+			yield {
+				type: "error",
+				content: "Response body is null or empty",
+				metadata: { status: response.status }
+			};
+			return;
+		}
+		const reader = response.body.getReader();
+		if (!reader) {
+			yield {
+				type: "error",
+				content: "Response body is not readable"
+			};
+			return;
+		}
+		const contentType = response.headers.get("content-type") || "";
+		const parser = this.createParser(contentType, params.chatConfig.chatApiEndpoint);
+		try {
+			for await (const chunk of parser.parse(reader)) yield chunk;
+		} catch (error) {
+			yield {
+				type: "error",
+				content: error instanceof Error ? error.message : "Failed to parse response stream",
+				metadata: {
+					error,
+					contentType
+				}
+			};
+		}
+	}
+};
+//#endregion
+//#region src/providers/openai-provider.ts
+var OpenAIProvider = class extends BaseProvider {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "openai";
+	}
+	canHandle(chatProvider) {
+		return chatProvider.chatApiEndpoint.includes("openai") || chatProvider.chatApiEndpoint.includes("v1/chat/completions");
+	}
+};
+//#endregion
+//#region src/providers/ollama-provider.ts
+var OllamaProvider = class extends BaseProvider {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "ollama";
+	}
+	canHandle(chatProvider) {
+		return chatProvider.name.toLowerCase() === "ollama" || chatProvider.chatApiEndpoint.includes("ollama") || chatProvider.chatApiEndpoint.includes("localhost:11434");
+	}
+};
+//#endregion
+//#region src/providers/provider-factory.ts
+var ProviderFactory = class {
+	constructor() {
+		this.providers = [];
+		this.providers.push(new OpenAIProvider());
+		this.providers.push(new OllamaProvider());
+	}
+	registerProvider(provider) {
+		this.providers.push(provider);
+	}
+	getProvider(chatProvider) {
+		return this.providers.find((p) => p.canHandle(chatProvider)) ?? this.providers[0];
+	}
+	getAllProviders() {
+		return [...this.providers];
+	}
+};
+//#endregion
+//#region src/agents/agent-registry.ts
+var AgentRegistry = class {
+	getAgentContributions() {
+		return contributionRegistry.getContributions(CID_AGENTS);
+	}
+	filterAndSortAgents(contributions, context) {
+		return contributions.filter((c) => !c.canHandle || c.canHandle(context)).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+	}
+	getMatchingAgents(context, roles) {
+		const contributions = this.getAgentContributions();
+		if (contributions.length === 0) throw new Error("No agents are registered. The App Support agent should be available from the AI system extension.");
+		const roleFiltered = roles?.length ? contributions.filter((c) => roles.includes(c.role)) : contributions;
+		const active = this.filterAndSortAgents(roleFiltered, context);
+		if (roles?.length && active.length === 0) throw new Error(`No agents found for requested roles: ${roles.join(", ")}. Available: ${contributions.map((c) => c.role).join(", ")}`);
+		if (!roles?.length && active.length === 0) throw new Error(`No agents can handle the current context. Available: ${contributions.map((c) => c.role).join(", ")}`);
+		return active;
+	}
+};
+//#endregion
+//#region src/core/message-utils.ts
+function sanitizeMessageForAPI(message) {
+	const apiMessage = {
+		role: message.role,
+		content: message.content
+	};
+	if ("tool_call_id" in message && message.tool_call_id) apiMessage.tool_call_id = message.tool_call_id;
+	if ("tool_calls" in message && message.tool_calls) apiMessage.tool_calls = message.tool_calls;
+	return apiMessage;
+}
+function sanitizeMessagesForAPI(messages) {
+	return messages.map(sanitizeMessageForAPI);
+}
+//#endregion
+//#region src/utils/tool-detector.ts
+var logger$2 = createLogger("ToolDetector");
+var GREETINGS = [
+	"hello",
+	"hi",
+	"hey",
+	"thanks",
+	"thank you",
+	"bye",
+	"goodbye"
+];
+var ACTION_KEYWORDS = [
+	"create",
+	"open",
+	"delete",
+	"read",
+	"write",
+	"edit",
+	"save",
+	"rename",
+	"move",
+	"copy",
+	"list",
+	"show",
+	"display",
+	"run",
+	"execute",
+	"build",
+	"add",
+	"remove",
+	"update",
+	"modify",
+	"change",
+	"set",
+	"get",
+	"find",
+	"search",
+	"filter",
+	"sort",
+	"install",
+	"uninstall",
+	"load",
+	"import",
+	"export",
+	"generate",
+	"make",
+	"do",
+	"perform",
+	"call",
+	"invoke"
+];
+var CONTEXT_KEYWORDS = [
+	"file",
+	"folder",
+	"directory",
+	"workspace",
+	"editor",
+	"map",
+	"layer",
+	"command",
+	"tool",
+	"extension",
+	"script",
+	"code",
+	"project"
+];
+/**
+* Heuristic tool detection: decides whether to attach tools based on prompt content
+* only. Avoids a 60MB ML dependency; simple chat never triggers a large download.
+*/
+var ToolDetector = class {
+	needsTools(prompt) {
+		if (!prompt?.trim()) return false;
+		const normalized = prompt.toLowerCase().trim();
+		if (GREETINGS.some((g) => normalized === g || normalized.startsWith(g + " "))) return false;
+		const hasAction = ACTION_KEYWORDS.some((k) => prompt.includes(k));
+		const hasContext = CONTEXT_KEYWORDS.some((k) => prompt.includes(k));
+		const needsTools = hasAction && (hasContext || prompt.length > 20);
+		if (needsTools) logger$2.info(`Heuristic: needsTools=true (action+context or long prompt)`);
+		return needsTools;
+	}
+	dispose() {}
+};
+var toolDetector = new ToolDetector();
+//#endregion
+//#region src/agents/prompt-builder.ts
+var logger$1 = createLogger("PromptBuilder");
+var PromptBuilder = class {
+	constructor(toolRegistry) {
+		this.toolRegistry = toolRegistry;
+		this.enhancers = [];
+	}
+	addEnhancer(enhancer) {
+		this.enhancers.push(enhancer);
+	}
+	async getSysPrompt(contribution, context) {
+		let sysPrompt = contribution.sysPrompt;
+		if (typeof sysPrompt === "function") sysPrompt = sysPrompt();
+		if (!sysPrompt || typeof sysPrompt !== "string") throw new Error(`Agent "${contribution.role}" is missing a system prompt.`);
+		const allEnhancers = [
+			...contribution.promptEnhancers || [],
+			...this.enhancers,
+			...this.getContributedEnhancers()
+		].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+		let enhanced = sysPrompt;
+		for (const enhancer of allEnhancers) try {
+			const result = await enhancer.enhance(enhanced, context);
+			if (result && typeof result === "string") enhanced = result;
+		} catch (err) {
+			logger$1.warn("Enhancer failed:", err);
+		}
+		return enhanced;
+	}
+	rewriteChatHistoryForAgent(history, targetRole) {
+		return history.map((m) => {
+			if (m.role === "user") return {
+				role: m.role,
+				content: m.content
+			};
+			if (m.role === targetRole) return {
+				role: "assistant",
+				content: m.content
+			};
+			return {
+				role: "user",
+				content: `***Agent '${m.role}' replied:***\n${m.content}`
+			};
+		});
+	}
+	getContributedEnhancers() {
+		return contributionRegistry.getContributions(CID_PROMPT_ENHANCERS).map((c) => ({
+			...c.enhancer,
+			priority: c.priority ?? c.enhancer.priority
+		}));
+	}
+	async build(contribution, messages, context, hooks) {
+		if (hooks?.beforeSend) await hooks.beforeSend(messages, context);
+		const sanitized = sanitizeMessagesForAPI(messages);
+		const rewritten = this.rewriteChatHistoryForAgent(sanitized, contribution.role);
+		let toolsConfig = contribution.tools;
+		if (typeof toolsConfig === "function") toolsConfig = await toolsConfig();
+		let tools;
+		if (toolsConfig?.enabled) if (toolsConfig.smartToolDetection) {
+			const lastUser = messages[messages.length - 1];
+			if (toolDetector.needsTools(lastUser?.content || "")) tools = this.toolRegistry.getAvailableTools(context, toolsConfig.commandFilter);
+		} else tools = this.toolRegistry.getAvailableTools(context, toolsConfig.commandFilter);
+		const sysPrompt = await this.getSysPrompt(contribution, context);
+		rewritten.unshift({
+			role: "system",
+			content: sysPrompt
+		});
+		return {
+			messages: rewritten,
+			userPromptIndex: rewritten.length - 1,
+			tools
+		};
+	}
+};
+//#endregion
+//#region src/agents/message-processor.ts
+var MessageProcessorService = class {
+	constructor() {
+		this.processors = [];
+	}
+	addProcessor(processor) {
+		this.processors.push(processor);
+	}
+	async process(message, contribution, context) {
+		const allProcessors = [...contribution.messageProcessors || [], ...this.processors].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+		let processed = { ...message };
+		for (const processor of allProcessors) processed = await processor.process(processed, context);
+		return processed;
+	}
+};
+//#endregion
+//#region src/tools/tool-call-accumulator.ts
+var ToolCallAccumulator = class {
+	constructor() {
+		this.accumulatedToolCalls = /* @__PURE__ */ new Map();
+		this.toolCallIndexMap = /* @__PURE__ */ new Map();
+	}
+	processChunk(chunk) {
+		if (chunk.type !== "token" || !chunk.toolCalls?.length) return;
+		for (const toolCall of chunk.toolCalls) {
+			const callIndex = toolCall._index;
+			const callId = toolCall.id;
+			let existing;
+			let targetId;
+			if (callIndex !== void 0 && this.toolCallIndexMap.has(callIndex)) {
+				targetId = this.toolCallIndexMap.get(callIndex);
+				existing = this.accumulatedToolCalls.get(targetId);
+			} else if (callId && this.accumulatedToolCalls.has(callId)) {
+				targetId = callId;
+				existing = this.accumulatedToolCalls.get(targetId);
+			} else {
+				targetId = callId || `call_${callIndex !== void 0 ? callIndex : Date.now()}_${Math.random()}`;
+				existing = void 0;
+			}
+			if (existing) {
+				this.accumulatedToolCalls.set(targetId, {
+					id: targetId,
+					type: toolCall.type || existing.type,
+					function: {
+						name: toolCall.function.name || existing.function.name,
+						arguments: (existing.function.arguments || "") + (toolCall.function.arguments || "")
+					}
+				});
+				if (callIndex !== void 0 && !this.toolCallIndexMap.has(callIndex)) this.toolCallIndexMap.set(callIndex, targetId);
+			} else {
+				this.accumulatedToolCalls.set(targetId, {
+					...toolCall,
+					id: targetId
+				});
+				if (callIndex !== void 0) this.toolCallIndexMap.set(callIndex, targetId);
+			}
+		}
+	}
+	getFinalToolCalls() {
+		return Array.from(this.accumulatedToolCalls.values()).filter((tc) => tc.function.name?.trim().length > 0).map((tc) => ({
+			...tc,
+			function: {
+				...tc.function,
+				arguments: tc.function.arguments?.trim() || "{}"
+			}
+		}));
+	}
+	reset() {
+		this.accumulatedToolCalls.clear();
+		this.toolCallIndexMap.clear();
+	}
+};
+//#endregion
+//#region src/tools/tool-name-utils.ts
+function sanitizeFunctionName(name) {
+	return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^[^a-zA-Z]/, "cmd_$&").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+//#endregion
+//#region src/tools/tool-executor.ts
+var ToolExecutor = class {
+	findCommand(toolCall, context) {
+		const sanitizedName = toolCall.function.name;
+		const direct = commandRegistry.getCommand(sanitizedName);
+		if (direct) return direct;
+		const allCommands = commandRegistry.listCommands();
+		for (const [commandId, command] of Object.entries(allCommands)) if (sanitizeFunctionName(commandId) === sanitizedName) return command;
+		return null;
+	}
+	parseArguments(argsStr) {
+		if (!argsStr?.trim() || argsStr === "{}") return {};
+		try {
+			const parsed = JSON.parse(argsStr);
+			return parsed && typeof parsed === "object" ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	sanitizeArguments(args, command) {
+		if (!command?.parameters || !args || typeof args !== "object") return args || {};
+		const sanitizedArgs = {};
+		command.parameters.forEach((param) => {
+			const sanitizedParamName = sanitizeFunctionName(param.name);
+			if (sanitizedParamName in args) sanitizedArgs[param.name] = args[sanitizedParamName];
+		});
+		return sanitizedArgs;
+	}
+	async executeToolCall(toolCall, context) {
+		try {
+			const command = this.findCommand(toolCall, context);
+			const commandId = command?.id || toolCall.function.name;
+			const args = this.parseArguments(toolCall.function.arguments || "{}");
+			const sanitizedArgs = this.sanitizeArguments(args, command);
+			const freshContext = commandRegistry.createExecutionContext(sanitizedArgs);
+			const execContext = {
+				...context,
+				...freshContext,
+				params: sanitizedArgs
+			};
+			const commandResult = await commandRegistry.execute(commandId, execContext);
+			const resultMessage = {
+				success: true,
+				message: `Command "${command?.name || commandId}" executed successfully`,
+				command: commandId
+			};
+			if (Object.keys(sanitizedArgs).length > 0) resultMessage.parameters = sanitizedArgs;
+			if (commandResult != null) {
+				let resolved = commandResult;
+				if (resolved instanceof Promise) resolved = await resolved;
+				resultMessage.result = resolved;
+				if (command?.output?.length) resultMessage.output = command.output.map((v) => `${v.name}: ${v.description || v.type || "value"}`).join(", ");
+			}
+			return {
+				id: toolCall.id,
+				result: resultMessage
+			};
+		} catch (error) {
+			let command = null;
+			try {
+				command = this.findCommand(toolCall, context);
+			} catch {}
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const commandName = command?.name || toolCall.function.name;
+			let detailedError = errorMessage;
+			if (errorMessage.includes("No handler found") || errorMessage.includes("No handlers registered")) detailedError = `Command "${commandName}" cannot be executed. ${errorMessage}.`;
+			return {
+				id: toolCall.id,
+				result: null,
+				error: detailedError
+			};
+		}
+	}
+	async executeToolCalls(toolCalls, context) {
+		const results = [];
+		for (const toolCall of toolCalls) results.push(await this.executeToolCall(toolCall, context));
+		return results;
+	}
+	createToolCallAccumulator() {
+		return new ToolCallAccumulator();
+	}
+	createToolCallSignature(toolCall) {
+		let args = {};
+		try {
+			const parsed = JSON.parse(toolCall.function.arguments || "{}");
+			args = parsed && typeof parsed === "object" ? parsed : {};
+		} catch {
+			args = {};
+		}
+		const sortedArgs = Object.keys(args).sort().reduce((acc, key) => {
+			acc[key] = args[key];
+			return acc;
+		}, {});
+		return `${toolCall.function.name}:${JSON.stringify(sortedArgs)}`;
+	}
+};
+//#endregion
+//#region src/tools/tool-registry.ts
+var ToolRegistry = class {
+	commandToTool(command, context) {
+		const properties = {};
+		const required = [];
+		command.parameters?.forEach((param) => {
+			const sanitizedParamName = sanitizeFunctionName(param.name);
+			properties[sanitizedParamName] = {
+				type: param.type || "string",
+				description: param.description,
+				...param.allowedValues && { enum: param.allowedValues }
+			};
+			if (param.required === true) required.push(sanitizedParamName);
+		});
+		return {
+			type: "function",
+			function: {
+				name: sanitizeFunctionName(command.id),
+				description: command.description || command.name,
+				parameters: {
+					type: "object",
+					properties,
+					required
+				}
+			}
+		};
+	}
+	getAvailableTools(context, commandFilter) {
+		const availableCommands = commandRegistry.listCommands();
+		let commandsArray = Object.values(availableCommands);
+		if (commandFilter) commandsArray = commandsArray.filter((cmd) => commandFilter(cmd, context));
+		return commandsArray.map((cmd) => this.commandToTool(cmd, context));
+	}
+};
+//#endregion
+//#region src/workflows/parallel-workflow.ts
+var ParallelWorkflowStrategy = class {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		await Promise.all(contributions.map(async (contrib) => {
+			try {
+				await executeAgent(contrib, options.chatContext.history, results.sharedState, chatConfig, options, results);
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				results.errors.set(contrib.role, err);
+				options.onAgentError?.(contrib.role, err);
+			}
+		}));
+	}
+};
+//#endregion
+//#region src/workflows/base-sequential-workflow.ts
+var BaseSequentialWorkflow = class {
+	createAgentContextWithPreviousAgents(accumulatedState, options, results) {
+		return {
+			...accumulatedState,
+			...options.callContext.getProxy(),
+			previousAgents: Array.from(results.messages.entries()).map(([role, msg]) => ({
+				role,
+				content: msg.content
+			}))
+		};
+	}
+	updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results) {
+		currentMessages.push(finalMessage);
+		accumulatedState = {
+			...accumulatedState,
+			...agentContext,
+			message: finalMessage
+		};
+		results.sharedState = accumulatedState;
+		return {
+			currentMessages,
+			accumulatedState
+		};
+	}
+};
+//#endregion
+//#region src/workflows/sequential-workflow.ts
+var SequentialWorkflowStrategy = class extends BaseSequentialWorkflow {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		let currentMessages = [...options.chatContext.history];
+		let accumulatedState = { ...results.sharedState };
+		for (const contrib of contributions) try {
+			const agentContext = this.createAgentContextWithPreviousAgents(accumulatedState, options, results);
+			const finalMessage = await executeAgent(contrib, currentMessages, accumulatedState, chatConfig, options, results);
+			if (!finalMessage) break;
+			const updated = this.updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results);
+			currentMessages = updated.currentMessages;
+			accumulatedState = updated.accumulatedState;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			results.errors.set(contrib.role, err);
+			options.onAgentError?.(contrib.role, err);
+			break;
+		}
+	}
+};
+//#endregion
+//#region src/workflows/conditional-workflow.ts
+var ConditionalWorkflowStrategy = class extends BaseSequentialWorkflow {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		let currentMessages = [...options.chatContext.history];
+		let accumulatedState = { ...results.sharedState };
+		for (const contrib of contributions) try {
+			const agentContext = this.createAgentContextWithPreviousAgents(accumulatedState, options, results);
+			if (contrib.canHandle && !contrib.canHandle(agentContext)) continue;
+			const finalMessage = await executeAgent(contrib, currentMessages, accumulatedState, chatConfig, options, results);
+			if (!finalMessage) break;
+			const updated = this.updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results);
+			currentMessages = updated.currentMessages;
+			accumulatedState = updated.accumulatedState;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			results.errors.set(contrib.role, err);
+			options.onAgentError?.(contrib.role, err);
+		}
+	}
+};
+//#endregion
+//#region src/workflows/pipeline-workflow.ts
+var PipelineWorkflowStrategy = class {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		let currentMessages = [...options.chatContext.history];
+		for (const wave of this.buildTopoOrder(contributions)) {
+			await Promise.all(wave.map(async (contrib) => {
+				try {
+					await executeAgent(contrib, currentMessages, results.sharedState, chatConfig, options, results);
+				} catch (error) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					results.errors.set(contrib.role, err);
+					options.onAgentError?.(contrib.role, err);
+				}
+			}));
+			for (const contrib of wave) {
+				const msg = results.messages.get(contrib.role);
+				if (msg) currentMessages.push(msg);
+			}
+		}
+	}
+	buildTopoOrder(contributions) {
+		const waves = [];
+		const placed = /* @__PURE__ */ new Set();
+		while (placed.size < contributions.length) {
+			const wave = contributions.filter((c) => {
+				if (placed.has(c.role)) return false;
+				if (!c.consumes?.length) return true;
+				const allProduced = contributions.filter((other) => placed.has(other.role)).flatMap((other) => other.produces || []);
+				return c.consumes.every((t) => allProduced.includes(t));
+			});
+			if (wave.length === 0) {
+				waves.push(contributions.filter((c) => !placed.has(c.role)));
+				break;
+			}
+			waves.push(wave);
+			for (const c of wave) placed.add(c.role);
+		}
+		return waves;
+	}
+};
+//#endregion
+//#region src/task/task-plan.ts
+function createTaskPlan(originalPrompt, steps) {
+	const now = Date.now();
+	return {
+		id: `plan-${now}-${Math.random().toString(36).slice(2, 9)}`,
+		originalPrompt,
+		steps: steps.map((s) => ({
+			...s,
+			status: "pending",
+			revisions: 0
+		})),
+		status: "planning",
+		createdAt: now,
+		updatedAt: now
+	};
+}
+function getNextRunnableSteps(plan) {
+	const completed = new Set(plan.steps.filter((s) => s.status === "completed").map((s) => s.id));
+	return plan.steps.filter((s) => s.status === "pending" && s.dependsOn.every((d) => completed.has(d)));
+}
+function isPlanComplete(plan) {
+	return plan.steps.every((s) => s.status === "completed" || s.status === "skipped");
+}
+function isPlanFailed(plan) {
+	return plan.steps.some((s) => s.status === "failed");
+}
+//#endregion
+//#region src/agents/orchestrator.ts
+var ORCHESTRATOR_SYS_PROMPT = `You are a task orchestrator. Given a user's complex request, decompose it into a structured execution plan.
+
+Respond with ONLY a JSON object matching this schema (no markdown, no explanation):
+{
+  "steps": [
+    {
+      "id": "step-1",
+      "role": "<agent role>",
+      "subTask": "<specific instruction for this step>",
+      "dependsOn": [],
+      "consumes": [],
+      "produces": ["<artifact-id>"]
+    }
+  ]
+}
+
+Rules:
+- Each step must have a unique id (step-1, step-2, ...)
+- "role" must match an available agent role
+- "dependsOn" lists step IDs that must complete before this step
+- "consumes" and "produces" are artifact IDs
+- Steps with no dependencies can run in parallel
+- Keep the plan minimal — only as many steps as needed`;
+async function orchestrateTask(options) {
+	const messages = [{
+		role: "system",
+		content: `${ORCHESTRATOR_SYS_PROMPT}\n\nAvailable agents:\n${options.availableAgents.filter((a) => !a.isOrchestrator).map((a) => `- ${a.role}: ${a.description}`).join("\n")}`
+	}, {
+		role: "user",
+		content: options.prompt
+	}];
+	const responseText = await options.executeCompletion(messages, options.chatConfig);
+	try {
+		const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+		if (!jsonMatch) throw new Error("No JSON found in orchestrator response");
+		const parsed = JSON.parse(jsonMatch[0]);
+		return createTaskPlan(options.prompt, parsed.steps || []);
+	} catch (error) {
+		const defaultAgent = options.availableAgents.find((a) => !a.isOrchestrator);
+		return createTaskPlan(options.prompt, [{
+			id: "step-1",
+			role: defaultAgent?.role || "appsupport",
+			subTask: options.prompt,
+			dependsOn: [],
+			consumes: [],
+			produces: ["step-1-result"]
+		}]);
+	}
+}
+//#endregion
+//#region src/workspace/workspace.ts
+var TaskWorkspace = class TaskWorkspace {
+	constructor(taskId, plan) {
+		this.artifacts = /* @__PURE__ */ new Map();
+		this.mailbox = /* @__PURE__ */ new Map();
+		this.taskId = taskId;
+		this.plan = plan;
+	}
+	putArtifact(artifact) {
+		this.artifacts.set(artifact.id, artifact);
+	}
+	getArtifact(id) {
+		return this.artifacts.get(id);
+	}
+	getArtifactsByType(type) {
+		return Array.from(this.artifacts.values()).filter((a) => a.type === type);
+	}
+	getArtifactsProducedBy(role) {
+		return Array.from(this.artifacts.values()).filter((a) => a.producedBy === role);
+	}
+	postMessage(message) {
+		const key = message.to === "*" ? "__broadcast__" : message.to;
+		const messages = this.mailbox.get(key) || [];
+		messages.push(message);
+		this.mailbox.set(key, messages);
+	}
+	readMessages(recipientRole) {
+		const direct = this.mailbox.get(recipientRole) || [];
+		const broadcast = this.mailbox.get("__broadcast__") || [];
+		return [...direct, ...broadcast];
+	}
+	clearMessages(recipientRole) {
+		this.mailbox.delete(recipientRole);
+	}
+	updateStepStatus(stepId, status, result) {
+		const step = this.plan.steps.find((s) => s.id === stepId);
+		if (!step) return;
+		step.status = status;
+		if (result) {
+			step.result = result;
+			this.putArtifact(result);
+		}
+		this.plan.updatedAt = Date.now();
+	}
+	getNextRunnableSteps() {
+		const completed = new Set(this.plan.steps.filter((s) => s.status === "completed").map((s) => s.id));
+		return this.plan.steps.filter((s) => s.status === "pending" && s.dependsOn.every((dep) => completed.has(dep)));
+	}
+	toJSON() {
+		return {
+			taskId: this.taskId,
+			plan: this.plan,
+			artifacts: Array.from(this.artifacts.values()),
+			mailbox: Object.fromEntries(this.mailbox.entries())
+		};
+	}
+	static fromJSON(data) {
+		const ws = new TaskWorkspace(data.taskId, data.plan);
+		for (const artifact of data.artifacts || []) ws.artifacts.set(artifact.id, artifact);
+		for (const [key, messages] of Object.entries(data.mailbox || {})) ws.mailbox.set(key, messages);
+		return ws;
+	}
+};
+//#endregion
+//#region src/task/task-checkpoint.ts
+var CHECKPOINT_KEY_PREFIX = "ai_task_checkpoint_";
+var REGISTRY_KEY = "ai_task_checkpoint_registry";
+var TaskCheckpointService = class {
+	async save(workspace) {
+		const key = `${CHECKPOINT_KEY_PREFIX}${workspace.taskId}`;
+		await appSettings.set(key, workspace.toJSON());
+	}
+	async restore(taskId) {
+		const key = `${CHECKPOINT_KEY_PREFIX}${taskId}`;
+		const data = await appSettings.get(key);
+		if (!data) return null;
+		return TaskWorkspace.fromJSON(data);
+	}
+	async delete(taskId) {
+		const key = `${CHECKPOINT_KEY_PREFIX}${taskId}`;
+		await appSettings.set(key, void 0);
+	}
+	async listCheckpoints() {
+		return this.getRegistry();
+	}
+	async registerCheckpoint(taskId) {
+		const registry = await this.getRegistry();
+		if (!registry.includes(taskId)) {
+			registry.push(taskId);
+			await appSettings.set(REGISTRY_KEY, registry);
+		}
+	}
+	async unregisterCheckpoint(taskId) {
+		const registry = await this.getRegistry();
+		await appSettings.set(REGISTRY_KEY, registry.filter((id) => id !== taskId));
+	}
+	async getRegistry() {
+		return await appSettings.get(REGISTRY_KEY) || [];
+	}
+};
+var taskCheckpointService = new TaskCheckpointService();
+//#endregion
+//#region src/task/task-runner.ts
+var TaskRunner = class {
+	constructor(executeStep) {
+		this.executeStep = executeStep;
+	}
+	async run(workspace, options) {
+		const plan = workspace.plan;
+		plan.status = "running";
+		await taskCheckpointService.save(workspace);
+		const errors = /* @__PURE__ */ new Map();
+		while (true) {
+			if (options.signal?.aborted) {
+				plan.status = "paused";
+				break;
+			}
+			const runnableSteps = getNextRunnableSteps(plan);
+			if (runnableSteps.length === 0) break;
+			await Promise.all(runnableSteps.map(async (step) => {
+				workspace.updateStepStatus(step.id, "running");
+				options.onStepStart?.(step);
+				try {
+					const artifact = await this.executeStep(step, workspace, options);
+					workspace.updateStepStatus(step.id, "completed", artifact);
+					options.onStepComplete?.(step, artifact);
+					await taskCheckpointService.save(workspace);
+				} catch (error) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					workspace.updateStepStatus(step.id, "failed");
+					errors.set(step.id, err);
+					options.onStepError?.(step, err);
+				}
+			}));
+			if (isPlanFailed(plan)) {
+				plan.status = "failed";
+				break;
+			}
+			if (isPlanComplete(plan)) {
+				plan.status = "completed";
+				break;
+			}
+		}
+		return {
+			plan,
+			artifacts: plan.steps.filter((s) => s.result).map((s) => s.result),
+			errors
+		};
+	}
+};
+//#endregion
+//#region src/workflows/orchestrated-workflow.ts
+/**
+* Orchestrated workflow: uses an orchestrator agent to decompose the prompt into
+* a TaskPlan and then executes it step by step via TaskRunner.
+*/
+var OrchestratedWorkflowStrategy = class {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		const prompt = options.chatContext.history[options.chatContext.history.length - 1]?.content || "";
+		const providerFactory = new ProviderFactory();
+		const plan = await orchestrateTask({
+			prompt,
+			availableAgents: contributions,
+			chatConfig,
+			context: options.callContext.getProxy(),
+			executeCompletion: (messages, cfg) => streamToText(messages, cfg, providerFactory)
+		});
+		const workspace = new TaskWorkspace(`wf-${Date.now()}`, plan);
+		const byRole = new Map(contributions.map((c) => [c.role, c]));
+		const combined = (await new TaskRunner(async (step, ws, _opts) => {
+			const content = (await executeAgent(byRole.get(step.role) || contributions[0], [...options.chatContext.history, {
+				role: "user",
+				content: step.subTask
+			}], results.sharedState, chatConfig, options, results))?.content || "";
+			return {
+				id: step.produces[0] || `${step.id}-result`,
+				type: "text",
+				content,
+				producedBy: step.role,
+				createdAt: Date.now()
+			};
+		}).run(workspace, {
+			prompt,
+			chatConfig,
+			callContext: options.callContext,
+			signal: options.signal
+		})).artifacts.map((a) => a.content).filter(Boolean).join("\n\n");
+		if (combined) results.messages.set("orchestrator", {
+			role: "assistant",
+			content: combined
+		});
+	}
+};
+//#endregion
+//#region src/agents/reviewer.ts
+var REVIEWER_SYS_PROMPT = `You are a quality reviewer. Evaluate the provided artifact against the original task.
+
+Respond with ONLY a JSON object:
+{
+  "verdict": "approved" | "needs-revision",
+  "score": 0-100,
+  "notes": "<feedback for revision, empty if approved>"
+}`;
+async function reviewArtifact(options) {
+	const messages = [{
+		role: "system",
+		content: REVIEWER_SYS_PROMPT
+	}, {
+		role: "user",
+		content: `Original task: ${options.originalTask}\n\nArtifact to review:\n${options.artifact.content}`
+	}];
+	try {
+		const jsonMatch = (await options.executeCompletion(messages, options.chatConfig)).match(/\{[\s\S]*\}/);
+		if (!jsonMatch) throw new Error("No JSON in reviewer response");
+		const parsed = JSON.parse(jsonMatch[0]);
+		return {
+			verdict: parsed.verdict === "approved" ? "approved" : "needs-revision",
+			score: typeof parsed.score === "number" ? parsed.score : 50,
+			notes: parsed.notes || ""
+		};
+	} catch {
+		return {
+			verdict: "approved",
+			score: 70,
+			notes: ""
+		};
+	}
+}
+//#endregion
+//#region src/workflows/review-workflow.ts
+/**
+* Review workflow: a producer agent creates an artifact, a reviewer evaluates it,
+* and the producer can revise up to maxRevisions times.
+*/
+var ReviewWorkflowStrategy = class {
+	async execute(contributions, options, results, executeAgent) {
+		const chatConfig = options.chatConfig;
+		if (!chatConfig) throw new Error("Chat config is required");
+		const providerFactory = new ProviderFactory();
+		const producer = contributions[0];
+		const reviewer = contributions.find((c) => c.reviewerFor?.includes(producer.role));
+		const maxRevisions = producer.maxRevisions ?? 2;
+		let currentMessages = [...options.chatContext.history];
+		let revisions = 0;
+		while (revisions <= maxRevisions) {
+			const finalMessage = await executeAgent(producer, currentMessages, results.sharedState, chatConfig, options, results);
+			if (!finalMessage) break;
+			if (!reviewer) {
+				results.messages.set(producer.role, finalMessage);
+				break;
+			}
+			const review = await reviewArtifact({
+				artifact: {
+					id: `draft-${revisions}`,
+					type: "text",
+					content: finalMessage.content,
+					producedBy: producer.role,
+					createdAt: Date.now()
+				},
+				originalTask: options.chatContext.history[options.chatContext.history.length - 1]?.content || "",
+				chatConfig,
+				executeCompletion: (messages, cfg) => streamToText(messages, cfg, providerFactory)
+			});
+			if (review.verdict === "approved" || revisions >= maxRevisions) {
+				results.messages.set(producer.role, finalMessage);
+				break;
+			}
+			currentMessages = [
+				...options.chatContext.history,
+				finalMessage,
+				{
+					role: "user",
+					content: `Please revise based on this feedback: ${review.notes}`
+				}
+			];
+			revisions++;
+		}
+	}
+};
+//#endregion
+//#region src/workflows/workflow-engine.ts
+var WorkflowEngine = class {
+	constructor() {
+		this.strategies = new Map([
+			["parallel", new ParallelWorkflowStrategy()],
+			["sequential", new SequentialWorkflowStrategy()],
+			["conditional", new ConditionalWorkflowStrategy()],
+			["pipeline", new PipelineWorkflowStrategy()],
+			["orchestrated", new OrchestratedWorkflowStrategy()],
+			["review", new ReviewWorkflowStrategy()]
+		]);
+	}
+	registerStrategy(name, strategy) {
+		this.strategies.set(name, strategy);
+	}
+	async execute(contributions, options, executeAgent) {
+		const workflowId = `workflow-${Date.now()}-${Math.random()}`;
+		const execution = options.execution || "parallel";
+		const results = {
+			messages: /* @__PURE__ */ new Map(),
+			sharedState: { ...options.sharedState || {} },
+			errors: /* @__PURE__ */ new Map()
+		};
+		publish(TOPIC_AGENT_WORKFLOW_STARTED, {
+			workflowId,
+			options
+		});
+		try {
+			const strategy = this.strategies.get(execution);
+			if (!strategy) throw new Error(`Unknown workflow execution strategy: ${execution}`);
+			await strategy.execute(contributions, options, results, executeAgent);
+			publish(TOPIC_AGENT_WORKFLOW_COMPLETE, {
+				workflowId,
+				results
+			});
+			return results;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			publish(TOPIC_AGENT_WORKFLOW_ERROR, {
+				workflowId,
+				error: err
+			});
+			throw err;
+		}
+	}
+};
+//#endregion
+//#region src/tools/token-estimator.ts
+var TokenEstimator = class {
+	static {
+		this.AVERAGE_CHARS_PER_TOKEN = 4;
+	}
+	static {
+		this.TOOL_DEFINITION_OVERHEAD = 50;
+	}
+	static {
+		this.TOOL_CALL_OVERHEAD = 10;
+	}
+	static {
+		this.MESSAGE_OVERHEAD = 4;
+	}
+	static estimateTokens(text) {
+		if (text == null) return 0;
+		let raw = "";
+		if (typeof text === "string") raw = text;
+		else if (typeof text === "number" || typeof text === "boolean" || typeof text === "bigint") raw = String(text);
+		else if (typeof text === "object") try {
+			raw = JSON.stringify(text);
+		} catch {
+			return 0;
+		}
+		else return 0;
+		const trimmed = raw.trim();
+		if (!trimmed) return 0;
+		return Math.max(1, Math.ceil(trimmed.length / this.AVERAGE_CHARS_PER_TOKEN + trimmed.split(/\s+/).filter((w) => w.length > 0).length * .3));
+	}
+	static estimateMessageTokens(message) {
+		let tokens = this.MESSAGE_OVERHEAD;
+		if (message.content) tokens += this.estimateTokens(message.content);
+		if (message.role) tokens += this.estimateTokens(message.role);
+		if (message.tool_calls) for (const tc of message.tool_calls) tokens += this.estimateTokens(tc.function.name || "") + this.estimateTokens(tc.function.arguments || "{}") + this.TOOL_CALL_OVERHEAD;
+		if (message.tool_call_id) tokens += this.estimateTokens(message.tool_call_id);
+		return tokens;
+	}
+	static estimatePromptTokens(messages, tools) {
+		let total = messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+		if (tools?.length) for (const tool of tools) {
+			total += this.TOOL_DEFINITION_OVERHEAD;
+			total += this.estimateTokens(tool.function.name || "");
+			total += this.estimateTokens(tool.function.description || "");
+			if (tool.function.parameters) total += this.estimateTokens(JSON.stringify(tool.function.parameters));
+		}
+		return total;
+	}
+	static estimateCompletionTokens(content, toolCalls) {
+		let tokens = this.estimateTokens(content);
+		if (toolCalls?.length) for (const tc of toolCalls) tokens += this.TOOL_CALL_OVERHEAD + this.estimateTokens(tc.function?.name || "") + this.estimateTokens(tc.function?.arguments || "{}");
+		return tokens;
+	}
+};
+//#endregion
+//#region src/service/token-usage-tracker.ts
+var TOKEN_USAGE_KEY = "ai_token_usage";
+var EMPTY_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	totalTokens: 0,
+	requestCount: 0
+};
+var TokenUsageTracker = class {
+	constructor() {
+		this.data = null;
+		this.loadPromise = null;
+	}
+	async loadData() {
+		if (this.data) return this.data;
+		if (this.loadPromise) return this.loadPromise;
+		this.loadPromise = (async () => {
+			const stored = await persistenceService.getObject(TOKEN_USAGE_KEY);
+			this.data = stored ? stored : {
+				providers: {},
+				total: { ...EMPTY_USAGE },
+				lastUpdated: Date.now()
+			};
+			if (!this.data) {
+				this.data = {
+					providers: {},
+					total: { ...EMPTY_USAGE },
+					lastUpdated: Date.now()
+				};
+				await this.saveData();
+			}
+			this.loadPromise = null;
+			return this.data;
+		})();
+		return this.loadPromise;
+	}
+	async saveData() {
+		if (!this.data) return;
+		this.data.lastUpdated = Date.now();
+		await persistenceService.persistObject(TOKEN_USAGE_KEY, this.data);
+	}
+	async recordUsage(providerName, usage) {
+		await this.loadData();
+		if (!this.data) return;
+		this.data.providers[providerName] ??= { ...EMPTY_USAGE };
+		const provider = this.data.providers[providerName];
+		provider.promptTokens += usage.promptTokens;
+		provider.completionTokens += usage.completionTokens;
+		provider.totalTokens += usage.totalTokens;
+		provider.requestCount += 1;
+		this.data.total.promptTokens += usage.promptTokens;
+		this.data.total.completionTokens += usage.completionTokens;
+		this.data.total.totalTokens += usage.totalTokens;
+		this.data.total.requestCount += 1;
+		await this.saveData();
+	}
+	async getProviderUsage(providerName) {
+		await this.loadData();
+		return this.data?.providers[providerName] || null;
+	}
+	async getAllProviderUsage() {
+		await this.loadData();
+		return this.data?.providers || {};
+	}
+	async getTotalUsage() {
+		await this.loadData();
+		return this.data?.total || { ...EMPTY_USAGE };
+	}
+	async reset() {
+		this.data = {
+			providers: {},
+			total: { ...EMPTY_USAGE },
+			lastUpdated: Date.now()
+		};
+		await this.saveData();
+	}
+	async resetProvider(providerName) {
+		await this.loadData();
+		if (!this.data) return;
+		const provider = this.data.providers[providerName];
+		if (!provider) return;
+		this.data.total.promptTokens -= provider.promptTokens;
+		this.data.total.completionTokens -= provider.completionTokens;
+		this.data.total.totalTokens -= provider.totalTokens;
+		this.data.total.requestCount -= provider.requestCount;
+		delete this.data.providers[providerName];
+		await this.saveData();
+	}
+};
+var tokenUsageTracker = new TokenUsageTracker();
+//#endregion
+//#region src/service/ai-service.ts
+var AIService = class {
+	constructor() {
+		this.activeRequests = /* @__PURE__ */ new Map();
+		this.activeTasks = /* @__PURE__ */ new Map();
+		this.toolRegistry = new ToolRegistry();
+		this.providerFactory = new ProviderFactory();
+		this.agentRegistry = new AgentRegistry();
+		this._promptBuilder = new PromptBuilder(this.toolRegistry);
+		this.messageProcessor = new MessageProcessorService();
+		this.toolExecutor = new ToolExecutor();
+		this.workflowEngine = new WorkflowEngine();
+		subscribe(TOPIC_SETTINGS_CHANGED, () => {
+			this.aiConfig = void 0;
+			this.configCheckPromise = void 0;
+			this.checkAIConfig().then();
+		});
+		this.checkAIConfig().then();
+	}
+	get promptBuilder() {
+		return this._promptBuilder;
+	}
+	getAgentContributions() {
+		return this.agentRegistry.getAgentContributions();
+	}
+	async getProviders() {
+		await this.checkAIConfig();
+		return this.aiConfig?.providers || [];
+	}
+	async getDefaultProvider() {
+		await this.checkAIConfig();
+		const providers = await this.getProviders();
+		if (this.aiConfig?.defaultProvider) {
+			const config = providers.find((p) => p.name === this.aiConfig?.defaultProvider);
+			if (config) return config;
+		}
+		return providers[0];
+	}
+	async setDefaultProvider(defaultProviderName) {
+		await this.checkAIConfig();
+		if (this.aiConfig) {
+			this.aiConfig.defaultProvider = defaultProviderName;
+			await appSettings.set(KEY_AI_CONFIG, this.aiConfig);
+		}
+		return this.getDefaultProvider();
+	}
+	createMessage(prompt) {
+		return {
+			role: "user",
+			content: prompt
+		};
+	}
+	registerStreamingFetcher(provider) {
+		this.providerFactory.registerProvider(provider);
+	}
+	getContributedProviders() {
+		return contributionRegistry.getContributions(CID_CHAT_PROVIDERS).map((c) => c.provider);
+	}
+	mergeProviders(existing, contributed) {
+		const existingNames = new Set(existing.map((p) => p.name));
+		const missing = contributed.filter((p) => !existingNames.has(p.name));
+		return missing.length > 0 ? [...existing, ...missing] : existing;
+	}
+	async createInitialConfig() {
+		const initialConfig = {
+			...AI_CONFIG_TEMPLATE,
+			providers: this.getContributedProviders()
+		};
+		await appSettings.set(KEY_AI_CONFIG, initialConfig);
+		return appSettings.get(KEY_AI_CONFIG);
+	}
+	async updateConfigWithMissingProviders(config) {
+		const merged = this.mergeProviders(config.providers, this.getContributedProviders());
+		if (merged.length === config.providers.length) return config;
+		const updated = {
+			...config,
+			providers: merged
+		};
+		await appSettings.set(KEY_AI_CONFIG, updated);
+		return updated;
+	}
+	async checkAIConfig() {
+		if (this.aiConfig) return;
+		if (this.configCheckPromise) return this.configCheckPromise;
+		this.configCheckPromise = this.performConfigCheck();
+		return this.configCheckPromise;
+	}
+	async performConfigCheck() {
+		try {
+			this.aiConfig = await appSettings.get(KEY_AI_CONFIG);
+			this.aiConfig = this.aiConfig ? await this.updateConfigWithMissingProviders(this.aiConfig) : await this.createInitialConfig();
+			publish(TOPIC_AICONFIG_CHANGED, this.aiConfig);
+		} finally {
+			this.configCheckPromise = void 0;
+		}
+	}
+	createAgentContext(sharedState, callContext, additional = {}) {
+		return {
+			...sharedState,
+			...callContext.getProxy(),
+			...additional
+		};
+	}
+	async *streamCompletion(options) {
+		const requestId = `${Date.now()}-${Math.random()}`;
+		const abortController = new AbortController();
+		this.activeRequests.set(requestId, abortController);
+		if (options.signal) options.signal.addEventListener("abort", () => abortController.abort());
+		const effectiveSignal = options.signal || abortController.signal;
+		try {
+			options.onStatus?.("starting");
+			publish(TOPIC_AI_STREAM_STARTED, {
+				requestId,
+				options
+			});
+			const chatConfig = options.chatConfig || await this.getDefaultProvider();
+			const messages = sanitizeMessagesForAPI(options.chatContext.history);
+			const provider = this.providerFactory.getProvider(chatConfig);
+			const accumulator = this.toolExecutor.createToolCallAccumulator();
+			let accumulatedContent = "";
+			let accumulatedRole = "assistant";
+			let tokenUsage;
+			for await (const chunk of provider.stream({
+				model: chatConfig.model,
+				messages,
+				chatConfig,
+				tools: options.tools,
+				signal: effectiveSignal
+			})) {
+				if (chunk.type === "error") {
+					options.onStatus?.("error");
+					publish(TOPIC_AI_STREAM_ERROR, {
+						requestId,
+						chunk
+					});
+					yield chunk;
+					break;
+				}
+				if (chunk.type === "token") {
+					accumulator.processChunk(chunk);
+					if (!chunk.toolCalls?.length) accumulatedContent += chunk.content;
+					if (chunk.message?.role) accumulatedRole = chunk.message.role;
+					if (chunk.content) options.onToken?.(chunk.content);
+					options.onStatus?.("streaming");
+					options.onProgress?.({ received: accumulatedContent.length });
+					publish(TOPIC_AI_STREAM_CHUNK, {
+						requestId,
+						chunk
+					});
+					yield chunk;
+				} else if (chunk.type === "done") {
+					if (chunk.metadata?.usage) tokenUsage = chunk.metadata.usage;
+					options.onStatus?.("complete");
+					publish(TOPIC_AI_STREAM_COMPLETE, { requestId });
+					yield chunk;
+					break;
+				} else yield chunk;
+			}
+			const finalToolCalls = accumulator.getFinalToolCalls();
+			const finalMessage = {
+				role: accumulatedRole,
+				content: accumulatedContent,
+				...finalToolCalls.length > 0 && { toolCalls: finalToolCalls }
+			};
+			if (!tokenUsage) {
+				const promptTokens = TokenEstimator.estimatePromptTokens(messages, options.tools);
+				const completionTokens = TokenEstimator.estimateCompletionTokens(accumulatedContent, finalToolCalls);
+				tokenUsage = {
+					promptTokens,
+					completionTokens,
+					totalTokens: promptTokens + completionTokens,
+					estimated: true
+				};
+			}
+			tokenUsageTracker.recordUsage(chatConfig.name, tokenUsage).catch((err) => {
+				logger.error(`Failed to record token usage: ${err instanceof Error ? err.message : String(err)}`);
+			});
+			return {
+				message: finalMessage,
+				tokenUsage
+			};
+		} catch (error) {
+			if (error instanceof Error && error.name === "AbortError") {
+				options.onStatus?.("error");
+				publish(TOPIC_AI_STREAM_ERROR, {
+					requestId,
+					error: "Request cancelled"
+				});
+				throw error;
+			}
+			options.onStatus?.("error");
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			publish(TOPIC_AI_STREAM_ERROR, {
+				requestId,
+				error: errorMessage
+			});
+			yield {
+				type: "error",
+				content: errorMessage,
+				metadata: { error }
+			};
+			throw error;
+		} finally {
+			this.activeRequests.delete(requestId);
+		}
+	}
+	async handleStreamingPromptDirect(options) {
+		const stream = this.streamCompletion(options);
+		let lastValue;
+		while (true) {
+			lastValue = await stream.next();
+			if (lastValue.done) return lastValue.value.message;
+			const chunk = lastValue.value;
+			if (chunk.type === "error") throw new Error(chunk.content);
+			if (chunk.type === "done") {
+				const final = await stream.next();
+				if (final.done && final.value) return final.value.message;
+				if (!final.done) continue;
+				throw new Error("Stream completed without return value");
+			}
+		}
+	}
+	async handleStreamingPrompt(options) {
+		const callContext = options.callContext || rootContext.createChild({});
+		const agentContext = this.createAgentContext({}, callContext, { userPrompt: options.chatContext.history[options.chatContext.history.length - 1]?.content || "" });
+		const matchingAgents = this.agentRegistry.getMatchingAgents(agentContext);
+		const roles = matchingAgents.length > 0 ? matchingAgents.map((a) => a.role) : ["assistant"];
+		const workflowResult = await this.executeAgentWorkflow({
+			chatContext: options.chatContext,
+			chatConfig: options.chatConfig,
+			callContext,
+			execution: "parallel",
+			stream: options.stream,
+			signal: options.signal,
+			onToken: (_role, token) => options.onToken?.(token),
+			onStatus: (_role, status) => options.onStatus?.(status),
+			roles
+		});
+		const messages = Array.from(workflowResult.messages.values());
+		return messages.length === 1 ? messages[0] : messages;
+	}
+	cancelRequest(requestId) {
+		const controller = this.activeRequests.get(requestId);
+		if (!controller) return false;
+		controller.abort();
+		this.activeRequests.delete(requestId);
+		return true;
+	}
+	async executeAgentWorkflow(options) {
+		const agentContext = this.createAgentContext(options.sharedState || {}, options.callContext);
+		const matchingAgents = this.agentRegistry.getMatchingAgents(agentContext, options.roles);
+		return this.workflowEngine.execute(matchingAgents, options, (contrib, messages, sharedState, chatConfig, workflowOptions, results) => this.executeAgent(contrib, messages, sharedState, chatConfig, workflowOptions, results));
+	}
+	async executeAgent(contrib, messages, sharedState, chatConfig, options, results) {
+		options.onAgentStart?.(contrib.role);
+		const agentContext = this.createAgentContext(sharedState, options.callContext, { userPrompt: messages[messages.length - 1]?.content || "" });
+		const { messages: preparedMessages, tools } = await this._promptBuilder.build(contrib, messages, agentContext, contrib.hooks);
+		const chatMessages = preparedMessages.map((msg) => {
+			const chatMsg = {
+				role: msg.role,
+				content: msg.content
+			};
+			if (msg.tool_call_id) chatMsg.tool_call_id = msg.tool_call_id;
+			if (msg.tool_calls) chatMsg.tool_calls = msg.tool_calls;
+			return chatMsg;
+		});
+		let rawMessage = await this.handleStreamingPromptDirect({
+			chatContext: { history: chatMessages },
+			chatConfig,
+			callContext: options.callContext,
+			stream: options.stream ?? true,
+			signal: options.signal,
+			onToken: options.onToken ? (token) => options.onToken(contrib.role, token) : void 0,
+			tools
+		});
+		let toolCallIteration = 0;
+		const conversationHistory = [...preparedMessages];
+		while (rawMessage.toolCalls && rawMessage.toolCalls.length > 0) {
+			toolCallIteration++;
+			if (toolCallIteration > 10) {
+				logger.warn("Max tool call iterations reached");
+				break;
+			}
+			let toolResults;
+			if (options.requireToolApproval && options.onToolApprovalRequest) {
+				const toolCallDescriptions = rawMessage.toolCalls.map((tc) => {
+					let parsedArgs = {};
+					try {
+						parsedArgs = JSON.parse(tc.function.arguments || "{}");
+					} catch {}
+					return `${tc.function.name}(${Object.entries(parsedArgs).map(([k, v]) => `${k}=${v}`).join(", ")})`;
+				}).join(", ");
+				const approvalRequest = {
+					toolCalls: rawMessage.toolCalls,
+					message: `The AI wants to execute: ${toolCallDescriptions}`
+				};
+				if (!await options.onToolApprovalRequest(contrib.role, approvalRequest)) toolResults = rawMessage.toolCalls.map((tc) => ({
+					id: tc.id,
+					result: {
+						success: false,
+						message: "Tool execution cancelled by user",
+						cancelled: true
+					}
+				}));
+				else toolResults = await this.toolExecutor.executeToolCalls(rawMessage.toolCalls, agentContext);
+			} else toolResults = await this.toolExecutor.executeToolCalls(rawMessage.toolCalls, agentContext);
+			const toolMessages = toolResults.map((tr) => ({
+				role: "tool",
+				content: tr.error ? JSON.stringify({ error: tr.error }) : JSON.stringify(tr.result),
+				tool_call_id: tr.id
+			}));
+			const assistantMessage = {
+				role: "assistant",
+				content: rawMessage.content || ""
+			};
+			if (rawMessage.toolCalls?.length) assistantMessage.tool_calls = rawMessage.toolCalls.filter((tc) => tc.function.name?.trim()).map((tc) => ({
+				id: tc.id,
+				type: tc.type,
+				function: {
+					name: tc.function.name,
+					arguments: tc.function.arguments || "{}"
+				}
+			}));
+			conversationHistory.push(assistantMessage, ...toolMessages);
+			rawMessage = await this.handleStreamingPromptDirect({
+				chatContext: { history: conversationHistory.map((m) => ({
+					role: m.role,
+					content: m.content,
+					...m.tool_call_id && { tool_call_id: m.tool_call_id },
+					...m.tool_calls && { tool_calls: m.tool_calls }
+				})) },
+				chatConfig,
+				callContext: options.callContext,
+				stream: options.stream ?? true,
+				signal: options.signal,
+				tools
+			});
+			if (rawMessage.content?.trim() && !rawMessage.toolCalls?.length) break;
+		}
+		const processedMessage = await this.messageProcessor.process(rawMessage, contrib, this.createAgentContext(sharedState, options.callContext, { message: rawMessage }));
+		if (contrib.hooks?.afterReceive) await contrib.hooks.afterReceive(processedMessage, this.createAgentContext(sharedState, options.callContext));
+		const finalMessage = {
+			role: contrib.role,
+			content: processedMessage.content
+		};
+		results.messages.set(contrib.role, finalMessage);
+		options.onAgentComplete?.(contrib.role, finalMessage);
+		return finalMessage;
+	}
+	async planTask(prompt, context) {
+		const chatConfig = await this.getDefaultProvider();
+		const contributions = this.agentRegistry.getAgentContributions();
+		rootContext.createChild({});
+		return orchestrateTask({
+			prompt,
+			availableAgents: contributions,
+			chatConfig,
+			context,
+			executeCompletion: (messages, cfg) => streamToText(messages, cfg, this.providerFactory)
+		});
+	}
+	async executeTask(options) {
+		const chatConfig = options.chatConfig || await this.getDefaultProvider();
+		const callContext = options.callContext || rootContext.createChild({});
+		const contributions = this.agentRegistry.getAgentContributions();
+		const plan = await this.planTask(options.prompt, callContext.getProxy());
+		options.onPlanReady?.(plan);
+		const workspace = new TaskWorkspace(`task-${Date.now()}`, plan);
+		await taskCheckpointService.registerCheckpoint(workspace.taskId);
+		const abortController = new AbortController();
+		this.activeTasks.set(workspace.taskId, abortController);
+		const taskOptions = {
+			...options,
+			signal: options.signal ?? abortController.signal
+		};
+		const byRole = new Map(contributions.map((c) => [c.role, c]));
+		const runner = new TaskRunner(this.createStepExecutor(byRole, contributions, chatConfig, callContext, taskOptions));
+		try {
+			const result = await runner.run(workspace, taskOptions);
+			await taskCheckpointService.unregisterCheckpoint(workspace.taskId);
+			return result;
+		} finally {
+			this.activeTasks.delete(workspace.taskId);
+		}
+	}
+	async resumeTask(taskId, options) {
+		const workspace = await taskCheckpointService.restore(taskId);
+		if (!workspace) throw new Error(`No checkpoint found for task ${taskId}`);
+		const chatConfig = options.chatConfig || await this.getDefaultProvider();
+		const callContext = options.callContext || rootContext.createChild({});
+		const contributions = this.agentRegistry.getAgentContributions();
+		const byRole = new Map(contributions.map((c) => [c.role, c]));
+		return new TaskRunner(this.createStepExecutor(byRole, contributions, chatConfig, callContext, options)).run(workspace, options);
+	}
+	createStepExecutor(byRole, contributions, chatConfig, callContext, options) {
+		return async (step, _ws, _opts) => {
+			const contrib = byRole.get(step.role) || contributions[0];
+			const stepMessages = [...options.chatContext?.history || [], {
+				role: "user",
+				content: step.subTask
+			}];
+			const msg = (await this.workflowEngine.execute([contrib], {
+				chatContext: { history: stepMessages },
+				chatConfig,
+				callContext,
+				execution: "parallel",
+				stream: true,
+				signal: options.signal,
+				roles: [contrib.role]
+			}, (c, msgs, state, cfg, wopts, results) => this.executeAgent(c, msgs, state, cfg, wopts, results))).messages.get(contrib.role);
+			return {
+				id: step.produces[0] || `${step.id}-result`,
+				type: "text",
+				content: msg?.content || "",
+				producedBy: step.role,
+				createdAt: Date.now()
+			};
+		};
+	}
+	cancelTask(taskId) {
+		const controller = this.activeTasks.get(taskId);
+		if (controller) {
+			controller.abort();
+			this.activeTasks.delete(taskId);
+		}
+	}
+};
+var aiService = new AIService();
+//#endregion
+export { CID_AGENTS as A, TOPIC_AICONFIG_CHANGED as B, BaseProvider as C, SSEParser as D, OllamaParser as E, MAX_RECENT_TOOL_CALLS as F, TOPIC_AI_STREAM_COMPLETE as H, MAX_TOOL_ITERATIONS as I, TOPIC_AGENT_WORKFLOW_COMPLETE as L, CID_PROMPT_ENHANCERS as M, DEFAULT_AGENT_ROLE as N, StreamParser as O, KEY_AI_CONFIG as P, TOPIC_AGENT_WORKFLOW_ERROR as R, OpenAIProvider as S, streamToText as T, TOPIC_AI_STREAM_ERROR as U, TOPIC_AI_STREAM_CHUNK as V, TOPIC_AI_STREAM_STARTED as W, MessageProcessorService as _, WorkflowEngine as a, ProviderFactory as b, PipelineWorkflowStrategy as c, BaseSequentialWorkflow as d, ParallelWorkflowStrategy as f, ToolCallAccumulator as g, sanitizeFunctionName as h, TokenEstimator as i, CID_CHAT_PROVIDERS as j, AI_CONFIG_TEMPLATE as k, ConditionalWorkflowStrategy as l, ToolExecutor as m, EMPTY_USAGE as n, ReviewWorkflowStrategy as o, ToolRegistry as p, tokenUsageTracker as r, OrchestratedWorkflowStrategy as s, aiService as t, SequentialWorkflowStrategy as u, PromptBuilder as v, extractBaseUrl as w, OllamaProvider as x, AgentRegistry as y, TOPIC_AGENT_WORKFLOW_STARTED as z };
+
+//# sourceMappingURL=ai-service-CQaQJORq.js.map