模型管理

package nexus.io.mosskb.controller;

import com.alibaba.fastjson2.JSON;
import nexus.io.annotation.Get;
import nexus.io.annotation.Post;
import nexus.io.annotation.Put;
import nexus.io.annotation.RequestPath;
import nexus.io.jfinal.aop.Aop;
import nexus.io.mosskb.service.kb.ModelCatalogService;
import nexus.io.model.result.ResultVo;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.http.common.HttpRequest;

@RequestPath("/api/provider")
public class ApiProviderController {
  private final ModelCatalogService catalog = Aop.get(ModelCatalogService.class);
  @Get("")
  public ResultVo index() { return ResultVo.ok(catalog.providers()); }
  @Get("/model_type_list")
  public ResultVo model_type_list(String provider) { return ResultVo.ok(catalog.types(provider)); }
  @Get("/model_list")
  public ResultVo model_list(String provider, String model_type) { return ResultVo.ok(catalog.models(provider, model_type)); }
  @Get("/model_form")
  public ResultVo model_form(String provider, String model_type, String model_name) { return ResultVo.ok(catalog.form(provider, "credential_form")); }
  @Get("/model_params_form")
  public ResultVo model_params_form(String provider, String model_type, String model_name) { return ResultVo.ok(catalog.form(provider, "params_form")); }
  @Post("/catalog/discover")
  public ResultVo discover(HttpRequest request) { return catalog.discover(TioRequestContext.getUserIdLong(), JSON.parseObject(request.getBodyString())); }
  @Put("/catalog")
  public ResultVo saveCatalog(HttpRequest request) { return catalog.saveCatalog(TioRequestContext.getUserIdLong(), JSON.parseObject(request.getBodyString())); }
}

package nexus.io.mosskb.controller;

import nexus.io.annotation.Delete;
import nexus.io.annotation.EnableCORS;
import nexus.io.annotation.Get;
import nexus.io.annotation.Post;
import nexus.io.annotation.Put;
import nexus.io.annotation.RequestPath;
import nexus.io.jfinal.aop.Aop;
import nexus.io.mosskb.service.kb.MossKbModelService;
import nexus.io.mosskb.vo.ModelVo;
import nexus.io.model.result.ResultVo;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.http.common.HttpRequest;
import nexus.io.tio.utils.json.FastJson2Utils;

@RequestPath("/api/model")
@EnableCORS
public class ApiModelController {

  MossKbModelService modelService = Aop.get(MossKbModelService.class);

  @Get("")
  public ResultVo index(HttpRequest request) {
    String name = request.getParam("name");
    return modelService.list(name, request.getParam("model_type"));
  }

  @Post("")
  public ResultVo save(HttpRequest request) {
    Long userId = TioRequestContext.getUserIdLong();
    String bodyString = request.getBodyString();
    ModelVo modelVo = FastJson2Utils.parse(bodyString, ModelVo.class);
    return modelService.save(userId, modelVo);
  }

  @Put("/{id}")
  public ResultVo update(HttpRequest request,Long id) {
    Long userId = TioRequestContext.getUserIdLong();
    String bodyString = request.getBodyString();
    ModelVo modelVo = FastJson2Utils.parse(bodyString, ModelVo.class);
    modelVo.setId(id);
    return modelService.save(userId, modelVo);
  }

  @Delete("/{id}")
  public ResultVo delete(Long id) {
    return modelService.delete(id);
  }

  @Get("/{id}")
  public ResultVo get(Long id) {
    return modelService.get(id);
  }

  @Get("/{id}/model_params_form")
  public ResultVo modelParams(Long id) {
    nexus.io.db.activerecord.Row row = nexus.io.db.activerecord.Db.findById("moss_kb_model", id);
    if (row == null) {
      return ResultVo.fail(404, "模型不存在");
    }
    return ResultVo.ok(com.alibaba.fastjson2.JSON.parseArray(row.getStr("model_params_form")));
  }

  @Put("/{id}/model_params_form")
  public ResultVo updateModelParams(Long id, HttpRequest request) {
    com.alibaba.fastjson2.JSONArray form = com.alibaba.fastjson2.JSON.parseArray(request.getBodyString());
    nexus.io.db.activerecord.Db.update("update moss_kb_model set model_params_form=?::jsonb where id=?", form.toJSONString(), id);
    return ResultVo.ok(form);
  }

}

package nexus.io.mosskb.service.kb;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.postgresql.util.PGobject;

import com.jfinal.kit.Kv;

