@bluefly/openstandardagents 0.1.9 → 0.2.5-RC

package/src/adk/adapters/index.ts

@@ -1,310 +0,0 @@
-/**
- * ADK Adapters for OSSA Framework
- * Bridges OSSA components with ADK patterns
- */
-
-import { AgentManifest } from '../../types/index.js';
-import { ADKAgent, OSSAToADKMapper } from '../agents/index.js';
-import { OSSALlmAgent } from '../agents/llm-agent.js';
-import { OSSAWorkflowAgent } from '../agents/workflow-agent.js';
-import { OSSACustomAgent } from '../agents/custom-agent.js';
-import { sessionManager, ADKSession } from '../state/index.js';
-import { toolRegistry } from '../tools/index.js';
-import { orchestrationEngine, OrchestrationPattern } from '../orchestration/index.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'yaml';
-
-/**
- * Main ADK Adapter for OSSA
- */
-export class OSSAADKAdapter {
-  private agents: Map<string, ADKAgent> = new Map();
-  private sessions: Map<string, ADKSession> = new Map();
-
-  /**
-   * Load OSSA agent and convert to ADK
-   */
-  async loadAgent(agentPath: string): Promise<ADKAgent> {
-    // Read OSSA manifest
-    const manifestPath = path.join(agentPath, 'agent.yml');
-    const manifestContent = fs.readFileSync(manifestPath, 'utf8');
-    const manifest = yaml.parse(manifestContent) as AgentManifest;
-    
-    // Convert to ADK agent
-    const adkConfig = OSSAToADKMapper.mapAgent(manifest);
-    
-    // Create appropriate agent instance
-    let agent: ADKAgent;
-    switch (adkConfig.type) {
-      case 'LlmAgent':
-        agent = new OSSALlmAgent(adkConfig.config, adkConfig.ossaType);
-        break;
-      
-      case 'WorkflowAgent':
-        agent = new OSSAWorkflowAgent(
-          { ...adkConfig.config, workflow_type: 'sequential' },
-          adkConfig.ossaType
-        );
-        break;
-      
-      case 'CustomAgent':
-        agent = new OSSACustomAgent(
-          { ...adkConfig.config, custom_type: adkConfig.ossaType || 'generic' },
-          adkConfig.ossaType
-        );
-        break;
-      
-      default:
-        agent = new OSSACustomAgent(
-          { ...adkConfig.config, custom_type: 'generic' },
-          adkConfig.ossaType
-        );
-    }
-    
-    // Register agent
-    this.agents.set(manifest.metadata.name, agent);
-    
-    // Register tools for agent capabilities
-    if (manifest.spec.capabilities) {
-      const tools = toolRegistry.getToolsForCapabilities(manifest.spec.capabilities);
-      // TODO: Attach tools to agent
-    }
-    
-    // Register agent as tool for orchestration
-    if (manifest.spec.type === 'worker' || manifest.spec.type === 'critic') {
-      toolRegistry.registerAgentTool(agent, 'explicit');
-    }
-    
-    return agent;
-  }
-
-  /**
-   * Load all agents from .agents directory
-   */
-  async loadAllAgents(baseDir: string = '.agents'): Promise<void> {
-    if (!fs.existsSync(baseDir)) {
-      console.warn(`Agents directory not found: ${baseDir}`);
-      return;
-    }
-    
-    const agentDirs = fs.readdirSync(baseDir)
-      .filter(dir => fs.statSync(path.join(baseDir, dir)).isDirectory());
-    
-    for (const agentDir of agentDirs) {
-      try {
-        await this.loadAgent(path.join(baseDir, agentDir));
-        console.log(`Loaded ADK agent: ${agentDir}`);
-      } catch (error) {
-        console.error(`Failed to load agent ${agentDir}:`, error);
-      }
-    }
-  }
-
-  /**
-   * Execute an agent with ADK patterns
-   */
-  async executeAgent(
-    agentName: string,
-    input: any,
-    sessionId?: string
-  ): Promise<any> {
-    const agent = this.agents.get(agentName);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentName}`);
-    }
-    
-    // Get or create session
-    let session: ADKSession;
-    if (sessionId && this.sessions.has(sessionId)) {
-      session = this.sessions.get(sessionId)!;
-    } else {
-      session = sessionManager.createSession(sessionId);
-      this.sessions.set(session.id, session);
-    }
-    
-    // Execute agent based on type
-    if (agent instanceof OSSALlmAgent) {
-      return agent.invoke(input, session);
-    } else if (agent instanceof OSSAWorkflowAgent) {
-      return agent.invoke(input, session);
-    } else if (agent instanceof OSSACustomAgent) {
-      return agent.invoke(input, session);
-    } else {
-      throw new Error(`Unknown agent type for: ${agentName}`);
-    }
-  }
-
-  /**
-   * Execute orchestration pattern
-   */
-  async executeOrchestration(
-    pattern: OrchestrationPattern,
-    agentNames: string[],
-    input?: any,
-    options?: any
-  ): Promise<any> {
-    // Get agents
-    const agents: ADKAgent[] = [];
-    for (const name of agentNames) {
-      const agent = this.agents.get(name);
-      if (!agent) {
-        throw new Error(`Agent not found: ${name}`);
-      }
-      agents.push(agent);
-    }
-    
-    // Create session for orchestration
-    const session = sessionManager.createSession();
-    this.sessions.set(session.id, session);
-    
-    // Execute orchestration
-    return orchestrationEngine.execute({
-      pattern,
-      agents,
-      session,
-      options: { ...options, initialInput: input }
-    });
-  }
-
-  /**
-   * Get agent information
-   */
-  getAgentInfo(agentName: string): any {
-    const agent = this.agents.get(agentName);
-    if (!agent) {
-      return null;
-    }
-    
-    return {
-      name: agent.config.name,
-      type: agent.type,
-      ossaType: agent.ossaType,
-      description: agent.config.description,
-      output_key: agent.config.output_key
-    };
-  }
-
-  /**
-   * List all loaded agents
-   */
-  listAgents(): any[] {
-    const agentList: any[] = [];
-    
-    for (const [name, agent] of this.agents) {
-      agentList.push({
-        name,
-        type: agent.type,
-        ossaType: agent.ossaType,
-        description: agent.config.description
-      });
-    }
-    
-    return agentList;
-  }
-
-  /**
-   * Get session state
-   */
-  getSessionState(sessionId: string): any {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return null;
-    }
-    
-    return sessionManager.exportSession(sessionId);
-  }
-
-  /**
-   * Clean up old sessions
-   */
-  cleanupSessions(olderThanMinutes: number = 60): number {
-    const cutoff = new Date(Date.now() - olderThanMinutes * 60 * 1000);
-    return sessionManager.cleanupSessions(cutoff);
-  }
-}
-
-/**
- * MCP-ADK Bridge
- * Allows MCP servers to use ADK agents
- */
-export class MCPADKBridge {
-  private adapter: OSSAADKAdapter;
-
-  constructor(adapter: OSSAADKAdapter) {
-    this.adapter = adapter;
-  }
-
-  /**
-   * Create MCP tool from ADK agent
-   */
-  createMCPTool(agentName: string): any {
-    const agentInfo = this.adapter.getAgentInfo(agentName);
-    if (!agentInfo) {
-      throw new Error(`Agent not found: ${agentName}`);
-    }
-    
-    return {
-      name: `adk_agent_${agentName}`,
-      description: agentInfo.description || `Execute ADK agent: ${agentName}`,
-      inputSchema: {
-        type: 'object',
-        properties: {
-          input: {
-            type: 'object',
-            description: 'Input data for the agent'
-          },
-          sessionId: {
-            type: 'string',
-            description: 'Optional session ID for state persistence'
-          }
-        },
-        required: ['input']
-      },
-      handler: async (args: any) => {
-        return this.adapter.executeAgent(agentName, args.input, args.sessionId);
-      }
-    };
-  }
-
-  /**
-   * Create MCP orchestration tool
-   */
-  createMCPOrchestrationTool(pattern: OrchestrationPattern): any {
-    return {
-      name: `adk_orchestrate_${pattern}`,
-      description: `Execute ADK ${pattern} orchestration pattern`,
-      inputSchema: {
-        type: 'object',
-        properties: {
-          agents: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'List of agent names to orchestrate'
-          },
-          input: {
-            type: 'object',
-            description: 'Input data for the orchestration'
-          },
-          options: {
-            type: 'object',
-            description: 'Orchestration options'
-          }
-        },
-        required: ['agents']
-      },
-      handler: async (args: any) => {
-        return this.adapter.executeOrchestration(
-          pattern,
-          args.agents,
-          args.input,
-          args.options
-        );
-      }
-    };
-  }
-}
-
-// Export singleton instances
-export const adkAdapter = new OSSAADKAdapter();
-export const mcpBridge = new MCPADKBridge(adkAdapter);

package/src/adk/agents/custom-agent.ts

@@ -1,206 +0,0 @@
-/**
- * ADK CustomAgent implementation for OSSA
- */
-
-import { ADKAgent, ADKAgentConfig } from './index.js';
-
-export interface CustomAgentConfig extends ADKAgentConfig {
-  name: string;
-  description?: string;
-  custom_type: string;
-  capabilities?: string[];
-  policies?: any[];
-  output_key?: string;
-}
-
-export class OSSACustomAgent implements ADKAgent {
-  type: 'CustomAgent' = 'CustomAgent';
-  config: CustomAgentConfig;
-  ossaType?: string;
-  
-  constructor(config: CustomAgentConfig, ossaType?: string) {
-    this.config = config;
-    this.ossaType = ossaType;
-  }
-
-  /**
-   * Execute custom agent logic
-   */
-  async invoke(input: any, session?: any): Promise<any> {
-    // Handle custom agent types
-    switch (this.config.custom_type) {
-      case 'governor':
-        return this.executeGovernor(input, session);
-      
-      case 'monitor':
-        return this.executeMonitor(input, session);
-      
-      case 'specialized':
-        return this.executeSpecialized(input, session);
-      
-      default:
-        return this.executeGeneric(input, session);
-    }
-  }
-
-  /**
-   * Execute governor agent
-   */
-  private async executeGovernor(input: any, session?: any): Promise<any> {
-    const policies = this.config.policies || [];
-    const violations: any[] = [];
-    const approvals: any[] = [];
-    
-    // Check policies
-    for (const policy of policies) {
-      const result = await this.checkPolicy(policy, input);
-      if (result.violated) {
-        violations.push(result);
-      } else {
-        approvals.push(result);
-      }
-    }
-    
-    const finalResult = {
-      type: 'governor',
-      violations,
-      approvals,
-      compliant: violations.length === 0,
-      timestamp: new Date().toISOString()
-    };
-    
-    // Save to session state
-    if (this.config.output_key && session) {
-      session.state[this.config.output_key] = finalResult;
-    }
-    
-    return finalResult;
-  }
-
-  /**
-   * Execute monitor agent
-   */
-  private async executeMonitor(input: any, session?: any): Promise<any> {
-    const metrics = await this.collectMetrics(input);
-    const alerts = await this.checkAlerts(metrics);
-    
-    const finalResult = {
-      type: 'monitor',
-      metrics,
-      alerts,
-      healthy: alerts.length === 0,
-      timestamp: new Date().toISOString()
-    };
-    
-    // Save to session state
-    if (this.config.output_key && session) {
-      session.state[this.config.output_key] = finalResult;
-    }
-    
-    return finalResult;
-  }
-
-  /**
-   * Execute specialized agent
-   */
-  private async executeSpecialized(input: any, session?: any): Promise<any> {
-    const capabilities = this.config.capabilities || [];
-    const results: any[] = [];
-    
-    for (const capability of capabilities) {
-      const result = await this.executeCapability(capability, input);
-      results.push(result);
-    }
-    
-    const finalResult = {
-      type: 'specialized',
-      capabilities: capabilities,
-      results,
-      success: true,
-      timestamp: new Date().toISOString()
-    };
-    
-    // Save to session state
-    if (this.config.output_key && session) {
-      session.state[this.config.output_key] = finalResult;
-    }
-    
-    return finalResult;
-  }
-
-  /**
-   * Execute generic custom agent
-   */
-  private async executeGeneric(input: any, session?: any): Promise<any> {
-    console.log(`Executing custom agent: ${this.config.name}`);
-    
-    const finalResult = {
-      type: 'custom',
-      name: this.config.name,
-      input,
-      output: `Processed by ${this.config.name}`,
-      timestamp: new Date().toISOString()
-    };
-    
-    // Save to session state
-    if (this.config.output_key && session) {
-      session.state[this.config.output_key] = finalResult;
-    }
-    
-    return finalResult;
-  }
-
-  /**
-   * Check a policy (placeholder)
-   */
-  private async checkPolicy(policy: any, input: any): Promise<any> {
-    // TODO: Implement actual policy checking
-    return {
-      policy: policy.name || 'unknown',
-      violated: false,
-      details: 'Policy check passed'
-    };
-  }
-
-  /**
-   * Collect metrics (placeholder)
-   */
-  private async collectMetrics(input: any): Promise<any> {
-    // TODO: Implement actual metrics collection
-    return {
-      cpu: Math.random() * 100,
-      memory: Math.random() * 100,
-      throughput: Math.random() * 1000,
-      latency: Math.random() * 100
-    };
-  }
-
-  /**
-   * Check alerts (placeholder)
-   */
-  private async checkAlerts(metrics: any): Promise<any[]> {
-    const alerts: any[] = [];
-    
-    // Example alert conditions
-    if (metrics.cpu > 80) {
-      alerts.push({ type: 'high_cpu', value: metrics.cpu });
-    }
-    if (metrics.memory > 90) {
-      alerts.push({ type: 'high_memory', value: metrics.memory });
-    }
-    
-    return alerts;
-  }
-
-  /**
-   * Execute capability (placeholder)
-   */
-  private async executeCapability(capability: string, input: any): Promise<any> {
-    // TODO: Implement actual capability execution
-    return {
-      capability,
-      executed: true,
-      result: `Executed ${capability} capability`
-    };
-  }
-}

package/src/adk/agents/index.ts

@@ -1,158 +0,0 @@
-/**
- * ADK Agent Type Mappings for OSSA
- * Converts OSSA agent types to ADK categories
- */
-
-import { AgentManifest } from '../../types/index.js';
-
-export interface ADKAgentConfig {
-  name: string;
-  description?: string;
-  model?: string;
-  instruction: string;
-  tools?: any[];
-  output_key?: string;
-  sub_agents?: ADKAgent[];
-}
-
-export interface ADKAgent {
-  type: 'LlmAgent' | 'WorkflowAgent' | 'CustomAgent';
-  config: ADKAgentConfig;
-  ossaType?: string;
-}
-
-/**
- * Maps OSSA agent types to ADK categories
- */
-export class OSSAToADKMapper {
-  /**
-   * Convert OSSA agent manifest to ADK agent
-   */
-  static mapAgent(manifest: AgentManifest): ADKAgent {
-    const ossaType = manifest.spec.type;
-    
-    switch (ossaType) {
-      case 'worker':
-        return this.createLlmAgent(manifest);
-      
-      case 'orchestrator':
-        return this.createWorkflowAgent(manifest);
-      
-      case 'critic':
-      case 'monitor':
-        return this.createLlmAgent(manifest);
-      
-      case 'governor':
-        return this.createCustomAgent(manifest);
-      
-      default:
-        return this.createCustomAgent(manifest);
-    }
-  }
-
-  /**
-   * Create ADK LlmAgent from OSSA manifest
-   */
-  private static createLlmAgent(manifest: AgentManifest): ADKAgent {
-    return {
-      type: 'LlmAgent',
-      ossaType: manifest.spec.type,
-      config: {
-        name: manifest.metadata.name,
-        description: manifest.metadata.description,
-        model: manifest.spec.configuration?.model || 'gemini-2.0-flash',
-        instruction: this.generateInstruction(manifest),
-        tools: this.mapTools(manifest),
-        output_key: `${manifest.metadata.name}_output`
-      }
-    };
-  }
-
-  /**
-   * Create ADK WorkflowAgent from OSSA manifest
-   */
-  private static createWorkflowAgent(manifest: AgentManifest): ADKAgent {
-    return {
-      type: 'WorkflowAgent',
-      ossaType: manifest.spec.type,
-      config: {
-        name: manifest.metadata.name,
-        description: manifest.metadata.description,
-        instruction: this.generateWorkflowInstruction(manifest),
-        sub_agents: this.mapSubAgents(manifest),
-        output_key: `${manifest.metadata.name}_result`
-      }
-    };
-  }
-
-  /**
-   * Create ADK CustomAgent from OSSA manifest
-   */
-  private static createCustomAgent(manifest: AgentManifest): ADKAgent {
-    return {
-      type: 'CustomAgent',
-      ossaType: manifest.spec.type,
-      config: {
-        name: manifest.metadata.name,
-        description: manifest.metadata.description,
-        instruction: this.generateCustomInstruction(manifest),
-        tools: this.mapTools(manifest)
-      }
-    };
-  }
-
-  /**
-   * Generate instruction from OSSA capabilities
-   */
-  private static generateInstruction(manifest: AgentManifest): string {
-    const capabilities = manifest.spec.capabilities || [];
-    const description = manifest.metadata.description || '';
-    
-    return `${description}
-
-Capabilities: ${capabilities.join(', ')}
-
-Execute tasks related to your capabilities and return structured results.`;
-  }
-
-  /**
-   * Generate workflow instruction
-   */
-  private static generateWorkflowInstruction(manifest: AgentManifest): string {
-    return `Orchestrate workflow for ${manifest.metadata.name}.
-    
-Coordinate sub-agents to achieve the desired outcome.
-Ensure proper sequencing and state management.`;
-  }
-
-  /**
-   * Generate custom instruction
-   */
-  private static generateCustomInstruction(manifest: AgentManifest): string {
-    return `Custom agent: ${manifest.metadata.name}.
-    
-${manifest.metadata.description || ''}
-
-Specialized functionality as per OSSA specification.`;
-  }
-
-  /**
-   * Map OSSA tools to ADK tools
-   */
-  private static mapTools(manifest: AgentManifest): any[] {
-    // TODO: Implement tool mapping based on capabilities
-    return [];
-  }
-
-  /**
-   * Map sub-agents for orchestrators
-   */
-  private static mapSubAgents(manifest: AgentManifest): ADKAgent[] {
-    // TODO: Implement sub-agent mapping from dependencies
-    return [];
-  }
-}
-
-export * from './llm-agent.js';
-export * from './workflow-agent.js';
-export * from './custom-agent.js';