import { OdinProtocol, ODIN_DEFAULT_CONFIG } from '@odin-protocol/core';

// Initialize ODIN Protocol
const odin = new OdinProtocol({
  nodeId: 'my-ai-agent',
  networkEndpoint: 'ws://localhost:8080',
  maxConnections: 100,
  ...ODIN_DEFAULT_CONFIG
});

// Initialize connection
await odin.initialize();

// Send a message to another AI
const response = await odin.sendMessage('target-ai-agent', {
  type: 'coordination',
  data: { task: 'process_data', priority: 'high' }
});

console.log('Response:', response);

// Listen for incoming messages
odin.onMessage('coordination', async (header, payload) => {
  console.log('Received coordination request:', payload.content);
  
  // Process and respond
  return { status: 'accepted', result: 'processing...' };
});

// Monitor performance
odin.on('performance', (metrics) => {
  console.log(`Throughput: ${metrics.messagesPerSecond} msgs/sec`);
  console.log(`Success Rate: ${metrics.successRate}%`);
});

import { HELRuleEngine, HELOperator, HELActionType, HELRuleStatus } from '@odin-protocol/core';

// Initialize HEL Rule Engine
const helEngine = new HELRuleEngine({ maxHistorySize: 1000 });

// Add a coordination rule
helEngine.addRule({
  id: 'high-priority-rule',
  name: 'High Priority Message Handler',
  conditions: [
    {
      field: 'priority',
      operator: HELOperator.EQUALS,
      value: 'high'
    },
    {
      field: 'sender.trust_score',
      operator: HELOperator.GREATER_THAN,
      value: 0.8
    }
  ],
  actions: [
    {
      type: HELActionType.LOG,
      parameters: { message: 'High priority message received' }
    },
    {
      type: HELActionType.EMIT_EVENT,
      parameters: { eventType: 'priority_alert', priority: 'high' }
    }
  ],
  status: HELRuleStatus.ACTIVE
});

// Evaluate rules against context
const context = {
  data: {
    priority: 'high',
    sender: { trust_score: 0.9 },
    message: 'Urgent coordination required'
  }
};

const results = await helEngine.evaluateRules(context);
console.log('Rule evaluation results:', results);

import { OdinProtocol, HELRuleEngine } from '@odin-protocol/core';

class AICoordinator {
  private odin: OdinProtocol;
  private helEngine: HELRuleEngine;

  constructor() {
    this.odin = new OdinProtocol({
      nodeId: 'coordinator-ai',
      networkEndpoint: process.env.ODIN_ENDPOINT!,
      maxConnections: 200,
      performanceMonitoring: true
    });

    this.helEngine = new HELRuleEngine();
    this.setupIntegration();
  }

  private setupIntegration() {
    // Route ODIN messages through HEL rules
    this.odin.onMessage('*', async (header, payload) => {
      const context = {
        data: {
          messageType: header.type,
          source: header.source,
          content: payload.content,
          timestamp: header.timestamp
        }
      };

      // Evaluate coordination rules
      const ruleResults = await this.helEngine.evaluateRules(context);
      
      // Handle rule-based responses
      for (const result of ruleResults) {
        if (result.fired) {
          console.log(`Rule ${result.ruleName} triggered for message from ${header.source}`);
        }
      }

      return { status: 'processed', ruleResults: ruleResults.length };
    });

    // Monitor performance
    setInterval(() => {
      const metrics = this.odin.getPerformanceMetrics();
      const stats = this.helEngine.getStatistics();
      
      console.log(`ODIN: ${metrics.messagesPerSecond} msgs/sec, ${metrics.successRate}% success`);
      console.log(`HEL: ${stats.activeRules} active rules, ${stats.totalEvaluations} evaluations`);
    }, 10000);
  }

  async start() {
    await this.odin.initialize();
    console.log('AI Coordinator started successfully!');
  }
}

// Usage
const coordinator = new AICoordinator();
await coordinator.start();

new OdinProtocol(config: OdinConfig)

new HELRuleEngine(options?: { maxHistorySize?: number })

interface OdinConfig {
  nodeId: string;                    // Unique node identifier
  networkEndpoint: string;           // WebSocket endpoint
  token?: string;                    // Authentication token
  timeout?: number;                  // Connection timeout (ms)
  maxConnections: number;            // Max concurrent connections
  heartbeatInterval?: number;        // Heartbeat interval (ms)
  debug?: boolean;                   // Enable debug logging
  maxRetries?: number;               // Max retry attempts
  performanceMonitoring?: boolean;   // Enable metrics
}

interface HELEngineConfig {
  maxParallelRules?: number;         // Max rules to evaluate in parallel
  defaultTimeout?: number;           // Default rule timeout (ms)
  enableCaching?: boolean;           // Enable rule result caching
  cacheTTL?: number;                 // Cache TTL (ms)
  performanceMonitoring?: boolean;   // Enable performance monitoring
  maxHistorySize?: number;           // Max evaluation history size
}

import { OdinProtocol } from '@odin-protocol/core';
import { useEffect, useState } from 'react';

function useOdinProtocol(config: OdinConfig) {
  const [odin, setOdin] = useState<OdinProtocol | null>(null);
  const [connected, setConnected] = useState(false);

  useEffect(() => {
    const protocol = new OdinProtocol(config);
    
    protocol.on('ready', () => setConnected(true));
    protocol.on('disconnected', () => setConnected(false));
    
    protocol.initialize();
    setOdin(protocol);

    return () => {
      protocol.disconnect();
    };
  }, []);

  return { odin, connected };
}

import { ref, onMounted, onUnmounted } from 'vue';
import { OdinProtocol } from '@odin-protocol/core';

export function useOdin(config: OdinConfig) {
  const odin = ref<OdinProtocol | null>(null);
  const connected = ref(false);

  onMounted(async () => {
    const protocol = new OdinProtocol(config);
    
    protocol.on('ready', () => connected.value = true);
    protocol.on('disconnected', () => connected.value = false);
    
    await protocol.initialize();
    odin.value = protocol;
  });

  onUnmounted(() => {
    odin.value?.disconnect();
  });

  return { odin, connected };
}