import lombok.extern.slf4j.Slf4j;
import nexus.io.chat.PlatformInput;
import nexus.io.chat.UniChatMessage;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;
import nexus.io.jfinal.aop.Aop;
import nexus.io.mosskb.constant.MossKbTableNames;
import nexus.io.mosskb.dao.ModelDao;
import nexus.io.mosskb.model.MossKbModel;
import nexus.io.mosskb.vo.CredentialVo;
import nexus.io.mosskb.vo.ModelVo;
import nexus.io.model.result.ResultVo;
import nexus.io.openai.client.OpenAiClient;
import nexus.io.tio.utils.json.JsonUtils;
import okhttp3.Response;

@Slf4j
public class MossKbModelService {

  /**
   * @param name
   * @return
   */
  public ResultVo list(String name) {
    return list(name, null);
  }

  public ResultVo list(String name, String modelType) {
    MossKbUserService mossKbUserService = Aop.get(MossKbUserService.class);

    String[] jsonFields = new String[] { "meta" };
    String sql = null;
    if (name == null) {
      sql = "select id,provider,name,model_type,model_name,status,meta,permission_type,user_id from %s";
      sql = String.format(sql, MossKbTableNames.moss_kb_model);
      List<Row> list = Db.findWithJsonField(sql, jsonFields);
      List<Kv> kvs = new ArrayList<>();
      for (Row r : list) {
        if (!ModelAccess.canUse(nexus.io.tio.boot.http.TioRequestContext.getUserIdLong(), r.getLong("id"))) {
          continue;
        }
        if (modelType != null && !modelType.equals(r.getStr("model_type"))) {
          continue;
        }
        Kv kv = r.toKv();
        kv.set("id", kv.get("id").toString());
        kv.set("user_id", kv.get("user_id").toString());
        Object meta = kv.get("meta");
        if (meta instanceof PGobject) {
          kv.set("meta", JsonUtils.parseObject(((PGobject) meta).getValue()));
        } else if (meta == null) {
          kv.set("meta", Kv.create());
        }

        String username = mossKbUserService.queryUsername(kv.getLong("user_id"));
        kv.set("username", username);

        kvs.add(kv);
      }
      return ResultVo.ok(kvs);
    }

    sql = "select id,provider,name,model_type,model_name,status,meta,permission_type,user_id from %s where name=?";
    sql = String.format(sql, MossKbTableNames.moss_kb_model);

    List<Kv> kvs = new ArrayList<>();
    List<Row> list = Db.findWithJsonField(sql, jsonFields, name);
    for (Row record : list) {
      if (!ModelAccess.canUse(nexus.io.tio.boot.http.TioRequestContext.getUserIdLong(), record.getLong("id"))) {
        continue;
      }
      if (modelType != null && !modelType.equals(record.getStr("model_type"))) {
        continue;
      }
      Kv kv = record.toKv();
      String username = mossKbUserService.queryUsername(kv.getLong("user_id"));
      kv.set("username", username);
      kvs.add(kv);
    }
    return ResultVo.ok(kvs);
  }

