结构化输出与 Schema 校验：JSON Mode 与手写轻量级类型验证器

export const s = {
  string: (opts = {}) => ({
    type: 'string',
    ...opts,
    validate(val, path = '$') {
      if (typeof val !== 'string') return [`${path}: 期望 string，实际为 ${typeof val}`]
      if (opts.enum && !opts.enum.includes(val)) {
        return [`${path}: 值 "${val}" 不在允许枚举 [${opts.enum.join(', ')}] 内`]
      }
      if (opts.minLength && val.length < opts.minLength) {
        return [`${path}: 长度不能小于 ${opts.minLength}`]
      }
      return []
    }
  }),

  number: (opts = {}) => ({
    type: 'number',
    ...opts,
    validate(val, path = '$') {
      if (typeof val !== 'number' || Number.isNaN(val)) {
        return [`${path}: 期望有效 number，实际为 ${JSON.stringify(val)}`]
      }
      if (opts.min !== undefined && val < opts.min) return [`${path}: 不能小于 ${opts.min}`]
      if (opts.max !== undefined && val > opts.max) return [`${path}: 不能大于 ${opts.max}`]
      return []
    }
  }),

  array: (itemSchema, opts = {}) => ({
    type: 'array',
    items: itemSchema,
    ...opts,
    validate(val, path = '$') {
      if (!Array.isArray(val)) return [`${path}: 期望 array，实际为 ${typeof val}`]
      return val.flatMap((item, i) => itemSchema.validate(item, `${path}[${i}]`))
    }
  }),

  object: (shape, { required = Object.keys(shape) } = {}) => ({
    type: 'object',
    properties: shape,
    required,
    additionalProperties: false,
    validate(val, path = '$') {
      if (typeof val !== 'object' || val === null || Array.isArray(val)) {
        return [`${path}: 期望非空 object`]
      }
      const errs = []
      for (const reqKey of required) {
        if (!(reqKey in val) || val[reqKey] === undefined) {
          errs.push(`${path}.${reqKey}: 缺少必填字段`)
        }
      }
      for (const [k, propSchema] of Object.entries(shape)) {
        if (val[k] !== undefined) {
          errs.push(...propSchema.validate(val[k], `${path}.${k}`))
        }
      }
      return errs
    }
  })
}

// 从夹杂 Markdown 围栏或解释文字的模型回复中安全剥离 JSON
export function extractJsonObject(rawText) {
  const text = String(rawText || '').trim()
  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text)
  const candidate = fenced ? fenced[1].trim() : text
  const firstBrace = candidate.search(/[{[]/)
  const lastBrace = Math.max(candidate.lastIndexOf('}'), candidate.lastIndexOf(']'))
  if (firstBrace === -1 || lastBrace === -1 || lastBrace < firstBrace) {
    throw new Error('回复中未找到有效的 JSON 括号边界')
  }
  return JSON.parse(candidate.slice(firstBrace, lastBrace + 1))
}

// 带自愈反馈的结构化推理调用器
export async function generateStructured({ llm, messages, schema, maxRetries = 3 }) {
  const workingMessages = [...messages]

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    const res = await llm.chat({
      messages: workingMessages,
      response_format: { type: 'json_object' }
    })
    const raw = res.message.content || ''

    try {
      const parsed = extractJsonObject(raw)
      const errors = schema.validate(parsed)
      if (errors.length === 0) return parsed

      // 校验未通过：把具体哪个字段错、期望什么类型直接反馈给模型重修
      workingMessages.push(
        { role: 'assistant', content: raw },
        {
          role: 'user',
          content: `你输出的 JSON 未通过 Schema 校验，错误如下：
${errors.join('
')}
请严格修正上述字段并重新输出合法 JSON。`
        }
      )
    } catch (parseErr) {
      workingMessages.push(
        { role: 'assistant', content: raw },
        {
          role: 'user',
          content: `JSON 解析语法错误：${parseErr.message}。请仅输出严格合法的 JSON 字符串。`
        }
      )
    }
  }
  throw new Error(`结构化输出在重试 ${maxRetries} 次后仍未通过 Schema 校验`)
}