Comprehensive comparison for AI technology in Agent Framework applications

import { FlowiseClient } from 'flowise-sdk';
import express from 'express';
import { z } from 'zod';

// Initialize Flowise client with API configuration
const flowiseClient = new FlowiseClient({
  baseUrl: process.env.FLOWISE_BASE_URL || 'http://localhost:3000',
  apiKey: process.env.FLOWISE_API_KEY
});

const app = express();
app.use(express.json());

// Request validation schema
const chatRequestSchema = z.object({
  question: z.string().min(1).max(1000),
  sessionId: z.string().optional(),
  chatflowId: z.string().uuid()
});

// Agent Framework endpoint for customer support automation
app.post('/api/agent/customer-support', async (req, res) => {
  try {
    // Validate incoming request
    const validatedData = chatRequestSchema.parse(req.body);
    const { question, sessionId, chatflowId } = validatedData;

    // Check rate limiting (example implementation)
    const rateLimitKey = `rate_limit_${req.ip}`;
    // In production, use Redis or similar for rate limiting

    // Prepare agent context with metadata
    const agentContext = {
      userId: req.headers['x-user-id'] || 'anonymous',
      timestamp: new Date().toISOString(),
      userAgent: req.headers['user-agent']
    };

    // Execute Flowise chatflow with streaming support
    const prediction = await flowiseClient.createPrediction({
      chatflowId: chatflowId,
      question: question,
      streaming: false,
      overrideConfig: {
        sessionId: sessionId || `session_${Date.now()}`,
        returnSourceDocuments: true
      },
      uploads: req.files || []
    });

    // Process agent response
    if (!prediction || !prediction.text) {
      throw new Error('Invalid response from agent');
    }

    // Extract and structure response data
    const agentResponse = {
      answer: prediction.text,
      sourceDocuments: prediction.sourceDocuments || [],
      sessionId: prediction.sessionId,
      agentContext: agentContext,
      confidence: calculateConfidence(prediction),
      followUpActions: extractFollowUpActions(prediction)
    };

    // Log interaction for analytics
    await logAgentInteraction({
      question,
      response: agentResponse,
      context: agentContext,
      chatflowId
    });

    res.status(200).json({
      success: true,
      data: agentResponse,
      timestamp: new Date().toISOString()
    });

  } catch (error) {
    console.error('Agent Framework Error:', error);

    // Handle specific error types
    if (error instanceof z.ZodError) {
      return res.status(400).json({
        success: false,
        error: 'Invalid request format',
        details: error.errors
      });
    }

    if (error.message.includes('rate limit')) {
      return res.status(429).json({
        success: false,
        error: 'Too many requests',
        retryAfter: 60
      });
    }

    res.status(500).json({
      success: false,
      error: 'Agent processing failed',
      message: process.env.NODE_ENV === 'development' ? error.message : 'Internal server error'
    });
  }
});

// Helper function to calculate response confidence
function calculateConfidence(prediction) {
  const hasSourceDocs = prediction.sourceDocuments?.length > 0;
  const responseLength = prediction.text?.length || 0;
  return hasSourceDocs && responseLength > 50 ? 'high' : 'medium';
}

// Extract follow-up actions from agent response
function extractFollowUpActions(prediction) {
  const actions = [];
  if (prediction.text?.includes('ticket')) actions.push('create_ticket');
  if (prediction.text?.includes('escalate')) actions.push('escalate_to_human');
  return actions;
}

// Log agent interactions for monitoring
async function logAgentInteraction(data) {
  // In production, send to logging service or database
  console.log('Agent Interaction:', JSON.stringify(data, null, 2));
}

const PORT = process.env.PORT || 4000;
app.listen(PORT, () => {
  console.log(`Agent Framework API running on port ${PORT}`);
});