qwen-audio-agent 实时语音 Agent Runtime

86export function attachRealtimeGateway(server, {
87  identityManager,
88  memoryStore,
89  coordinator,
90  coordinatorAvailable = async () => true,
91  respondPermission,
92  permissionPolicy,
93}) {
94  const wss = new WebSocketServer({ noServer: true, maxPayload: 2 * 1024 * 1024 })
95  const activeVoiceClients = new ActiveVoiceClients()
96  const voiceConnections = new Map()
97
98  const broadcastVoiceOwnership = ownerId => {
99    const active = activeVoiceClients.active(ownerId)
100    const holder = active?.descriptor || null
101    for (const client of voiceConnections.get(ownerId) || []) {
102      send(client.ws, {
103        type: 'voice.ownership',
104        state: active === client
105          ? 'active'

187  async handle(event, callContext = {}) {
188    const callId = event.call_id || event.item?.call_id || ''
189    const toolName = event.name || event.item?.name || ''
190    if (!callId) throw new Error('Realtime 工具调用缺少 call_id')
191    if (this.processedCalls.has(callId)) return
192    this.processedCalls.add(callId)
193    if (this.processedCalls.size > 500) {
194      this.processedCalls.delete(this.processedCalls.values().next().value)
195    }
196
197    const turnId = callContext.turnId
198      || event.__voiceContext?.turnId
199      || this.getTurnId()
200    const generation = Number.isInteger(callContext.turnGeneration)
201      ? callContext.turnGeneration
202      : Number.isInteger(event.__voiceContext?.turnGeneration)
203        ? event.__voiceContext.turnGeneration
204        : this.getTurnGeneration()
205    let args = {}
206    try {
207      args = JSON.parse(event.arguments || '{}')
208    } catch {
209      // Invalid arguments are handled as missing fields below.
210    }
211
212    if (this.isStale(turnId, generation)) {
213      await this.closeStaleCall(callId, turnId)
214      return
215    }
216
217    if (toolName === GET_CURRENT_TIME_TOOL_NAME) {
218      await this.getCurrentTime(callId, turnId)
219      return
220    }
221    if (toolName === USER_MEMORY_TOOL_NAME) {
222      await this.userMemory(callId, turnId, generation, args)
223      return
224    }
225    if (toolName === CANCEL_AGENT_TASK_TOOL_NAME) {
226      await this.cancelAgentTask(callId, turnId, args)
227      return
228    }
229    if (toolName === GET_AGENT_TASK_STATUS_TOOL_NAME) {
230      await this.getAgentTaskStatus(callId, turnId, args)
231      return
232    }
233    if (toolName === RESPOND_AGENT_PERMISSION_TOOL_NAME) {
234      await this.respondAgentPermission(callId, turnId, args)
235      return
236    }
237    if (toolName !== DELEGATE_TOOL_NAME) {
238      await this.sendOutput(
239        callId,
240        failure('unsupported_tool', '当前无法执行这个操作。'),
241        turnId,
242      )
243      return
244    }

280      return this.coordinatorSessions.get(key)
281    }
282    if (this.coordinatorSessionPromises.has(key)) {
283      return this.coordinatorSessionPromises.get(key)
284    }
285    const pending = (async () => {
286      const stored = this.registry.get(key)
287      let session
288      if (stored?.sessionId) {
289        try {
290          session = await this.client.resumeSession(stored.sessionId, {
291            cwd: stored.cwd || this.directory,
292            mcpServers,
293            meta: this.coordinatorMeta(ownerId),
294            ownerId,
295            role: 'coordinator',
296          })
297          const accepted = this.profile.acceptResumedSession?.({
298            session,
299            role: 'coordinator',
300            coordinatorAgent: this.coordinatorAgent,
301          }) !== false
302          if (!accepted) {
303            this.registry.delete(key)
304            session = null
305          } else {
306            session.isNew = false
307          }
308        } catch {
309          this.registry.delete(key)
310        }
311      }
312      if (!session) {
313        session = await this.client.newSession({
314          cwd: this.directory,
315          mcpServers,
316          meta: this.coordinatorMeta(ownerId),
317          ownerId,
318          role: 'coordinator',
319        })
320        session.isNew = true
321      }
322      await this.configureSession(session, 'coordinator')
323      this.coordinatorSessions.set(key, session)
324      this.registry.set(key, session)
325      return session
326    })().finally(() => this.coordinatorSessionPromises.delete(key))
327    this.coordinatorSessionPromises.set(key, pending)
328    return pending
329  }

39test('confirms task notifications when client playback starts', () => {
40  assert.equal(confirmsTaskNotificationOnPlaybackStart({
41    origin: 'announcement',
42  }), true)
43  assert.equal(confirmsTaskNotificationOnPlaybackStart({
44    origin: 'model',
45    consumesTaskNotification: true,
46  }), true)
47  assert.equal(confirmsTaskNotificationOnPlaybackStart({
48    origin: 'model',
49  }), false)
50})
51
52test('accepts playback receipts only from the active output client for a known response', () => {
53  assert.equal(acceptsPlaybackReceipt({
54    outputEnabled: true,
55    active: true,
56    responseKnown: true,
57  }), true)
58  assert.equal(acceptsPlaybackReceipt({
59    outputEnabled: true,
60    active: false,
61    responseKnown: true,
62  }), false)
63  assert.equal(acceptsPlaybackReceipt({
64    outputEnabled: false,
65    active: true,
66    responseKnown: true,
67  }), false)
68  assert.equal(acceptsPlaybackReceipt({
69    outputEnabled: true,
70    active: true,
71    responseKnown: false,
72  }), false)
73})