agentSdk.registerAudio2Tts(Audio2TtsCallback(agentSdk: agentSdk) {})

// 或继承并重载：
final class MyAudio2Tts: Audio2TtsCallback {
    override func onRobotOnline(agentId: String, agentMeta: AgentMeta) {
        // 机器人上线：初始化该机器人资源
        // agentMeta 含唤醒词、城市等配置
        let wakeup = agentMeta.wakeupWord
    }

    override func onRobotOffline(agentId: String) {
        // 机器人下线：清理该机器人资源
    }

    override func onRequest(
        agentId: String, eventId: String, itemId: String,
        flag: Int, audio: Data?, param: AgentParam,
        response: Audio2TtsResponse
    ) {
        switch flag {
        case 0:
            // VAD 开始：初始化 ASR 会话
            break
        case 1:
            // 音频帧：发给 ASR 做流式识别
            sendToAsr(audio)
        case 2:
            // VAD 结束：完成 ASR → LLM → TTS
            let asrText = finalizeAsr()
            response.onAsrFinal(eventId: eventId, finalAsr: asrText)

            let llmReply = callLlm(asrText)
            response.onLlmItemDelta(eventId: eventId, itemId: itemId, textDelta: llmReply)
            response.onLlmItemDone(eventId: eventId, itemId: itemId)
            response.onLlmDone(eventId: eventId)

            let ttsAudio = synthesizeTts(llmReply)   // Data
            response.onTtsItemDelta(eventId: eventId, itemId: itemId, audio: ttsAudio)
            response.onTtsItemDone(eventId: eventId, itemId: itemId)
            response.onTtsDone(eventId: eventId)
        default:
            break
        }
    }
}
agentSdk.registerAudio2Tts(MyAudio2Tts(agentSdk: agentSdk))

onRequest(flag=0) → 初始化
onRequest(flag=1) → 累积音频 → ASR 流式识别
                              └→ onAsrMiddle()（可选，中间结果）
onRequest(flag=2) → ASR 完成 → onAsrFinal()
                            → LLM 调用 → onLlmItemDelta() × N
                                       → onLlmItemDone()
                                       → onLlmDone()
                            → TTS 合成 → onTtsItemDelta() × N
                                       → onTtsItemDone()
                                       → onTtsDone()

onRequest(text="今天天气怎么样")
      │
      ▼
语义理解分类
      ├─ 拒识 → 直接 return，不调用任何 response.on* 方法
      │
      └─ 有效指令
           ① 必须先 response.onInterrupt(...)
           ② 再按命中结果回填 onSkill / onLlm* / onVlm* / onTts*

override func onRequest(agentId: String, eventId: String, text: String,
                        param: AgentParam, response: Asr2LlmResponse) {

    let nlu = classify(text)   // 业务侧语义理解

    // ① 拒识：直接 return
    if nlu.isRejected { return }

    let itemId = IdGenerator.generateItemId()

    // ② 有效指令——必须先打断
    if nlu.isRiskControl {
        response.onInterrupt(eventId: eventId, interruptType: "risk_control",
                             interruptTips: "你谈到敏感话题了，咱们换个话题聊吧")
        return
    } else if nlu.isSkill {
        response.onInterrupt(eventId: eventId, interruptType: "action", interruptTips: nil)
    } else {
        response.onInterrupt(eventId: eventId, interruptType: "chat", interruptTips: nil)
    }

    // ③ 命中技能：下发 skillParam
    if nlu.isSkill {
        let skillParam = AgentParam.create()
            .setString("movement", "move_forward")
            .setInt("meter", 10)
        response.onSkill(eventId: eventId, itemId: itemId,
                         skillType: "movement", skillName: "move_forward",
                         skillParam: skillParam)
    }

    // ④ LLM 流式回复
    response.onLlmItemDelta(eventId: eventId, itemId: itemId, textDelta: "好的，我开始向前走。")
    response.onLlmItemDone(eventId: eventId, itemId: itemId)
    response.onLlmDone(eventId: eventId)
}

override func onFunctionCall(agentId: String, eventId: String,
                             functionCall: FunctionCallInfo, response: Asr2LlmResponse) {
    // functionCall 描述了本次待处理的 function call
}

response.onArbiter(eventId: eventId, decision: ArbiterDecision.delegate.decision, arbParam: nil)

override func onFunctionCall(agentId: String, eventId: String,
                             functionCall: FunctionCallInfo, response: Audio2TtsResponse) {
    if functionCall.policy == "body" {
        response.onArbiter(eventId: eventId, decision: ArbiterDecision.delegate.decision, arbParam: nil)
    } else if functionCall.policy == "cloud" {
        response.onArbiter(eventId: eventId, decision: ArbiterDecision.override.decision, arbParam: nil)
    }
}

override func onGreetSignal(agentId: String, eventId: String,
                            param: AgentParam, response: GreetResponse) {
    // 模式一：VLM 文本流式应答
    response.onGreetVlmDelta(eventId: eventId, textDelta: "你好")
    response.onGreetVlmDone(eventId: eventId)

    // 模式二：TTS 音频流式应答（textDelta 是 base64 编码的音频字符串片段）
    response.onGreetTtsDelta(eventId: eventId, textDelta: base64Chunk1)
    response.onGreetTtsDone(eventId: eventId)

    // response.onError(eventId: eventId, errorCode: 5101, errorMsg: "打招呼生成失败")
}