  /**
   * 
   * @param map {"name":"text-embedding-3-large","model_type":"EMBEDDING","model_name":"text-embedding-3-large","permission_type":"PRIVATE","credential":{"api_base":"https://api.openai.com/v1","api_key":"11111111"},"provider":"model_openai_provider"}
   * @return
   */
  public ResultVo save(Long userId, ModelVo modelVo) {
    if (modelVo.getId() != null && !ModelAccess.owns(userId, modelVo.getId())) {
      return ResultVo.fail("无权修改模型");
    }
    String name = modelVo.getName();
    if (name == null || name.isBlank() || name.length() > 64) {
      return ResultVo.fail(400, "模型名称须为 1 至 64 个字符");
    }
    if (modelVo.getId() == null && Db.exists(MossKbTableNames.moss_kb_model, "name", name)) {
      return ResultVo.fail(400, "模型名称【" + name + "】已存在");
    }

    try {
      ModelCatalogService catalog = Aop.get(ModelCatalogService.class);
      Row provider = catalog.provider(modelVo.getProvider());
      if (provider == null) {
        return ResultVo.fail(400, "供应商不存在或已停用");
      }
      if (!List.of("LLM", "EMBEDDING").contains(modelVo.getModel_type()) || !List.of("PRIVATE", "PUBLIC").contains(modelVo.getPermission_type())) {
        return ResultVo.fail(400, "模型类型或权限参数无效");
      }
      modelVo.setModel_name(ModelCatalogService.modelId(modelVo.getModel_name()));
      CredentialVo credential = modelVo.getCredential();
      if (credential == null) {
        return ResultVo.fail(400, "请填写模型凭据");
      }
      if (credential.getApi_base() == null || credential.getApi_base().isBlank()) {
        credential.setApi_base(provider.getStr("api_base"));
      }
      credential.setApi_base(ModelCatalogService.baseUrl(credential.getApi_base()));
      String key = credential.getApi_key();
      if (modelVo.getId() != null && (key == null || key.isBlank() || key.contains("*"))) {
        CredentialVo previous = ModelCatalogService.credential(Db.findById(MossKbTableNames.moss_kb_model, modelVo.getId()));
        if (!credential.getApi_base().equals(ModelCatalogService.baseUrl(previous.getApi_base()))) {
          return ResultVo.fail(400, "修改 API 域名时必须重新填写该平台的 API Key");
        }
        credential.setApi_key(previous.getApi_key());
      }
      if (credential.getApi_key() == null || credential.getApi_key().isBlank() || credential.getApi_key().contains("*")) {
        return ResultVo.fail(400, "请填写该平台的 API Key");
      }
      if (modelVo.getId() != null) {
        Row previous = Db.findById(MossKbTableNames.moss_kb_model, modelVo.getId());
        CredentialVo oldCredential = ModelCatalogService.credential(previous);
        if ("EMBEDDING".equals(previous.getStr("model_type"))
            && (!modelVo.getModel_name().equals(previous.getStr("model_name")) || !modelVo.getModel_type().equals(previous.getStr("model_type"))
                || !credential.getApi_base().equals(ModelCatalogService.baseUrl(oldCredential.getApi_base())))
            && Db.queryLong("select count(*) from moss_kb_dataset where embedding_mode_id=?", modelVo.getId()) > 0) {
          return ResultVo.fail(400, "被知识库使用的向量模型不能直接更换模型 ID 或 API 地址，请新建模型和知识库");
        }
      }
      try {
        validateModel(modelVo);
      } catch (Exception e) {
        return ResultVo.fail(400, "模型校验失败，请检查模型 ID、API 地址、密钥、额度；向量模型须支持 1024 维");
      }
    } catch (IllegalArgumentException e) {
      return ResultVo.fail(400, e.getMessage());
    } catch (Exception e) {
      return ResultVo.fail(400, "模型校验失败，请检查模型 ID、API 地址、密钥及平台额度");
    }

    Aop.get(ModelDao.class).saveOrUpdate(userId, modelVo);
    return ResultVo.ok();
  }

  static void validateModel(ModelVo model) throws IOException {
    CredentialVo credential = model.getCredential();
    if ("EMBEDDING".equals(model.getModel_type())) {
      com.alibaba.fastjson2.JSONObject input = new com.alibaba.fastjson2.JSONObject();
      input.put("model", model.getModel_name());
      input.put("input", List.of("模型连接测试"));
      input.put("dimensions", 1024);
      try (Response response = OpenAiClient.embeddings(credential.getApi_base(), credential.getApi_key(), input.toJSONString())) {
        if (!response.isSuccessful() || response.body() == null) {
          throw new IllegalArgumentException("向量模型校验失败，HTTP " + response.code());
        }
        float[] vector = com.alibaba.fastjson2.JSON.parseObject(response.body().string()).getJSONArray("data").getJSONObject(0).getObject("embedding", float[].class);
        if (vector == null || vector.length != 1024) {
          throw new IllegalArgumentException("当前知识库需要 1024 维向量，请选用支持 dimensions=1024 的模型");
        }
        for (float value : vector) {
          if (!Float.isFinite(value)) {
            throw new IllegalArgumentException("向量模型返回无效数据");
          }
        }
      }
    } else {
      nexus.io.chat.UniChatRequest request = new nexus.io.chat.UniChatRequest();
      request.setModel(model.getModel_name()).setApiPrefixUrl(credential.getApi_base()).setApiKey(credential.getApi_key())
          .setStream(false).setMessages(List.of(new UniChatMessage("user", "Reply OK")));
      nexus.io.chat.UniChatResponse response = nexus.io.chat.UniChatClient.generate(request);
      if (response == null || response.getRawData() == null) {
        throw new IllegalArgumentException("模型未返回有效响应");
      }
    }
  }

  public ResultVo delete(Long id) {
    if (Db.queryLong("select count(*) from moss_kb_dataset where embedding_mode_id=?", id) > 0
        || Db.queryLong("select count(*) from moss_kb_application where model_id=?", id) > 0) {
      return ResultVo.fail(400, "该模型仍被应用或知识库使用");
    }
    boolean ok = Aop.get(ModelDao.class).deleteById(id);
    if (ok) {
      return ResultVo.ok();
    } else {
      return ResultVo.fail();
    }
  }

