claude-flow-novice 1.0.0

package/dist/src/services/agentic-flow-hooks/llm-hooks.js

@@ -0,0 +1,445 @@
+/**
+ * LLM-specific hooks for agentic-flow integration
+ *
+ * Provides pre/post operation hooks for all LLM calls with
+ * memory persistence and performance optimization.
+ */ import { agenticHookManager } from './hook-manager.js';
+// ===== Pre-LLM Call Hook =====
+export const preLLMCallHook = {
+    id: 'agentic-pre-llm-call',
+    type: 'pre-llm-call',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { provider, model, operation: operation1, request } = payload;
+        // Check memory for similar requests
+        const cacheKey = generateCacheKey(provider, model, request);
+        const cached = await checkMemoryCache(cacheKey, context);
+        if (cached) {
+            return {
+                continue: false,
+                modified: true,
+                payload: {
+                    ...payload,
+                    response: cached.response,
+                    metrics: {
+                        ...cached.metrics,
+                        cacheHit: true
+                    }
+                },
+                sideEffects: [
+                    {
+                        type: 'metric',
+                        action: 'increment',
+                        data: {
+                            name: 'llm.cache.hits'
+                        }
+                    }
+                ]
+            };
+        }
+        // Load provider-specific optimizations
+        const optimizations = await loadProviderOptimizations(provider, context);
+        // Apply request optimizations
+        const optimizedRequest = applyRequestOptimizations(request, optimizations, context);
+        // Track pre-call metrics
+        const sideEffects = [
+            {
+                type: 'metric',
+                action: 'increment',
+                data: {
+                    name: `llm.calls.${provider}.${model}`
+                }
+            },
+            {
+                type: 'memory',
+                action: 'store',
+                data: {
+                    key: `llm:request:${context.correlationId}`,
+                    value: {
+                        provider,
+                        model,
+                        operation: operation1,
+                        request: optimizedRequest,
+                        timestamp: Date.now()
+                    },
+                    ttl: 3600
+                }
+            }
+        ];
+        return {
+            continue: true,
+            modified: true,
+            payload: {
+                ...payload,
+                request: optimizedRequest
+            },
+            sideEffects
+        };
+    }
+};
+// ===== Post-LLM Call Hook =====
+export const postLLMCallHook = {
+    id: 'agentic-post-llm-call',
+    type: 'post-llm-call',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { provider, model, request, response, metrics } = payload;
+        if (!response || !metrics) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Store response in memory for caching
+        const cacheKey = generateCacheKey(provider, model, request);
+        sideEffects.push({
+            type: 'memory',
+            action: 'store',
+            data: {
+                key: `llm:cache:${cacheKey}`,
+                value: {
+                    response,
+                    metrics,
+                    timestamp: Date.now()
+                },
+                ttl: determineCacheTTL(operation, response)
+            }
+        });
+        // Extract patterns for neural training
+        const patterns = extractResponsePatterns(request, response, metrics);
+        if (patterns.length > 0) {
+            sideEffects.push({
+                type: 'neural',
+                action: 'train',
+                data: {
+                    patterns,
+                    modelId: `llm-optimizer-${provider}`
+                }
+            });
+        }
+        // Update performance metrics
+        sideEffects.push({
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: `llm.latency.${provider}.${model}`,
+                value: metrics.latency
+            }
+        }, {
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: `llm.tokens.${provider}.${model}`,
+                value: response.usage.totalTokens
+            }
+        }, {
+            type: 'metric',
+            action: 'update',
+            data: {
+                name: `llm.cost.${provider}.${model}`,
+                value: metrics.costEstimate
+            }
+        });
+        // Check for performance issues
+        if (metrics.latency > getLatencyThreshold(provider, model)) {
+            sideEffects.push({
+                type: 'notification',
+                action: 'send',
+                data: {
+                    level: 'warning',
+                    message: `High latency detected for ${provider}/${model}: ${metrics.latency}ms`
+                }
+            });
+        }
+        // Store provider health score
+        await updateProviderHealth(provider, metrics.providerHealth, context);
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== LLM Error Hook =====
+export const llmErrorHook = {
+    id: 'agentic-llm-error',
+    type: 'llm-error',
+    priority: 100,
+    handler: async (payload, context)=>{
+        const { provider, model, error } = payload;
+        if (!error) {
+            return {
+                continue: true
+            };
+        }
+        const sideEffects = [];
+        // Log error details
+        sideEffects.push({
+            type: 'log',
+            action: 'write',
+            data: {
+                level: 'error',
+                message: `LLM error from ${provider}/${model}`,
+                data: {
+                    error: error.message,
+                    stack: error.stack,
+                    request: payload.request
+                }
+            }
+        });
+        // Update error metrics
+        sideEffects.push({
+            type: 'metric',
+            action: 'increment',
+            data: {
+                name: `llm.errors.${provider}.${model}`
+            }
+        });
+        // Check if we should fallback
+        const fallbackProvider = await selectFallbackProvider(provider, model, error, context);
+        if (fallbackProvider) {
+            return {
+                continue: false,
+                modified: true,
+                payload: {
+                    ...payload,
+                    provider: fallbackProvider.provider,
+                    model: fallbackProvider.model,
+                    error: undefined
+                },
+                sideEffects: [
+                    ...sideEffects,
+                    {
+                        type: 'notification',
+                        action: 'send',
+                        data: {
+                            level: 'info',
+                            message: `Falling back from ${provider}/${model} to ${fallbackProvider.provider}/${fallbackProvider.model}`
+                        }
+                    }
+                ]
+            };
+        }
+        return {
+            continue: true,
+            sideEffects
+        };
+    }
+};
+// ===== LLM Retry Hook =====
+export const llmRetryHook = {
+    id: 'agentic-llm-retry',
+    type: 'llm-retry',
+    priority: 90,
+    handler: async (payload, context)=>{
+        const { provider, model, metrics } = payload;
+        const retryCount = metrics?.retryCount || 0;
+        // Adjust request parameters for retry
+        const adjustedRequest = adjustRequestForRetry(payload.request, retryCount);
+        const sideEffects = [
+            {
+                type: 'metric',
+                action: 'increment',
+                data: {
+                    name: `llm.retries.${provider}.${model}`
+                }
+            }
+        ];
+        // Apply exponential backoff
+        const backoffMs = Math.min(1000 * Math.pow(2, retryCount), 10000);
+        await new Promise((resolve)=>setTimeout(resolve, backoffMs));
+        return {
+            continue: true,
+            modified: true,
+            payload: {
+                ...payload,
+                request: adjustedRequest,
+                metrics: {
+                    ...metrics,
+                    retryCount: retryCount + 1
+                }
+            },
+            sideEffects
+        };
+    }
+};
+// ===== Helper Functions =====
+function generateCacheKey(provider, model, request) {
+    const normalized = {
+        provider,
+        model,
+        messages: request.messages?.map((m)=>({
+                role: m.role,
+                content: m.content.substring(0, 100)
+            })),
+        temperature: request.temperature,
+        maxTokens: request.maxTokens
+    };
+    return Buffer.from(JSON.stringify(normalized)).toString('base64');
+}
+async function checkMemoryCache(cacheKey, context) {
+    // Implementation would integrate with memory service
+    // This is a placeholder
+    return null;
+}
+async function loadProviderOptimizations(provider, context) {
+    // Load provider-specific optimizations from memory
+    // This is a placeholder
+    return {
+        maxRetries: 3,
+        timeout: 30000,
+        rateLimit: 100
+    };
+}
+function applyRequestOptimizations(request, optimizations, context) {
+    // Apply various optimizations
+    const optimized = {
+        ...request
+    };
+    // Optimize token usage
+    if (optimized.maxTokens && optimized.maxTokens > 4000) {
+        optimized.maxTokens = 4000; // Cap at reasonable limit
+    }
+    // Optimize temperature for consistency
+    if (optimized.temperature === undefined) {
+        optimized.temperature = 0.7;
+    }
+    // Add stop sequences if missing
+    if (!optimized.stopSequences && optimized.messages) {
+        optimized.stopSequences = [
+            '\n\nHuman:',
+            '\n\nAssistant:'
+        ];
+    }
+    return optimized;
+}
+function determineCacheTTL(operation1, response) {
+    // Determine cache TTL based on operation and response
+    switch(operation1){
+        case 'embedding':
+            return 86400; // 24 hours for embeddings
+        case 'completion':
+            // Shorter TTL for completions
+            return response?.usage?.totalTokens && response.usage.totalTokens > 1000 ? 1800 // 30 minutes for long responses
+             : 3600; // 1 hour for short responses
+        default:
+            return 3600; // 1 hour default
+    }
+}
+function extractResponsePatterns(request, response, metrics) {
+    const patterns = [];
+    // Extract performance patterns
+    if (metrics.latency > 1000) {
+        patterns.push({
+            id: `perf_${Date.now()}`,
+            type: 'optimization',
+            confidence: 0.8,
+            occurrences: 1,
+            context: {
+                provider: metrics.providerHealth < 0.8 ? 'unhealthy' : 'healthy',
+                requestSize: JSON.stringify(request).length,
+                responseTokens: response?.usage?.totalTokens || 0,
+                latency: metrics.latency
+            }
+        });
+    }
+    // Extract success patterns
+    if (response?.choices?.[0]?.finishReason === 'stop') {
+        patterns.push({
+            id: `success_${Date.now()}`,
+            type: 'success',
+            confidence: 0.9,
+            occurrences: 1,
+            context: {
+                temperature: request.temperature,
+                maxTokens: request.maxTokens,
+                actualTokens: response.usage?.totalTokens || 0
+            }
+        });
+    }
+    return patterns;
+}
+function getLatencyThreshold(provider, model) {
+    // Provider/model specific thresholds
+    const thresholds = {
+        'openai:gpt-4': 5000,
+        'openai:gpt-3.5-turbo': 2000,
+        'anthropic:claude-3': 4000,
+        'anthropic:claude-instant': 1500
+    };
+    return thresholds[`${provider}:${model}`] || 3000;
+}
+async function updateProviderHealth(provider, health, context) {
+    // Update provider health in memory
+    const healthKey = `provider:health:${provider}`;
+    const currentHealth = await context.memory.cache.get(healthKey) || [];
+    currentHealth.push({
+        timestamp: Date.now(),
+        health
+    });
+    // Keep last 100 health checks
+    if (currentHealth.length > 100) {
+        currentHealth.shift();
+    }
+    await context.memory.cache.set(healthKey, currentHealth);
+}
+async function selectFallbackProvider(provider, model, error, context) {
+    // Implement intelligent fallback selection
+    const fallbacks = {
+        openai: [
+            {
+                provider: 'anthropic',
+                model: 'claude-3'
+            },
+            {
+                provider: 'cohere',
+                model: 'command'
+            }
+        ],
+        anthropic: [
+            {
+                provider: 'openai',
+                model: 'gpt-4'
+            },
+            {
+                provider: 'cohere',
+                model: 'command'
+            }
+        ]
+    };
+    const candidates = fallbacks[provider] || [];
+    // Select based on health scores
+    for (const candidate of candidates){
+        const healthKey = `provider:health:${candidate.provider}`;
+        const healthData = await context.memory.cache.get(healthKey) || [];
+        if (healthData.length > 0) {
+            const avgHealth = healthData.reduce((sum, h)=>sum + h.health, 0) / healthData.length;
+            if (avgHealth > 0.7) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function adjustRequestForRetry(request, retryCount) {
+    const adjusted = {
+        ...request
+    };
+    // Increase temperature slightly for variety
+    if (adjusted.temperature !== undefined) {
+        adjusted.temperature = Math.min(adjusted.temperature + 0.1 * retryCount, 1.0);
+    }
+    // Reduce max tokens to improve success rate
+    if (adjusted.maxTokens !== undefined) {
+        adjusted.maxTokens = Math.floor(adjusted.maxTokens * Math.pow(0.9, retryCount));
+    }
+    return adjusted;
+}
+// ===== Register Hooks =====
+export function registerLLMHooks() {
+    agenticHookManager.register(preLLMCallHook);
+    agenticHookManager.register(postLLMCallHook);
+    agenticHookManager.register(llmErrorHook);
+    agenticHookManager.register(llmRetryHook);
+}
+
+//# sourceMappingURL=llm-hooks.js.map

package/dist/src/services/agentic-flow-hooks/llm-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/agentic-flow-hooks/llm-hooks.ts"],"names":["agenticHookManager","preLLMCallHook","id","type","priority","handler","payload","context","provider","model","operation","request","cacheKey","generateCacheKey","cached","checkMemoryCache","continue","modified","response","metrics","cacheHit","sideEffects","action","data","name","optimizations","loadProviderOptimizations","optimizedRequest","applyRequestOptimizations","key","correlationId","value","timestamp","Date","now","ttl","postLLMCallHook","push","determineCacheTTL","patterns","extractResponsePatterns","length","modelId","latency","usage","totalTokens","costEstimate","getLatencyThreshold","level","message","updateProviderHealth","providerHealth","llmErrorHook","error","stack","fallbackProvider","selectFallbackProvider","undefined","llmRetryHook","retryCount","adjustedRequest","adjustRequestForRetry","backoffMs","Math","min","pow","Promise","resolve","setTimeout","normalized","messages","map","m","role","content","substring","temperature","maxTokens","Buffer","from","JSON","stringify","toString","maxRetries","timeout","rateLimit","optimized","stopSequences","confidence","occurrences","requestSize","responseTokens","choices","finishReason","actualTokens","thresholds","health","healthKey","currentHealth","memory","cache","get","shift","set","fallbacks","openai","anthropic","candidates","candidate","healthData","avgHealth","reduce","sum","h","adjusted","floor","registerLLMHooks","register"],"mappings":"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"}