express-genix 4.5.2 → 4.6.1

package/templates/agents/graph.js.ejs

@@ -1,84 +0,0 @@
-const { createReactAgent } = require('@langchain/langgraph/prebuilt');
-const { tool } = require('@langchain/core/tools');
-const { HumanMessage } = require('@langchain/core/messages');
-const { z } = require('zod');
-const { getModel } = require('../config/ai');
-
-// --- Built-in Tools ---
-
-const currentTimeTool = tool(
-  async () => new Date().toISOString(),
-  {
-    name: 'current_time',
-    description: 'Get the current date and time in ISO 8601 format',
-    schema: z.object({}),
-  }
-);
-
-const calculatorTool = tool(
-  async ({ expression }) => {
-    // Only allow digits and math operators — no code injection possible
-    const sanitized = expression.replace(/[^0-9+\-*/().%\s]/g, '');
-    if (sanitized !== expression.trim()) {
-      return 'Error: Expression contains invalid characters. Use only numbers and +, -, *, /, (, ), %';
-    }
-    try {
-      const result = new Function(`"use strict"; return (${sanitized})`)();
-      if (!isFinite(result)) return 'Error: Result is not a finite number';
-      return String(result);
-    } catch {
-      return 'Error: Could not evaluate expression';
-    }
-  },
-  {
-    name: 'calculator',
-    description: 'Evaluate a mathematical expression using standard operators: +, -, *, /, %',
-    schema: z.object({
-      expression: z.string().describe('Math expression, e.g. "2 + 3 * 4"'),
-    }),
-  }
-);
-
-/**
- * Create a LangGraph ReAct agent with tool-calling capabilities.
- *
- * @param {Object} options
- * @param {Array}  options.tools - Additional @langchain/core tools to register
- * @param {string} options.systemPrompt - System instruction for the agent
- * @param {string} options.model - Model name override
- */
-const createAgent = (options = {}) => {
-  const tools = [
-    currentTimeTool,
-    calculatorTool,
-    ...(options.tools || []),
-  ];
-
-  const model = getModel(options);
-
-  return createReactAgent({
-    llm: model,
-    tools,
-    messageModifier: options.systemPrompt || 'You are a helpful assistant. Use the provided tools when needed to answer questions accurately.',
-  });
-};
-
-/**
- * Run the agent with a single message and return the final response.
- */
-const runAgent = async (message, options = {}) => {
-  const agent = createAgent(options);
-
-  const result = await agent.invoke({
-    messages: [new HumanMessage(message)],
-  });
-
-  const lastMessage = result.messages[result.messages.length - 1];
-
-  return {
-    content: lastMessage.content,
-    steps: result.messages.length,
-  };
-};
-
-module.exports = { createAgent, runAgent, currentTimeTool, calculatorTool };

package/templates/config/ai.js.ejs

@@ -1,47 +0,0 @@
-<% if (aiProvider === 'openai') { %>
-const { ChatOpenAI } = require('@langchain/openai');
-<% } else if (aiProvider === 'anthropic') { %>
-const { ChatAnthropic } = require('@langchain/anthropic');
-<% } else if (aiProvider === 'gemini') { %>
-const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
-<% } else if (aiProvider === 'ollama') { %>
-const { ChatOllama } = require('@langchain/ollama');
-<% } %>
-
-/**
- * Create a LangChain chat model based on the configured provider.
- */
-const getModel = (options = {}) => {
-  const temperature = options.temperature ?? parseFloat(process.env.AI_TEMPERATURE || '0.7');
-  const maxTokens = options.maxTokens ?? parseInt(process.env.AI_MAX_TOKENS || '2048', 10);
-<% if (aiProvider === 'openai') { %>
-  return new ChatOpenAI({
-    modelName: options.model || process.env.AI_MODEL || 'gpt-4o-mini',
-    temperature,
-    maxTokens,
-    openAIApiKey: process.env.OPENAI_API_KEY,
-  });
-<% } else if (aiProvider === 'anthropic') { %>
-  return new ChatAnthropic({
-    modelName: options.model || process.env.AI_MODEL || 'claude-sonnet-4-20250514',
-    temperature,
-    maxTokens,
-    anthropicApiKey: process.env.ANTHROPIC_API_KEY,
-  });
-<% } else if (aiProvider === 'gemini') { %>
-  return new ChatGoogleGenerativeAI({
-    model: options.model || process.env.AI_MODEL || 'gemini-2.0-flash',
-    temperature,
-    maxOutputTokens: maxTokens,
-    apiKey: process.env.GOOGLE_API_KEY,
-  });
-<% } else if (aiProvider === 'ollama') { %>
-  return new ChatOllama({
-    model: options.model || process.env.AI_MODEL || 'llama3',
-    temperature,
-    baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-  });
-<% } %>
-};
-
-module.exports = { getModel };

