一级转运中心 (OLT)  ──干线──▶  一级转运中心 (OLT)     例：北京 → 上海
        │
        │ 支线
        ▼
二级转运中心 (TLT)  ──接驳──▶  网点 (AGENCY)          例：北京朝阳 → 通州
        │
        │ 接驳
        ▼
      网点 (AGENCY)

// chain-cloud-ms-transport-service entity/node/
@Node("AGENCY")  public class AgencyEntity extends BaseEntity {}   // 网点
@Node("OLT")     public class OLTEntity     extends BaseEntity {}   // 一级转运中心
@Node("TLT")     public class TLTEntity     extends BaseEntity {}   // 二级转运中心

@Id @GeneratedValue private Long id;          // Neo4j 内部 id
private Long parentId;                        // 父节点（OLT 的 parentId 固定为 0）
private Long bid;                             // 业务 id（对应 MySQL 里的机构 id）
private String name; private String managerName; private String phone;
private String address;
private Point location;                       // 经纬度（Neo4j Point）
private Boolean status;
private String extra;                         // 扩展 JSON
public abstract OrganTypeEnum getAgencyType(); // 类型

// TransportLineRepositoryImpl#create
String cypher = """
    MATCH (m:{}) {bid : $startId}
    WITH m  MATCH (n:{}) {bid : $endId}  WITH m,n
    CREATE
    (m) -[r:IN_LINE  {cost:$cost, number:$number, type:1, name:$name,
                     distance:$distance, time:$time, extra:'',
                     startOrganId:$startOrganId, endOrganId:$endOrganId}]-> (n),
    (m) <-[:OUT_LINE {cost:$cost, number:$number, type:1, name:$name,
                     distance:$distance, time:$time, extra:'',
                     startOrganId:$endOrganId,   endOrganId:$startOrganId}]- (n)
    RETURN count(r) AS c
    """;

// 标签从 @Node 注解反射拿到，不是硬编码
String firstType  = firstNode.getClass().getAnnotation(Node.class).value()[0];
String secondType = secondNode.getClass().getAnnotation(Node.class).value()[0];

// DispatchConfigurationServiceImpl
public DispatchConfigurationDTO findConfiguration() {
    String dispatchTime   = opsForValue().get("DISPATCH_CONFIGURATION:TIME");    // 默认 2 小时
    String dispatchMethod = opsForValue().get("DISPATCH_CONFIGURATION:METHOD");  // 默认 2 = 成本最低
    ...
}

// TransportLineServiceImpl#queryPathByDispatchMethod
@Override
public TransportLineNodeDTO queryPathByDispatchMethod(Long startId, Long endId) {
    // 调度方式：1-转运次数最少，2-成本最低
    Integer dispatchMethod = dispatchConfigurationService.findConfiguration().getDispatchMethod();
    if (dispatchMethod == 1) {
        return queryShortestPath(startId, endId);
    }
    return findLowestPath(startId, endId);
}

// TransportLineRepositoryImpl#findShortestPath
String cypherQuery = StrUtil.format(
    "MATCH path = shortestPath((start:{}) -[*..{}]-> (end:{}))\n" +
    "WHERE start.bid = $startId AND end.bid = $endId \n" +
    "RETURN path", type, depth, type);

// TransportLineRepositoryImpl#findLowestPath
String cypherQuery = StrUtil.format(
    "MATCH path = (n:{}) -[*..10]->(m:{})\n" +
    "WHERE n.bid = $startId AND m.bid = $endId\n" +
    "UNWIND relationships(path) AS r\n" +
    "WITH sum(r.cost) AS cost, path\n" +
    "RETURN path ORDER BY cost ASC, LENGTH(path) ASC LIMIT 1", type, type);

// TransportLineServiceImpl#initMap
Coordinate origin      = new Coordinate(startOrgan.getLongitude(), startOrgan.getLatitude());
Coordinate destination = new Coordinate(endOrgan.getLongitude(), endOrgan.getLatitude());
Map<String, Object> params = new HashMap<>();
params.put("show_fields", "cost");          // 高德默认不返回 cost 字段，必须显式要
String driving = eagleMapTemplate.opsForDirection().driving(ProviderEnum.AMAP, origin, destination, params);
JSONObject jsonObject = JSONUtil.parseObj(driving);
Integer distance = jsonObject.getByPath("route.paths[0].distance", Integer.class);  // 米
Long    duration = jsonObject.getByPath("route.paths[0].cost.duration", Long.class);  // 秒

