@bluefly/openstandardagents 0.4.4 → 0.4.6

package/dist/adapters/a2a/swarm-orchestration.js

@@ -0,0 +1,322 @@
+/**
+ * Swarm Intelligence Orchestration
+ *
+ * Multi-agent swarm coordination for complex task decomposition
+ * and distributed execution
+ *
+ * @module adapters/a2a/swarm-orchestration
+ */
+/**
+ * Swarm Orchestrator
+ * Coordinates multi-agent swarms for complex task execution
+ */
+export class SwarmOrchestrator {
+    agents = new Map();
+    tasks = new Map();
+    assignments = new Map();
+    config;
+    constructor(config = {}) {
+        this.config = {
+            maxSize: 100,
+            minSize: 1,
+            autoScaling: true,
+            scaleUpThreshold: 0.8,
+            scaleDownThreshold: 0.2,
+            maxQueueSize: 1000,
+            coordinationStrategy: 'hybrid',
+            ...config,
+        };
+    }
+    /**
+     * Decompose complex task into agent subtasks
+     */
+    decomposeTask(task) {
+        const subtasks = [];
+        // Analyze task complexity
+        const complexity = this.analyzeComplexity(task);
+        // Determine decomposition strategy
+        const strategy = this.selectDecompositionStrategy(complexity);
+        // Decompose based on strategy
+        switch (strategy) {
+            case 'sequential':
+                return this.decomposeSequential(task);
+            case 'parallel':
+                return this.decomposeParallel(task);
+            case 'hierarchical':
+                return this.decomposeHierarchical(task);
+            case 'pipeline':
+                return this.decomposePipeline(task);
+            default:
+                return this.decomposeParallel(task);
+        }
+    }
+    /**
+     * Load balance tasks across agent pool
+     */
+    balanceLoad(tasks, agents) {
+        const assignments = [];
+        const availableAgents = agents.filter((a) => a.status === 'available');
+        // Sort tasks by priority and estimated duration (create copy to avoid mutating input)
+        const sortedTasks = tasks.slice().sort((a, b) => {
+            if (a.priority !== b.priority) {
+                return (this.priorityToNumber(b.priority) - this.priorityToNumber(a.priority));
+            }
+            return a.estimatedDuration - b.estimatedDuration;
+        });
+        // Assign tasks using capability-aware load balancing
+        for (const task of sortedTasks) {
+            const suitableAgents = this.findSuitableAgents(task, availableAgents);
+            if (suitableAgents.length === 0) {
+                console.warn(`No suitable agents for task ${task.id}`);
+                continue;
+            }
+            // Select best agent based on load, capabilities, and performance
+            const bestAgent = this.selectBestAgent(task, suitableAgents);
+            // Create assignment
+            const assignment = {
+                taskId: task.id,
+                agent: bestAgent,
+                assignedAt: new Date().toISOString(),
+                expectedCompletion: this.calculateExpectedCompletion(task, bestAgent),
+                score: this.calculateAssignmentScore(task, bestAgent),
+            };
+            assignments.push(assignment);
+            // Update agent load
+            bestAgent.load += task.estimatedDuration / 3600000; // Convert to hours
+            bestAgent.capacity = 1 - bestAgent.load;
+        }
+        return assignments;
+    }
+    /**
+     * Build consensus among agents
+     */
+    async buildConsensus(proposals) {
+        const results = [];
+        for (const proposal of proposals) {
+            const result = await this.processProposal(proposal);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Adapt swarm based on metrics
+     */
+    adaptSwarm(metrics) {
+        const newConfig = { ...this.config };
+        // Auto-scaling logic
+        if (this.config.autoScaling) {
+            if (metrics.avgLoad > this.config.scaleUpThreshold) {
+                newConfig.maxSize = Math.min(this.config.maxSize * 1.5, this.config.maxSize + 10);
+            }
+            else if (metrics.avgLoad < this.config.scaleDownThreshold) {
+                newConfig.maxSize = Math.max(this.config.maxSize * 0.8, this.config.minSize);
+            }
+        }
+        // Adjust coordination strategy based on swarm size
+        if (metrics.totalAgents > 50) {
+            newConfig.coordinationStrategy = 'decentralized';
+        }
+        else if (metrics.totalAgents < 10) {
+            newConfig.coordinationStrategy = 'centralized';
+        }
+        else {
+            newConfig.coordinationStrategy = 'hybrid';
+        }
+        this.config = newConfig;
+        return newConfig;
+    }
+    /**
+     * Register agent in swarm
+     */
+    registerAgent(agent) {
+        this.agents.set(agent.identity.id, agent);
+    }
+    /**
+     * Unregister agent from swarm
+     */
+    unregisterAgent(agentId) {
+        this.agents.delete(agentId);
+    }
+    /**
+     * Get swarm metrics
+     */
+    getMetrics() {
+        const agents = Array.from(this.agents.values());
+        const activeAgents = agents.filter((a) => a.status !== 'offline');
+        const totalLoad = agents.reduce((sum, a) => sum + a.load, 0);
+        const totalCompleted = agents.reduce((sum, a) => sum + a.metrics.tasksCompleted, 0);
+        const avgCompletionTime = agents.reduce((sum, a) => sum + a.metrics.avgCompletionTime, 0) /
+            agents.length;
+        const avgSuccessRate = agents.reduce((sum, a) => sum + a.metrics.successRate, 0) / agents.length;
+        return {
+            totalAgents: agents.length,
+            activeAgents: activeAgents.length,
+            avgLoad: totalLoad / agents.length,
+            tasksInProgress: this.assignments.size,
+            tasksCompleted: totalCompleted,
+            avgCompletionTime,
+            successRate: avgSuccessRate,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // Private helper methods
+    analyzeComplexity(task) {
+        // Simple complexity score (0-1)
+        let score = 0;
+        score += task.requirements.capabilities.length * 0.1;
+        score += (task.requirements.minAgents || 1) * 0.2;
+        score += task.constraints.maxExecutionTime ? 0.1 : 0;
+        return Math.min(score, 1);
+    }
+    selectDecompositionStrategy(complexity) {
+        if (complexity > 0.7)
+            return 'hierarchical';
+        if (complexity > 0.4)
+            return 'pipeline';
+        if (complexity > 0.2)
+            return 'parallel';
+        return 'sequential';
+    }
+    decomposeSequential(task) {
+        // Simple sequential decomposition
+        return [
+            {
+                id: crypto.randomUUID(),
+                parentId: task.id,
+                name: `${task.name} - Step 1`,
+                description: task.description,
+                capabilities: task.requirements.capabilities,
+                input: {},
+                dependencies: [],
+                estimatedDuration: 60000,
+                priority: task.priority,
+            },
+        ];
+    }
+    decomposeParallel(task) {
+        // Parallel decomposition - split into independent subtasks
+        return task.requirements.capabilities.map((capability, index) => ({
+            id: crypto.randomUUID(),
+            parentId: task.id,
+            name: `${task.name} - Part ${index + 1}`,
+            description: `Handle ${capability} for ${task.name}`,
+            capabilities: [capability],
+            input: {},
+            dependencies: [],
+            estimatedDuration: 60000,
+            priority: task.priority,
+        }));
+    }
+    decomposeHierarchical(task) {
+        // Hierarchical decomposition - tree structure
+        const rootTask = {
+            id: crypto.randomUUID(),
+            parentId: task.id,
+            name: `${task.name} - Coordinator`,
+            description: 'Coordinate subtasks',
+            capabilities: ['coordination'],
+            input: {},
+            dependencies: [],
+            estimatedDuration: 30000,
+            priority: task.priority,
+        };
+        const subtasks = task.requirements.capabilities.map((capability) => ({
+            id: crypto.randomUUID(),
+            parentId: rootTask.id,
+            name: `${task.name} - ${capability}`,
+            description: `Execute ${capability}`,
+            capabilities: [capability],
+            input: {},
+            dependencies: [rootTask.id],
+            estimatedDuration: 60000,
+            priority: task.priority,
+        }));
+        return [rootTask, ...subtasks];
+    }
+    decomposePipeline(task) {
+        // Pipeline decomposition - sequential with data flow
+        const tasks = [];
+        let previousTaskId = null;
+        for (let i = 0; i < task.requirements.capabilities.length; i++) {
+            const capability = task.requirements.capabilities[i];
+            const taskId = crypto.randomUUID();
+            tasks.push({
+                id: taskId,
+                parentId: task.id,
+                name: `${task.name} - Stage ${i + 1}`,
+                description: `Pipeline stage: ${capability}`,
+                capabilities: [capability],
+                input: {},
+                dependencies: previousTaskId ? [previousTaskId] : [],
+                estimatedDuration: 60000,
+                priority: task.priority,
+            });
+            previousTaskId = taskId;
+        }
+        return tasks;
+    }
+    findSuitableAgents(task, agents) {
+        return agents.filter((agent) => {
+            // Check capability match
+            const hasCapabilities = task.capabilities.every((cap) => agent.capabilities.includes(cap));
+            // Check capacity
+            const hasCapacity = agent.capacity > 0.1;
+            return hasCapabilities && hasCapacity;
+        });
+    }
+    selectBestAgent(task, agents) {
+        // Score each agent
+        const scored = agents.map((agent) => ({
+            agent,
+            score: this.calculateAssignmentScore(task, agent),
+        }));
+        // Sort by score (descending)
+        scored.sort((a, b) => b.score - a.score);
+        return scored[0].agent;
+    }
+    calculateAssignmentScore(task, agent) {
+        let score = 0;
+        // Capacity score (0-0.4)
+        score += agent.capacity * 0.4;
+        // Performance score (0-0.3)
+        score += agent.metrics.successRate * 0.3;
+        // Load score (0-0.3) - prefer less loaded agents
+        score += (1 - agent.load) * 0.3;
+        return Math.min(score, 1);
+    }
+    calculateExpectedCompletion(task, agent) {
+        const completionTime = new Date(Date.now() + task.estimatedDuration * (1 / agent.metrics.successRate));
+        return completionTime.toISOString();
+    }
+    async processProposal(proposal) {
+        // Count votes
+        const votes = {
+            approve: proposal.votes.filter((v) => v.value === 'approve').length,
+            reject: proposal.votes.filter((v) => v.value === 'reject').length,
+            abstain: proposal.votes.filter((v) => v.value === 'abstain').length,
+        };
+        // Determine consensus (simple majority)
+        const totalVotes = votes.approve + votes.reject + votes.abstain;
+        const reached = totalVotes >= this.agents.size * 0.5;
+        const decision = votes.approve > votes.reject ? 'accepted' : 'rejected';
+        return {
+            proposalId: proposal.id,
+            reached,
+            decision,
+            votes,
+            participants: proposal.votes.map((v) => v.voter),
+            timestamp: new Date().toISOString(),
+        };
+    }
+    priorityToNumber(priority) {
+        const mapping = {
+            low: 1,
+            normal: 2,
+            high: 3,
+            urgent: 4,
+            critical: 5,
+        };
+        return mapping[priority] || 2;
+    }
+}
+//# sourceMappingURL=swarm-orchestration.js.map

package/dist/adapters/agent-skills/exporter.js

@@ -39,7 +39,9 @@ export class AgentSkillsExporter {
                 content: yaml.stringify(manifest),
             });
             // Generate scripts directory if tools exist
-            if (options.includeScripts && manifest.spec?.tools && manifest.spec.tools.length > 0) {
+            if (options.includeScripts &&
+                manifest.spec?.tools &&
+                manifest.spec.tools.length > 0) {
                 const setupScript = this.generateSetupScript(manifest);
                 files.push({
                     path: 'scripts/setup.sh',
@@ -47,7 +49,8 @@ export class AgentSkillsExporter {
                 });
             }
             // Generate references if knowledge sources exist
-            if (options.includeReferences && manifest.spec?.knowledge_sources) {
+            if (options.includeReferences &&
+                manifest.spec?.knowledge_sources) {
                 const references = this.generateReferences(manifest);
                 files.push({
                     path: 'references/knowledge-sources.md',
@@ -246,13 +249,15 @@ echo "✅ Setup complete!"
         const knowledgeSources = spec?.knowledge_sources || [];
         return `# Knowledge Sources
 
-${knowledgeSources.map((source) => `
+${knowledgeSources
+            .map((source) => `
 ## ${source.name || 'Unnamed Source'}
 
 - **Type:** ${source.type || 'Not specified'}
 - **Location:** ${source.location || 'Not specified'}
 - **Description:** ${source.description || 'No description'}
-`).join('\n') || 'No knowledge sources configured'}
+`)
+            .join('\n') || 'No knowledge sources configured'}
 `;
     }
     /**
@@ -338,13 +343,15 @@ ${knowledgeSources.map((source) => `
         if (tools.length === 0) {
             return '*No tools configured*';
         }
-        return tools.map((tool) => `
+        return tools
+            .map((tool) => `
 ### ${tool.name || 'Unnamed Tool'}
 
 ${tool.description || 'No description'}
 
 ${tool.capabilities ? `**Capabilities:** ${tool.capabilities.join(', ')}` : ''}
-`).join('\n');
+`)
+            .join('\n');
     }
     /**
      * Generate config section

package/dist/adapters/anthropic/claude-optimizations.js

@@ -77,7 +77,8 @@ export function generateClaudeClientCode(manifest, optimizations) {
     // Prompt caching setup
     if (optimizations.promptCaching?.enabled) {
         code += '// Prompt caching (reduces costs by up to 90%)\n';
-        code += 'async function createMessageWithCaching(messages, systemPrompt) {\n';
+        code +=
+            'async function createMessageWithCaching(messages, systemPrompt) {\n';
         code += '  return await client.messages.create({\n';
         code += "    model: 'claude-sonnet-4.5-20250929',\n";
         code += '    max_tokens: 4096,\n';
@@ -85,7 +86,8 @@ export function generateClaudeClientCode(manifest, optimizations) {
         code += '      {\n';
         code += '        type: "text",\n';
         code += '        text: systemPrompt,\n';
-        code += '        cache_control: { type: "ephemeral" }, // Cache system prompt\n';
+        code +=
+            '        cache_control: { type: "ephemeral" }, // Cache system prompt\n';
         code += '      },\n';
         code += '    ],\n';
         code += '    messages,\n';
@@ -115,7 +117,8 @@ export function generateClaudeClientCode(manifest, optimizations) {
         code += '      {\n';
         code += "        role: 'user',\n";
         code += '        content: [\n';
-        code += '          { type: "image", source: { type: "url", url: imageUrl } },\n';
+        code +=
+            '          { type: "image", source: { type: "url", url: imageUrl } },\n';
         code += '          { type: "text", text: prompt },\n';
         code += '        ],\n';
         code += '      },\n';
@@ -142,8 +145,10 @@ export function generateClaudeBestPractices(optimizations) {
     let section = '## Claude Best Practices\n\n';
     if (optimizations.promptCaching?.enabled) {
         section += '### Prompt Caching\n\n';
-        section += 'This agent is configured with **prompt caching** to reduce costs:\n\n';
-        section += '- Cache system prompts with `cache_control: { type: "ephemeral" }`\n';
+        section +=
+            'This agent is configured with **prompt caching** to reduce costs:\n\n';
+        section +=
+            '- Cache system prompts with `cache_control: { type: "ephemeral" }`\n';
         section += '- Cached prompts cost **90% less** for repeated use\n';
         section += '- Cache persists for 5 minutes\n\n';
     }
@@ -160,9 +165,11 @@ export function generateClaudeBestPractices(optimizations) {
         section += 'Claude supports parallel tool calls:\n\n';
         section += '```typescript\n';
         section += 'const tools = [\n';
-        section += '  { name: "get_weather", description: "...", input_schema: {...} },\n';
+        section +=
+            '  { name: "get_weather", description: "...", input_schema: {...} },\n';
         section += '];\n';
-        section += 'const response = await client.messages.create({ tools, ... });\n';
+        section +=
+            'const response = await client.messages.create({ tools, ... });\n';
         section += '```\n\n';
     }
     if (optimizations.vision?.enabled) {

package/dist/adapters/anthropic/client.d.ts

@@ -1,137 +1,45 @@
 /**
- * Tool and Capability Mapping
- * Convert between OSSA capabilities and Anthropic tools
+ * Anthropic Client using Official SDK
+ * Replaces custom serialization with SDK client methods
  */
+import Anthropic from '@anthropic-ai/sdk';
 import type { Tool } from '@anthropic-ai/sdk/resources/messages';
+import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
 import type { AnthropicConfig } from './config.js';
 import type { OssaAgent } from '../../types/index.js';
 /**
- * OSSA capability definition
- */
-export interface OssaCapability {
-    name: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-    output_schema?: Record<string, unknown>;
-    examples?: Array<{
-        name?: string;
-        input?: Record<string, unknown>;
-        output?: Record<string, unknown>;
-    }>;
-}
-/**
- * Tool handler function type
- */
-export type ToolHandler = (args: Record<string, unknown>) => Promise<string | Record<string, unknown>>;
-/**
- * Tool definition with handler
- */
-export interface ToolDefinition {
-    tool: Tool;
-    handler?: ToolHandler;
-    capability?: OssaCapability;
-}
-/**
- * Tool mapper for converting OSSA capabilities to Anthropic tools
- */
-export declare class ToolMapper {
-    private tools;
-    /**
-     * Map OSSA capabilities to Anthropic tools
-     */
-    mapCapabilities(capabilities: OssaCapability[]): Tool[];
-    /**
-     * Map OSSA agent tools to Anthropic tools
-     */
-    mapAgentTools(agent: OssaAgent): Tool[];
-    /**
-     * Register a tool handler
-     */
-    registerToolHandler(name: string, handler: ToolHandler): boolean;
-    /**
-     * Get a tool by name
-     */
-    getTool(name: string): ToolDefinition | undefined;
-    /**
-     * Get all tools
-     */
-    getTools(): Tool[];
-    /**
-     * Execute a tool
-     */
-    executeTool(name: string, input: Record<string, unknown>): Promise<string>;
-    /**
-     * Clear all tools
-     */
-    clear(): void;
-    /**
-     * Convert OSSA capability to Anthropic tool
-     */
-    private convertCapabilityToTool;
-    /**
-     * Convert OSSA function tool to Anthropic tool
-     */
-    private convertFunctionToTool;
-    /**
-     * Normalize input schema to Anthropic format
-     */
-    private normalizeInputSchema;
-}
-/**
- * Create tool mapper from OSSA agent
- */
-export declare function createToolMapper(agent: OssaAgent): ToolMapper;
-/**
- * Extract capabilities from OSSA agent
- */
-export declare function extractCapabilities(agent: OssaAgent): OssaCapability[];
-/**
- * Validate tool input against schema
- */
-export declare function validateToolInput(input: Record<string, unknown>, schema: Record<string, unknown>): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Create a simple tool definition
- */
-export declare function createTool(name: string, description: string, properties: Record<string, {
-    type: string;
-    description?: string;
-}>, required?: string[]): Tool;
-/**
- * Common tool templates
+ * Anthropic Client Wrapper
+ * Uses official SDK for all API calls
  */
-export declare const COMMON_TOOLS: {
-    /**
-     * Web search tool
-     */
-    readonly webSearch: Tool;
-    /**
-     * Read file tool
-     */
-    readonly readFile: Tool;
+export declare class AnthropicClient {
+    private client;
+    private config;
+    private stats;
+    constructor(config: AnthropicConfig);
     /**
-     * Write file tool
+     * Create a message using SDK
      */
-    readonly writeFile: Tool;
+    createMessage(params: {
+        system?: string;
+        messages: MessageParam[];
+        tools?: Tool[];
+        max_tokens?: number;
+    }): Promise<Anthropic.Messages.Message & {
+        _request_id?: string | null;
+    }>;
     /**
-     * Execute code tool
+     * Create a streaming message using SDK
      */
-    readonly executeCode: Tool;
+    createMessageStream(params: {
+        system?: string;
+        messages: MessageParam[];
+        tools?: Tool[];
+        max_tokens?: number;
+    }): Promise<import("@anthropic-ai/sdk/lib/MessageStream.mjs").MessageStream>;
     /**
-     * HTTP request tool
+     * Get SDK client instance
      */
-    readonly httpRequest: Tool;
-};
-/**
- * Anthropic Client Wrapper
- * Provides compatibility layer for tests and legacy code
- */
-export declare class AnthropicClient {
-    private config;
-    private stats;
-    constructor(config: AnthropicConfig);
+    getClient(): Anthropic;
     getConfig(): AnthropicConfig;
     getStats(): {
         requestCount: number;
@@ -141,4 +49,8 @@ export declare class AnthropicClient {
     resetStats(): void;
     updateConfig(config: Partial<AnthropicConfig>): void;
 }
+/**
+ * Create Anthropic client from OSSA agent
+ */
+export declare function createAnthropicClient(agent: OssaAgent): AnthropicClient;
 //# sourceMappingURL=client.d.ts.map