package/templates/controllers/aiController.js.ejs

@@ -1,100 +0,0 @@
-const aiService = require('../services/aiService');
-const { runAgent } = require('../agents/graph');
-const { success, error } = require('../utils/response');
-
-/**
- * POST /ai/chat — Send a message, get a complete AI response.
- */
-const chatHandler = async (req, res, next) => {
-  try {
-    const { message, systemPrompt, history, model, temperature, maxTokens } = req.body;
-
-    if (!message) {
-      return error(res, 'Message is required', 400);
-    }
-
-    const result = await aiService.chat(message, {
-      systemPrompt,
-      history,
-      model,
-      temperature,
-      maxTokens,
-    });
-
-    return success(res, result);
-  } catch (err) {
-    next(err);
-  }
-};
-
-/**
- * POST /ai/stream — Stream an AI response via Server-Sent Events.
- */
-const streamHandler = async (req, res, next) => {
-  try {
-    const { message, systemPrompt, history, model, temperature, maxTokens } = req.body;
-
-    if (!message) {
-      return error(res, 'Message is required', 400);
-    }
-
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Cache-Control', 'no-cache');
-    res.setHeader('Connection', 'keep-alive');
-
-    const generator = aiService.stream(message, {
-      systemPrompt,
-      history,
-      model,
-      temperature,
-      maxTokens,
-    });
-
-    for await (const chunk of generator) {
-      res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
-    }
-
-    res.write('data: [DONE]\n\n');
-    res.end();
-  } catch (err) {
-    next(err);
-  }
-};
-
-/**
- * POST /ai/chain — Run a prompt template chain with variables.
- */
-const chainHandler = async (req, res, next) => {
-  try {
-    const { template, variables, model } = req.body;
-
-    if (!template) {
-      return error(res, 'Template is required', 400);
-    }
-
-    const result = await aiService.chain(template, variables || {}, { model });
-    return success(res, { content: result });
-  } catch (err) {
-    next(err);
-  }
-};
-
-/**
- * POST /ai/agent — Run the LangGraph ReAct agent.
- */
-const agentHandler = async (req, res, next) => {
-  try {
-    const { message, systemPrompt, model } = req.body;
-
-    if (!message) {
-      return error(res, 'Message is required', 400);
-    }
-
-    const result = await runAgent(message, { systemPrompt, model });
-    return success(res, result);
-  } catch (err) {
-    next(err);
-  }
-};
-
-module.exports = { chatHandler, streamHandler, chainHandler, agentHandler };

package/templates/routes/aiRoutes.js.ejs

