@bluefly/openstandardagents 0.1.9

package/src/adk/adapters/index.ts

@@ -0,0 +1,310 @@
+/**
+ * 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

@@ -0,0 +1,206 @@
+/**
+ * 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

@@ -0,0 +1,158 @@
+/**
+ * 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';