217 lines
7.6 KiB
TypeScript
217 lines
7.6 KiB
TypeScript
import type { PlanningRequest } from '@/domain/travel'
|
||
|
||
interface RemoteAPIError {
|
||
detail?: unknown
|
||
}
|
||
|
||
export interface RemotePoiCandidate {
|
||
id: string
|
||
name: string
|
||
categoryCode: string
|
||
tagCodes: string[]
|
||
summary: string
|
||
recommendationIndex: number
|
||
}
|
||
|
||
export interface RemotePoiCandidateInput {
|
||
id: string
|
||
name: string
|
||
categoryCode: string
|
||
tagCodes: readonly string[]
|
||
summary: string
|
||
recommendationIndex: number
|
||
}
|
||
|
||
export interface RemoteRecommendationItem {
|
||
poiId: string
|
||
reason: string
|
||
order: number
|
||
}
|
||
|
||
export interface RemoteRecommendationResponse {
|
||
requestId: string
|
||
mode: PlanningRequest['mode']
|
||
assistantMessage: string
|
||
recommendations: RemoteRecommendationItem[]
|
||
generationMode: 'mock' | 'real'
|
||
}
|
||
|
||
function apiBaseUrl(): string {
|
||
const value = import.meta.env.VITE_TRAVEL_ASSISTANT_API_BASE_URL
|
||
return typeof value === 'string' ? value.trim().replace(/\/+$/, '') : ''
|
||
}
|
||
|
||
export function isRemoteTravelAssistantEnabled(): boolean {
|
||
return apiBaseUrl().length > 0
|
||
}
|
||
|
||
function remoteUrl(path: string): string {
|
||
const baseUrl = apiBaseUrl()
|
||
if (!/^https?:\/\//i.test(baseUrl))
|
||
throw new Error('VITE_TRAVEL_ASSISTANT_API_BASE_URL 必须是有效的 HTTP(S) 地址')
|
||
return `${baseUrl}${path}`
|
||
}
|
||
|
||
function errorDetail(data: unknown, statusCode: number): string {
|
||
if (typeof data === 'object' && data !== null) {
|
||
const detail = (data as RemoteAPIError).detail
|
||
if (typeof detail === 'string' && detail.trim())
|
||
return detail.trim()
|
||
}
|
||
return `行程服务请求失败（${statusCode}）`
|
||
}
|
||
|
||
function request<T>(options: UniApp.RequestOptions): Promise<T> {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
...options,
|
||
success(response) {
|
||
if (response.statusCode >= 200 && response.statusCode < 300) {
|
||
resolve(response.data as T)
|
||
return
|
||
}
|
||
reject(new Error(errorDetail(response.data, response.statusCode)))
|
||
},
|
||
fail() {
|
||
reject(new Error('无法连接行程服务，请检查网络、服务地址和微信合法域名配置'))
|
||
},
|
||
})
|
||
})
|
||
}
|
||
|
||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
||
}
|
||
|
||
function readNonEmptyString(value: unknown, fieldName: string, maxLength: number): string {
|
||
if (typeof value !== 'string' || !value.trim() || value.trim().length > maxLength)
|
||
throw new Error(`AI 推荐响应中的${fieldName}格式无效`)
|
||
return value.trim()
|
||
}
|
||
|
||
function safeCandidates(candidates: readonly RemotePoiCandidateInput[]): RemotePoiCandidate[] {
|
||
if (candidates.length < 1 || candidates.length > 100)
|
||
throw new Error('发送给 AI 的 POI 候选数量必须为 1 至 100 个')
|
||
|
||
const ids = new Set<string>()
|
||
return candidates.map((candidate) => {
|
||
const id = candidate.id.trim()
|
||
if (!id || ids.has(id))
|
||
throw new Error(`发送给 AI 的 POI ID 无效或重复：${id || '空值'}`)
|
||
const name = candidate.name.trim()
|
||
const categoryCode = candidate.categoryCode.trim()
|
||
const summary = candidate.summary.trim()
|
||
if (!name || name.length > 100)
|
||
throw new Error(`发送给 AI 的 POI 名称无效：${id}`)
|
||
if (!categoryCode || categoryCode.length > 64)
|
||
throw new Error(`发送给 AI 的 POI 分类无效：${id}`)
|
||
if (summary.length > 300)
|
||
throw new Error(`发送给 AI 的 POI 摘要过长：${id}`)
|
||
if (!Number.isInteger(candidate.recommendationIndex)
|
||
|| candidate.recommendationIndex < 1
|
||
|| candidate.recommendationIndex > 5) {
|
||
throw new Error(`发送给 AI 的 POI 推荐指数无效：${id}`)
|
||
}
|
||
const tagCodes = [...new Set(candidate.tagCodes.map(tagCode => tagCode.trim()).filter(Boolean))]
|
||
if (tagCodes.length > 20 || tagCodes.some(tagCode => tagCode.length > 64))
|
||
throw new Error(`发送给 AI 的 POI 标签无效：${id}`)
|
||
ids.add(id)
|
||
return {
|
||
id,
|
||
name,
|
||
categoryCode,
|
||
tagCodes,
|
||
summary,
|
||
recommendationIndex: candidate.recommendationIndex,
|
||
}
|
||
})
|
||
}
|
||
|
||
function normalizeRecommendations(
|
||
value: unknown,
|
||
planningRequest: PlanningRequest,
|
||
candidates: readonly RemotePoiCandidate[],
|
||
): RemoteRecommendationResponse {
|
||
if (!isRecord(value))
|
||
throw new Error('AI 推荐响应格式无效')
|
||
if (value.mode !== planningRequest.mode)
|
||
throw new Error('AI 推荐响应的规划模式不匹配')
|
||
if (value.generationMode !== 'mock' && value.generationMode !== 'real')
|
||
throw new Error('AI 推荐响应的生成模式无效')
|
||
if (!Array.isArray(value.recommendations) || value.recommendations.length < 1 || value.recommendations.length > 8)
|
||
throw new Error('AI 推荐响应必须包含 1 至 8 个 POI')
|
||
|
||
const allowedIds = new Set(candidates.map(candidate => candidate.id))
|
||
const seenIds = new Set<string>()
|
||
const seenOrders = new Set<number>()
|
||
const recommendations = value.recommendations.map((item): RemoteRecommendationItem => {
|
||
if (!isRecord(item))
|
||
throw new Error('AI 推荐项格式无效')
|
||
const poiId = readNonEmptyString(item.poiId, 'POI ID', 100)
|
||
if (!allowedIds.has(poiId))
|
||
throw new Error(`AI 返回了候选白名单外的 POI：${poiId}`)
|
||
if (seenIds.has(poiId))
|
||
throw new Error(`AI 返回了重复 POI：${poiId}`)
|
||
if (!Number.isInteger(item.order) || (item.order as number) < 1 || (item.order as number) > 8)
|
||
throw new Error('AI 推荐响应中的顺序格式无效')
|
||
if (seenOrders.has(item.order as number))
|
||
throw new Error('AI 推荐响应中存在重复顺序')
|
||
seenIds.add(poiId)
|
||
seenOrders.add(item.order as number)
|
||
return {
|
||
poiId,
|
||
reason: readNonEmptyString(item.reason, '推荐理由', 300),
|
||
order: item.order as number,
|
||
}
|
||
}).sort((left, right) => left.order - right.order)
|
||
|
||
if (recommendations.some((item, index) => item.order !== index + 1))
|
||
throw new Error('AI 推荐响应中的顺序必须从 1 连续递增')
|
||
if (planningRequest.mode === 'custom') {
|
||
const selectedIds = new Set(planningRequest.selectedPoiIds)
|
||
if (recommendations.length !== selectedIds.size
|
||
|| recommendations.some(item => !selectedIds.has(item.poiId))) {
|
||
throw new Error('AI 自选规划未完整保留用户选择的 POI')
|
||
}
|
||
}
|
||
|
||
return {
|
||
requestId: readNonEmptyString(value.requestId, '请求 ID', 200),
|
||
mode: planningRequest.mode,
|
||
assistantMessage: readNonEmptyString(value.assistantMessage, '助手消息', 1000),
|
||
recommendations,
|
||
generationMode: value.generationMode,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Requests coordinate-free POI recommendations. The caller must calculate the
|
||
* final route and duration locally; planningRequest.origin is never uploaded.
|
||
*/
|
||
export async function createRemoteRecommendations(
|
||
planningRequest: PlanningRequest,
|
||
candidateInputs: readonly RemotePoiCandidateInput[],
|
||
): Promise<RemoteRecommendationResponse> {
|
||
const candidates = safeCandidates(candidateInputs)
|
||
const response = await request<unknown>({
|
||
url: remoteUrl('/api/v1/plans'),
|
||
method: 'POST',
|
||
data: {
|
||
mode: planningRequest.mode,
|
||
preferences: {
|
||
destination: planningRequest.preferences.destination,
|
||
themes: [...planningRequest.preferences.themes],
|
||
pace: planningRequest.preferences.pace,
|
||
interests: [...planningRequest.preferences.interests],
|
||
transport: planningRequest.preferences.transport,
|
||
},
|
||
durationMinutes: planningRequest.durationMinutes,
|
||
selectedPoiIds: [...planningRequest.selectedPoiIds],
|
||
candidates,
|
||
},
|
||
header: { 'content-type': 'application/json' },
|
||
timeout: 50000,
|
||
})
|
||
return normalizeRecommendations(response, planningRequest, candidates)
|
||
}
|