add code

lib/agent-wrapper.ts

@@ -0,0 +1,203 @@
+import { Agent, StreamedRunResult } from '@openai/agents';
+import HierarchyGenerator, { GenerationParams } from './components/hierarchy-generator';
+import TemplateManager, { DomainTemplate } from './components/template-manager';
+import OutputFormatter, { OutputOptions, FormattedOutput } from './components/output-formatter';
+
+export interface AgentConfig {
+  name: string;
+  instructions: string;
+  model?: string;
+}
+
+export interface HierarchyGenerationOptions extends GenerationParams {
+  outputFormat?: OutputOptions;
+  templateKey?: string;
+  stream?: boolean;
+}
+
+export class HierarchyAgent {
+  private agent: Agent;
+  private generator: HierarchyGenerator;
+  private templateManager: TemplateManager;
+  private outputFormatter: OutputFormatter;
+
+  constructor(config: AgentConfig) {
+    this.agent = new Agent({
+      name: config.name,
+      instructions: config.instructions,
+      model: config.model || 'gpt-4o-mini'
+    });
+
+    this.generator = new HierarchyGenerator(this.agent);
+    this.templateManager = new TemplateManager();
+    this.outputFormatter = new OutputFormatter();
+  }
+
+  async generateHierarchy(options: HierarchyGenerationOptions): Promise<FormattedOutput | StreamedRunResult> {
+    let template: DomainTemplate;
+
+    if (options.templateKey) {
+      template = this.templateManager.getTemplate(options.templateKey);
+      if (!template) {
+        throw new Error(`Template not found: ${options.templateKey}`);
+      }
+    } else {
+      // Create a default template for the domain
+      const version = options.version || 'v2';
+      template = this.templateManager.createCustomTemplate(
+        `${options.domain}-${version}`,
+        options.domain,
+        version
+      );
+    }
+
+    const generationParams: GenerationParams = {
+      domain: options.domain,
+      complexity: options.complexity || 'medium',
+      includeSkills: options.includeSkills ?? true,
+      includeTools: options.includeTools ?? true,
+      includeExamples: options.includeExamples ?? true,
+      stream: options.stream
+    };
+
+    const content = await this.generator.generateFromTemplate(template, generationParams);
+
+    // If streaming, return the stream directly
+    if (options.stream && content instanceof Object && 'toStream' in content) {
+      return content as StreamedRunResult;
+    }
+
+    const outputOptions = options.outputFormat || this.outputFormatter.getDefaultOptions();
+    const formattedOutput = this.outputFormatter.formatOutput(
+      content as string,
+      options.domain,
+      template.version,
+      outputOptions
+    );
+
+    return formattedOutput;
+  }
+
+  // New method for streaming with enhanced visibility
+  async generateHierarchyWithStreaming(
+    options: HierarchyGenerationOptions,
+    onStreamEvent?: (event: any) => void
+  ): Promise<FormattedOutput> {
+    let template: DomainTemplate;
+
+    if (options.templateKey) {
+      template = this.templateManager.getTemplate(options.templateKey);
+      if (!template) {
+        throw new Error(`Template not found: ${options.templateKey}`);
+      }
+    } else {
+      // Create a default template for the domain
+      const version = options.version || 'v2';
+      template = this.templateManager.createCustomTemplate(
+        `${options.domain}-${version}`,
+        options.domain,
+        version
+      );
+    }
+
+    const generationParams: GenerationParams = {
+      domain: options.domain,
+      complexity: options.complexity || 'medium',
+      includeSkills: options.includeSkills ?? true,
+      includeTools: options.includeTools ?? true,
+      includeExamples: options.includeExamples ?? true
+    };
+
+    const content = await this.generator.generateFromTemplateWithStreaming(
+      template, 
+      generationParams, 
+      onStreamEvent
+    );
+
+    // Format the output
+    const outputOptions = options.outputFormat || this.outputFormatter.getDefaultOptions();
+    const formattedOutput = this.outputFormatter.formatOutput(
+      content,
+      options.domain,
+      template.version,
+      outputOptions
+    );
+
+    return formattedOutput;
+  }
+
+  async generateExample(
+    domain: string, 
+    version: 'v1' | 'v2' = 'v2',
+    complexity: 'simple' | 'medium' | 'complex' = 'medium'
+  ): Promise<FormattedOutput> {
+    return this.generateHierarchy({
+      domain,
+      version,
+      complexity,
+      includeSkills: true,
+      includeTools: true,
+      includeExamples: true
+    });
+  }
+
+  // Template management methods
+  getAvailableTemplates(): DomainTemplate[] {
+    return this.templateManager.getAllTemplates();
+  }
+
+  getTemplatesByDomain(domain: string): DomainTemplate[] {
+    return this.templateManager.getTemplatesByDomain(domain);
+  }
+
+  getTemplatesByVersion(version: 'v1' | 'v2'): DomainTemplate[] {
+    return this.templateManager.getTemplatesByVersion(version);
+  }
+
+  addCustomTemplate(key: string, template: DomainTemplate): void {
+    this.templateManager.addTemplate(key, template);
+  }
+
+  // Validation and optimization methods
+  async validateHierarchy(hierarchyData: any): Promise<boolean> {
+    // TODO: Implement validation logic using the agent
+    // Could validate structure, naming conventions, completeness, etc.
+    return true;
+  }
+
+  async optimizeHierarchy(hierarchyData: any): Promise<any> {
+    // TODO: Implement optimization logic using the agent
+    // Could suggest improvements, fill gaps, optimize structure, etc.
+    return hierarchyData;
+  }
+
+  // Batch generation methods
+  async generateMultipleExamples(
+    domains: string[],
+    version: 'v1' | 'v2' = 'v2',
+    outputFormat?: OutputOptions
+  ): Promise<FormattedOutput[]> {
+    const results: FormattedOutput[] = [];
+
+    for (const domain of domains) {
+      try {
+        const result = await this.generateHierarchy({
+          domain,
+          version,
+          complexity: 'medium',
+          includeSkills: true,
+          includeTools: true,
+          includeExamples: true,
+          outputFormat
+        });
+        results.push(result);
+      } catch (error) {
+        console.error(`Error generating example for ${domain}:`, error);
+      }
+    }
+
+    return results;
+  }
+}
+
+export default HierarchyAgent;