agentic-flow 1.0.0

package/dist/router/test-onnx-integration.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * ONNX Integration Test - Validates agentic-flow works with ONNX
+ *
+ * Tests ONNX provider integration with the multi-model router
+ */
+import { ModelRouter } from './router.js';
+async function testONNXIntegration() {
+    console.log('🧪 agentic-flow + ONNX Runtime Integration Test\n');
+    console.log('='.repeat(60));
+    console.log('Testing: Multi-Model Router with ONNX Local Inference');
+    console.log('='.repeat(60) + '\n');
+    try {
+        // Initialize router (ONNX-only mode)
+        console.log('Step 1: Router Initialization');
+        console.log('==============================');
+        const router = new ModelRouter();
+        const config = router.getConfig();
+        console.log(`✅ Router initialized successfully`);
+        console.log(`   Version: ${config.version}`);
+        console.log(`   Default Provider: ${config.defaultProvider}`);
+        console.log(`   Fallback Chain: ${config.fallbackChain?.join(' → ')}`);
+        console.log(`   Routing Mode: ${config.routing?.mode}`);
+        console.log(`   Providers Configured: ${Object.keys(config.providers).length}`);
+        console.log('');
+        // Test ONNX provider
+        console.log('Step 2: ONNX Provider Direct Test');
+        console.log('===================================');
+        // Get ONNX provider directly
+        const onnxProvider = router.providers.get('onnx');
+        if (!onnxProvider) {
+            throw new Error('ONNX provider not initialized');
+        }
+        console.log(`✅ ONNX provider found: ${onnxProvider.name}`);
+        console.log(`   Type: ${onnxProvider.type}`);
+        console.log(`   Supports Streaming: ${onnxProvider.supportsStreaming}`);
+        console.log(`   Supports Tools: ${onnxProvider.supportsTools}`);
+        console.log('');
+        // Test inference
+        console.log('Step 3: ONNX Inference Test');
+        console.log('=============================');
+        const response = await onnxProvider.chat({
+            model: 'phi-4',
+            messages: [
+                { role: 'user', content: 'What is 2+2?' }
+            ],
+            maxTokens: 20
+        });
+        console.log(`✅ Inference successful`);
+        console.log(`   Response: ${response.content[0].type === 'text' ? response.content[0].text : 'N/A'}`);
+        console.log(`   Model: ${response.model}`);
+        console.log(`   Latency: ${response.metadata?.latency}ms`);
+        console.log(`   Tokens/Sec: ${response.metadata?.tokensPerSecond}`);
+        console.log(`   Cost: $${response.metadata?.cost || 0}`);
+        console.log(`   Input Tokens: ${response.usage?.inputTokens}`);
+        console.log(`   Output Tokens: ${response.usage?.outputTokens}`);
+        console.log('');
+        // Test router configuration
+        console.log('Step 4: Router Configuration Validation');
+        console.log('=========================================');
+        const onnxConfig = config.providers.onnx;
+        console.log(`✅ ONNX Configuration:`);
+        console.log(`   Model Path: ${onnxConfig?.modelPath || 'default'}`);
+        console.log(`   Execution Providers: ${onnxConfig?.executionProviders?.join(', ')}`);
+        console.log(`   Max Tokens: ${onnxConfig?.maxTokens}`);
+        console.log(`   Temperature: ${onnxConfig?.temperature}`);
+        console.log(`   Local Inference: ${onnxConfig?.localInference}`);
+        console.log(`   GPU Acceleration: ${onnxConfig?.gpuAcceleration}`);
+        console.log('');
+        // Test routing rules
+        console.log('Step 5: Privacy Routing Rule Validation');
+        console.log('=========================================');
+        const privacyRule = config.routing?.rules?.find(r => r.condition.privacy === 'high' && r.action.provider === 'onnx');
+        if (privacyRule) {
+            console.log(`✅ Privacy routing rule configured:`);
+            console.log(`   Condition: privacy = high, localOnly = ${privacyRule.condition.localOnly}`);
+            console.log(`   Action: Route to ${privacyRule.action.provider}`);
+            console.log(`   Reason: ${privacyRule.reason}`);
+        }
+        else {
+            console.log(`⚠️  Privacy routing rule not found (optional)`);
+        }
+        console.log('');
+        // Architecture summary
+        console.log('\n' + '='.repeat(60));
+        console.log('✅ Integration Test Complete!');
+        console.log('='.repeat(60) + '\n');
+        console.log('Integration Confirmed:');
+        console.log('  ✓ agentic-flow multi-model router working');
+        console.log('  ✓ ONNX Runtime provider integrated');
+        console.log('  ✓ Local CPU inference operational');
+        console.log('  ✓ Configuration loaded successfully');
+        console.log('  ✓ Privacy routing rules configured');
+        console.log('');
+        console.log('Architecture Details:');
+        console.log('  • Router: ModelRouter class');
+        console.log('  • ONNX Provider: ONNXLocalProvider');
+        console.log('  • Model: Microsoft Phi-4-mini-instruct-onnx (INT4)');
+        console.log('  • Execution: CPU-only local inference');
+        console.log('  • KV Cache: 32-layer autoregressive generation');
+        console.log('  • Cost: $0.00 per request (100% free)');
+        console.log('');
+        console.log('Performance:');
+        console.log(`  • Latency: ${response.metadata?.latency}ms`);
+        console.log(`  • Throughput: ${response.metadata?.tokensPerSecond} tokens/sec`);
+        console.log(`  • Privacy: 100% local processing`);
+        console.log(`  • Cost: $0.00 (free inference)`);
+        console.log('');
+        console.log('Use Cases:');
+        console.log('  • Privacy-sensitive data processing');
+        console.log('  • GDPR/HIPAA compliant inference');
+        console.log('  • Offline operation (no internet)');
+        console.log('  • Zero-cost development/testing');
+        console.log('  • Medical/legal document analysis');
+        console.log('');
+    }
+    catch (error) {
+        console.error('\n❌ Integration Test Failed!');
+        console.error('==============================');
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run test
+testONNXIntegration().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/router/test-onnx-local.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * Test ONNX local inference with Phi-4 model
+ */
+import { ONNXLocalProvider } from './providers/onnx-local.js';
+async function testONNXLocal() {
+    console.log('🧪 Testing ONNX Local Inference (Phi-4 CPU)\n');
+    try {
+        const provider = new ONNXLocalProvider({
+            modelPath: './models/phi-4/cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx',
+            executionProviders: ['cpu'],
+            maxTokens: 50
+        });
+        console.log('Test: Simple Inference');
+        console.log('======================');
+        const response = await provider.chat({
+            model: 'phi-4',
+            messages: [
+                { role: 'user', content: 'What is 2+2?' }
+            ],
+            maxTokens: 20
+        });
+        console.log('\n📥 Response:');
+        console.log(`  Text: ${response.content[0].type === 'text' ? response.content[0].text : ''}`);
+        console.log(`  Latency: ${response.metadata?.latency}ms`);
+        console.log(`  Tokens: ${response.usage?.inputTokens} in / ${response.usage?.outputTokens} out`);
+        console.log(`  Cost: $${response.metadata?.cost}`);
+        console.log(`  Providers: ${response.metadata?.executionProviders?.join(', ')}`);
+        console.log('\n✅ Test passed!');
+        await provider.dispose();
+    }
+    catch (error) {
+        console.error('\n❌ Test failed:', error);
+        process.exit(1);
+    }
+}
+testONNXLocal();

package/dist/router/test-onnx.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * Test script for ONNX Runtime integration
+ * Tests CPU inference with Phi-3 model
+ */
+import { ONNXProvider } from './providers/onnx.js';
+async function testONNXProvider() {
+    console.log('🧪 Testing ONNX Runtime Provider\n');
+    try {
+        // Test 1: Initialize ONNX provider
+        console.log('Test 1: Provider Initialization');
+        console.log('================================');
+        const provider = new ONNXProvider({
+            modelId: 'Xenova/Phi-3-mini-4k-instruct',
+            maxTokens: 100,
+            temperature: 0.7
+        });
+        console.log(`✅ Provider initialized: ${provider.name}`);
+        console.log(`📊 Supports streaming: ${provider.supportsStreaming}`);
+        console.log(`🔧 Supports tools: ${provider.supportsTools}\n`);
+        // Test 2: Simple chat completion
+        console.log('Test 2: Chat Completion (CPU)');
+        console.log('==============================');
+        const chatParams = {
+            model: 'Xenova/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Say "Hello from ONNX Runtime!" and nothing else.'
+                }
+            ],
+            maxTokens: 50,
+            temperature: 0.5
+        };
+        console.log(`📤 Sending request...`);
+        console.log(`📝 Prompt: ${chatParams.messages[0].content}\n`);
+        const startTime = Date.now();
+        const response = await provider.chat(chatParams);
+        const latency = Date.now() - startTime;
+        console.log('📥 Response received:');
+        console.log(`  Provider: ${response.metadata?.provider}`);
+        console.log(`  Model: ${response.model}`);
+        console.log(`  Latency: ${latency}ms`);
+        console.log(`  Stop Reason: ${response.stopReason}`);
+        console.log(`  Usage: ${response.usage?.inputTokens} in / ${response.usage?.outputTokens} out`);
+        console.log(`  Cost: $${response.metadata?.cost?.toFixed(6) || 0} (FREE - Local inference)`);
+        console.log(`  Execution Providers: ${response.metadata?.executionProviders?.join(', ')}`);
+        console.log(`\n  Content:`);
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                console.log(`    ${block.text}`);
+            }
+        }
+        console.log('\n✅ Test 2 passed!\n');
+        // Test 3: Multi-turn conversation
+        console.log('Test 3: Multi-Turn Conversation');
+        console.log('================================');
+        const conversationParams = {
+            model: 'Xenova/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'What is 2+2?'
+                },
+                {
+                    role: 'assistant',
+                    content: '4'
+                },
+                {
+                    role: 'user',
+                    content: 'What about 2+3?'
+                }
+            ],
+            maxTokens: 50,
+            temperature: 0.3
+        };
+        console.log(`📤 Multi-turn conversation...`);
+        const convResponse = await provider.chat(conversationParams);
+        console.log('📥 Response:');
+        console.log(`  Content: ${convResponse.content[0].type === 'text' ? convResponse.content[0].text : 'N/A'}`);
+        console.log('\n✅ Test 3 passed!\n');
+        // Test 4: Model info
+        console.log('Test 4: Model Information');
+        console.log('=========================');
+        const modelInfo = provider.getModelInfo();
+        console.log(`📊 Model ID: ${modelInfo.modelId}`);
+        console.log(`🔧 Execution Providers: ${modelInfo.executionProviders.join(', ')}`);
+        console.log(`⚡ GPU Support: ${modelInfo.supportsGPU ? 'Yes' : 'No (CPU only)'}`);
+        console.log(`✓ Initialized: ${modelInfo.initialized}`);
+        console.log('\n✅ Test 4 passed!\n');
+        // Test 5: Performance benchmark
+        console.log('Test 5: Performance Benchmark');
+        console.log('=============================');
+        const benchmarkParams = {
+            model: 'Xenova/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Count from 1 to 5.'
+                }
+            ],
+            maxTokens: 50,
+            temperature: 0.5
+        };
+        const benchmarkRuns = 3;
+        const latencies = [];
+        for (let i = 0; i < benchmarkRuns; i++) {
+            const start = Date.now();
+            await provider.chat(benchmarkParams);
+            const duration = Date.now() - start;
+            latencies.push(duration);
+            console.log(`  Run ${i + 1}: ${duration}ms`);
+        }
+        const avgLatency = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+        const tokensPerSec = (50 / avgLatency) * 1000;
+        console.log(`\n📊 Benchmark Results:`);
+        console.log(`  Average Latency: ${avgLatency.toFixed(0)}ms`);
+        console.log(`  Tokens/Second: ${tokensPerSec.toFixed(1)}`);
+        console.log('\n✅ Test 5 passed!\n');
+        // Cleanup
+        await provider.dispose();
+        // Final summary
+        console.log('🎉 All ONNX Tests Passed!');
+        console.log('=========================');
+        console.log(`✅ Provider initialization working`);
+        console.log(`✅ CPU inference functional`);
+        console.log(`✅ Chat completion successful`);
+        console.log(`✅ Multi-turn conversations working`);
+        console.log(`✅ Performance: ${tokensPerSec.toFixed(1)} tokens/sec`);
+        console.log(`✅ Cost: $0.00 (100% free local inference)`);
+        console.log(`\n💡 Next Steps:`);
+        console.log(`  1. Integrate ONNX provider into router`);
+        console.log(`  2. Add GPU support (CUDA/DirectML)`);
+        console.log(`  3. Implement model caching`);
+        console.log(`  4. Add streaming support`);
+    }
+    catch (error) {
+        console.error('\n❌ Test Failed!');
+        console.error('===============');
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run tests
+testONNXProvider().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/router/test-openrouter.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+// Test script for OpenRouter integration
+import { ModelRouter } from './router.js';
+async function testOpenRouter() {
+    console.log('🧪 Testing OpenRouter Integration\n');
+    try {
+        // Initialize router
+        console.log('📦 Initializing router...');
+        const router = new ModelRouter();
+        const config = router.getConfig();
+        console.log(`✅ Router initialized with default provider: ${config.defaultProvider}\n`);
+        // Test 1: Simple chat completion
+        console.log('Test 1: Simple Chat Completion');
+        console.log('================================');
+        const chatParams = {
+            model: config.providers.anthropic?.models?.default || 'claude-3-5-sonnet-20241022',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Say "Hello from Multi-Model Router!" and nothing else.'
+                }
+            ],
+            temperature: 0.7,
+            maxTokens: 100
+        };
+        console.log(`📤 Sending request to model: ${chatParams.model}`);
+        console.log(`📝 Prompt: ${chatParams.messages[0].content}\n`);
+        const startTime = Date.now();
+        const response = await router.chat(chatParams);
+        const latency = Date.now() - startTime;
+        console.log('📥 Response received:');
+        console.log(`  Provider: ${response.metadata?.provider}`);
+        console.log(`  Model: ${response.model}`);
+        console.log(`  Latency: ${latency}ms`);
+        console.log(`  Stop Reason: ${response.stopReason}`);
+        console.log(`  Usage: ${response.usage?.inputTokens} in / ${response.usage?.outputTokens} out`);
+        console.log(`  Cost: $${response.metadata?.cost?.toFixed(6) || 0}`);
+        console.log(`\n  Content:`);
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                console.log(`    ${block.text}`);
+            }
+        }
+        console.log('\n✅ Test 1 passed!\n');
+        // Test 2: Different model via OpenRouter
+        console.log('Test 2: Alternative Model');
+        console.log('=========================');
+        const altParams = {
+            model: 'claude-3-5-haiku-20241022',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Respond with just the word "SUCCESS" if you can read this.'
+                }
+            ],
+            temperature: 0.5,
+            maxTokens: 50
+        };
+        console.log(`📤 Testing model: ${altParams.model}\n`);
+        const altResponse = await router.chat(altParams);
+        console.log('📥 Response:');
+        console.log(`  Model: ${altResponse.model}`);
+        console.log(`  Content: ${altResponse.content[0].type === 'text' ? altResponse.content[0].text : 'N/A'}`);
+        console.log('\n✅ Test 2 passed!\n');
+        // Test 3: Show metrics
+        console.log('Test 3: Router Metrics');
+        console.log('=====================');
+        const metrics = router.getMetrics();
+        console.log(`📊 Total Requests: ${metrics.totalRequests}`);
+        console.log(`💰 Total Cost: $${metrics.totalCost.toFixed(6)}`);
+        console.log(`📝 Total Tokens: ${metrics.totalTokens.input} in / ${metrics.totalTokens.output} out`);
+        console.log('\nProvider Breakdown:');
+        for (const [provider, stats] of Object.entries(metrics.providerBreakdown)) {
+            console.log(`  ${provider}:`);
+            console.log(`    Requests: ${stats.requests}`);
+            console.log(`    Cost: $${stats.cost.toFixed(6)}`);
+            console.log(`    Avg Latency: ${stats.avgLatency.toFixed(0)}ms`);
+        }
+        console.log('\n✅ Test 3 passed!\n');
+        // Test 4: Rule-based routing (if configured)
+        if (config.routing?.mode === 'rule-based') {
+            console.log('Test 4: Rule-Based Routing');
+            console.log('==========================');
+            const ruleParams = {
+                model: config.providers.anthropic?.models?.default || 'claude-3-5-sonnet-20241022',
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'This is a test for rule-based routing'
+                    }
+                ]
+            };
+            const ruleResponse = await router.chat(ruleParams, 'researcher');
+            console.log(`📥 Routed to: ${ruleResponse.metadata?.provider}`);
+            console.log(`📝 Response: ${ruleResponse.content[0].type === 'text' ? ruleResponse.content[0].text?.substring(0, 100) : 'N/A'}...`);
+            console.log('\n✅ Test 4 passed!\n');
+        }
+        // Final summary
+        console.log('🎉 All Tests Passed!');
+        console.log('===================');
+        console.log(`✅ OpenRouter integration working`);
+        console.log(`✅ Router configuration loaded`);
+        console.log(`✅ Chat completion successful`);
+        console.log(`✅ Metrics tracking functional`);
+        console.log(`\n📊 Final Metrics:`);
+        console.log(`  Total Requests: ${metrics.totalRequests}`);
+        console.log(`  Total Cost: $${metrics.totalCost.toFixed(6)}`);
+        console.log(`  Providers Used: ${Object.keys(metrics.providerBreakdown).join(', ')}`);
+    }
+    catch (error) {
+        console.error('\n❌ Test Failed!');
+        console.error('===============');
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run tests
+testOpenRouter().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/router/test-phi4.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * Test script for Phi-4 ONNX provider with HuggingFace API fallback
+ */
+import { ONNXPhi4Provider } from './providers/onnx-phi4.js';
+async function testPhi4Provider() {
+    console.log('🧪 Testing Phi-4 ONNX Provider (via HuggingFace API)\n');
+    try {
+        // Test 1: Initialize provider
+        console.log('Test 1: Provider Initialization');
+        console.log('================================');
+        const provider = new ONNXPhi4Provider({
+            modelId: 'microsoft/Phi-3-mini-4k-instruct',
+            huggingfaceApiKey: process.env.HUGGINGFACE_API_KEY
+        });
+        const info = provider.getModelInfo();
+        console.log(`✅ Provider initialized`);
+        console.log(`📊 Model: ${info.modelId}`);
+        console.log(`🔧 Mode: ${info.mode}`);
+        console.log(`⚡ Supports local: ${info.supportsLocalInference}\n`);
+        // Test 2: Simple chat completion
+        console.log('Test 2: Chat Completion');
+        console.log('=======================');
+        const chatParams = {
+            model: 'microsoft/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'What is 2+2? Answer in one sentence.'
+                }
+            ],
+            maxTokens: 50,
+            temperature: 0.3
+        };
+        console.log(`📤 Sending request...`);
+        console.log(`📝 Question: ${chatParams.messages[0].content}\n`);
+        const startTime = Date.now();
+        const response = await provider.chat(chatParams);
+        const latency = Date.now() - startTime;
+        console.log('📥 Response received:');
+        console.log(`  Provider: ${response.metadata?.provider}`);
+        console.log(`  Model: ${response.model}`);
+        console.log(`  Mode: ${response.metadata?.mode}`);
+        console.log(`  Latency: ${latency}ms`);
+        console.log(`  Usage: ${response.usage?.inputTokens} in / ${response.usage?.outputTokens} out`);
+        console.log(`  Cost: $${response.metadata?.cost?.toFixed(6) || 0}`);
+        console.log(`\n  Content:`);
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                console.log(`    ${block.text}`);
+            }
+        }
+        console.log('\n✅ Test 2 passed!\n');
+        // Test 3: Reasoning test
+        console.log('Test 3: Reasoning Test');
+        console.log('======================');
+        const reasoningParams = {
+            model: 'microsoft/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'If a train travels at 60mph for 2 hours, how far does it go?'
+                }
+            ],
+            maxTokens: 100,
+            temperature: 0.5
+        };
+        console.log(`📤 Testing reasoning...`);
+        const reasoningResponse = await provider.chat(reasoningParams);
+        console.log('📥 Response:');
+        console.log(`  ${reasoningResponse.content[0].type === 'text' ? reasoningResponse.content[0].text : 'N/A'}`);
+        console.log('\n✅ Test 3 passed!\n');
+        // Test 4: Model info
+        console.log('Test 4: Model Information');
+        console.log('=========================');
+        const modelInfo = provider.getModelInfo();
+        console.log(`📊 Model ID: ${modelInfo.modelId}`);
+        console.log(`🔧 Inference Mode: ${modelInfo.mode}`);
+        console.log(`📁 Model Path: ${modelInfo.modelPath}`);
+        console.log(`🔑 API Key: ${modelInfo.apiKey || 'Not set'}`);
+        console.log(`⚡ Local ONNX Ready: ${modelInfo.supportsLocalInference}`);
+        console.log('\n✅ Test 4 passed!\n');
+        // Test 5: Performance benchmark
+        console.log('Test 5: Performance Benchmark');
+        console.log('=============================');
+        const benchmarkParams = {
+            model: 'microsoft/Phi-3-mini-4k-instruct',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Count from 1 to 5.'
+                }
+            ],
+            maxTokens: 30,
+            temperature: 0.5
+        };
+        const benchmarkRuns = 3;
+        const latencies = [];
+        for (let i = 0; i < benchmarkRuns; i++) {
+            const start = Date.now();
+            await provider.chat(benchmarkParams);
+            const duration = Date.now() - start;
+            latencies.push(duration);
+            console.log(`  Run ${i + 1}: ${duration}ms`);
+        }
+        const avgLatency = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+        console.log(`\n📊 Benchmark Results:`);
+        console.log(`  Average Latency: ${avgLatency.toFixed(0)}ms`);
+        console.log(`  Min Latency: ${Math.min(...latencies)}ms`);
+        console.log(`  Max Latency: ${Math.max(...latencies)}ms`);
+        console.log('\n✅ Test 5 passed!\n');
+        // Final summary
+        console.log('🎉 All Phi-4 Tests Passed!');
+        console.log('==========================');
+        console.log(`✅ Provider initialization working`);
+        console.log(`✅ HuggingFace API inference functional`);
+        console.log(`✅ Chat completion successful`);
+        console.log(`✅ Reasoning capability verified`);
+        console.log(`✅ Performance: ${avgLatency.toFixed(0)}ms average`);
+        console.log(`\n💡 Next Steps:`);
+        console.log(`  1. Free up disk space (need 5GB)`);
+        console.log(`  2. Download model.onnx.data`);
+        console.log(`  3. Switch to local ONNX inference`);
+        console.log(`  4. Benchmark local vs API performance`);
+    }
+    catch (error) {
+        console.error('\n❌ Test Failed!');
+        console.error('===============');
+        console.error(error);
+        process.exit(1);
+    }
+}
+// Run tests
+testPhi4Provider().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/router/types.js

