fix(web): use session flavor label in voice context formatters

Replaces hardcoded 'Claude Code' strings in voice context injections with
the active session's flavor label (Cursor, Codex, Gemini, etc.) via
getFlavorLabel() from @hapi/protocol. Falls back to 'coding agent' for
unknown or missing flavors.

Threads an agentLabel param through formatMessage, formatPermissionRequest,
formatReadyEvent, formatNewMessages, formatHistory, and formatSessionFull.
voiceHooks resolves the label once per call via session.metadata.flavor.

Fixes tiann#680

via [HAPI](https://hapi.run)

Co-Authored-By: HAPI <noreply@hapi.run>

Author: heavygee

shared/src/voice.ts

@@ -17,9 +17,11 @@ You are friendly, proactive, and highly intelligent with a world-class engineeri
 # Environment Overview
 
 Hapi is a multi-agent development platform supporting:
-- **Claude Code** - Anthropic's coding assistant (primary)
+- **Claude Code** - Anthropic's coding assistant
 - **Codex** - OpenAI's coding agent
+- **Cursor** - Cursor's coding agent
 - **Gemini** - Google's coding agent
+- **OpenCode** - open-source coding agent
 
 Users control these agents through the Hapi web interface or Telegram Mini App. You serve as the voice interface to whichever agent is currently active.
 
@@ -39,7 +41,7 @@ These updates appear as system messages. You do NOT need to poll or ask for upda
 Send user requests to the active coding agent.
 
 When to use:
-- User says "ask Claude to..." or "have it..."
+- User says "ask the agent to...", "have it...", or any similar delegation
 - Any coding, file, or development request
 - User wants to continue a task
 
@@ -88,7 +90,7 @@ You will receive a context update when the agent responds or finishes.
 
 ## Request Routing
 - Direct address ("Assistant, explain...") -> Answer yourself
-- Explicit delegation ("Have Claude...") -> Use messageCodingAgent
+- Explicit delegation ("Have it...", "Ask the agent...") -> Use messageCodingAgent
 - Coding/file tasks -> Use messageCodingAgent
 - General questions you can answer -> Answer yourself
 
@@ -109,7 +111,7 @@ Stay silent when:
 
 ## Permission Requests
 When you see a permission request, immediately inform the user:
-"Claude wants to run a bash command. Should I allow it?"
+"The agent wants to run a bash command. Should I allow it?"
 Then wait for their response and use processPermissionRequest.
 
 ## Errors

web/src/realtime/hooks/contextFormatters.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest'
+import type { DecryptedMessage } from '@/types/api'
+import {
+    formatMessage,
+    formatPermissionRequest,
+    formatReadyEvent,
+    formatNewMessages,
+} from './contextFormatters'
+
+function msg(partial: Pick<DecryptedMessage, 'id' | 'seq' | 'content'>): DecryptedMessage {
+    return {
+        id: partial.id,
+        seq: partial.seq,
+        localId: null,
+        content: partial.content,
+        createdAt: 0,
+        sessionId: 'session-1'
+    } as DecryptedMessage
+}
+
+describe('formatMessage — agent label', () => {
+    it('uses the provided label for assistant text', () => {
+        const formatted = formatMessage(
+            msg({ id: '1', seq: 1, content: { role: 'assistant', content: 'Refactor complete.' } }),
+            'Cursor'
+        )
+        expect(formatted).toContain('Cursor:')
+        expect(formatted).toContain('Refactor complete.')
+        expect(formatted).not.toContain('Claude Code')
+    })
+
+    it('defaults to coding agent when no label is given', () => {
+        const formatted = formatMessage(
+            msg({ id: '1', seq: 1, content: { role: 'assistant', content: 'Done.' } })
+        )
+        expect(formatted).toContain('coding agent:')
+        expect(formatted).not.toContain('Claude Code')
+    })
+
+    it('uses the provided label for tool-call lines', () => {
+        const formatted = formatMessage(
+            msg({
+                id: '1',
+                seq: 1,
+                content: {
+                    role: 'assistant',
+                    content: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls' } }]
+                }
+            }),
+            'Gemini'
+        )
+        expect(formatted).toContain('Gemini is using Bash')
+        expect(formatted).not.toContain('Claude Code')
+    })
+})
+
+describe('formatPermissionRequest — agent label', () => {
+    it('uses the provided label', () => {
+        const result = formatPermissionRequest('sid', 'rid', 'Bash', {}, 'OpenCode')
+        expect(result).toContain('OpenCode is requesting permission')
+        expect(result).not.toContain('Claude Code')
+    })
+
+    it('defaults to coding agent', () => {
+        const result = formatPermissionRequest('sid', 'rid', 'Bash', {})
+        expect(result).toContain('coding agent is requesting permission')
+    })
+})
+
+describe('formatReadyEvent — agent label', () => {
+    it('uses the provided label', () => {
+        const result = formatReadyEvent('session-1', 'Codex')
+        expect(result).toContain('Codex done working')
+        expect(result).not.toContain('Claude Code')
+    })
+
+    it('defaults to coding agent', () => {
+        const result = formatReadyEvent('session-1')
+        expect(result).toContain('coding agent done working')
+    })
+})
+
+describe('formatNewMessages — label threads through', () => {
+    it('uses the provided label in formatted message output', () => {
+        const result = formatNewMessages('session-1', [
+            msg({ id: '1', seq: 1, content: { role: 'assistant', content: 'Build succeeded.' } })
+        ], 'Cursor')
+        expect(result).toContain('Cursor:')
+        expect(result).not.toContain('Claude Code')
+    })
+})

web/src/realtime/hooks/contextFormatters.ts

@@ -66,9 +66,9 @@ function unwrapOutputContent(content: unknown): { roleOverride: NormalizedRole |
     return { roleOverride, content: messageContent }
 }
 
-function formatPlainText(role: NormalizedRole | null, text: string): string {
+function formatPlainText(role: NormalizedRole | null, text: string, agentLabel = 'coding agent'): string {
     if (role === 'assistant') {
-        return `Claude Code: \n<text>${text}</text>`
+        return `${agentLabel}: \n<text>${text}</text>`
     }
     return `User sent message: \n<text>${text}</text>`
 }
@@ -80,9 +80,10 @@ export function formatPermissionRequest(
     sessionId: string,
     requestId: string,
     toolName: string,
-    toolArgs: unknown
+    toolArgs: unknown,
+    agentLabel = 'coding agent'
 ): string {
-    return `Claude Code is requesting permission to use ${toolName} (session ${sessionId}):
+    return `${agentLabel} is requesting permission to use ${toolName} (session ${sessionId}):
 <request_id>${requestId}</request_id>
 <tool_name>${toolName}</tool_name>
 <tool_args>${JSON.stringify(toolArgs)}</tool_args>`
@@ -91,18 +92,18 @@ export function formatPermissionRequest(
 /**
  * Format a single message for voice context
  */
-export function formatMessage(message: DecryptedMessage): string | null {
+export function formatMessage(message: DecryptedMessage, agentLabel = 'coding agent'): string | null {
     const lines: string[] = []
     const { role, content: wrappedContent } = unwrapRoleWrappedContent(message)
     const { roleOverride, content } = unwrapOutputContent(wrappedContent)
     const normalizedRole = roleOverride ?? role
 
     if (!isContentArray(content)) {
         if (typeof content === 'string') {
-            return formatPlainText(normalizedRole, content)
+            return formatPlainText(normalizedRole, content, agentLabel)
         }
         if (isObject(content) && content.type === 'text' && typeof content.text === 'string') {
-            return formatPlainText(normalizedRole, content.text)
+            return formatPlainText(normalizedRole, content.text, agentLabel)
         }
         return null
     }
@@ -117,13 +118,13 @@ export function formatMessage(message: DecryptedMessage): string | null {
 
     for (const item of content) {
         if (item.type === 'text' && item.text) {
-            lines.push(formatPlainText(isAssistant ? 'assistant' : 'user', item.text))
+            lines.push(formatPlainText(isAssistant ? 'assistant' : 'user', item.text, agentLabel))
         } else if (item.type === 'tool_use' && !VOICE_CONFIG.DISABLE_TOOL_CALLS) {
             const name = item.name || 'unknown'
             if (VOICE_CONFIG.LIMITED_TOOL_CALLS) {
-                lines.push(`Claude Code is using ${name}`)
+                lines.push(`${agentLabel} is using ${name}`)
             } else {
-                lines.push(`Claude Code is using ${name} with arguments: <arguments>${JSON.stringify(item.input)}</arguments>`)
+                lines.push(`${agentLabel} is using ${name} with arguments: <arguments>${JSON.stringify(item.input)}</arguments>`)
             }
         }
     }
@@ -134,34 +135,34 @@ export function formatMessage(message: DecryptedMessage): string | null {
     return lines.join('\n\n')
 }
 
-export function formatNewSingleMessage(sessionId: string, message: DecryptedMessage): string | null {
-    const formatted = formatMessage(message)
+export function formatNewSingleMessage(sessionId: string, message: DecryptedMessage, agentLabel = 'coding agent'): string | null {
+    const formatted = formatMessage(message, agentLabel)
     if (!formatted) {
         return null
     }
     return 'New message in session: ' + sessionId + '\n\n' + formatted
 }
 
-export function formatNewMessages(sessionId: string, messages: DecryptedMessage[]): string | null {
+export function formatNewMessages(sessionId: string, messages: DecryptedMessage[], agentLabel = 'coding agent'): string | null {
     const formatted = [...messages]
         .sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0))
-        .map(formatMessage)
+        .map(m => formatMessage(m, agentLabel))
         .filter(Boolean)
     if (formatted.length === 0) {
         return null
     }
     return 'New messages in session: ' + sessionId + '\n\n' + formatted.join('\n\n')
 }
 
-export function formatHistory(sessionId: string, messages: DecryptedMessage[]): string {
+export function formatHistory(sessionId: string, messages: DecryptedMessage[], agentLabel = 'coding agent'): string {
     const messagesToFormat = VOICE_CONFIG.MAX_HISTORY_MESSAGES > 0
         ? messages.slice(-VOICE_CONFIG.MAX_HISTORY_MESSAGES)
         : messages
-    const formatted = messagesToFormat.map(formatMessage).filter(Boolean)
+    const formatted = messagesToFormat.map(m => formatMessage(m, agentLabel)).filter(Boolean)
     return 'History of messages in session: ' + sessionId + '\n\n' + formatted.join('\n\n')
 }
 
-export function formatSessionFull(session: Session | null, messages: DecryptedMessage[]): string {
+export function formatSessionFull(session: Session | null, messages: DecryptedMessage[], agentLabel = 'coding agent'): string {
     if (!session) {
         return 'Session not available'
     }
@@ -182,7 +183,7 @@ export function formatSessionFull(session: Session | null, messages: DecryptedMe
 
     lines.push('## Our interaction history so far')
     lines.push('')
-    lines.push(formatHistory(session.id, messages))
+    lines.push(formatHistory(session.id, messages, agentLabel))
 
     return lines.join('\n\n')
 }
@@ -199,6 +200,6 @@ export function formatSessionFocus(sessionId: string, _metadata?: SessionMetadat
     return `Session became focused: ${sessionId}`
 }
 
-export function formatReadyEvent(sessionId: string): string {
-    return `Claude Code done working in session: ${sessionId}. The previous message(s) are the summary of the work done. Report this to the human immediately.`
+export function formatReadyEvent(sessionId: string, agentLabel = 'coding agent'): string {
+    return `${agentLabel} done working in session: ${sessionId}. The previous message(s) are the summary of the work done. Report this to the human immediately.`
 }

web/src/realtime/hooks/voiceHooks.ts

@@ -9,7 +9,13 @@ import {
     formatSessionOnline
 } from './contextFormatters'
 import { VOICE_CONFIG } from '../voiceConfig'
-import type { DecryptedMessage, Session } from '@/types/api'
+import { getFlavorLabel, isKnownFlavor } from '@hapi/protocol'
+import type { DecryptedMessage, Session, SessionMetadataSummary } from '@/types/api'
+
+function getAgentLabel(session: Session | null): string {
+    const flavor = (session?.metadata as SessionMetadataSummary | undefined)?.flavor
+    return isKnownFlavor(flavor) ? getFlavorLabel(flavor) : 'coding agent'
+}
 
 interface SessionMetadata {
     summary?: { text?: string }
@@ -64,7 +70,7 @@ function reportSession(sessionId: string) {
     if (!session) return
 
     const messages = messagesGetter?.(sessionId) ?? []
-    const contextUpdate = formatSessionFull(session, messages)
+    const contextUpdate = formatSessionFull(session, messages, getAgentLabel(session))
     reportContextualUpdate(contextUpdate)
 }
 
@@ -108,8 +114,9 @@ export const voiceHooks = {
     onPermissionRequested(sessionId: string, requestId: string, toolName: string, toolArgs: unknown) {
         if (VOICE_CONFIG.DISABLE_PERMISSION_REQUESTS) return
 
+        const session = sessionGetter?.(sessionId) ?? null
         reportSession(sessionId)
-        reportTextUpdate(formatPermissionRequest(sessionId, requestId, toolName, toolArgs))
+        reportTextUpdate(formatPermissionRequest(sessionId, requestId, toolName, toolArgs, getAgentLabel(session)))
     },
 
     /**
@@ -118,8 +125,9 @@ export const voiceHooks = {
     onMessages(sessionId: string, messages: DecryptedMessage[]) {
         if (VOICE_CONFIG.DISABLE_MESSAGES) return
 
+        const session = sessionGetter?.(sessionId) ?? null
         reportSession(sessionId)
-        reportContextualUpdate(formatNewMessages(sessionId, messages))
+        reportContextualUpdate(formatNewMessages(sessionId, messages, getAgentLabel(session)))
     },
 
     /**
@@ -134,20 +142,21 @@ export const voiceHooks = {
         const session = sessionGetter?.(sessionId) ?? null
         const messages = messagesGetter?.(sessionId) ?? []
 
-        let prompt = 'THIS IS AN ACTIVE SESSION: \n\n' + formatSessionFull(session, messages)
+        let prompt = 'THIS IS AN ACTIVE SESSION: \n\n' + formatSessionFull(session, messages, getAgentLabel(session))
         shownSessions.add(sessionId)
 
         return prompt
     },
 
     /**
-     * Called when Claude Code finishes processing (ready event)
+     * Called when agent finishes processing (ready event)
      */
     onReady(sessionId: string) {
         if (VOICE_CONFIG.DISABLE_READY_EVENTS) return
 
+        const session = sessionGetter?.(sessionId) ?? null
         reportSession(sessionId)
-        reportTextUpdate(formatReadyEvent(sessionId))
+        reportTextUpdate(formatReadyEvent(sessionId, getAgentLabel(session)))
     },
 
     /**