  public ResultVo get(Long id) {
    Row record = Db.findById(MossKbTableNames.moss_kb_model, id);
    if (record == null) {
      return ResultVo.fail(404, "模型不存在");
    }
    CredentialVo credential = ModelCatalogService.credential(record);
    record.getColumns().remove("credential");
    Kv kv = record.toKv();
    credential.setApi_key("********");
    kv.set("credential", credential);
    kv.set("id", String.valueOf(id));
    kv.set("model_params_form", com.alibaba.fastjson2.JSON.parseArray(record.getStr("model_params_form")));
    return ResultVo.ok(kv);
  }

  public PlatformInput getEmbeddingPlatformInput(Long embedding_mode_id) {
    String sqlModelName = String.format("SELECT provider,model_name FROM %s WHERE id = ?",
        MossKbTableNames.moss_kb_model);
    MossKbModel mossKbModel = MossKbModel.dao.findFirst(sqlModelName, embedding_mode_id);
    String embeddingPlatformName = null;
    String embeddingModel = null;
    if (mossKbModel != null) {
      embeddingPlatformName = mossKbModel.getProvider();
      embeddingModel = mossKbModel.getModelName();
    } else {
      embeddingPlatformName = MossKbEnvUtils.getEmbeddingPlatform();
      embeddingModel = MossKbEnvUtils.getEmbeddingModel();
    }
    PlatformInput platformInput = new PlatformInput(embeddingPlatformName, embeddingModel);
    return platformInput;
  }
}

package nexus.io.mosskb.dao;

import java.util.Map;

import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;
import nexus.io.mosskb.constant.MossKbTableNames;
import nexus.io.mosskb.vo.ModelVo;
import nexus.io.tio.utils.snowflake.SnowflakeIdUtils;

public class ModelDao {

  public void save(Map<String, Object> map) {
    Db.save(MossKbTableNames.moss_kb_model, Row.fromMap(map));
  }

  public boolean deleteById(Long id) {
    return Db.deleteById(MossKbTableNames.moss_kb_model, id);
  }

  public boolean saveOrUpdate(Long userId, ModelVo modelVo) {
    Row record = new Row();
    record.set("name", modelVo.getName()).set("model_type", modelVo.getModel_type()).set("model_name", modelVo.getModel_name())
        //
        .set("permission_type", modelVo.getPermission_type())
        //
        .set("credential", modelVo.getCredential()).set("status", "SUCCESS");

    String provider = modelVo.getProvider();
    if (provider != null) {
      record.set("provider", provider);
    }

    if (modelVo.getModel_params_form() != null) {
      record.set("model_params_form", modelVo.getModel_params_form());
    }
    Long id = modelVo.getId();
    if (id != null) {
      record.set("id", id);
      return Db.update(MossKbTableNames.moss_kb_model, "id", record, new String[] { "credential", "model_params_form" });
    } else {
      record.set("id", SnowflakeIdUtils.id()).set("user_id", userId);
      return Db.save(MossKbTableNames.moss_kb_model, record, new String[] { "credential", "model_params_form" });
    }
  }

}

package nexus.io.mosskb.service.kb;

import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.jfinal.kit.Kv;
import nexus.io.chat.UniChatClient;
import nexus.io.chat.ChatModelResponse;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;
import nexus.io.mosskb.vo.CredentialVo;
import nexus.io.model.result.ResultVo;
import nexus.io.tio.utils.environment.EnvUtils;

/** Database-backed catalog; catalog membership is never a model ID whitelist. */
public class ModelCatalogService {
  public List<Kv> providers() {
    List<Kv> result = new ArrayList<>();
    for (Row row : Db.find("select provider,name,icon from moss_kb_model_provider where enabled=true order by sort_order,name")) {
      result.add(row.toKv());
    }
    return result;
  }

  public Row provider(String id) {
    return Db.findFirst("select * from moss_kb_model_provider where provider=? and enabled=true", id);
  }

  public Object types(String provider) {
    Row row = provider(provider);
    return row == null ? new JSONArray() : JSON.parseArray(row.getStr("model_types"));
  }

  public Object form(String provider, String column) {
    if (!List.of("credential_form", "params_form").contains(column)) {
      throw new IllegalArgumentException("Invalid form");
    }
    Row row = provider(provider);
    return row == null ? new JSONArray() : JSON.parseArray(row.getStr(column));
  }

  public List<Kv> models(String provider, String type) {
    List<Kv> result = new ArrayList<>();
    for (Row row : Db.find("select model_id as name,description as desc,model_type from moss_kb_model_catalog c "
        + "where provider=? and model_type=? and enabled=true and exists(select 1 from moss_kb_model_provider p where p.provider=c.provider and p.enabled=true) order by model_id", provider, type)) {
      result.add(row.toKv());
    }
    return result;
  }

