@roadiehq/rag-ai-backend/dist/plugin.cjs.js

'use strict';

var backendCommon = require('@backstage/backend-common');
var backendPluginApi = require('@backstage/backend-plugin-api');
var router = require('./service/router.cjs.js');
var ragAiNode = require('@roadiehq/rag-ai-node');

const ragAiPlugin = backendPluginApi.createBackendPlugin({
  pluginId: "rag-ai",
  register(env) {
    let augmentationIndexer;
    let retrievalPipeline;
    let model;
    env.registerExtensionPoint(ragAiNode.augmentationIndexerExtensionPoint, {
      setAugmentationIndexer(indexer) {
        if (augmentationIndexer) {
          throw new Error("AugmentationIndexer may only be set once");
        }
        augmentationIndexer = indexer;
      }
    });
    env.registerExtensionPoint(ragAiNode.retrievalPipelineExtensionPoint, {
      setRetrievalPipeline(pipeline) {
        if (retrievalPipeline) {
          throw new Error("RetrievalPipeline may only be set once");
        }
        retrievalPipeline = pipeline;
      }
    });
    env.registerExtensionPoint(ragAiNode.modelExtensionPoint, {
      setBaseLLM(llm) {
        if (model) {
          throw new Error("Model may only be set once");
        }
        model = llm;
      }
    });
    env.registerInit({
      deps: {
        logger: backendPluginApi.coreServices.logger,
        config: backendPluginApi.coreServices.rootConfig,
        httpRouter: backendPluginApi.coreServices.httpRouter
      },
      async init({ logger, config, httpRouter }) {
        const winstonLogger = backendCommon.loggerToWinstonLogger(logger);
        if (!(augmentationIndexer && model && retrievalPipeline)) {
          throw new Error("augmentationIndexer must be registered");
        }
        httpRouter.use(
          await router.createRouter({
            logger: winstonLogger,
            config,
            augmentationIndexer,
            retrievalPipeline,
            model
          })
        );
      }
    });
  }
});

exports.ragAiPlugin = ragAiPlugin;
//# sourceMappingURL=plugin.cjs.js.map