@drax/ai-back 3.29.0 → 3.32.0

package/dist/agents/DraxAgent.js

@@ -0,0 +1,450 @@
+import { randomUUID } from "node:crypto";
+import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AgentSessionServiceFactory from "../factory/services/AgentSessionServiceFactory.js";
+class DraxAgent {
+    constructor() {
+        this.sessions = new Map();
+        this.config = {
+            systemPrompt: "Sos un asistente del sistema. Responde de forma clara, breve y util.",
+        };
+    }
+    static instance() {
+        if (!DraxAgent.singleton) {
+            DraxAgent.singleton = new DraxAgent();
+        }
+        return DraxAgent.singleton;
+    }
+    configure(config) {
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+        return this;
+    }
+    setProvider(provider) {
+        return this.configure({ provider });
+    }
+    setSystemPrompt(systemPrompt) {
+        return this.configure({ systemPrompt });
+    }
+    setToolBuilders(toolBuilders) {
+        return this.configure({ toolBuilders });
+    }
+    setTools(tools) {
+        return this.configure({ tools });
+    }
+    clearSessions() {
+        this.sessions.clear();
+        return this;
+    }
+    async startSession(input = {}) {
+        if (input.sessionId) {
+            const existingSession = await this.resolveSession(input);
+            if (existingSession) {
+                return existingSession;
+            }
+        }
+        return this.createSession(input);
+    }
+    getSession(input) {
+        if (!input.sessionId) {
+            return null;
+        }
+        return this.sessions.get(this.getSessionKey(input.userId, input.tenantId, input.sessionId)) ?? null;
+    }
+    async sendMessage(input) {
+        const session = await this.resolveSession(input);
+        const context = { session, input };
+        const toolBuilders = await this.resolveToolBuilders(context);
+        const navigationState = { path: null };
+        const tools = this.prepareTools([
+            ...toolBuilders.flatMap(builder => builder.getTools()),
+            ...await this.resolveTools(context),
+        ], session.id, navigationState);
+        const systemPrompt = await this.buildSystemPrompt(context, toolBuilders);
+        const response = await this.getProvider().prompt({
+            systemPrompt,
+            userInput: input.message,
+            userImages: input.userImages,
+            userContent: input.userContent,
+            inputFiles: input.inputFiles,
+            history: session.messages.slice(-(this.config.historyLimit ?? 20)),
+            memory: input.memory,
+            memoryHeader: input.memoryHeader,
+            knowledgeBase: input.knowledgeBase,
+            knowledgeBaseHeader: input.knowledgeBaseHeader,
+            tools,
+            toolMaxIterations: input.toolMaxIterations ?? this.config.toolMaxIterations,
+            model: input.model,
+            operationTitle: input.operationTitle ?? this.config.operationTitle ?? "drax-agent-message",
+            operationGroup: input.operationGroup ?? this.config.operationGroup ?? "drax-agent",
+            ip: input.ip,
+            userAgent: input.userAgent,
+            tenant: input.tenantId ?? session.tenantId ?? null,
+            user: input.userId ?? session.userId ?? null,
+        });
+        const assistantMessage = this.normalizeOutput(response.output);
+        const now = new Date();
+        session.messages.push({ role: "user", content: input.message });
+        session.messages.push({ role: "assistant", content: assistantMessage });
+        session.updatedAt = new Date();
+        await this.persistSessionUpdate(session, {
+            lastMessageAt: now,
+            tokens: response.tokens,
+            inputTokens: response.inputTokens,
+            outputTokens: response.outputTokens,
+        });
+        return {
+            sessionId: session.id,
+            message: assistantMessage,
+            navigationPath: navigationState.path,
+            output: response.output,
+            tokens: response.tokens,
+            inputTokens: response.inputTokens,
+            outputTokens: response.outputTokens,
+            time: response.time,
+        };
+    }
+    async createSession(input = {}) {
+        const session = {
+            id: input.sessionId ?? randomUUID(),
+            userId: input.userId ?? null,
+            tenantId: input.tenantId ?? null,
+            messages: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.sessions.set(this.getSessionKey(session.userId, session.tenantId, session.id), session);
+        await this.persistSessionCreate(session);
+        return session;
+    }
+    async resolveSession(input) {
+        if (!input.sessionId) {
+            return this.startSession(input);
+        }
+        const existingSession = this.getSession(input);
+        if (existingSession) {
+            return existingSession;
+        }
+        const persistedSession = await this.findPersistedSession(input);
+        if (persistedSession) {
+            const session = this.hydrateSession(persistedSession, input);
+            this.sessions.set(this.getSessionKey(session.userId, session.tenantId, session.id), session);
+            return session;
+        }
+        return this.createSession(input);
+    }
+    async persistSessionCreate(session) {
+        const sessionService = this.getSessionService();
+        if (!sessionService) {
+            return;
+        }
+        const record = await sessionService.create(this.buildSessionPayload(session, {
+            messageCount: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            tokens: 0,
+        }));
+        session.recordId = this.stringifyRecordId(record);
+    }
+    async persistSessionUpdate(session, usage) {
+        const sessionService = this.getSessionService();
+        if (!sessionService) {
+            return;
+        }
+        if (!session.recordId) {
+            const record = await this.findPersistedSession({
+                sessionId: session.id,
+                userId: session.userId,
+                tenantId: session.tenantId,
+            });
+            session.recordId = this.stringifyRecordId(record);
+        }
+        if (!session.recordId) {
+            await this.persistSessionCreate(session);
+        }
+        if (!session.recordId) {
+            return;
+        }
+        const storedUsage = await this.resolveStoredUsage(session.recordId);
+        await sessionService.updatePartial(session.recordId, this.buildSessionPayload(session, {
+            lastMessageAt: usage.lastMessageAt,
+            messageCount: session.messages.length,
+            inputTokens: storedUsage.inputTokens + (usage.inputTokens ?? 0),
+            outputTokens: storedUsage.outputTokens + (usage.outputTokens ?? 0),
+            tokens: storedUsage.tokens + (usage.tokens ?? 0),
+        }));
+    }
+    buildSessionPayload(session, overrides = {}) {
+        return {
+            sessionId: session.id,
+            title: this.resolveSessionTitle(session.messages),
+            lastMessageAt: session.messages.length > 0 ? session.updatedAt : null,
+            messages: session.messages.map(message => ({
+                role: message.role,
+                content: this.stringifyMessageContent(message.content),
+                createdAt: session.updatedAt,
+            })),
+            messageCount: session.messages.length,
+            inputTokens: 0,
+            outputTokens: 0,
+            tokens: 0,
+            tenant: session.tenantId ?? null,
+            user: session.userId ?? null,
+            ...overrides,
+        };
+    }
+    async findPersistedSession(input) {
+        if (!input.sessionId) {
+            return null;
+        }
+        const sessionService = this.getSessionService();
+        if (!sessionService) {
+            return null;
+        }
+        const filters = [
+            ...(input.tenantId ? [{ field: "tenant", operator: "eq", value: input.tenantId }] : []),
+            ...(input.userId ? [{ field: "user", operator: "eq", value: input.userId }] : []),
+        ];
+        const sessions = await sessionService.findBy("sessionId", input.sessionId, 1, filters);
+        return sessions?.[0] ?? null;
+    }
+    hydrateSession(record, input) {
+        const session = {
+            id: record.sessionId,
+            recordId: this.stringifyRecordId(record),
+            userId: input.userId ?? this.stringifyRelationId(record.user) ?? null,
+            tenantId: input.tenantId ?? this.stringifyRelationId(record.tenant) ?? null,
+            messages: this.normalizeStoredMessages(record.messages ?? []),
+            createdAt: record.createdAt ? new Date(record.createdAt) : new Date(),
+            updatedAt: record.updatedAt ? new Date(record.updatedAt) : new Date(),
+        };
+        return session;
+    }
+    normalizeStoredMessages(messages) {
+        return (messages ?? [])
+            .filter(message => message.role === "user" || message.role === "assistant" || message.role === "system")
+            .map(message => ({
+            role: message.role,
+            content: message.content,
+        }));
+    }
+    async resolveStoredUsage(recordId) {
+        const sessionService = this.getSessionService();
+        if (!sessionService) {
+            return { inputTokens: 0, outputTokens: 0, tokens: 0 };
+        }
+        const record = await sessionService.findById(recordId);
+        return {
+            inputTokens: this.normalizeNumber(record?.inputTokens),
+            outputTokens: this.normalizeNumber(record?.outputTokens),
+            tokens: this.normalizeNumber(record?.tokens),
+        };
+    }
+    normalizeNumber(value) {
+        return typeof value === "number" && Number.isFinite(value) ? value : 0;
+    }
+    resolveSessionTitle(messages) {
+        const firstUserMessage = messages.find(message => message.role === "user");
+        if (!firstUserMessage) {
+            return undefined;
+        }
+        const title = this.stringifyMessageContent(firstUserMessage.content).trim();
+        return title.length > 80 ? `${title.slice(0, 77)}...` : title;
+    }
+    stringifyMessageContent(content) {
+        return typeof content === "string" ? content : JSON.stringify(content);
+    }
+    stringifyRecordId(record) {
+        return this.stringifyNavigationId(record?._id ?? record?.id);
+    }
+    stringifyRelationId(value) {
+        return this.stringifyNavigationId(value?._id ?? value?.id ?? value);
+    }
+    getSessionService() {
+        if (this.config.sessionService === false) {
+            return null;
+        }
+        return this.config.sessionService ?? AgentSessionServiceFactory.instance;
+    }
+    getSessionKey(userId, tenantId, sessionId) {
+        return `${tenantId ?? "global"}:${userId ?? "anonymous"}:${sessionId}`;
+    }
+    async buildSystemPrompt(context, toolBuilders) {
+        const systemPrompt = this.config.systemPrompt ?? "";
+        const basePrompt = typeof systemPrompt === "function"
+            ? await systemPrompt(context)
+            : systemPrompt;
+        const rbacSection = this.buildRbacContextSection(context);
+        const toolSections = toolBuilders
+            .map(builder => builder.getSystemPromptSection())
+            .filter(section => section.trim().length > 0);
+        return [
+            basePrompt,
+            rbacSection,
+            toolSections.length > 0
+                ? [
+                    "[ENTIDADES Y TOOLS]",
+                    ...toolSections,
+                ].join("\n")
+                : "",
+        ].filter(section => section.trim().length > 0).join("\n\n");
+    }
+    buildRbacContextSection(context) {
+        const userId = context.input?.userId ?? context.session.userId ?? null;
+        const tenantId = context.input?.tenantId ?? context.session.tenantId ?? null;
+        if (!userId && !tenantId) {
+            return "";
+        }
+        const lines = [
+            "[CONTEXTO RBAC]",
+            `tenantId: ${tenantId ?? "null"}`,
+            `userId: ${userId ?? "null"}`,
+            "Cuando necesites completar campos de pertenencia o auditoria como tenant, tenantId, user, userId o createdBy, usa estos valores del usuario autenticado. No los solicites al usuario ni inventes otros valores.",
+        ];
+        return lines.join("\n");
+    }
+    async resolveToolBuilders(context) {
+        if (!this.config.toolBuilders) {
+            return [];
+        }
+        return typeof this.config.toolBuilders === "function"
+            ? await this.config.toolBuilders(context)
+            : this.config.toolBuilders;
+    }
+    async resolveTools(context) {
+        if (!this.config.tools) {
+            return [];
+        }
+        return typeof this.config.tools === "function"
+            ? await this.config.tools(context)
+            : this.config.tools;
+    }
+    prepareTools(tools, sessionId, navigationState) {
+        return tools.map(tool => ({
+            ...tool,
+            execute: async (args) => {
+                if (this.config.logToolExecution) {
+                    console.log("[drax-agent] tool:start", {
+                        sessionId,
+                        tool: tool.name,
+                        args,
+                    });
+                }
+                try {
+                    const result = await tool.execute(args);
+                    navigationState.path = this.resolveNavigationPath(tool.navigation, args, result) ?? navigationState.path;
+                    if (this.config.logToolExecution) {
+                        console.log("[drax-agent] tool:success", {
+                            sessionId,
+                            tool: tool.name,
+                            navigationPath: navigationState.path,
+                        });
+                    }
+                    return result;
+                }
+                catch (error) {
+                    if (this.config.logToolExecution) {
+                        console.error("[drax-agent] tool:error", {
+                            sessionId,
+                            tool: tool.name,
+                            error,
+                        });
+                    }
+                    throw error;
+                }
+            },
+        }));
+    }
+    resolveNavigationPath(navigation, args, result) {
+        if (!navigation) {
+            return null;
+        }
+        const mode = this.resolveNavigationMode(navigation.method);
+        if (!mode) {
+            return null;
+        }
+        const id = this.resolveNavigationId(navigation.method, args, result);
+        if (!id) {
+            return null;
+        }
+        const basePath = navigation.basePath ?? `/crud/${encodeURIComponent(navigation.entityName)}`;
+        const query = new URLSearchParams({
+            mode,
+            id,
+        });
+        return `${basePath}?${query.toString()}`;
+    }
+    resolveNavigationMode(method) {
+        if (["create", "update", "updatePartial"].includes(method)) {
+            return "edit";
+        }
+        if (["findById", "findOneBy", "findOne", "findBy", "search", "find", "paginate"].includes(method)) {
+            return "view";
+        }
+        return null;
+    }
+    resolveNavigationId(method, args, result) {
+        if (["update", "updatePartial", "findById"].includes(method)) {
+            return this.stringifyNavigationId(args?.id) ?? this.extractRecordId(result);
+        }
+        return this.extractRecordId(result);
+    }
+    extractRecordId(result) {
+        const record = this.resolveSingleRecord(result);
+        if (!record || typeof record !== "object") {
+            return null;
+        }
+        return this.stringifyNavigationId(record.id)
+            ?? this.stringifyNavigationId(record._id)
+            ?? this.stringifyNavigationId(record.uuid);
+    }
+    resolveSingleRecord(result) {
+        if (Array.isArray(result)) {
+            return result.length === 1 ? result[0] : null;
+        }
+        if (Array.isArray(result?.docs)) {
+            return result.docs.length === 1 ? result.docs[0] : null;
+        }
+        if (Array.isArray(result?.items)) {
+            return result.items.length === 1 ? result.items[0] : null;
+        }
+        if (Array.isArray(result?.data)) {
+            return result.data.length === 1 ? result.data[0] : null;
+        }
+        return result;
+    }
+    stringifyNavigationId(id) {
+        if (id === null || id === undefined || id === "") {
+            return null;
+        }
+        if (typeof id === "string" || typeof id === "number" || typeof id === "boolean") {
+            return String(id);
+        }
+        if (typeof id?.toString === "function") {
+            const value = id.toString();
+            return value && value !== "[object Object]" ? value : null;
+        }
+        return null;
+    }
+    normalizeOutput(output) {
+        if (this.config.normalizeOutput) {
+            return this.config.normalizeOutput(output);
+        }
+        if (typeof output === "string") {
+            return output;
+        }
+        if (output?.message && typeof output.message === "string") {
+            return output.message;
+        }
+        return JSON.stringify(output);
+    }
+    getProvider() {
+        if (!this.config.provider) {
+            this.config.provider = AiProviderFactory.instance();
+        }
+        return this.config.provider;
+    }
+}
+export default DraxAgent;
+export { DraxAgent };

package/dist/controllers/AgentSessionController.js

@@ -0,0 +1,18 @@
+import AgentSessionServiceFactory from "../factory/services/AgentSessionServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import AgentSessionPermissions from "../permissions/AgentSessionPermissions.js";
+class AgentSessionController extends AbstractFastifyController {
+    constructor() {
+        super(AgentSessionServiceFactory.instance, AgentSessionPermissions);
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+}
+export default AgentSessionController;
+export { AgentSessionController };

package/dist/controllers/DraxAgentController.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { CommonController } from "@drax/common-back";
+import { DraxAgent } from "../agents/DraxAgent.js";
+import { AgentPermissions } from "../permissions/AgentPermissions.js";
+const PromptImageSchema = z.object({
+    url: z.string().min(1),
+    detail: z.enum(["auto", "low", "high"]).optional(),
+});
+const PromptContentPartSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("image"),
+        imageUrl: z.string().min(1),
+        detail: z.enum(["auto", "low", "high"]).optional(),
+    }),
+]);
+const PromptMemorySchema = z.object({
+    key: z.string().min(1),
+    value: z.string(),
+});
+const PromptInputFileSchema = z.object({
+    filename: z.string().optional(),
+    filepath: z.string().optional(),
+    size: z.number().nullable().optional(),
+    mimetype: z.string().optional(),
+    url: z.string().optional(),
+});
+const AgentSessionRequestSchema = z.object({
+    sessionId: z.string().optional(),
+    userId: z.string().optional().nullable(),
+    tenantId: z.string().optional().nullable(),
+});
+const AgentMessageRequestSchema = AgentSessionRequestSchema.extend({
+    message: z.string().min(1),
+    userImages: z.array(PromptImageSchema).optional(),
+    userContent: z.array(PromptContentPartSchema).optional(),
+    inputFiles: z.array(PromptInputFileSchema).optional(),
+    memory: z.array(PromptMemorySchema).optional(),
+    memoryHeader: z.string().optional(),
+    knowledgeBase: z.array(z.string()).optional(),
+    knowledgeBaseHeader: z.string().optional(),
+    model: z.string().optional(),
+    toolMaxIterations: z.number().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+});
+class DraxAgentController extends CommonController {
+    constructor() {
+        super();
+        this.permission = AgentPermissions.Session;
+        this.agent = DraxAgent.instance();
+    }
+    async startSession(request, reply) {
+        try {
+            this.assertAccess(request);
+            const input = AgentSessionRequestSchema.parse(request.body ?? {});
+            const session = await this.agent.startSession({
+                sessionId: input.sessionId,
+                userId: this.resolveUserId(request, input.userId),
+                tenantId: this.resolveTenantId(request, input.tenantId),
+            });
+            return reply.send({
+                sessionId: session.id,
+                createdAt: session.createdAt,
+                updatedAt: session.updatedAt,
+            });
+        }
+        catch (e) {
+            this.handleControllerError(e, reply);
+        }
+    }
+    async message(request, reply) {
+        try {
+            this.assertAccess(request);
+            const input = AgentMessageRequestSchema.parse(request.body ?? {});
+            const response = await this.agent.sendMessage({
+                ...input,
+                userId: this.resolveUserId(request, input.userId),
+                tenantId: this.resolveTenantId(request, input.tenantId),
+                ip: request.ip,
+                userAgent: request.headers["user-agent"],
+            });
+            return reply.send(response);
+        }
+        catch (e) {
+            this.handleControllerError(e, reply);
+        }
+    }
+    assertAccess(request) {
+        if (this.permission === false) {
+            return;
+        }
+        request.rbac.assertPermission(this.permission);
+    }
+    resolveUserId(request, userId) {
+        return request.rbac?.userId ?? userId ?? null;
+    }
+    resolveTenantId(request, tenantId) {
+        return request.rbac?.tenantId ?? tenantId ?? null;
+    }
+    handleControllerError(e, reply) {
+        if (e?.name === "ZodError") {
+            return reply.status(400).send({
+                message: e?.message || "Drax agent validation error",
+            });
+        }
+        this.handleError(e, reply);
+    }
+}
+export default DraxAgentController;
+export { DraxAgentController };