// 基准成本 = 距离(km) × 该线路类型的每公里单价
Double costPerKm = costConfigurationService.findCostByType(transportLine.getType());
Double baseCost  = NumberUtil.round(distance / 1000 * costPerKm, 2).doubleValue();

// CostConfigurationServiceImpl
private static final Map<Object, Object> DEFAULT_COST = Map.of(
        TransportLineEnum.TRUNK_LINE.getCode(),   0.6,   // 干线 0.6 元/km
        TransportLineEnum.BRANCH_LINE.getCode(),  1.0,   // 支线 1.0 元/km
        TransportLineEnum.CONNECT_LINE.getCode(), 1.5);  // 接驳 1.5 元/km

请根据以下新建路线信息输出路线 cost 修正因子 JSON。

【路线基础信息】
- lineType: {lineType}
- startOrganId / endOrganId / startOrganName / endOrganName
- startOrganLevel / endOrganLevel        ← 机构级别：OLT / TLT / AGENCY
- startCoordinate / endCoordinate

【基础成本信息】
- unitCostByType: {unitCostByType}        ← 每公里单价
- baseCost: {baseCost}                    ← Java 已经算好的基准成本

【程序已知上下文】
- sameCity / sameProvince / crossProvince ← 同城/省内/跨省
- preCalculatedDistanceKm                ← 高德算的实际路网距离
- preCalculatedDurationHour
- straightLineDistanceKm                 ← Haversine 直线距离（绕路程度的分母）

要求：
1. 你可以自主决定是否调用高德 MCP 工具；
2. 如果已有输入足够，请减少无意义工具调用；
3. 你只能输出 JSON；
4. 不要输出 finalCost；          ← ★ 明确禁止 LLM 输出最终金额
5. 所有 factor 必须在合法范围内；
6. 信息不足时采用保守输出。

// TransportLineServiceImpl#initMap（第 159-191 行）
// 获取每一个因子，判断是否在 0.95 到 1.10 之间，不在则直接赋值 1.0
List<Double> factors = List.of(
        costFactorResponse.getRegionFactor(),
        costFactorResponse.getDistanceSegmentFactor(),
        costFactorResponse.getEfficiencyFactor(),
        costFactorResponse.getTollFactor(),
        costFactorResponse.getDetourFactor(),
        costFactorResponse.getRouteComplexityFactor(),
        costFactorResponse.getCorridorFactor(),
        costFactorResponse.getSimilarityCalibrationFactor(),
        costFactorResponse.getAccessFactor());

double multiplier = 1.0;
for (Double factor : factors) {
    if (factor == null || factor < 0.95 || factor > 1.10) {
        factor = 1.0;                       // ← 越界或空 → 回归中性值
    }
    multiplier *= factor;
}

// 乘积再做一次粗粒度保护：9 个 1.10 相乘可达 1.10^9 ≈ 2.36
if (multiplier < 0.85 || multiplier > 1.25) {
    multiplier = 1.0;
}

// 最终成本 = 乘积 × Java 算好的基准成本
double finalCost = NumberUtil.round(multiplier * baseCost, 2).doubleValue();
transportLine.setCost(finalCost);
transportLine.setExtra(costFactorResponse.getReason());   // 理由入库，可审计

单因子 ∈ [0.95, 1.10]  → 9 个因子乘积理论范围 [0.95^9, 1.10^9] ≈ [0.63, 2.36]
乘积   ∈ [0.85, 1.25]  → 收窄到 ±15% / ±25%

// AuthMQListener#resolveOrganType
private OrganTypeEnum resolveOrganType(String name) {
    // - xxx转运中心  →  一级转运中心（OLT）
    // - xxx分拣中心 →  二级转运中心 （TLT）
    // - xxx营业部  →  网点（AGENCY）
    if (name.endsWith("转运中心")) {
        return OrganTypeEnum.OLT;
    } else if (name.endsWith("分拣中心")) {
        return OrganTypeEnum.TLT;
    } else if (name.endsWith("营业部")) {
        return OrganTypeEnum.AGENCY;
    } else {
        // TODO
        return null;          // ← 返回 null，后面的 switch 会 NPE
    }
}

1. 权威源：权限中心的机构表里本来就有 orgType/orgLevel 字段，直接同步过来
2. 兜底：关键字匹配（保留现在的逻辑）
3. 再兜底：AI 分类（Agent 1005），返回 UNKNOWN 时走人工确认队列

transportLine.setExtra(costFactorResponse.getReason());

