societyai 0.0.1

package/dist/strategies.js

@@ -0,0 +1,678 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strategies = exports.StrategyBuilder = void 0;
+exports.createStrategy = createStrategy;
+exports.chainStrategies = chainStrategies;
+exports.parallelStrategies = parallelStrategies;
+class StrategyBuilder {
+    constructor() {
+        this._name = 'custom';
+    }
+    static create() {
+        return new StrategyBuilder();
+    }
+    withName(name) {
+        this._name = name;
+        return this;
+    }
+    withDescription(description) {
+        this._description = description;
+        return this;
+    }
+    withAggregator(fn) {
+        this._aggregateFn = fn;
+        return this;
+    }
+    build() {
+        if (!this._aggregateFn) {
+            throw new Error('Aggregator function is required');
+        }
+        const aggregateFn = this._aggregateFn;
+        const name = this._name;
+        return {
+            name: this._name,
+            description: this._description,
+            aggregate: aggregateFn,
+            aggregateFull: (results) => {
+                const successful = results.filter((r) => r.success);
+                return {
+                    output: aggregateFn(results),
+                    metadata: {
+                        successCount: successful.length,
+                        failedCount: results.length - successful.length,
+                        strategy: name,
+                    },
+                };
+            },
+        };
+    }
+}
+exports.StrategyBuilder = StrategyBuilder;
+exports.Strategies = {
+    concat: (separator = '\n\n') => ({
+        name: 'concat',
+        description: `Concatenates all successful results with "${separator}"`,
+        aggregate: (results) => results
+            .filter((r) => r.success)
+            .map((r) => r.content)
+            .join(separator),
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            return {
+                output: successful.map((r) => r.content).join(separator),
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'concat',
+                    separator,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r.success,
+                })),
+            };
+        },
+    }),
+    first: () => ({
+        name: 'first',
+        description: 'Returns only the first successful result',
+        aggregate: (results) => {
+            const first = results.find((r) => r.success);
+            return first?.content ?? '';
+        },
+        aggregateFull: (results) => {
+            const first = results.find((r) => r.success);
+            return {
+                output: first?.content ?? '',
+                metadata: {
+                    successCount: first ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'first',
+                    selectedAgent: first?.agentId,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r === first,
+                })),
+            };
+        },
+    }),
+    last: () => ({
+        name: 'last',
+        description: 'Returns only the last successful result',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            return successful[successful.length - 1]?.content ?? '';
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const last = successful[successful.length - 1];
+            return {
+                output: last?.content ?? '',
+                metadata: {
+                    successCount: last ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'last',
+                    selectedAgent: last?.agentId,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r === last,
+                })),
+            };
+        },
+    }),
+    longest: () => ({
+        name: 'longest',
+        description: 'Returns the longest successful result',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            return successful.reduce((a, b) => (a.content.length > b.content.length ? a : b)).content;
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const longest = successful.length > 0
+                ? successful.reduce((a, b) => (a.content.length > b.content.length ? a : b))
+                : null;
+            return {
+                output: longest?.content ?? '',
+                metadata: {
+                    successCount: longest ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'longest',
+                    selectedAgent: longest?.agentId,
+                    contentLength: longest?.content.length ?? 0,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r === longest,
+                })),
+            };
+        },
+    }),
+    shortest: () => ({
+        name: 'shortest',
+        description: 'Returns the shortest successful result',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            return successful.reduce((a, b) => (a.content.length < b.content.length ? a : b)).content;
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const shortest = successful.length > 0
+                ? successful.reduce((a, b) => (a.content.length < b.content.length ? a : b))
+                : null;
+            return {
+                output: shortest?.content ?? '',
+                metadata: {
+                    successCount: shortest ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'shortest',
+                    selectedAgent: shortest?.agentId,
+                    contentLength: shortest?.content.length ?? 0,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r === shortest,
+                })),
+            };
+        },
+    }),
+    best: (scorer) => ({
+        name: 'best',
+        description: 'Selects the best result based on a scoring function',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            const scored = successful.map((r) => ({ result: r, score: scorer(r) }));
+            scored.sort((a, b) => b.score - a.score);
+            return scored[0].result.content;
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const scored = successful.map((r) => ({ result: r, score: scorer(r) }));
+            scored.sort((a, b) => b.score - a.score);
+            const best = scored[0];
+            return {
+                output: best?.result.content ?? '',
+                metadata: {
+                    successCount: best ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'best',
+                    selectedAgent: best?.result.agentId,
+                    score: best?.score ?? 0,
+                    scores: Object.fromEntries(scored.map((s) => [s.result.agentId, s.score])),
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    weight: scorer(r),
+                    included: r === best?.result,
+                })),
+            };
+        },
+    }),
+    random: () => ({
+        name: 'random',
+        description: 'Randomly selects one successful result',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            const randomIndex = Math.floor(Math.random() * successful.length);
+            return successful[randomIndex].content;
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const randomIndex = successful.length > 0 ? Math.floor(Math.random() * successful.length) : -1;
+            const selected = successful[randomIndex];
+            return {
+                output: selected?.content ?? '',
+                metadata: {
+                    successCount: selected ? 1 : 0,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'random',
+                    selectedAgent: selected?.agentId,
+                    selectedIndex: randomIndex,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r === selected,
+                })),
+            };
+        },
+    }),
+    weighted: (weights) => ({
+        name: 'weighted',
+        description: 'Concatenates results weighted by agent importance',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            const sorted = successful.sort((a, b) => (weights[b.agentId] ?? 1) - (weights[a.agentId] ?? 1));
+            return sorted.map((r) => r.content).join('\n\n');
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const sorted = successful.sort((a, b) => (weights[b.agentId] ?? 1) - (weights[a.agentId] ?? 1));
+            return {
+                output: sorted.map((r) => r.content).join('\n\n'),
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'weighted',
+                    weights,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    weight: weights[r.agentId] ?? 1,
+                    included: r.success,
+                })),
+            };
+        },
+    }),
+    weightedVote: (weights) => ({
+        name: 'weightedVote',
+        description: 'Selects the result with highest weighted vote',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            const votes = new Map();
+            for (const result of successful) {
+                const weight = weights[result.agentId] ?? 1;
+                const key = result.content.trim().toLowerCase().substring(0, 100);
+                const existing = votes.get(key);
+                if (existing) {
+                    existing.weight += weight;
+                    existing.agents.push(result.agentId);
+                }
+                else {
+                    votes.set(key, { content: result.content, weight, agents: [result.agentId] });
+                }
+            }
+            let best = { content: '', weight: 0, agents: [] };
+            for (const vote of votes.values()) {
+                if (vote.weight > best.weight) {
+                    best = vote;
+                }
+            }
+            return best.content;
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const votes = new Map();
+            for (const result of successful) {
+                const weight = weights[result.agentId] ?? 1;
+                const key = result.content.trim().toLowerCase().substring(0, 100);
+                const existing = votes.get(key);
+                if (existing) {
+                    existing.weight += weight;
+                    existing.agents.push(result.agentId);
+                }
+                else {
+                    votes.set(key, { content: result.content, weight, agents: [result.agentId] });
+                }
+            }
+            let best = { content: '', weight: 0, agents: [] };
+            for (const vote of votes.values()) {
+                if (vote.weight > best.weight) {
+                    best = vote;
+                }
+            }
+            return {
+                output: best.content,
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'weightedVote',
+                    winningWeight: best.weight,
+                    winningAgents: best.agents,
+                    totalGroups: votes.size,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    weight: weights[r.agentId] ?? 1,
+                    included: best.agents.includes(r.agentId),
+                })),
+            };
+        },
+    }),
+    majority: () => ({
+        name: 'majority',
+        description: 'Selects the most common response (simple majority)',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            const votes = new Map();
+            for (const result of successful) {
+                const key = result.content.trim().toLowerCase().substring(0, 200);
+                votes.set(key, (votes.get(key) ?? 0) + 1);
+            }
+            let maxVotes = 0;
+            let winner = '';
+            for (const [content, count] of votes) {
+                if (count > maxVotes) {
+                    maxVotes = count;
+                    winner = content;
+                }
+            }
+            return successful.find((r) => r.content.trim().toLowerCase().substring(0, 200) === winner)?.content ?? '';
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const votes = new Map();
+            for (const result of successful) {
+                const key = result.content.trim().toLowerCase().substring(0, 200);
+                const existing = votes.get(key);
+                if (existing) {
+                    existing.count++;
+                    existing.agents.push(result.agentId);
+                }
+                else {
+                    votes.set(key, { count: 1, original: result.content, agents: [result.agentId] });
+                }
+            }
+            let maxVotes = 0;
+            let winner = { count: 0, original: '', agents: [] };
+            for (const vote of votes.values()) {
+                if (vote.count > maxVotes) {
+                    maxVotes = vote.count;
+                    winner = vote;
+                }
+            }
+            return {
+                output: winner.original,
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'majority',
+                    winningVotes: winner.count,
+                    totalVotes: successful.length,
+                    uniqueResponses: votes.size,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: winner.agents.includes(r.agentId),
+                })),
+            };
+        },
+    }),
+    consensus: (threshold = 0.5) => ({
+        name: 'consensus',
+        description: `Requires ${threshold * 100}% agreement for consensus`,
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            if (successful.length === 0)
+                return '';
+            const votes = new Map();
+            for (const result of successful) {
+                const key = result.content.trim().toLowerCase().substring(0, 200);
+                votes.set(key, (votes.get(key) ?? 0) + 1);
+            }
+            for (const [content, count] of votes) {
+                if (count / successful.length >= threshold) {
+                    return successful.find((r) => r.content.trim().toLowerCase().substring(0, 200) === content)?.content ?? '';
+                }
+            }
+            return '';
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const votes = new Map();
+            for (const result of successful) {
+                const key = result.content.trim().toLowerCase().substring(0, 200);
+                const existing = votes.get(key);
+                if (existing) {
+                    existing.count++;
+                    existing.agents.push(result.agentId);
+                }
+                else {
+                    votes.set(key, { count: 1, original: result.content, agents: [result.agentId] });
+                }
+            }
+            let consensus = { count: 0, original: '', agents: [], achieved: false };
+            for (const vote of votes.values()) {
+                if (vote.count / successful.length >= threshold && vote.count > consensus.count) {
+                    consensus = { ...vote, achieved: true };
+                }
+            }
+            return {
+                output: consensus.original,
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'consensus',
+                    threshold,
+                    consensusAchieved: consensus.achieved,
+                    agreementLevel: successful.length > 0 ? consensus.count / successful.length : 0,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: consensus.agents.includes(r.agentId),
+                })),
+            };
+        },
+    }),
+    format: (style = 'markdown') => ({
+        name: `format-${style}`,
+        description: `Formats results as ${style}`,
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            switch (style) {
+                case 'json':
+                    return JSON.stringify(successful.map((r) => ({ agent: r.agentId, content: r.content })), null, 2);
+                case 'list':
+                    return successful.map((r) => `- ${r.content}`).join('\n');
+                case 'numbered':
+                    return successful.map((r, i) => `${i + 1}. ${r.content}`).join('\n');
+                case 'table': {
+                    const header = '| Agent | Response |\n|-------|----------|';
+                    const rows = successful.map((r) => `| ${r.agentId} | ${r.content.replace(/\n/g, ' ').substring(0, 100)} |`);
+                    return [header, ...rows].join('\n');
+                }
+                case 'markdown':
+                default:
+                    return successful.map((r) => `## ${r.agentId}\n\n${r.content}`).join('\n\n---\n\n');
+            }
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            return {
+                output: exports.Strategies.format(style).aggregate(results),
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: `format-${style}`,
+                    style,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r.success,
+                })),
+            };
+        },
+    }),
+    reduce: (reducer, initial, finalize) => ({
+        name: 'reduce',
+        description: 'Custom reduction of results',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            const accumulated = successful.reduce(reducer, initial);
+            return finalize(accumulated);
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const accumulated = successful.reduce(reducer, initial);
+            return {
+                output: finalize(accumulated),
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'reduce',
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r.success,
+                })),
+            };
+        },
+    }),
+    mapReduce: (mapper, reducer, initial, finalize) => ({
+        name: 'mapReduce',
+        description: 'Map-reduce pattern for result aggregation',
+        aggregate: (results) => {
+            const successful = results.filter((r) => r.success);
+            const mapped = successful.map(mapper);
+            const reduced = mapped.reduce(reducer, initial);
+            return finalize(reduced);
+        },
+        aggregateFull: (results) => {
+            const successful = results.filter((r) => r.success);
+            const mapped = successful.map(mapper);
+            const reduced = mapped.reduce(reducer, initial);
+            return {
+                output: finalize(reduced),
+                metadata: {
+                    successCount: successful.length,
+                    failedCount: results.length - successful.length,
+                    strategy: 'mapReduce',
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: r.success,
+                })),
+            };
+        },
+    }),
+    filter: (predicate) => ({
+        name: 'filter',
+        description: 'Filters results before aggregation',
+        aggregate: (results) => {
+            return results
+                .filter(predicate)
+                .map((r) => r.content)
+                .join('\n\n');
+        },
+        aggregateFull: (results) => {
+            const filtered = results.filter(predicate);
+            return {
+                output: filtered.map((r) => r.content).join('\n\n'),
+                metadata: {
+                    successCount: filtered.length,
+                    failedCount: results.length - filtered.length,
+                    strategy: 'filter',
+                    originalCount: results.length,
+                    filteredCount: filtered.length,
+                },
+                contributions: results.map((r) => ({
+                    agentId: r.agentId,
+                    included: predicate(r),
+                })),
+            };
+        },
+    }),
+    compose: (...strategies) => ({
+        name: 'composed',
+        description: `Composed strategy: ${strategies.map((s) => s.name).join(' → ')}`,
+        aggregate: (results) => {
+            const currentResults = results;
+            let finalOutput = '';
+            for (const strategy of strategies) {
+                finalOutput = strategy.aggregate(currentResults);
+            }
+            return finalOutput;
+        },
+        aggregateFull: (results) => {
+            let finalOutput = '';
+            const allMetadata = [];
+            for (const strategy of strategies) {
+                const result = strategy.aggregateFull(results);
+                finalOutput = result.output;
+                allMetadata.push(result.metadata);
+            }
+            return {
+                output: finalOutput,
+                metadata: {
+                    successCount: results.filter((r) => r.success).length,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'composed',
+                    composedStrategies: strategies.map((s) => s.name),
+                    stepMetadata: allMetadata,
+                },
+            };
+        },
+    }),
+    fallback: (primary, backup) => ({
+        name: 'fallback',
+        description: `${primary.name} with fallback to ${backup.name}`,
+        aggregate: (results) => {
+            const primaryResult = primary.aggregate(results);
+            if (primaryResult && primaryResult.trim() !== '') {
+                return primaryResult;
+            }
+            return backup.aggregate(results);
+        },
+        aggregateFull: (results) => {
+            const primaryResult = primary.aggregateFull(results);
+            if (primaryResult.output && primaryResult.output.trim() !== '') {
+                return {
+                    ...primaryResult,
+                    metadata: {
+                        ...primaryResult.metadata,
+                        usedFallback: false,
+                    },
+                };
+            }
+            const backupResult = backup.aggregateFull(results);
+            return {
+                ...backupResult,
+                metadata: {
+                    ...backupResult.metadata,
+                    usedFallback: true,
+                    primaryStrategy: primary.name,
+                    backupStrategy: backup.name,
+                },
+            };
+        },
+    }),
+};
+function createStrategy(name, aggregator, description) {
+    return StrategyBuilder.create()
+        .withName(name)
+        .withDescription(description ?? name)
+        .withAggregator(aggregator)
+        .build();
+}
+function chainStrategies(...strategies) {
+    return (results) => {
+        return exports.Strategies.compose(...strategies).aggregate(results);
+    };
+}
+function parallelStrategies(strategies, merger = (outputs) => outputs.join('\n\n')) {
+    return {
+        name: 'parallel',
+        description: `Parallel execution of: ${strategies.map((s) => s.name).join(', ')}`,
+        aggregate: (results) => {
+            const outputs = strategies.map((s) => s.aggregate(results));
+            return merger(outputs);
+        },
+        aggregateFull: (results) => {
+            const outputs = strategies.map((s) => s.aggregateFull(results));
+            return {
+                output: merger(outputs.map((o) => o.output)),
+                metadata: {
+                    successCount: results.filter((r) => r.success).length,
+                    failedCount: results.filter((r) => !r.success).length,
+                    strategy: 'parallel',
+                    parallelStrategies: strategies.map((s) => s.name),
+                    parallelResults: outputs.map((o) => o.metadata),
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=strategies.js.map