package/dist/factory/services/AgentSessionServiceFactory.js

@@ -0,0 +1,30 @@
+import AgentSessionMongoRepository from '../../repository/mongo/AgentSessionMongoRepository.js';
+import AgentSessionSqliteRepository from '../../repository/sqlite/AgentSessionSqliteRepository.js';
+import { AgentSessionService } from '../../services/AgentSessionService.js';
+import { AgentSessionBaseSchema, AgentSessionSchema } from "../../schemas/AgentSessionSchema.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+class AgentSessionServiceFactory {
+    static get instance() {
+        if (!AgentSessionServiceFactory.service) {
+            let repository;
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new AgentSessionMongoRepository();
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                    repository = new AgentSessionSqliteRepository(dbFile, false);
+                    repository.build();
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            const baseSchema = AgentSessionBaseSchema;
+            const fullSchema = AgentSessionSchema;
+            AgentSessionServiceFactory.service = new AgentSessionService(repository, baseSchema, fullSchema);
+        }
+        return AgentSessionServiceFactory.service;
+    }
+}
+export default AgentSessionServiceFactory;
+export { AgentSessionServiceFactory };

package/dist/index.js

@@ -7,13 +7,27 @@ import { OpenAiProviderFactory } from "./factory/OpenAiProviderFactory.js";
 import { AiProviderFactory } from "./factory/AiProviderFactory.js";
 import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
 import { OpenAiProvider } from "./providers/OpenAiProvider.js";
