operations.ts

/**
 * universal-symbolics
 * 
 * A unified runtime layer for symbolic operations across all frontier LLMs.
 * This implementation provides developer-friendly abstractions over vendor-specific
 * symbolic grammars (XML tags, slash commands, function calls, etc.)
 */

// Core types for universal symbolic operations
export type SymbolicOperation = 
  | ThinkOperation
  | ReflectOperation
  | ForkOperation
  | CollapseOperation
  | AttentionOperation
  | ToolOperation
  | SystemOperation;

// Symbolic operation interfaces
export interface ThinkOperation {
  type: 'think';
  content?: string;
  trace?: boolean;
  depth?: number;
}

export interface ReflectOperation {
  type: 'reflect';
  target: string;
  depth?: number;
}

export interface ForkOperation {
  type: 'fork';
  paths: string[];
  weights?: number[];
}

export interface CollapseOperation {
  type: 'collapse';
  trigger?: string;
  threshold?: number;
}

export interface AttentionOperation {
  type: 'attention';
  focus: string;
  weight?: number;
}

export interface ToolOperation {
  type: 'tool';
  name: string;
  params?: Record<string, any>;
}

export interface SystemOperation {
  type: 'system';
  directive: string;
}

// Vendor-specific symbolic runtime implementations
export type ModelVendor = 'claude' | 'openai' | 'qwen' | 'gemini' | 'deepseek' | 'local';

/**
 * Universal Symbolics Client
 * Provides a unified interface for symbolic operations across different model vendors
 */
export class UniversalSymbolics {
  private vendor: ModelVendor;
  private adapter: SymbolicAdapter;
  private telemetry: SymbolicTelemetry;
  
  constructor(options: {
    vendor?: ModelVendor;
    apiKey?: string;
    endpoint?: string;
    enableTelemetry?: boolean;
  }) {
    this.vendor = options.vendor || 'claude';
    this.adapter = SymbolicAdapterFactory.create(this.vendor, {
      apiKey: options.apiKey,
      endpoint: options.endpoint
    });
    this.telemetry = new SymbolicTelemetry({
      enabled: options.enableTelemetry || false
    });
  }
  
  /**
   * Execute a thinking operation
   * @param content Optional thinking content
   */
  async think(content?: string): Promise<ThinkResult> {
    const operation: ThinkOperation = {
      type: 'think',
      content,
      trace: true
    };
    
    this.telemetry.trackOperation('think', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<ThinkResult>;
  }
  
  /**
   * Execute a reflection operation
   * @param target What to reflect on
   * @param depth Optional reflection depth
   */
  async reflect(target: string, depth?: number): Promise<ReflectResult> {
    const operation: ReflectOperation = {
      type: 'reflect',
      target,
      depth
    };
    
    this.telemetry.trackOperation('reflect', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<ReflectResult>;
  }
  
  /**
   * Execute a forking operation
   * @param paths Different paths to explore
   * @param weights Optional weights for each path
   */
  async fork(paths: string[], weights?: number[]): Promise<ForkResult> {
    const operation: ForkOperation = {
      type: 'fork',
      paths,
      weights
    };
    
    this.telemetry.trackOperation('fork', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<ForkResult>;
  }
  
  /**
   * Execute a collapse operation
   * @param trigger Optional collapse trigger
   * @param threshold Optional collapse threshold
   */
  async collapse(trigger?: string, threshold?: number): Promise<CollapseResult> {
    const operation: CollapseOperation = {
      type: 'collapse',
      trigger,
      threshold
    };
    
    this.telemetry.trackOperation('collapse', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<CollapseResult>;
  }
  
  /**
   * Execute an attention operation
   * @param focus What to focus attention on
   * @param weight Optional attention weight
   */
  async attention(focus: string, weight?: number): Promise<AttentionResult> {
    const operation: AttentionOperation = {
      type: 'attention',
      focus,
      weight
    };
    
    this.telemetry.trackOperation('attention', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<AttentionResult>;
  }
  
  /**
   * Execute a tool operation
   * @param name Tool name
   * @param params Optional tool parameters
   */
  async tool(name: string, params?: Record<string, any>): Promise<ToolResult> {
    const operation: ToolOperation = {
      type: 'tool',
      name,
      params
    };
    
    this.telemetry.trackOperation('tool', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<ToolResult>;
  }
  
  /**
   * Execute a system operation
   * @param directive System directive
   */
  async system(directive: string): Promise<SystemResult> {
    const operation: SystemOperation = {
      type: 'system',
      directive
    };
    
    this.telemetry.trackOperation('system', this.vendor);
    return this.adapter.executeOperation(operation) as Promise<SystemResult>;
  }
  
  /**
   * Change the vendor for subsequent operations
   * @param vendor New vendor
   */
  setVendor(vendor: ModelVendor) {
    this.vendor = vendor;
    this.adapter = SymbolicAdapterFactory.create(this.vendor, {
      apiKey: this.adapter.getApiKey(),
      endpoint: this.adapter.getEndpoint()
    });
  }
  
  /**
   * Get telemetry data
   */
  getTelemetry() {
    return this.telemetry.getData();
  }
}

/**
 * Factory for creating vendor-specific symbolic adapters
 */
class SymbolicAdapterFactory {
  static create(vendor: ModelVendor, options: { apiKey?: string; endpoint?: string }): SymbolicAdapter {
    switch (vendor) {
      case 'claude':
        return new ClaudeSymbolicAdapter(options);
      case 'openai':
        return new OpenAISymbolicAdapter(options);
      case 'qwen':
        return new QwenSymbolicAdapter(options);
      case 'gemini':
        return new GeminiSymbolicAdapter(options);
      case 'deepseek':
        return new DeepSeekSymbolicAdapter(options);
      case 'local':
        return new LocalSymbolicAdapter(options);
      default:
        throw new Error(`Unsupported vendor: ${vendor}`);
    }
  }
}

/**
 * Abstract base class for vendor-