societyai 0.0.1

package/dist/society.js

@@ -0,0 +1,721 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultWorkflowExecutor = exports.WorkflowConfigBuilder = exports.StepBuilder = exports.AgentBuilder = exports.RoleBuilder = exports.MessageBus = void 0;
+const logger_1 = require("./logger");
+const worker_pool_1 = require("./worker-pool");
+class MessageBus {
+    constructor() {
+        this.handlers = new Map();
+        this.history = [];
+    }
+    async send(message) {
+        this.history.push(message);
+        if (message.to === 'broadcast') {
+            for (const [agentId, handler] of this.handlers) {
+                if (agentId !== message.from) {
+                    handler(message);
+                }
+            }
+        }
+        else {
+            const handler = this.handlers.get(message.to);
+            if (handler) {
+                handler(message);
+            }
+        }
+    }
+    subscribe(agentId, handler) {
+        this.handlers.set(agentId, handler);
+    }
+    unsubscribe(agentId) {
+        this.handlers.delete(agentId);
+    }
+    getHistory(filter) {
+        if (!filter)
+            return [...this.history];
+        return this.history.filter((msg) => {
+            if (filter.from && msg.from !== filter.from)
+                return false;
+            if (filter.to && msg.to !== filter.to && msg.to !== 'broadcast')
+                return false;
+            if (filter.type && msg.type !== filter.type)
+                return false;
+            return true;
+        });
+    }
+    clearHistory() {
+        this.history = [];
+    }
+}
+exports.MessageBus = MessageBus;
+class RoleBuilder {
+    constructor(idOrName) {
+        this.role = {};
+        if (idOrName) {
+            this.role.id = idOrName;
+            this.role.name = idOrName;
+        }
+    }
+    static create() {
+        return new RoleBuilder();
+    }
+    withId(id) {
+        this.role.id = id;
+        return this;
+    }
+    withName(name) {
+        this.role.name = name;
+        return this;
+    }
+    withDescription(description) {
+        this.role.description = description;
+        return this;
+    }
+    withSystemPrompt(prompt) {
+        this.role.systemPrompt = prompt;
+        return this;
+    }
+    withCapabilities(capabilities) {
+        this.role.capabilities = capabilities;
+        return this;
+    }
+    withConstraints(constraints) {
+        this.role.constraints = constraints;
+        return this;
+    }
+    withPromptTemplate(template) {
+        this.role.promptTemplate = template;
+        return this;
+    }
+    build() {
+        if (!this.role.id)
+            throw new Error('Role id is required');
+        if (!this.role.name)
+            throw new Error('Role name is required');
+        if (!this.role.systemPrompt)
+            throw new Error('Role systemPrompt is required');
+        return {
+            id: this.role.id,
+            name: this.role.name,
+            systemPrompt: this.role.systemPrompt,
+            description: this.role.description,
+            capabilities: this.role.capabilities,
+            constraints: this.role.constraints,
+            promptTemplate: this.role.promptTemplate,
+        };
+    }
+}
+exports.RoleBuilder = RoleBuilder;
+class AgentBuilder {
+    constructor(id) {
+        this.config = {};
+        if (id) {
+            this.config.id = id;
+            this.config.name = id;
+        }
+    }
+    static create() {
+        return new AgentBuilder();
+    }
+    withId(id) {
+        this.config.id = id;
+        return this;
+    }
+    withName(name) {
+        this.config.name = name;
+        return this;
+    }
+    withRole(role) {
+        this.config.role = role;
+        return this;
+    }
+    withModel(model) {
+        this.config.model = model;
+        return this;
+    }
+    canCommunicateWith(agentIds) {
+        this.config.canCommunicateWith = agentIds;
+        return this;
+    }
+    withPriority(priority) {
+        this.config.priority = priority;
+        return this;
+    }
+    withInitialContext(context) {
+        this.config.initialContext = context;
+        return this;
+    }
+    build() {
+        if (!this.config.id)
+            throw new Error('Agent id is required');
+        if (!this.config.role)
+            throw new Error('Agent role is required');
+        if (!this.config.model)
+            throw new Error('Agent model is required');
+        return {
+            id: this.config.id,
+            name: this.config.name,
+            role: this.config.role,
+            model: this.config.model,
+            canCommunicateWith: this.config.canCommunicateWith,
+            priority: this.config.priority ?? 0,
+            initialContext: this.config.initialContext,
+        };
+    }
+}
+exports.AgentBuilder = AgentBuilder;
+class StepBuilder {
+    constructor(id) {
+        this.step = {};
+        if (id) {
+            this.step.id = id;
+            this.step.name = id;
+        }
+    }
+    static create() {
+        return new StepBuilder();
+    }
+    withId(id) {
+        this.step.id = id;
+        return this;
+    }
+    withName(name) {
+        this.step.name = name;
+        return this;
+    }
+    withDescription(description) {
+        this.step.description = description;
+        return this;
+    }
+    withAgents(agentIds) {
+        this.step.agentIds = agentIds;
+        return this;
+    }
+    withExecutionType(type) {
+        this.step.executionType = type;
+        return this;
+    }
+    withInstructions(instructions) {
+        this.step.instructions = instructions;
+        return this;
+    }
+    withPromptTemplate(template) {
+        this.step.promptTemplate = template;
+        return this;
+    }
+    withMaxIterations(max) {
+        this.step.maxIterations = max;
+        return this;
+    }
+    withCompletionCondition(condition) {
+        this.step.completionCondition = condition;
+        return this;
+    }
+    withResultTransformer(transformer) {
+        this.step.resultTransformer = transformer;
+        return this;
+    }
+    withCondition(condition) {
+        this.step.condition = condition;
+        return this;
+    }
+    withNextSteps(stepIds) {
+        this.step.nextSteps = stepIds;
+        return this;
+    }
+    withNextStepResolver(resolver) {
+        this.step.nextStepResolver = resolver;
+        return this;
+    }
+    build() {
+        if (!this.step.id)
+            throw new Error('Step id is required');
+        if (!this.step.name)
+            throw new Error('Step name is required');
+        if (!this.step.agentIds || this.step.agentIds.length === 0) {
+            throw new Error('Step must have at least one agent');
+        }
+        return {
+            id: this.step.id,
+            name: this.step.name,
+            description: this.step.description,
+            agentIds: this.step.agentIds,
+            executionType: this.step.executionType ?? 'sequential',
+            instructions: this.step.instructions,
+            promptTemplate: this.step.promptTemplate,
+            maxIterations: this.step.maxIterations,
+            completionCondition: this.step.completionCondition,
+            resultTransformer: this.step.resultTransformer,
+            condition: this.step.condition,
+            nextSteps: this.step.nextSteps,
+            nextStepResolver: this.step.nextStepResolver,
+        };
+    }
+}
+exports.StepBuilder = StepBuilder;
+class WorkflowConfigBuilder {
+    constructor(id) {
+        this.config = {
+            agents: [],
+            steps: [],
+        };
+        if (id) {
+            this.config.id = id;
+            this.config.name = id;
+        }
+    }
+    static create() {
+        return new WorkflowConfigBuilder();
+    }
+    withId(id) {
+        this.config.id = id;
+        return this;
+    }
+    withName(name) {
+        this.config.name = name;
+        return this;
+    }
+    withDescription(description) {
+        this.config.description = description;
+        return this;
+    }
+    addAgent(agent) {
+        this.config.agents.push(agent);
+        return this;
+    }
+    addAgents(agents) {
+        this.config.agents.push(...agents);
+        return this;
+    }
+    addStep(step) {
+        this.config.steps.push(step);
+        return this;
+    }
+    addSteps(steps) {
+        this.config.steps.push(...steps);
+        return this;
+    }
+    withEntryStep(stepId) {
+        this.config.entryStepId = stepId;
+        return this;
+    }
+    withGlobalContext(context) {
+        this.config.globalContext = context;
+        return this;
+    }
+    onBeforeStep(handler) {
+        this.config.onBeforeStep = handler;
+        return this;
+    }
+    onAfterStep(handler) {
+        this.config.onAfterStep = handler;
+        return this;
+    }
+    withFinalResultGenerator(generator) {
+        this.config.finalResultGenerator = generator;
+        return this;
+    }
+    build() {
+        if (!this.config.id)
+            throw new Error('Workflow id is required');
+        if (!this.config.name)
+            throw new Error('Workflow name is required');
+        if (this.config.agents.length === 0)
+            throw new Error('Workflow must have at least one agent');
+        if (this.config.steps.length === 0)
+            throw new Error('Workflow must have at least one step');
+        return {
+            id: this.config.id,
+            name: this.config.name,
+            description: this.config.description,
+            agents: this.config.agents,
+            steps: this.config.steps,
+            entryStepId: this.config.entryStepId ?? this.config.steps[0].id,
+            globalContext: this.config.globalContext,
+            onBeforeStep: this.config.onBeforeStep,
+            onAfterStep: this.config.onAfterStep,
+            finalResultGenerator: this.config.finalResultGenerator,
+        };
+    }
+}
+exports.WorkflowConfigBuilder = WorkflowConfigBuilder;
+class DefaultWorkflowExecutor {
+    constructor(observer) {
+        this.logger = (0, logger_1.getLogger)();
+        this.messageBus = new MessageBus();
+        this.observer = observer;
+    }
+    buildAgentPrompt(agent, step, context) {
+        const defaultTemplate = '{systemPrompt}\n\n{instructions}\n\nInput: {input}\n\nContext: {context}';
+        const template = step.promptTemplate ?? agent.role.promptTemplate ?? defaultTemplate;
+        const contextData = {
+            systemPrompt: agent.role.systemPrompt,
+            instructions: step.instructions ?? '',
+            input: context.input,
+            context: this.formatSharedData(context.sharedData),
+            history: this.formatMessageHistory(context.messageHistory, agent.id),
+            previousResults: this.formatPreviousResults(context.stepResults),
+        };
+        if (agent.role.capabilities?.length) {
+            contextData.capabilities = `Capabilities: ${agent.role.capabilities.join(', ')}`;
+        }
+        if (agent.role.constraints?.length) {
+            contextData.constraints = `Constraints: ${agent.role.constraints.join(', ')}`;
+        }
+        let prompt = template;
+        for (const [key, value] of Object.entries(contextData)) {
+            prompt = prompt.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
+        }
+        return prompt;
+    }
+    formatSharedData(data) {
+        if (data.size === 0)
+            return '';
+        const entries = [];
+        for (const [key, value] of data) {
+            entries.push(`${key}: ${JSON.stringify(value)}`);
+        }
+        return entries.join('\n');
+    }
+    formatMessageHistory(messages, agentId) {
+        const relevant = messages.filter((m) => m.from === agentId || m.to === agentId || m.to === 'broadcast');
+        if (relevant.length === 0)
+            return '';
+        return relevant.map((m) => `[${m.from} → ${m.to}]: ${m.content}`).join('\n');
+    }
+    formatPreviousResults(results) {
+        if (results.size === 0)
+            return '';
+        const formatted = [];
+        for (const [stepId, stepResults] of results) {
+            formatted.push(`--- Step: ${stepId} ---`);
+            for (const result of stepResults) {
+                if (result.success) {
+                    formatted.push(`[${result.agentId}]: ${result.content}`);
+                }
+            }
+        }
+        return formatted.join('\n');
+    }
+    async executeSequential(step, agents, context, signal) {
+        const results = [];
+        for (const agentId of step.agentIds) {
+            if (signal?.aborted)
+                throw new Error('Operation cancelled');
+            const agent = agents.get(agentId);
+            if (!agent) {
+                this.logger.error(`Agent ${agentId} not found`);
+                continue;
+            }
+            const prompt = this.buildAgentPrompt(agent, step, context);
+            this.logger.debug(`Agent ${agentId} processing step ${step.id}`);
+            if (this.observer) {
+                this.observer.onAgentStart(parseInt(agentId) || 0, agent.model.name(), prompt);
+            }
+            try {
+                const content = await agent.model.process(prompt, signal);
+                const result = {
+                    agentId,
+                    stepId: step.id,
+                    content,
+                    timestamp: Date.now(),
+                    success: true,
+                };
+                results.push(result);
+                context.sharedData.set(`${step.id}_${agentId}_result`, content);
+                if (this.observer) {
+                    this.observer.onAgentComplete(parseInt(agentId) || 0, agent.model.name(), content);
+                }
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw error;
+                }
+                const result = {
+                    agentId,
+                    stepId: step.id,
+                    content: '',
+                    timestamp: Date.now(),
+                    success: false,
+                    error: error,
+                };
+                results.push(result);
+                if (this.observer) {
+                    this.observer.onAgentError(parseInt(agentId) || 0, agent.model.name(), error);
+                }
+            }
+        }
+        return results;
+    }
+    async executeParallel(step, agents, context, signal) {
+        const pool = new worker_pool_1.WorkerPool(step.agentIds.length, signal);
+        const results = [];
+        const tasks = step.agentIds.map((agentId) => async () => {
+            const agent = agents.get(agentId);
+            if (!agent) {
+                this.logger.error(`Agent ${agentId} not found`);
+                return null;
+            }
+            const prompt = this.buildAgentPrompt(agent, step, context);
+            this.logger.debug(`Agent ${agentId} processing step ${step.id} (parallel)`);
+            if (this.observer) {
+                this.observer.onAgentStart(parseInt(agentId) || 0, agent.model.name(), prompt);
+            }
+            try {
+                const content = await agent.model.process(prompt, signal);
+                const result = {
+                    agentId,
+                    stepId: step.id,
+                    content,
+                    timestamp: Date.now(),
+                    success: true,
+                };
+                if (this.observer) {
+                    this.observer.onAgentComplete(parseInt(agentId) || 0, agent.model.name(), content);
+                }
+                return result;
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw error;
+                }
+                if (this.observer) {
+                    this.observer.onAgentError(parseInt(agentId) || 0, agent.model.name(), error);
+                }
+                return {
+                    agentId,
+                    stepId: step.id,
+                    content: '',
+                    timestamp: Date.now(),
+                    success: false,
+                    error: error,
+                };
+            }
+        });
+        const taskResults = await Promise.all(tasks.map((task) => pool.submit(task)));
+        await pool.waitAll();
+        for (const result of taskResults) {
+            if (result) {
+                results.push(result);
+                if (result.success) {
+                    context.sharedData.set(`${step.id}_${result.agentId}_result`, result.content);
+                }
+            }
+        }
+        return results;
+    }
+    async executeCollaborative(step, agents, context, signal) {
+        const maxIterations = step.maxIterations ?? 3;
+        let allResults = [];
+        for (let iteration = 0; iteration < maxIterations; iteration++) {
+            if (signal?.aborted)
+                throw new Error('Operation cancelled');
+            this.logger.info(`Collaborative step ${step.id} - iteration ${iteration + 1}/${maxIterations}`);
+            const iterationResults = [];
+            for (const agentId of step.agentIds) {
+                const agent = agents.get(agentId);
+                if (!agent)
+                    continue;
+                const enrichedContext = { ...context };
+                enrichedContext.sharedData = new Map(context.sharedData);
+                enrichedContext.sharedData.set('currentIteration', iteration);
+                enrichedContext.sharedData.set('previousIterationResults', allResults);
+                const prompt = this.buildAgentPrompt(agent, step, enrichedContext);
+                try {
+                    const content = await agent.model.process(prompt, signal);
+                    const result = {
+                        agentId,
+                        stepId: step.id,
+                        content,
+                        timestamp: Date.now(),
+                        success: true,
+                        iteration,
+                    };
+                    iterationResults.push(result);
+                    const message = {
+                        from: agentId,
+                        to: 'broadcast',
+                        type: 'data',
+                        content: content,
+                        timestamp: Date.now(),
+                        messageId: `${agentId}-${step.id}-${iteration}-${Date.now()}`,
+                    };
+                    await this.messageBus.send(message);
+                    context.messageHistory.push(message);
+                }
+                catch (error) {
+                    if (signal?.aborted) {
+                        throw error;
+                    }
+                    iterationResults.push({
+                        agentId,
+                        stepId: step.id,
+                        content: '',
+                        timestamp: Date.now(),
+                        success: false,
+                        error: error,
+                        iteration,
+                    });
+                }
+            }
+            allResults = [...allResults, ...iterationResults];
+            if (step.completionCondition && step.completionCondition(allResults, iteration)) {
+                this.logger.info(`Collaborative step ${step.id} completed at iteration ${iteration + 1}`);
+                break;
+            }
+        }
+        return allResults;
+    }
+    async executeStep(step, agents, context, signal) {
+        this.logger.info(`Executing step: ${step.name} (${step.executionType})`);
+        if (this.observer) {
+            this.observer.onPhaseStart(step.name);
+        }
+        if (step.executionType === 'conditional' && step.condition) {
+            if (!step.condition(context.stepResults)) {
+                this.logger.info(`Step ${step.id} skipped (condition not met)`);
+                if (this.observer) {
+                    this.observer.onPhaseComplete(step.name);
+                }
+                return [];
+            }
+        }
+        let results;
+        switch (step.executionType) {
+            case 'parallel':
+                results = await this.executeParallel(step, agents, context, signal);
+                break;
+            case 'collaborative':
+                results = await this.executeCollaborative(step, agents, context, signal);
+                break;
+            case 'sequential':
+            case 'conditional':
+            default:
+                results = await this.executeSequential(step, agents, context, signal);
+                break;
+        }
+        if (step.resultTransformer && results.length > 0) {
+            const transformedContent = step.resultTransformer(results);
+            context.sharedData.set(`${step.id}_transformed`, transformedContent);
+        }
+        if (this.observer) {
+            this.observer.onPhaseComplete(step.name);
+        }
+        return results;
+    }
+    async execute(workflow, input, signal) {
+        const startTime = Date.now();
+        const errors = [];
+        if (signal?.aborted) {
+            throw new Error('Operation cancelled');
+        }
+        this.logger.info(`Starting workflow: ${workflow.name}`);
+        if (this.observer) {
+            this.observer.onSocietyStart(input, workflow.agents.length);
+        }
+        const agentsMap = new Map();
+        for (const agent of workflow.agents) {
+            agentsMap.set(agent.id, agent);
+            this.messageBus.subscribe(agent.id, (message) => {
+                this.logger.debug(`Agent ${agent.id} received message from ${message.from}`);
+            });
+        }
+        const context = {
+            input,
+            sharedData: new Map(Object.entries(workflow.globalContext ?? {})),
+            stepResults: new Map(),
+            messageHistory: [],
+            metadata: {},
+        };
+        const stepsMap = new Map();
+        for (const step of workflow.steps) {
+            stepsMap.set(step.id, step);
+        }
+        let currentStepId = workflow.entryStepId ?? workflow.steps[0].id;
+        while (currentStepId) {
+            if (signal?.aborted) {
+                throw new Error('Operation cancelled');
+            }
+            const step = stepsMap.get(currentStepId);
+            if (!step) {
+                errors.push(new Error(`Step ${currentStepId} not found`));
+                break;
+            }
+            if (workflow.onBeforeStep) {
+                await workflow.onBeforeStep(step, context);
+            }
+            try {
+                const stepResults = await this.executeStep(step, agentsMap, context, signal);
+                context.stepResults.set(step.id, stepResults);
+                for (const stepResult of stepResults) {
+                    if (!stepResult.success && stepResult.error) {
+                        errors.push(stepResult.error);
+                    }
+                }
+                if (workflow.onAfterStep) {
+                    await workflow.onAfterStep(step, stepResults, context);
+                }
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw error;
+                }
+                errors.push(error);
+                this.logger.error(`Step ${step.id} failed: ${error.message}`);
+            }
+            if (step.nextStepResolver) {
+                currentStepId = step.nextStepResolver(context.stepResults.get(step.id) ?? []);
+            }
+            else if (step.nextSteps && step.nextSteps.length > 0) {
+                currentStepId = step.nextSteps[0];
+            }
+            else {
+                const currentIndex = workflow.steps.findIndex((s) => s.id === currentStepId);
+                if (currentIndex >= 0 && currentIndex < workflow.steps.length - 1) {
+                    currentStepId = workflow.steps[currentIndex + 1].id;
+                }
+                else {
+                    currentStepId = null;
+                }
+            }
+        }
+        let output;
+        if (workflow.finalResultGenerator) {
+            output = await workflow.finalResultGenerator(context.stepResults, context);
+        }
+        else {
+            output = this.generateDefaultOutput(context.stepResults);
+        }
+        for (const agent of workflow.agents) {
+            this.messageBus.unsubscribe(agent.id);
+        }
+        const result = {
+            success: errors.length === 0,
+            output,
+            stepResults: context.stepResults,
+            messages: context.messageHistory,
+            duration: Date.now() - startTime,
+            errors: errors.length > 0 ? errors : undefined,
+        };
+        if (this.observer) {
+            this.observer.onSocietyComplete(output);
+        }
+        this.logger.info(`Workflow completed in ${result.duration}ms`);
+        return result;
+    }
+    generateDefaultOutput(stepResults) {
+        const parts = [];
+        for (const [stepId, results] of stepResults) {
+            parts.push(`=== ${stepId} ===`);
+            for (const result of results) {
+                if (result.success) {
+                    parts.push(`[${result.agentId}]: ${result.content}`);
+                }
+            }
+            parts.push('');
+        }
+        return parts.join('\n');
+    }
+}
+exports.DefaultWorkflowExecutor = DefaultWorkflowExecutor;
+//# sourceMappingURL=society.js.map