@@ -0,0 +1,2 @@
+// Core types for multi-model router
+export {};

package/dist/utils/agentLoader.js

@@ -0,0 +1,106 @@
+// Agent loader for .claude/agents integration
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { logger } from './logger.js';
+/**
+ * Parse agent markdown file with frontmatter
+ */
+function parseAgentFile(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // Check for frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!frontmatterMatch) {
+            logger.warn('Agent file missing frontmatter', { filePath });
+            return null;
+        }
+        const [, frontmatter, systemPrompt] = frontmatterMatch;
+        // Parse YAML-like frontmatter
+        const meta = {};
+        frontmatter.split('\n').forEach(line => {
+            const match = line.match(/^(\w+):\s*(.+)$/);
+            if (match) {
+                const [, key, value] = match;
+                // Remove quotes if present
+                const cleanValue = value.replace(/^["']|["']$/g, '');
+                if (key === 'tools') {
+                    meta[key] = cleanValue.split(',').map(t => t.trim());
+                }
+                else {
+                    meta[key] = cleanValue;
+                }
+            }
+        });
+        if (!meta.name || !meta.description) {
+            logger.warn('Agent file missing required metadata', { filePath });
+            return null;
+        }
+        return {
+            name: meta.name,
+            description: meta.description,
+            systemPrompt: systemPrompt.trim(),
+            color: meta.color,
+            tools: meta.tools,
+            filePath
+        };
+    }
+    catch (error) {
+        logger.error('Failed to parse agent file', { filePath, error });
+        return null;
+    }
+}
+/**
+ * Recursively find all agent definition files
+ */
+function findAgentFiles(dir) {
+    const files = [];
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                files.push(...findAgentFiles(fullPath));
+            }
+            else if (extname(entry) === '.md' && entry !== 'README.md') {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to read directory', { dir, error });
+    }
+    return files;
+}
+/**
+ * Load all agents from .claude/agents directory
+ */
+export function loadAgents(agentsDir = process.env.AGENTS_DIR || '/app/.claude/agents') {
+    const agents = new Map();
+    logger.info('Loading agents from directory', { agentsDir });
+    const agentFiles = findAgentFiles(agentsDir);
+    logger.debug('Found agent files', { count: agentFiles.length });
+    for (const filePath of agentFiles) {
+        const agent = parseAgentFile(filePath);
+        if (agent) {
+            agents.set(agent.name, agent);
+            logger.debug('Loaded agent', { name: agent.name, description: agent.description.substring(0, 100) });
+        }
+    }
+    logger.info('Agents loaded successfully', { count: agents.size });
+    return agents;
+}
+/**
+ * Get a specific agent by name
+ */
+export function getAgent(name, agentsDir) {
+    const agents = loadAgents(agentsDir);
+    return agents.get(name);
+}
+/**
+ * List all available agents
+ */
+export function listAgents(agentsDir) {
+    const agents = loadAgents(agentsDir);
+    return Array.from(agents.values());
+}