  public static String baseUrl(String value) {
    if (value == null || value.isBlank()) {
      throw new IllegalArgumentException("请填写 API 域名");
    }
    String base = value.trim().replaceAll("/+$", "");
    URI uri = URI.create(base);
    if ((!"https".equals(uri.getScheme()) && !"http".equals(uri.getScheme())) || uri.getHost() == null
        || uri.getUserInfo() != null || uri.getQuery() != null || uri.getFragment() != null) {
      throw new IllegalArgumentException("API 域名须为 HTTP(S) 基础地址，不含密钥、查询参数或片段");
    }
    return base;
  }

  public static String modelId(String value) {
    if (value == null || value.isBlank() || value.length() > 256 || value.chars().anyMatch(Character::isISOControl)) {
      throw new IllegalArgumentException("请填写有效的模型 ID（最多 256 字符）");
    }
    return value.trim();
  }

  public static CredentialVo credential(Row model) {
    Object raw = model.get("credential");
    JSONObject object = raw == null ? new JSONObject() : raw instanceof java.util.Map ? (JSONObject) JSON.toJSON(raw) : JSON.parseObject(raw.toString());
    CredentialVo credential = new CredentialVo();
    credential.setApi_base(object.getString("api_base"));
    credential.setApi_key(object.getString("api_key"));
    // Only the two seeded Gitee models may use the server's Gitee credential.
    if ((Long.valueOf(1001).equals(model.getLong("id")) || Long.valueOf(1002).equals(model.getLong("id"))) && object.isEmpty()) {
      credential.setApi_base(KnowledgeModelService.baseUrl());
      credential.setApi_key(EnvUtils.get("GITEE_API_KEY"));
    }
    return credential;
  }

  public static boolean admin(Long userId) {
    return userId != null && Db.queryLong("select count(*) from moss_kb_user where id=? and role='ADMIN' and is_active=true and deleted=0", userId) > 0;
  }

  public ResultVo discover(Long userId, JSONObject input) {
    if (!admin(userId)) {
      return ResultVo.fail(403, "仅管理员可管理共享模型目录");
    }
    try {
      String base = baseUrl(input.getString("api_base"));
      String key = input.getString("api_key");
      if (key == null || key.isBlank()) {
        return ResultVo.fail(400, "请提供该平台的 API Key；发现操作不保存凭据");
      }
      ChatModelResponse response = UniChatClient.getModels(base, key);
      if (response == null || response.getData() == null) {
        return ResultVo.fail(400, "模型发现失败，请检查平台是否支持 /models 接口及密钥权限");
      }
      return ResultVo.ok(response.getData());
    } catch (Exception e) {
      return ResultVo.fail(400, "模型发现失败，请检查 API 地址及凭据");
    }
  }

  public ResultVo saveCatalog(Long userId, JSONObject input) {
    if (!admin(userId)) {
      return ResultVo.fail(403, "仅管理员可管理共享模型目录");
    }
    try {
      String provider = input.getString("provider");
      if (provider(provider) == null) {
        return ResultVo.fail(400, "供应商不存在或已停用");
      }
      JSONArray models = input.getJSONArray("models");
      if (models == null || models.size() > 5000) {
        return ResultVo.fail(400, "models 必须是最多 5000 项的数组");
      }
      for (int i = 0; i < models.size(); i++) {
        JSONObject model = models.getJSONObject(i);
        modelId(model.getString("name"));
        if (!List.of("LLM", "EMBEDDING").contains(model.getString("model_type"))) {
          return ResultVo.fail(400, "当前支持 LLM 和 EMBEDDING 类型");
        }
      }
      Db.tx(() -> {
        for (int i = 0; i < models.size(); i++) {
          JSONObject model = models.getJSONObject(i);
          Db.update("insert into moss_kb_model_catalog(provider,model_type,model_id,description,source,enabled) values(?,?,?,?,?,?) "
              + "on conflict(provider,model_type,model_id) do update set description=excluded.description,source=excluded.source,enabled=excluded.enabled,updated_at=now()",
              provider, model.getString("model_type"), modelId(model.getString("name")), model.getString("desc"),
              "admin", !Boolean.FALSE.equals(model.getBoolean("enabled")));
        }
        return true;
      });
      return ResultVo.ok(Kv.by("updated", models.size()));
    } catch (IllegalArgumentException e) {
      return ResultVo.fail(400, e.getMessage());
    }
  }
}