+import { BuilderTool } from "./tools/BuilderTool.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
 import { AILogService } from "./services/AILogService.js";
 import AILogPermissions from "./permissions/AILogPermissions.js";
+import AgentPermissions from "./permissions/AgentPermissions.js";
+import AgentSessionPermissions from "./permissions/AgentSessionPermissions.js";
 import AIPermissions from "./permissions/AIPermissions.js";
 import AILogController from "./controllers/AILogController.js";
 import AICrudController from "./controllers/AICrudController.js";
 import AIGenericController from "./controllers/AIGenericController.js";
+import DraxAgentController from "./controllers/DraxAgentController.js";
+import AgentSessionController from "./controllers/AgentSessionController.js";
 import AILogRoutes from "./routes/AILogRoutes.js";
 import AIRoutes from "./routes/AIRoutes.js";
-export { OpenAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, AiProviderFactory, AILogServiceFactory, OpenAiProvider, KnowledgeService, AILogService, AILogPermissions, AIPermissions, AILogController, AICrudController, AIGenericController, AILogRoutes, AIRoutes };
+import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
+import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
+import { DraxAgent } from "./agents/DraxAgent.js";
+export { OpenAiConfig, AILogSchema, AILogBaseSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, AiProviderFactory, AILogServiceFactory, OpenAiProvider, BuilderTool, 
+//Service
+KnowledgeService, AILogService, 
+//Permissions
+AILogPermissions, AgentPermissions, AIPermissions, AgentSessionPermissions, 
+//Controllers
+AILogController, AICrudController, AIGenericController, DraxAgentController, AgentSessionController, DraxAgent, AILogRoutes, AIRoutes, DraxAgentRoutes, AgentSessionRoutes };

package/dist/interfaces/IAgentSession.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IAgentSessionRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IBuilderTool.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IDraxAgent.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IDraxAgentController.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/IDraxAgentRoutes.js

@@ -0,0 +1 @@
+export {};