double straightLineKm = DistanceCalculator.calculateDistance(
        startOrgan.getLongitude(), startOrgan.getLatitude(),
        endOrgan.getLongitude(),   endOrgan.getLatitude());

// 启动时抽样校验：经度必须在 [-180,180]，纬度必须在 [-90,90]
// 北京的经度 ~116.3，如果被当纬度存就是 116.3（>90），一眼看出问题

neo4jClient.query(cypherQuery)
    .bind(start.getBid()).to("startId")
    .bind(end.getBid()).to("endId")

// TransportLineRepositoryImpl（分页查询）
StringBuilder whereBuilder = new StringBuilder();
if (StrUtil.isNotBlank(dto.getName())) {
    whereBuilder.append(" AND r.name CONTAINS '").append(dto.getName()).append("'");
}
if (StrUtil.isNotBlank(dto.getNumber())) {
    whereBuilder.append(" AND r.number CONTAINS '").append(dto.getNumber()).append("'");
}
if (dto.getStartOrganId() != null) {
    whereBuilder.append(" AND r.startOrganId = ").append(dto.getStartOrganId());
}

// OrganRepositoryImpl#findByBid
var cypherQuery = StrUtil.format("""
        MATCH (n)
        WHERE n.bid = {}
        RETURN n""", bid);

neo4jClient.query("MATCH ()-[r]->() WHERE r.name CONTAINS $name RETURN r")
    .bind(name).to("name")

// create 里 RETURN count(r) AS c   —— count 的是 IN_LINE，返回 1

MATCH ()-[r]->() WHERE id(r) = $lineId
DELETE r

@ApiOperation(value = "删除路线", notes = "删除路线，单向删除")

// 一次删两个方向
MATCH (a)-[r:IN_LINE|OUT_LINE]-(b)
WHERE id(r) = $lineId OR {startOrganId: a.bid, endOrganId: b.bid} = ...

// TransportLineServiceImpl#createLine
switch (transportLineEnum) {
    case TRUNK_LINE:   firstNode = new OLTEntity();    secondNode = new OLTEntity();    break;
    case BRANCH_LINE:  firstNode = new TLTEntity();    secondNode = new OLTEntity();    break;
    case CONNECT_LINE: firstNode = new AgencyEntity(); secondNode = new TLTEntity();    break;
    default: break;    // ← SPECIAL_LINE(专线) 和 TEMP_LINE(临时线路) 落到这里
}
...
Long count = transportLineRepository.queryCount(firstNode, secondNode);  // ← NPE

// 只 putAll，不 delete
stringRedisTemplate.opsForHash().putAll(CC_TRANSPORT_COST_REDIS_KEY, costMap);

CostFactorResponse costFactorResponse = aigcFeign.identifyCostInfo(routeInfo);
// 没有 try-catch，没有 fallbackFactory，没有熔断

# chain-cloud-ms-aigc-service/src/main/resources/bootstrap.yml
feign:
  client:
    config:
      default:
        connect-timeout: 10000
        read-timeout: 1000000      # ← 1000 秒 ≈ 16.7 分钟

// 1. 专属超时：给 AgentServerClient 单独配，不跟其它 Feign 共用
@FeignClient(name = "chain-cloud-agent-server", contextId = "AgentServer",
             path = "/",
             fallbackFactory = AgentServerFallback.class)   // 2. 降级
public interface AgentServerClient {
    @PostMapping("/chat")
    String chat(@RequestBody ChatRequestDTO chatRequestDTO);
}

// 3. Feign 层超时只能兜底，真正的解法是把超时前置
//    在 Java 侧用 CompletableFuture.orTimeout(3, TimeUnit.SECONDS)
//    或用 Resilience4j 的 TimeLimiter 包一层

feign:
  client:
    config:
      default:
        connect-timeout: 3000
        read-timeout: 5000
      chain-cloud-agent-server:      # 按服务名单独覆盖
        connect-timeout: 1000
        read-timeout: 3000

@Component
public class AgentServerFallback implements FallbackFactory<AgentServerClient> {
    @Override
    public AgentServerClient create(Throwable cause) {
        return dto -> {
            log.warn("AI 服务不可用，成本因子降级为中性值 1.0", cause);
            // 全 1.0 因子 → multiplier = 1.0 → finalCost = baseCost
            return JSONUtil.toBean("{\"regionFactor\":1.0,\"confidence\":0.0,\"reason\":\"AI_DEGRADED\"}",
                                   CostFactorResponse.class);
        };
    }
}