@@ -1,117 +0,0 @@
-const express = require('express');
-const { chatHandler, streamHandler, chainHandler, agentHandler } = require('../controllers/aiController');
-
-const router = express.Router();
-
-/**
- * @swagger
- * <% if (hasApiVersioning) { %>/v1<% } %>/ai/chat:
- *   post:
- *     summary: Send a chat message to the AI
- *     tags: [AI]
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required: [message]
- *             properties:
- *               message:
- *                 type: string
- *                 example: "What is Node.js?"
- *               systemPrompt:
- *                 type: string
- *                 example: "You are a helpful coding assistant."
- *               history:
- *                 type: array
- *                 items:
- *                   type: object
- *                   properties:
- *                     role:
- *                       type: string
- *                       enum: [user, assistant]
- *                     content:
- *                       type: string
- *               model:
- *                 type: string
- *     responses:
- *       200:
- *         description: AI response
- */
-router.post('/chat', chatHandler);
-
-/**
- * @swagger
- * <% if (hasApiVersioning) { %>/v1<% } %>/ai/stream:
- *   post:
- *     summary: Stream an AI response via Server-Sent Events
- *     tags: [AI]
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required: [message]
- *             properties:
- *               message:
- *                 type: string
- *     responses:
- *       200:
- *         description: SSE stream of AI response chunks
- */
-router.post('/stream', streamHandler);
-
-/**
- * @swagger
- * <% if (hasApiVersioning) { %>/v1<% } %>/ai/chain:
- *   post:
- *     summary: Run a prompt template chain with variable substitution
- *     tags: [AI]
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required: [template]
- *             properties:
- *               template:
- *                 type: string
- *                 example: "Summarize the following text: {text}"
- *               variables:
- *                 type: object
- *                 example: { "text": "Node.js is a JavaScript runtime..." }
- *     responses:
- *       200:
- *         description: Chain result
- */
-router.post('/chain', chainHandler);
-
-/**
- * @swagger
- * <% if (hasApiVersioning) { %>/v1<% } %>/ai/agent:
- *   post:
- *     summary: Run the LangGraph ReAct agent with tool calling
- *     tags: [AI]
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required: [message]
- *             properties:
- *               message:
- *                 type: string
- *                 example: "What time is it right now?"
- *               systemPrompt:
- *                 type: string
- *     responses:
- *       200:
- *         description: Agent response with tool-use steps
- */
-router.post('/agent', agentHandler);
-
-module.exports = router;

package/templates/services/aiService.js.ejs

@@ -1,80 +0,0 @@
-const { getModel } = require('../config/ai');
-const { HumanMessage, SystemMessage, AIMessage } = require('@langchain/core/messages');
-const { StringOutputParser } = require('@langchain/core/output_parsers');
-const { ChatPromptTemplate } = require('@langchain/core/prompts');
-const { logger } = require('../utils/logger');
-
-const DEFAULT_SYSTEM_PROMPT = 'You are a helpful AI assistant.';
-
-/**
- * Send a chat message and get a complete response.
- */
-const chat = async (message, options = {}) => {
-  const model = getModel(options);
-  const messages = [
-    new SystemMessage(options.systemPrompt || DEFAULT_SYSTEM_PROMPT),
-  ];
-
-  if (Array.isArray(options.history)) {
-    for (const msg of options.history) {
-      if (msg.role === 'user') messages.push(new HumanMessage(msg.content));
-      else if (msg.role === 'assistant') messages.push(new AIMessage(msg.content));
-    }
-  }
-
-  messages.push(new HumanMessage(message));
-
-  const response = await model.invoke(messages);
-
-  logger.info('AI chat completed', {
-    provider: process.env.AI_PROVIDER,
-  });
-
-  return {
-    content: response.content,
-    model: response.response_metadata?.model || 'unknown',
-    usage: response.usage_metadata || null,
-  };
-};
-
-/**
- * Stream a chat response. Returns an async generator yielding text chunks.
- */
-const stream = async function* (message, options = {}) {
-  const model = getModel(options);
-  const messages = [
-    new SystemMessage(options.systemPrompt || DEFAULT_SYSTEM_PROMPT),
-  ];
-
-  if (Array.isArray(options.history)) {
-    for (const msg of options.history) {
-      if (msg.role === 'user') messages.push(new HumanMessage(msg.content));
-      else if (msg.role === 'assistant') messages.push(new AIMessage(msg.content));
-    }
-  }
-
-  messages.push(new HumanMessage(message));
-
-  const streamResponse = await model.stream(messages);
-
-  for await (const chunk of streamResponse) {
-    if (chunk.content) {
-      yield chunk.content;
-    }
-  }
-};
-
-/**
- * Run a prompt template chain with variable substitution.
- */
-const chain = async (template, variables = {}, options = {}) => {
-  const model = getModel(options);
-  const prompt = ChatPromptTemplate.fromTemplate(template);
-  const outputParser = new StringOutputParser();
-  const pipeline = prompt.pipe(model).pipe(outputParser);
-
-  const result = await pipeline.invoke(variables);
-  return result;
-};
-
-module.exports = { chat, stream, chain };