@od-oneapp/ai-platform 0.1.0

package/dist/aggregation-BDop87kL.mjs

@@ -0,0 +1,1180 @@
+import { z } from "zod";
+import { logError, logInfo } from "@od-oneapp/shared/logs";
+import { EventEmitter } from "node:events";
+
+//#region src/agents/multi/swarm/swarm-executor.ts
+/**
+* Swarm Executor - Core agent swarm coordination
+* Based on VERCEL_AI_SDK_V6_PATTERNS.md section 4.4
+* Orchestrates multiple agents working in parallel with various coordination strategies
+*/
+/**
+* Agent definition schema
+* Describes an individual agent in the swarm
+*/
+const AgentDefinitionSchema = z.object({
+	id: z.string().describe("Unique identifier for the agent"),
+	name: z.string().describe("Human-readable agent name"),
+	role: z.string().describe("Role/responsibility of the agent"),
+	description: z.string().describe("What this agent does"),
+	dependencies: z.array(z.string()).default([]).describe("IDs of agents this one depends on"),
+	config: z.record(z.string(), z.unknown()).optional().describe("Agent-specific configuration")
+});
+/**
+* Agent result from execution
+*/
+const AgentResultSchema = z.object({
+	agentId: z.string(),
+	agentName: z.string(),
+	status: z.enum([
+		"success",
+		"failed",
+		"timeout",
+		"skipped"
+	]),
+	result: z.unknown().optional(),
+	error: z.string().optional(),
+	startTime: z.number(),
+	endTime: z.number(),
+	duration: z.number(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Swarm timing information
+*/
+const SwarmTimingSchema = z.object({
+	startTime: z.number(),
+	endTime: z.number(),
+	totalDuration: z.number(),
+	parallelDuration: z.number(),
+	sequentialDuration: z.number(),
+	agentTimings: z.record(z.string(), z.number())
+});
+/**
+* Swarm configuration
+*/
+const SwarmConfigSchema = z.object({
+	agents: z.array(AgentDefinitionSchema),
+	coordinator: z.enum([
+		"sequential",
+		"parallel",
+		"hybrid",
+		"custom"
+	]),
+	maxConcurrency: z.number().min(1).default(4),
+	timeout: z.number().min(1e3).default(3e4),
+	aggregation: z.enum([
+		"merge",
+		"vote",
+		"consensus",
+		"weighted",
+		"custom"
+	]).default("merge"),
+	enableLogging: z.boolean().default(false),
+	retryPolicy: z.object({
+		maxRetries: z.number().min(0).default(0),
+		retryDelay: z.number().min(0).default(1e3),
+		retryableErrors: z.array(z.string()).optional()
+	}).optional()
+});
+/**
+* Swarm task definition
+*/
+const SwarmTaskSchema = z.object({
+	taskId: z.string(),
+	description: z.string(),
+	params: z.record(z.string(), z.unknown()).optional(),
+	targetAgents: z.array(z.string()).optional().describe("Specific agents to run; empty = all"),
+	context: z.record(z.string(), z.unknown()).optional().describe("Shared context passed to all agents")
+});
+/**
+* Swarm execution result
+*/
+const SwarmResultSchema = z.object({
+	taskId: z.string(),
+	results: z.record(z.string(), AgentResultSchema),
+	aggregated: z.unknown().optional(),
+	timing: SwarmTimingSchema,
+	status: z.enum([
+		"completed",
+		"partial",
+		"failed"
+	]),
+	error: z.string().optional()
+});
+/**
+* Factory function to create a swarm executor
+*/
+function createSwarm(config) {
+	return new SwarmExecutor(config);
+}
+/**
+* Main swarm executor implementation
+*/
+var SwarmExecutor = class {
+	config;
+	agentMap;
+	constructor(config) {
+		this.config = config;
+		this.agentMap = new Map(config.agents.map((agent) => [agent.id, agent]));
+	}
+	async execute(task) {
+		const startTime = Date.now();
+		const results = /* @__PURE__ */ new Map();
+		if (this.config.enableLogging) {
+			logInfo(`[Swarm] Starting execution of task: ${task.taskId}`);
+			logInfo(`[Swarm] Coordination strategy: ${this.config.coordinator}`);
+		}
+		try {
+			const targetAgents = task.targetAgents ?? [];
+			const agentsToRun = targetAgents.length > 0 ? this.config.agents.filter((a) => targetAgents.includes(a.id)) : this.config.agents;
+			if (this.config.enableLogging) logInfo(`[Swarm] Running ${agentsToRun.length} agents`);
+			let parallelDuration = 0;
+			let sequentialDuration = 0;
+			switch (this.config.coordinator) {
+				case "sequential":
+					sequentialDuration = await this.executeSequential(agentsToRun, task, results);
+					break;
+				case "parallel":
+					parallelDuration = await this.executeParallel(agentsToRun, task, results);
+					break;
+				case "hybrid": {
+					const { parallel, sequential } = await this.executeHybrid(agentsToRun, task, results);
+					parallelDuration = parallel;
+					sequentialDuration = sequential;
+					break;
+				}
+				case "custom":
+					await this.executeParallel(agentsToRun, task, results);
+					break;
+			}
+			const endTime = Date.now();
+			const totalDuration = endTime - startTime;
+			const aggregated = await this.aggregateResults(Array.from(results.values()));
+			const timing = {
+				startTime,
+				endTime,
+				totalDuration,
+				parallelDuration,
+				sequentialDuration,
+				agentTimings: this.extractAgentTimings(results)
+			};
+			const status = Array.from(results.values()).every((r) => r.status === "success") ? "completed" : Array.from(results.values()).some((r) => r.status === "success") ? "partial" : "failed";
+			if (this.config.enableLogging) {
+				logInfo(`[Swarm] Task ${task.taskId} completed with status: ${status}`);
+				logInfo(`[Swarm] Total duration: ${totalDuration}ms`);
+			}
+			return {
+				taskId: task.taskId,
+				results: Object.fromEntries(results),
+				aggregated,
+				timing,
+				status
+			};
+		} catch (error) {
+			const endTime = Date.now();
+			const totalDuration = endTime - startTime;
+			return {
+				taskId: task.taskId,
+				results: Object.fromEntries(results),
+				timing: {
+					startTime,
+					endTime,
+					totalDuration,
+					parallelDuration: 0,
+					sequentialDuration: totalDuration,
+					agentTimings: this.extractAgentTimings(results)
+				},
+				status: "failed",
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	async executeSequential(agents, task, results) {
+		const startTime = Date.now();
+		for (const agent of agents) try {
+			const result = await this.executeAgent(agent, task);
+			results.set(agent.id, result);
+		} catch (error) {
+			results.set(agent.id, {
+				agentId: agent.id,
+				agentName: agent.name,
+				status: "failed",
+				error: error instanceof Error ? error.message : "Unknown error",
+				startTime: Date.now(),
+				endTime: Date.now(),
+				duration: 0
+			});
+		}
+		return Date.now() - startTime;
+	}
+	async executeParallel(agents, task, results) {
+		const startTime = Date.now();
+		const chunks = this.chunkArray(agents, this.config.maxConcurrency);
+		for (const chunk of chunks) {
+			const promises = chunk.map(async (agent) => {
+				try {
+					const result = await this.executeAgent(agent, task);
+					results.set(agent.id, result);
+				} catch (error) {
+					results.set(agent.id, {
+						agentId: agent.id,
+						agentName: agent.name,
+						status: "failed",
+						error: error instanceof Error ? error.message : "Unknown error",
+						startTime: Date.now(),
+						endTime: Date.now(),
+						duration: 0
+					});
+				}
+			});
+			await Promise.all(promises);
+		}
+		return Date.now() - startTime;
+	}
+	async executeHybrid(agents, task, results) {
+		const parallelAgents = agents.filter((a) => !a.dependencies || a.dependencies.length === 0);
+		const parallelDuration = await this.executeParallel(parallelAgents, task, results);
+		const dependentAgents = agents.filter((a) => a.dependencies && a.dependencies.length > 0);
+		return {
+			parallel: parallelDuration,
+			sequential: await this.executeSequential(dependentAgents, task, results)
+		};
+	}
+	async executeAgent(agent, task) {
+		const startTime = Date.now();
+		const timeoutMs = this.config.timeout;
+		try {
+			const executionPromise = this.simulateAgentExecution(agent, task);
+			const timeoutPromise = new Promise((resolve, reject) => {
+				setTimeout(() => reject(/* @__PURE__ */ new Error("AGENT_TIMEOUT")), timeoutMs);
+			});
+			await Promise.race([executionPromise, timeoutPromise]);
+			const endTime = Date.now();
+			const duration = endTime - startTime;
+			return {
+				agentId: agent.id,
+				agentName: agent.name,
+				status: "success",
+				result: {
+					processedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					role: agent.role,
+					taskId: task.taskId
+				},
+				startTime,
+				endTime,
+				duration
+			};
+		} catch (error) {
+			const endTime = Date.now();
+			const duration = endTime - startTime;
+			if (error instanceof Error && error.message === "AGENT_TIMEOUT") return {
+				agentId: agent.id,
+				agentName: agent.name,
+				status: "timeout",
+				error: `Agent execution exceeded timeout of ${timeoutMs}ms`,
+				startTime,
+				endTime,
+				duration
+			};
+			return {
+				agentId: agent.id,
+				agentName: agent.name,
+				status: "failed",
+				error: error instanceof Error ? error.message : "Unknown error",
+				startTime,
+				endTime,
+				duration
+			};
+		}
+	}
+	async simulateAgentExecution(agent, task) {
+		const delay = Math.random() * 100 + 50;
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	async aggregateResults(results) {
+		switch (this.config.aggregation) {
+			case "merge": return this.mergeResults(results);
+			case "vote": return this.voteOnResults(results);
+			case "consensus": return this.consensusResults(results);
+			case "weighted": return this.mergeResults(results);
+			case "custom": return this.mergeResults(results);
+			default: return this.mergeResults(results);
+		}
+	}
+	mergeResults(results) {
+		return {
+			totalAgents: results.length,
+			successfulAgents: results.filter((r) => r.status === "success").length,
+			failedAgents: results.filter((r) => r.status === "failed").length,
+			agentResults: results.map((r) => ({
+				agentId: r.agentId,
+				status: r.status,
+				duration: r.duration
+			}))
+		};
+	}
+	voteOnResults(results) {
+		const successCount = results.filter((r) => r.status === "success").length;
+		const failureCount = results.filter((r) => r.status === "failed").length;
+		return {
+			consensus: successCount > failureCount ? "success" : "failure",
+			successVotes: successCount,
+			failureVotes: failureCount,
+			totalVotes: results.length
+		};
+	}
+	consensusResults(results) {
+		const totalResults = results.length;
+		const successfulResults = results.filter((r) => r.status === "success").length;
+		const confidenceScore = totalResults > 0 ? successfulResults / totalResults : 0;
+		return {
+			consensus: confidenceScore >= .5,
+			confidenceScore: Math.round(confidenceScore * 100) / 100,
+			successfulResults,
+			totalResults,
+			details: results.map((r) => ({
+				agentId: r.agentId,
+				status: r.status
+			}))
+		};
+	}
+	extractAgentTimings(results) {
+		const timings = {};
+		results.forEach((result, agentId) => {
+			timings[agentId] = result.duration;
+		});
+		return timings;
+	}
+	chunkArray(array, size) {
+		const chunks = [];
+		for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size));
+		return chunks;
+	}
+	getAgent(agentId) {
+		return this.agentMap.get(agentId);
+	}
+	getAgents() {
+		return this.config.agents;
+	}
+	getConfig() {
+		return this.config;
+	}
+};
+/**
+* Execute a swarm with a given task
+*/
+async function executeSwarm(swarm, task) {
+	return swarm.execute(task);
+}
+
+//#endregion
+//#region src/agents/multi/swarm/coordination.ts
+/**
+* Coordination Strategies - Different execution patterns for agent swarms
+* Based on VERCEL_AI_SDK_V6_PATTERNS.md section 4.4
+* Provides sequential, parallel, hybrid, and dependency-aware coordination
+*/
+/**
+* Sequential execution strategy
+* Agents run one after another in order
+* Useful for: Tasks with strict ordering requirements or low parallelism
+*/
+async function sequentialExecution(agents, task, executeAgent) {
+	const results = [];
+	for (const agent of agents) try {
+		const result = await executeAgent(agent, task);
+		results.push(result);
+	} catch (error) {
+		results.push({
+			agentId: agent.id,
+			agentName: agent.name,
+			status: "failed",
+			error: error instanceof Error ? error.message : "Unknown error",
+			startTime: Date.now(),
+			endTime: Date.now(),
+			duration: 0
+		});
+	}
+	return results;
+}
+/**
+* Parallel execution strategy
+* Agents run concurrently up to maxConcurrency limit
+* Useful for: Independent tasks that can run simultaneously
+*/
+async function parallelExecution(agents, task, executeAgent, maxConcurrency = 4) {
+	const results = [];
+	const chunks = chunkArray(agents, maxConcurrency);
+	for (const chunk of chunks) {
+		const promises = chunk.map(async (agent) => {
+			try {
+				return await executeAgent(agent, task);
+			} catch (error) {
+				return {
+					agentId: agent.id,
+					agentName: agent.name,
+					status: "failed",
+					error: error instanceof Error ? error.message : "Unknown error",
+					startTime: Date.now(),
+					endTime: Date.now(),
+					duration: 0
+				};
+			}
+		});
+		const chunkResults = await Promise.all(promises);
+		results.push(...chunkResults);
+	}
+	return results;
+}
+/**
+* Hybrid execution strategy
+* Combines sequential and parallel execution based on dependencies
+* Agents with no dependencies run in parallel
+* Agents with dependencies run sequentially after their dependencies
+* Useful for: Complex workflows with mixed dependency patterns
+*/
+async function hybridExecution(agents, task, executeAgent, maxConcurrency = 4) {
+	const phases = buildExecutionPhases(createDependencyGraph(agents));
+	const results = [];
+	const completedAgents = /* @__PURE__ */ new Set();
+	for (const phase of phases) if (phase.parallel) {
+		const phaseResults = await parallelExecution(phase.agents, task, executeAgent, maxConcurrency);
+		results.push(...phaseResults);
+		for (const r of phaseResults) completedAgents.add(r.agentId);
+	} else {
+		const phaseResults = await sequentialExecution(phase.agents, task, executeAgent);
+		results.push(...phaseResults);
+		for (const r of phaseResults) completedAgents.add(r.agentId);
+	}
+	return results;
+}
+/**
+* Create a dependency graph from agents
+* Analyzes agent dependencies and builds a directed acyclic graph
+*/
+function createDependencyGraph(agents) {
+	const agentMap = new Map(agents.map((a) => [a.id, a]));
+	const nodes = [];
+	for (const agent of agents) {
+		for (const depId of agent.dependencies || []) if (!agentMap.has(depId)) throw new Error(`Agent "${agent.id}" depends on unknown agent "${depId}"`);
+		nodes.push({
+			agentId: agent.id,
+			agent,
+			dependencies: agent.dependencies || [],
+			dependents: [],
+			level: 0
+		});
+	}
+	for (const node of nodes) for (const depId of node.dependencies) {
+		const depNode = nodes.find((n) => n.agentId === depId);
+		if (depNode) depNode.dependents.push(node.agentId);
+	}
+	calculateLevels(nodes);
+	return nodes;
+}
+/**
+* Build execution phases from dependency graph
+* Groups agents into phases that can be executed together
+*/
+function buildExecutionPhases(graph) {
+	const phases = [];
+	const maxLevel = Math.max(...graph.map((n) => n.level), 0);
+	for (let level = 0; level <= maxLevel; level++) {
+		const agentsAtLevel = graph.filter((n) => n.level === level).map((n) => n.agent);
+		if (agentsAtLevel.length > 0) phases.push({
+			phaseId: `phase_${level}`,
+			agents: agentsAtLevel,
+			dependsOn: level > 0 ? [`phase_${level - 1}`] : [],
+			parallel: agentsAtLevel.length > 1
+		});
+	}
+	return phases;
+}
+/**
+* Validate dependency graph for cycles
+* Returns true if graph is acyclic, false if cycles detected
+*/
+function validateDependencyGraph(graph) {
+	const visited = /* @__PURE__ */ new Set();
+	const recursionStack = /* @__PURE__ */ new Set();
+	const hasCycle = (nodeId) => {
+		visited.add(nodeId);
+		recursionStack.add(nodeId);
+		const node = graph.find((n) => n.agentId === nodeId);
+		if (!node) return false;
+		for (const depId of node.dependencies) if (!visited.has(depId)) {
+			if (hasCycle(depId)) return true;
+		} else if (recursionStack.has(depId)) return true;
+		recursionStack.delete(nodeId);
+		return false;
+	};
+	for (const node of graph) if (!visited.has(node.agentId)) {
+		if (hasCycle(node.agentId)) return false;
+	}
+	return true;
+}
+/**
+* Get agents that are ready to execute
+* Returns agents whose dependencies have all been satisfied
+*/
+function getReadyAgents(graph, completedAgents) {
+	return graph.filter((node) => {
+		if (completedAgents.has(node.agentId)) return false;
+		return node.dependencies.every((depId) => completedAgents.has(depId));
+	});
+}
+/**
+* Get all agents that depend on a specific agent
+*/
+function getDependentAgents(nodeId, graph) {
+	const node = graph.find((n) => n.agentId === nodeId);
+	if (!node) return [];
+	return graph.filter((n) => node.dependents.includes(n.agentId));
+}
+/**
+* Get all agents that a specific agent depends on
+*/
+function getDependencies(nodeId, graph) {
+	const node = graph.find((n) => n.agentId === nodeId);
+	if (!node) return [];
+	return graph.filter((n) => node.dependencies.includes(n.agentId));
+}
+/**
+* Calculate execution order based on dependencies
+*/
+function calculateExecutionOrder(graph) {
+	const order = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (nodeId) => {
+		if (visited.has(nodeId)) return;
+		visited.add(nodeId);
+		const node = graph.find((n) => n.agentId === nodeId);
+		if (!node) return;
+		for (const depId of node.dependencies) visit(depId);
+		const { level } = node;
+		if (!order[level]) order[level] = [];
+		order[level].push(nodeId);
+	};
+	for (const node of graph) visit(node.agentId);
+	return order.filter((group) => group.length > 0);
+}
+/**
+* Helper: Calculate levels in dependency graph (topological sort)
+*/
+function calculateLevels(nodes) {
+	const visited = /* @__PURE__ */ new Set();
+	const calculateLevel = (nodeId) => {
+		const node = nodes.find((n) => n.agentId === nodeId);
+		if (!node) return 0;
+		if (visited.has(nodeId)) return node.level;
+		visited.add(nodeId);
+		if (node.dependencies.length === 0) node.level = 0;
+		else node.level = Math.max(...node.dependencies.map((depId) => {
+			if (!nodes.find((n) => n.agentId === depId)) return 0;
+			return calculateLevel(depId);
+		}), 0) + 1;
+		return node.level;
+	};
+	for (const node of nodes) calculateLevel(node.agentId);
+}
+/**
+* Helper: Split array into chunks
+*/
+function chunkArray(array, size) {
+	const chunks = [];
+	for (let i = 0; i < array.length; i += size) chunks.push(array.slice(i, i + size));
+	return chunks;
+}
+/**
+* Coordination strategy schema for configuration
+*/
+const CoordinationStrategySchema = z.object({
+	type: z.enum([
+		"sequential",
+		"parallel",
+		"hybrid",
+		"custom"
+	]),
+	maxConcurrency: z.number().min(1).default(4),
+	enableDependencyTracking: z.boolean().default(true),
+	allowPartialFailure: z.boolean().default(true),
+	timeoutPerAgent: z.number().min(1e3).default(3e4)
+});
+
+//#endregion
+//#region src/agents/multi/swarm/communication.ts
+/**
+* Communication Layer - Inter-agent messaging system
+* Based on VERCEL_AI_SDK_V6_PATTERNS.md section 4.4
+* Enables agents to communicate and coordinate during execution
+*/
+/**
+* Message schema for inter-agent communication
+*/
+const MessageSchema = z.object({
+	messageId: z.string().describe("Unique message identifier"),
+	senderId: z.string().describe("ID of agent sending the message"),
+	senderName: z.string().describe("Name of agent sending the message"),
+	recipientId: z.string().optional().describe("ID of specific recipient; undefined = broadcast"),
+	topic: z.string().describe("Message topic for categorization"),
+	type: z.enum([
+		"request",
+		"response",
+		"notification",
+		"query",
+		"update"
+	]),
+	payload: z.unknown().describe("Message content"),
+	timestamp: z.number(),
+	correlationId: z.string().optional().describe("Links related messages"),
+	priority: z.enum([
+		"low",
+		"normal",
+		"high",
+		"critical"
+	]).default("normal"),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Create a message bus for inter-agent communication
+*/
+function createMessageBus() {
+	return new MessageBusImpl();
+}
+/**
+* Message bus implementation
+*/
+var MessageBusImpl = class extends EventEmitter {
+	messageHistory = [];
+	subscriptions = /* @__PURE__ */ new Map();
+	queryHandlers = /* @__PURE__ */ new Map();
+	messageCounter = 0;
+	broadcast(message) {
+		const fullMessage = {
+			...message,
+			messageId: this.generateMessageId(),
+			timestamp: Date.now(),
+			recipientId: void 0
+		};
+		this.recordMessage(fullMessage);
+		this.emit("broadcast", fullMessage);
+		this.notifySubscribers(fullMessage);
+	}
+	sendToAgent(recipientId, message) {
+		const fullMessage = {
+			...message,
+			messageId: this.generateMessageId(),
+			timestamp: Date.now(),
+			recipientId
+		};
+		this.recordMessage(fullMessage);
+		this.emit(`message:${recipientId}`, fullMessage);
+		this.notifySubscribers(fullMessage);
+	}
+	subscribe(agentId, handler, topic) {
+		const subscriptionId = `sub_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+		const subscription = {
+			subscriptionId,
+			agentId,
+			topic,
+			handler,
+			unsubscribe: () => {
+				this.unsubscribe(subscriptionId);
+			}
+		};
+		const key = topic ? `${agentId}:${topic}` : agentId;
+		let subscriptions = this.subscriptions.get(key);
+		if (!subscriptions) {
+			subscriptions = [];
+			this.subscriptions.set(key, subscriptions);
+		}
+		subscriptions.push(subscription);
+		return subscription;
+	}
+	async query(agentId, query) {
+		const handler = this.queryHandlers.get(agentId);
+		if (!handler) throw new Error(`No query handler registered for agent: ${agentId}`);
+		return handler(query);
+	}
+	getMessageHistory(topic) {
+		if (!topic) return [...this.messageHistory];
+		return this.messageHistory.filter((m) => m.topic === topic);
+	}
+	clearHistory() {
+		this.messageHistory = [];
+	}
+	/**
+	* Register a query handler for an agent
+	*/
+	registerQueryHandler(agentId, handler) {
+		this.queryHandlers.set(agentId, handler);
+	}
+	/**
+	* Get all subscriptions for an agent
+	*/
+	getSubscriptions(agentId) {
+		const subscriptions = [];
+		this.subscriptions.forEach((subs) => {
+			subscriptions.push(...subs.filter((s) => s.agentId === agentId));
+		});
+		return subscriptions;
+	}
+	/**
+	* Private: Notify relevant subscribers
+	*/
+	notifySubscribers(message) {
+		const allSubscribers = Array.from(this.subscriptions.values()).flat().filter((s) => {
+			if (message.recipientId && s.agentId !== message.recipientId && s.agentId !== "*") return false;
+			if (s.topic && s.topic !== message.topic) return false;
+			return true;
+		});
+		const seen = /* @__PURE__ */ new Set();
+		const uniqueSubscribers = allSubscribers.filter((s) => {
+			if (seen.has(s.subscriptionId)) return false;
+			seen.add(s.subscriptionId);
+			return true;
+		});
+		for (const subscription of uniqueSubscribers) (async () => {
+			try {
+				await subscription.handler(message);
+			} catch (error) {
+				logError(`Error in message handler for ${subscription.agentId}`, { error: error instanceof Error ? error : new Error(String(error)) });
+			}
+		})();
+	}
+	/**
+	* Private: Record message in history
+	*/
+	recordMessage(message) {
+		this.messageHistory.push(message);
+		if (this.messageHistory.length > 1e3) this.messageHistory = this.messageHistory.slice(-1e3);
+	}
+	/**
+	* Private: Generate unique message ID
+	*/
+	generateMessageId() {
+		return `msg_${++this.messageCounter}_${Date.now()}`;
+	}
+	/**
+	* Private: Unsubscribe
+	*/
+	unsubscribe(subscriptionId) {
+		this.subscriptions.forEach((subs) => {
+			const index = subs.findIndex((s) => s.subscriptionId === subscriptionId);
+			if (index !== -1) subs.splice(index, 1);
+		});
+	}
+};
+/**
+* Broadcast a message to all agents
+*/
+function broadcastMessage(bus, message) {
+	bus.broadcast(message);
+}
+/**
+* Route a message to a specific agent
+*/
+function routeMessage(bus, recipientId, message) {
+	bus.sendToAgent(recipientId, message);
+}
+/**
+* Subscribe to messages
+*/
+function subscribeToMessages(bus, agentId, handler, topic) {
+	return bus.subscribe(agentId, handler, topic);
+}
+/**
+* Message builder helper
+*/
+var MessageBuilder = class {
+	message = {};
+	from(senderId, senderName) {
+		this.message.senderId = senderId;
+		this.message.senderName = senderName;
+		return this;
+	}
+	to(recipientId) {
+		this.message.recipientId = recipientId;
+		return this;
+	}
+	topic(topic) {
+		this.message.topic = topic;
+		return this;
+	}
+	type(type) {
+		this.message.type = type;
+		return this;
+	}
+	payload(payload) {
+		this.message.payload = payload;
+		return this;
+	}
+	priority(priority) {
+		this.message.priority = priority;
+		return this;
+	}
+	correlationId(correlationId) {
+		this.message.correlationId = correlationId;
+		return this;
+	}
+	metadata(metadata) {
+		this.message.metadata = metadata;
+		return this;
+	}
+	build() {
+		if (!this.message.senderId || !this.message.senderName || !this.message.topic || !this.message.type || this.message.payload === void 0) throw new Error("Missing required message fields: senderId, senderName, topic, type, payload");
+		return {
+			senderId: this.message.senderId,
+			senderName: this.message.senderName,
+			recipientId: this.message.recipientId,
+			topic: this.message.topic,
+			type: this.message.type,
+			payload: this.message.payload,
+			priority: this.message.priority || "normal",
+			correlationId: this.message.correlationId,
+			metadata: this.message.metadata
+		};
+	}
+};
+/**
+* Request-response pattern helper
+*/
+async function sendRequest(bus, from, to, topic, payload) {
+	const correlationId = `req_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+	const message = new MessageBuilder().from(from.id, from.name).to(to).topic(topic).type("request").payload(payload).correlationId(correlationId).build();
+	return new Promise((resolve, reject) => {
+		let subscription = null;
+		const timeoutId = setTimeout(() => {
+			subscription?.unsubscribe();
+			reject(/* @__PURE__ */ new Error(`Request timeout for correlation ID: ${correlationId}`));
+		}, 5e3);
+		subscription = subscribeToMessages(bus, from.id, (msg) => {
+			if (msg.correlationId === correlationId && msg.type === "response") {
+				clearTimeout(timeoutId);
+				subscription?.unsubscribe();
+				resolve(msg.payload);
+			}
+		});
+		routeMessage(bus, to, message);
+	});
+}
+
+//#endregion
+//#region src/agents/multi/swarm/aggregation.ts
+/**
+* Result Aggregation - Combining outputs from multiple agents
+* Based on VERCEL_AI_SDK_V6_PATTERNS.md section 4.4
+* Provides strategies for merging, voting, and consensus-based result aggregation
+*/
+/**
+* Aggregation result
+*/
+const AggregationResultSchema = z.object({
+	strategy: z.enum([
+		"merge",
+		"vote",
+		"consensus",
+		"weighted",
+		"custom"
+	]),
+	finalResult: z.unknown(),
+	confidence: z.number().min(0).max(1),
+	details: z.record(z.string(), z.unknown()).optional(),
+	timestamp: z.number()
+});
+/**
+* Aggregate results from multiple agents
+* Combines outputs based on specified strategy
+*/
+function aggregateResults(results, options = {}) {
+	const strategy = options.strategy || "merge";
+	const timestamp = Date.now();
+	let finalResult;
+	let confidence;
+	let details;
+	switch (strategy) {
+		case "merge": {
+			const { result: mergedResult, confidence: mergedConfidence, details: mergedDetails } = mergeResults(results);
+			finalResult = mergedResult;
+			confidence = mergedConfidence;
+			details = mergedDetails;
+			break;
+		}
+		case "vote": {
+			const { result: votedResult, confidence: votedConfidence, details: votedDetails } = voteOnResults(results);
+			finalResult = votedResult;
+			confidence = votedConfidence;
+			details = votedDetails;
+			break;
+		}
+		case "consensus": {
+			const { result: consensusResultValue, confidence: consensusConfidence, details: consensusInfo } = consensusResult(results);
+			finalResult = consensusResultValue;
+			confidence = consensusConfidence;
+			details = consensusInfo;
+			break;
+		}
+		case "weighted": {
+			const { result: weightedResult, confidence: weightedConfidence, details: weightedDetails } = weightedAggregation(results, options.weights || {});
+			finalResult = weightedResult;
+			confidence = weightedConfidence;
+			details = weightedDetails;
+			break;
+		}
+		case "custom": {
+			const { result: fallbackResult, confidence: fallbackConfidence, details: fallbackDetails } = mergeResults(results);
+			finalResult = fallbackResult;
+			confidence = fallbackConfidence;
+			details = fallbackDetails;
+			break;
+		}
+		default: {
+			const { result: fallbackResult, confidence: fallbackConfidence, details: fallbackDetails } = mergeResults(results);
+			finalResult = fallbackResult;
+			confidence = fallbackConfidence;
+			details = fallbackDetails;
+		}
+	}
+	return {
+		strategy,
+		finalResult,
+		confidence,
+		details,
+		timestamp
+	};
+}
+/**
+* Merge results from all agents
+* Combines all successful results into a single output
+*/
+function mergeResults(results) {
+	const successfulResults = results.filter((r) => r.status === "success");
+	const failedResults = results.filter((r) => r.status === "failed");
+	const mergedData = {};
+	const agentSummaries = [];
+	for (const result of results) {
+		const { agentId, agentName, status, duration, result: agentResult } = result;
+		agentSummaries.push({
+			agentId,
+			agentName,
+			status,
+			duration
+		});
+		if (status === "success" && agentResult) mergedData[agentId] = agentResult;
+	}
+	const confidence = successfulResults.length / (successfulResults.length + failedResults.length) || 0;
+	return {
+		result: {
+			merged: mergedData,
+			summary: {
+				total: results.length,
+				successful: successfulResults.length,
+				failed: failedResults.length
+			}
+		},
+		confidence: Math.round(confidence * 100) / 100,
+		details: {
+			agentSummaries,
+			timestamp: Date.now()
+		}
+	};
+}
+/**
+* Vote on results - majority voting
+* Returns the most common successful result
+*/
+function voteOnResults(results) {
+	const successfulResults = results.filter((r) => r.status === "success");
+	if (successfulResults.length === 0) return {
+		result: null,
+		confidence: 0,
+		details: { error: "No successful results to vote on" }
+	};
+	const votes = /* @__PURE__ */ new Map();
+	for (const result of successfulResults) {
+		const key = JSON.stringify(result.result);
+		if (!votes.has(key)) votes.set(key, {
+			count: 0,
+			agents: [],
+			result
+		});
+		const vote = votes.get(key);
+		if (!vote) continue;
+		vote.count++;
+		vote.agents.push(result.agentId);
+	}
+	let majority = null;
+	for (const vote of votes.values()) if (!majority || vote.count > majority.count) majority = vote;
+	if (!majority) return {
+		result: null,
+		confidence: 0,
+		details: { error: "Could not determine majority vote" }
+	};
+	const confidence = majority.count / successfulResults.length;
+	return {
+		result: majority.result.result,
+		confidence: Math.round(confidence * 100) / 100,
+		details: {
+			majorityVotes: majority.count,
+			totalVotes: successfulResults.length,
+			votingAgents: majority.agents,
+			timestamp: Date.now()
+		}
+	};
+}
+/**
+* Consensus result - weighted consensus
+* Builds consensus from majority agreement with confidence scores
+*/
+function consensusResult(results) {
+	const successfulResults = results.filter((r) => r.status === "success");
+	if (successfulResults.length === 0) return {
+		result: null,
+		confidence: 0,
+		details: { error: "No successful results for consensus" }
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (const result of successfulResults) {
+		const key = JSON.stringify(result.result);
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				count: 0,
+				agents: []
+			};
+			groups.set(key, group);
+		}
+		group.count++;
+		group.agents.push(result.agentId);
+	}
+	let consensusGroup = null;
+	for (const [key, group] of groups) if (group.count / successfulResults.length > .5) {
+		consensusGroup = {
+			count: group.count,
+			agents: group.agents,
+			result: JSON.parse(key)
+		};
+		break;
+	}
+	if (!consensusGroup) {
+		let maxCount = 0;
+		let maxKey = null;
+		for (const [key, group] of groups) if (group.count > maxCount) {
+			maxCount = group.count;
+			maxKey = key;
+		}
+		if (maxKey) {
+			const group = groups.get(maxKey);
+			if (group) consensusGroup = {
+				count: maxCount,
+				agents: group.agents,
+				result: JSON.parse(maxKey)
+			};
+		}
+	}
+	if (!consensusGroup) return {
+		result: null,
+		confidence: 0,
+		details: { error: "Could not establish consensus" }
+	};
+	const confidence = consensusGroup.count / successfulResults.length;
+	return {
+		result: consensusGroup.result,
+		confidence: Math.round(confidence * 100) / 100,
+		details: {
+			consensusAgents: consensusGroup.agents,
+			agreeingCount: consensusGroup.count,
+			totalSuccessful: successfulResults.length,
+			totalAgents: results.length,
+			timestamp: Date.now()
+		}
+	};
+}
+/**
+* Weighted aggregation
+* Combines results using specified weights for each agent
+*/
+function weightedAggregation(results, weights = {}) {
+	const successfulResults = results.filter((r) => r.status === "success");
+	if (successfulResults.length === 0) return {
+		result: null,
+		confidence: 0,
+		details: { error: "No successful results for weighted aggregation" }
+	};
+	const normalizedWeights = {};
+	let totalWeight = 0;
+	for (const result of successfulResults) {
+		const weight = weights[result.agentId] || 1;
+		normalizedWeights[result.agentId] = weight;
+		totalWeight += weight;
+	}
+	const weightedResults = [];
+	let totalConfidence = 0;
+	for (const result of successfulResults) {
+		const weight = (normalizedWeights[result.agentId] ?? 0) / totalWeight;
+		weightedResults.push({
+			result: result.result,
+			weight,
+			agentId: result.agentId
+		});
+		totalConfidence += weight;
+	}
+	const aggregatedData = {};
+	for (const wr of weightedResults) if (typeof wr.result === "object" && wr.result !== null) {
+		for (const [key, value] of Object.entries(wr.result)) if (typeof value === "number") aggregatedData[key] = (aggregatedData[key] || 0) + value * wr.weight;
+	}
+	return {
+		result: aggregatedData,
+		confidence: Math.round(totalConfidence * 100) / 100,
+		details: {
+			weightedResults: weightedResults.map((wr) => ({
+				agentId: wr.agentId,
+				weight: wr.weight
+			})),
+			timestamp: Date.now()
+		}
+	};
+}
+/**
+* Build a custom aggregator
+*/
+function buildCustomAggregator(aggregateFn) {
+	return { aggregate: async (results) => {
+		return {
+			strategy: "custom",
+			finalResult: aggregateFn(results),
+			confidence: results.length ? results.filter((r) => r.status === "success").length / results.length : 0,
+			timestamp: Date.now()
+		};
+	} };
+}
+/**
+* Compare aggregation strategies
+* Returns metrics for different strategies applied to same results
+*/
+function compareStrategies(results) {
+	const strategies = [
+		"merge",
+		"vote",
+		"consensus",
+		"weighted"
+	];
+	const comparisons = {};
+	for (const strategy of strategies) try {
+		comparisons[strategy] = aggregateResults(results, { strategy });
+	} catch (error) {
+		comparisons[strategy] = {
+			strategy,
+			finalResult: null,
+			confidence: 0,
+			details: { error: error instanceof Error ? error.message : "Unknown error" },
+			timestamp: Date.now()
+		};
+	}
+	return comparisons;
+}
+
+//#endregion
+export { SwarmResultSchema as A, hybridExecution as C, AgentDefinitionSchema as D, validateDependencyGraph as E, SwarmTimingSchema as M, createSwarm as N, AgentResultSchema as O, executeSwarm as P, getReadyAgents as S, sequentialExecution as T, buildExecutionPhases as _, consensusResult as a, getDependencies as b, weightedAggregation as c, broadcastMessage as d, createMessageBus as f, CoordinationStrategySchema as g, subscribeToMessages as h, compareStrategies as i, SwarmTaskSchema as j, SwarmConfigSchema as k, MessageBuilder as l, sendRequest as m, aggregateResults as n, mergeResults as o, routeMessage as p, buildCustomAggregator as r, voteOnResults as s, AggregationResultSchema as t, MessageSchema as u, calculateExecutionOrder as v, parallelExecution as w, getDependentAgents as x, createDependencyGraph as y };
+//# sourceMappingURL=aggregation-BDop87kL.mjs.map