feat(queue): Pro-Projekt-Nachrichten-Queue mit Rueckfrage-Loop + Textfeld-Entwuerfe (App)
Zweite Nachricht waehrend ARIA arbeitet wird jetzt ANGESTELLT statt den laufenden Task abzubrechen. Stellt ARIA eine blockierende Rueckfrage, pausiert die Queue und die naechste Eingabe beantwortet sie — bis eine finale Antwort kommt, dann laeuft der naechste Queue-Eintrag (pro Projekt unabhaengig). - Brain: ARIA deklariert Rueckfragen per unsichtbarem [[AWAIT]]-Marker (wie speak/converse; kein '?'-Raten). _extract_await_marker strippt ihn, chat() gibt 5-Tupel (+awaiting_reply), System-Prompt erklaert den Marker. - Bridge: awaiting_reply aus Brain-Response in die chat-Broadcast-Payload. - App: app-lokale Queue + Zustandsautomat (idle/running/awaiting_reply) pro Projekt; Send-Flow von Abbruch auf Anstellen; Stop-Button (cancelRequest) schaltet die Queue weiter; sichtbare pending_queue-Bubbles (tippen loescht); Rueckfrage-/Queue-Banner ueber dem Eingabefeld. Voice bricht nicht mehr ab (haltet nur TTS, serialisiert im Brain-Lock); Text-Send erkennt Brain-busy als Fallback. Pro-Projekt-Textfeld-Entwuerfe (Draft-Map + AsyncStorage). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
@@ -64,6 +64,14 @@ interface Attachment {
|
||||
deleted?: boolean; // Datei wurde nachtraeglich geloescht (Diagnostic-Manager)
|
||||
}
|
||||
|
||||
// Pro-Projekt-Queue-Zustand: idle = nichts laeuft; running = ARIA arbeitet am
|
||||
// aktuellen Task; awaiting_reply = ARIA hat eine blockierende Rueckfrage gestellt,
|
||||
// die naechste Eingabe beantwortet sie (statt einen neuen Auftrag anzustellen).
|
||||
type CtxState = 'idle' | 'running' | 'awaiting_reply';
|
||||
|
||||
// Wartender Queue-Eintrag (id = die Bubble-ID der pending_queue-Nachricht).
|
||||
interface QueuedItem { id: string; text: string; }
|
||||
|
||||
interface ChatMessage {
|
||||
id: string;
|
||||
sender: 'user' | 'aria';
|
||||
@@ -131,7 +139,7 @@ interface ChatMessage {
|
||||
/** Delivery-Status der User-Bubble (WhatsApp-style): queued = noch nicht
|
||||
* raus (offline), sending = an Bridge unterwegs, sent = Bridge hat ACK
|
||||
* gesendet, delivered = Brain hat geantwortet, failed = Retry-Limit. */
|
||||
deliveryStatus?: 'queued' | 'sending' | 'sent' | 'delivered' | 'failed';
|
||||
deliveryStatus?: 'queued' | 'pending_queue' | 'sending' | 'sent' | 'delivered' | 'failed';
|
||||
/** Anzahl der bisherigen Sende-Versuche (fuer Retry-Limit). */
|
||||
sendAttempts?: number;
|
||||
}
|
||||
@@ -275,6 +283,7 @@ async function checkFileExists(uri: string): Promise<boolean> {
|
||||
const ChatScreen: React.FC = () => {
|
||||
const [messages, setMessages] = useState<ChatMessage[]>([]);
|
||||
const [inputText, setInputText] = useState('');
|
||||
const inputTextRef = useRef('');
|
||||
const [connectionState, setConnectionState] = useState<ConnectionState>('disconnected');
|
||||
const [showFileUpload, setShowFileUpload] = useState(false);
|
||||
const [showCameraUpload, setShowCameraUpload] = useState(false);
|
||||
@@ -301,6 +310,24 @@ const ChatScreen: React.FC = () => {
|
||||
// Ref-Spiegel fuer Callbacks (interruptAriaIfBusy liest den aktuellen
|
||||
// Busy-Status des fokussierten Kontexts ohne stale Closure).
|
||||
const queueStatusRef = useRef<Record<string, { busy: boolean; queue_size: number }>>({});
|
||||
// ── Pro-Projekt-Nachrichten-Queue + Zustandsautomat (app-lokal) ──
|
||||
// Key = projectId ('' = Hauptchat). state pro Kontext + Queue der wartenden
|
||||
// User-Bubbles. Sendet man waehrend 'running', wird angestellt statt
|
||||
// abgebrochen; 'awaiting_reply' leitet die naechste Eingabe als Antwort weiter.
|
||||
const [projectStates, setProjectStates] = useState<Record<string, CtxState>>({});
|
||||
const [projectQueues, setProjectQueues] = useState<Record<string, QueuedItem[]>>({});
|
||||
const projectStatesRef = useRef<Record<string, CtxState>>({});
|
||||
const projectQueuesRef = useRef<Record<string, QueuedItem[]>>({});
|
||||
// Pro-Projekt-Textfeld-Entwuerfe (noch nicht gesendeter Feldinhalt). Key = pid.
|
||||
const projectDraftsRef = useRef<Record<string, string>>({});
|
||||
const prevFocusedPidRef = useRef<string>('');
|
||||
// Ref-Bruecke, damit der frueh deklarierte RVS-Message-Handler den erst spaeter
|
||||
// deklarierten Queue-Automaten aufrufen kann (ohne TDZ / stale Closure).
|
||||
const queueApiRef = useRef<{
|
||||
getCtxState: (pid: string) => CtxState;
|
||||
setCtxState: (pid: string, s: CtxState) => void;
|
||||
advanceQueue: (pid: string) => void;
|
||||
} | null>(null);
|
||||
const [searchIndex, setSearchIndex] = useState(0); // welcher Treffer aktiv ist
|
||||
const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
|
||||
const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
|
||||
@@ -509,14 +536,39 @@ const ChatScreen: React.FC = () => {
|
||||
return () => unsub();
|
||||
}, []);
|
||||
|
||||
// Focus in Storage spiegeln damit der letzte Kontext nach Neustart wieder
|
||||
// da ist. Kein zwingender UX-Fix (Default = Hauptchat waere auch ok), aber
|
||||
// fuer den Auto-Fall angenehm.
|
||||
// Focus in Storage spiegeln + Pro-Projekt-Textfeld-Entwuerfe wechseln.
|
||||
useEffect(() => {
|
||||
AsyncStorage.setItem('aria_focused_project_id', focusedProjectId).catch(() => {});
|
||||
focusedProjectIdRef.current = focusedProjectId;
|
||||
// Draft-Wechsel: der aktuelle Feldinhalt gehoert dem VERLASSENEN Projekt,
|
||||
// der Entwurf des neuen Projekts wird geladen (leer = leeres Feld).
|
||||
const prevPid = prevFocusedPidRef.current;
|
||||
if (prevPid !== focusedProjectId) {
|
||||
projectDraftsRef.current = { ...projectDraftsRef.current, [prevPid]: inputTextRef.current };
|
||||
setInputText(projectDraftsRef.current[focusedProjectId] || '');
|
||||
prevFocusedPidRef.current = focusedProjectId;
|
||||
AsyncStorage.setItem('aria_project_drafts', JSON.stringify(projectDraftsRef.current)).catch(() => {});
|
||||
}
|
||||
}, [focusedProjectId]);
|
||||
|
||||
// inputText-Spiegel (damit der Draft-Wechsel oben inputText nicht als Dep braucht).
|
||||
useEffect(() => { inputTextRef.current = inputText; }, [inputText]);
|
||||
|
||||
// Drafts beim Start aus Storage laden.
|
||||
useEffect(() => {
|
||||
AsyncStorage.getItem('aria_project_drafts').then(v => {
|
||||
if (!v) return;
|
||||
try {
|
||||
const map = JSON.parse(v);
|
||||
if (map && typeof map === 'object') {
|
||||
projectDraftsRef.current = map;
|
||||
const cur = map[focusedProjectIdRef.current] || '';
|
||||
if (cur) setInputText(cur);
|
||||
}
|
||||
} catch {}
|
||||
}).catch(() => {});
|
||||
}, []);
|
||||
|
||||
// Ref-Spiegel damit useCallback-Handler die aktuelle Focus-ID lesen
|
||||
// ohne dass wir die Deps in jedes Callback muessen (sonst re-createn
|
||||
// die sich bei jedem Wechsel).
|
||||
@@ -1236,6 +1288,18 @@ const ChatScreen: React.FC = () => {
|
||||
: prev);
|
||||
setAgentActivity(cur =>
|
||||
cur.activity === 'idle' ? cur : { activity: 'idle', tool: '' });
|
||||
// ── Pro-Projekt-Queue-Automat: auf ARIAs Antwort reagieren ──
|
||||
const awaiting = !!(message.payload as any).awaiting_reply;
|
||||
const qapi = queueApiRef.current;
|
||||
if (qapi) {
|
||||
const st = qapi.getCtxState(ansPid);
|
||||
// Nur reagieren, wenn wir fuer diesen Kontext wirklich auf eine
|
||||
// Antwort warten (nicht bei unaufgeforderten Trigger-Nachrichten).
|
||||
if (st === 'running' || st === 'awaiting_reply') {
|
||||
if (awaiting) qapi.setCtxState(ansPid, 'awaiting_reply');
|
||||
else qapi.advanceQueue(ansPid);
|
||||
}
|
||||
}
|
||||
}
|
||||
// ALLE noch laufenden ACK-Timer clearen — Bridge hat unsere Messages
|
||||
// ja offensichtlich verarbeitet (sonst keine ARIA-Antwort). Wenn
|
||||
@@ -1972,6 +2036,65 @@ const ChatScreen: React.FC = () => {
|
||||
|
||||
// --- Nachricht senden ---
|
||||
|
||||
// ── Pro-Projekt-Queue: Zustands-Helfer ──────────────────────────
|
||||
const getCtxState = useCallback((pid: string): CtxState =>
|
||||
projectStatesRef.current[pid] || 'idle', []);
|
||||
|
||||
const setCtxState = useCallback((pid: string, s: CtxState) => {
|
||||
projectStatesRef.current = { ...projectStatesRef.current, [pid]: s };
|
||||
setProjectStates(prev => ({ ...prev, [pid]: s }));
|
||||
}, []);
|
||||
|
||||
const setCtxQueue = useCallback((pid: string, items: QueuedItem[]) => {
|
||||
projectQueuesRef.current = { ...projectQueuesRef.current, [pid]: items };
|
||||
setProjectQueues(prev => ({ ...prev, [pid]: items }));
|
||||
}, []);
|
||||
|
||||
// Sendet eine Nachricht WIRKLICH (Location holen + dispatchWithAck) und setzt
|
||||
// den Kontext auf 'running'. existingId gesetzt = eine bereits als pending_queue
|
||||
// angezeigte Bubble wird auf 'sending' gehoben (Dequeue), sonst neue Bubble.
|
||||
const actuallySend = useCallback(async (pid: string, text: string, existingId?: string) => {
|
||||
const cmid = nextClientMsgId();
|
||||
const location = await getCurrentLocation();
|
||||
const status: ChatMessage['deliveryStatus'] =
|
||||
connectionStateRef.current === 'connected' ? 'sending' : 'queued';
|
||||
if (existingId) {
|
||||
setMessages(prev => prev.map(m =>
|
||||
m.id === existingId ? { ...m, clientMsgId: cmid, deliveryStatus: status, sendAttempts: 1 } : m));
|
||||
} else {
|
||||
setMessages(prev => capMessages([...prev, {
|
||||
id: nextId(), sender: 'user', text, timestamp: Date.now(),
|
||||
clientMsgId: cmid, deliveryStatus: status, sendAttempts: 1, projectId: pid,
|
||||
}]));
|
||||
}
|
||||
setCtxState(pid, 'running');
|
||||
dispatchWithAck(cmid, 'chat', {
|
||||
text, voice: localXttsVoiceRef.current, speed: ttsSpeedRef.current,
|
||||
projectId: pid, ...(location && { location }),
|
||||
});
|
||||
}, [getCurrentLocation, dispatchWithAck, setCtxState]);
|
||||
|
||||
// Naechsten Queue-Eintrag von pid abarbeiten (falls vorhanden), sonst idle.
|
||||
const advanceQueue = useCallback((pid: string) => {
|
||||
const q = projectQueuesRef.current[pid] || [];
|
||||
if (q.length === 0) { setCtxState(pid, 'idle'); return; }
|
||||
const [next, ...rest] = q;
|
||||
setCtxQueue(pid, rest);
|
||||
actuallySend(pid, next.text, next.id);
|
||||
}, [actuallySend, setCtxQueue, setCtxState]);
|
||||
|
||||
// Einen wartenden Eintrag aus der Queue entfernen (User tippt auf ✕).
|
||||
const removeQueued = useCallback((pid: string, id: string) => {
|
||||
setCtxQueue(pid, (projectQueuesRef.current[pid] || []).filter(it => it.id !== id));
|
||||
setMessages(prev => prev.filter(m => m.id !== id));
|
||||
}, [setCtxQueue]);
|
||||
|
||||
// Ref-Bruecke fuellen, damit der frueh deklarierte Message-Handler den Automaten
|
||||
// erreicht (ohne TDZ / stale Closure).
|
||||
useEffect(() => {
|
||||
queueApiRef.current = { getCtxState, setCtxState, advanceQueue };
|
||||
}, [getCtxState, setCtxState, advanceQueue]);
|
||||
|
||||
// Aufraeumen von "verarbeitet"-Placeholder die nie ein STT-Result bekommen
|
||||
// haben (leere Aufnahme, Wake-Word-Echo, STT-Fehler etc). Timeout skaliert
|
||||
// mit der Aufnahmedauer — Whisper braucht auf der Gamebox grob real-time/5,
|
||||
@@ -2002,34 +2125,22 @@ const ChatScreen: React.FC = () => {
|
||||
setAgentActivityByCtx(prev => ({ ...prev, [pid]: { activity: 'idle', tool: '' } }));
|
||||
clearStuckWatchdog();
|
||||
rvs.send('cancel_request' as any, { projectId: pid });
|
||||
}, []);
|
||||
// Aktuellen Task abgebrochen → naechsten Queue-Eintrag dieses Projekts
|
||||
// starten (oder idle, wenn leer). Wartende Eintraege einzeln loeschbar.
|
||||
advanceQueue(pid);
|
||||
}, [advanceQueue]);
|
||||
|
||||
// Barge-In: wenn der User waehrend ARIA arbeitet/spricht eine neue Sprach-
|
||||
// Nachricht aufnimmt, alte Aktivitaet sofort abbrechen — TTS verstummen,
|
||||
// aria-core-Run via cancel_request abbrechen. So kann man "ach vergiss es,
|
||||
// mach lieber X" sagen wie in einem echten Gespraech.
|
||||
// Queue-Modus („immer anstellen"): eine neue Sprachnachricht bricht ARIAs
|
||||
// laufende Arbeit NICHT mehr ab. Sie wird — wie Text — angestellt und laeuft
|
||||
// serialisiert (der Brain-Lock pro Projekt reiht /chat-/audio-Turns auf).
|
||||
// Nur das TTS wird akustisch gestoppt, damit das Mikro ARIAs eigene Stimme
|
||||
// nicht mithoert. Explizites Abbrechen laeuft ueber den Stop-Button
|
||||
// (cancelRequest). Rueckgabe = false, weil kein Barge-In/Interrupt mehr.
|
||||
const interruptAriaIfBusy = useCallback(() => {
|
||||
const speaking = audioService.isPlayingAudio();
|
||||
// Multi-Threading: NUR den fokussierten Kontext als "busy" werten — nicht
|
||||
// global. Sonst bricht eine Nachricht im Hauptchat die parallele Arbeit in
|
||||
// einem Projekt ab (bzw. wird faelschlich als Barge-In behandelt und die
|
||||
// eigene Anfrage geht unter). Der Busy-Status kommt kontextgenau aus
|
||||
// /projects/queue-status (queueStatusRef). agentActivity ist global und
|
||||
// taugt dafuer nicht.
|
||||
const pid = focusedProjectIdRef.current || '';
|
||||
const focusKey = pid || '__main__';
|
||||
const focusBusy = !!queueStatusRef.current?.[focusKey]?.busy;
|
||||
if (!speaking && !focusBusy) return false;
|
||||
console.log('[Chat] Barge-In: speaking=%s focusBusy=%s (ctx=%s) — interrupting',
|
||||
speaking, focusBusy, focusKey);
|
||||
// TTS immer stoppen wenn ARIA gerade spricht — egal welcher Kontext.
|
||||
if (speaking) audioService.haltAllPlayback('user spricht (barge-in)');
|
||||
// Brain-Arbeit nur abbrechen wenn GENAU dieser Kontext arbeitet.
|
||||
if (focusBusy) {
|
||||
clearStuckWatchdog();
|
||||
rvs.send('cancel_request' as any, { projectId: pid });
|
||||
if (audioService.isPlayingAudio()) {
|
||||
audioService.haltAllPlayback('user startet Aufnahme (Queue-Modus, kein Abbruch)');
|
||||
}
|
||||
return true;
|
||||
return false;
|
||||
}, []);
|
||||
|
||||
// Manueller Aufnahme-Knopf (VoiceButton) — Start.
|
||||
@@ -2216,37 +2327,37 @@ const ChatScreen: React.FC = () => {
|
||||
|
||||
if (!text) return;
|
||||
|
||||
setInputText('');
|
||||
|
||||
// Barge-In: laufende ARIA-Aktivitaet abbrechen wenn welche da ist.
|
||||
const wasInterrupted = interruptAriaIfBusy();
|
||||
const location = await getCurrentLocation();
|
||||
|
||||
const cmid = nextClientMsgId();
|
||||
const activePid = focusedProjectIdRef.current;
|
||||
const userMsg: ChatMessage = {
|
||||
id: nextId(),
|
||||
sender: 'user',
|
||||
text,
|
||||
timestamp: Date.now(),
|
||||
clientMsgId: cmid,
|
||||
deliveryStatus: connectionStateRef.current === 'connected' ? 'sending' : 'queued',
|
||||
sendAttempts: 1,
|
||||
projectId: activePid,
|
||||
};
|
||||
setMessages(prev => capMessages([...prev, userMsg]));
|
||||
setInputText('');
|
||||
// Draft dieses Projekts leeren (wurde ja gerade abgeschickt/angestellt).
|
||||
projectDraftsRef.current = { ...projectDraftsRef.current, [activePid]: '' };
|
||||
|
||||
console.log('[Chat] sende cmid=%s voice=%s speed=%s interrupted=%s project=%s',
|
||||
cmid, localXttsVoiceRef.current || '(default)', ttsSpeedRef.current, wasInterrupted, activePid || '(main)');
|
||||
dispatchWithAck(cmid, 'chat', {
|
||||
text,
|
||||
voice: localXttsVoiceRef.current,
|
||||
speed: ttsSpeedRef.current,
|
||||
interrupted: wasInterrupted,
|
||||
projectId: activePid,
|
||||
...(location && { location }),
|
||||
});
|
||||
}, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments, interruptAriaIfBusy, dispatchWithAck]);
|
||||
const focusKey = activePid || '__main__';
|
||||
const brainBusy = !!queueStatusRef.current?.[focusKey]?.busy;
|
||||
let state = getCtxState(activePid);
|
||||
// Fallback: ein per SPRACHE gestarteter Turn streamt live und setzt den
|
||||
// App-State nicht — aber der Brain meldet busy. Dann Kontext als 'running'
|
||||
// behandeln (anstellen; die spaetere Antwort schaltet die Queue weiter).
|
||||
if (state === 'idle' && brainBusy) { setCtxState(activePid, 'running'); state = 'running'; }
|
||||
if (state === 'running') {
|
||||
// ARIA arbeitet noch am aktuellen Task → ANSTELLEN statt abbrechen.
|
||||
// Sichtbare pending_queue-Bubble; laeuft der Reihe nach, wenn der
|
||||
// aktuelle Task (und ggf. seine Rueckfragen) fertig ist.
|
||||
const id = nextId();
|
||||
setMessages(prev => capMessages([...prev, {
|
||||
id, sender: 'user', text, timestamp: Date.now(),
|
||||
projectId: activePid, deliveryStatus: 'pending_queue',
|
||||
}]));
|
||||
setCtxQueue(activePid, [...(projectQueuesRef.current[activePid] || []), { id, text }]);
|
||||
console.log('[Chat] angestellt (queue) project=%s len=%d', activePid || '(main)',
|
||||
(projectQueuesRef.current[activePid] || []).length);
|
||||
} else {
|
||||
// idle ODER awaiting_reply → sofort senden. Bei awaiting_reply ist DAS die
|
||||
// Antwort auf ARIAs Rueckfrage (normaler Turn in diesem Projekt).
|
||||
console.log('[Chat] sende sofort (state=%s) project=%s', state, activePid || '(main)');
|
||||
actuallySend(activePid, text);
|
||||
}
|
||||
}, [inputText, pendingAttachments, sendPendingAttachments, getCtxState, setCtxState, setCtxQueue, actuallySend]);
|
||||
|
||||
// --- Rendering ---
|
||||
|
||||
@@ -2546,7 +2657,16 @@ const ChatScreen: React.FC = () => {
|
||||
</TouchableOpacity>
|
||||
) : null}
|
||||
{isUser && item.deliveryStatus ? (
|
||||
item.deliveryStatus === 'failed' && item.clientMsgId ? (
|
||||
item.deliveryStatus === 'pending_queue' ? (
|
||||
// Wartet in der Projekt-Queue → tippen entfernt den Eintrag.
|
||||
<TouchableOpacity
|
||||
hitSlop={{top:6,bottom:6,left:6,right:6}}
|
||||
onPress={() => removeQueued(item.projectId || '', item.id)}
|
||||
accessibilityLabel="Aus Warteschlange entfernen"
|
||||
>
|
||||
<Text style={styles.statusQueued}>{'⏸ wartet · ✕'}</Text>
|
||||
</TouchableOpacity>
|
||||
) : item.deliveryStatus === 'failed' && item.clientMsgId ? (
|
||||
<TouchableOpacity
|
||||
hitSlop={{top:6,bottom:6,left:6,right:6}}
|
||||
onPress={() => retryFailedMessage(item.clientMsgId!)}
|
||||
@@ -2969,6 +3089,18 @@ const ChatScreen: React.FC = () => {
|
||||
</TouchableOpacity>
|
||||
)}
|
||||
|
||||
{/* Rueckfrage-Banner / Queue-Zaehler fuer den fokussierten Kontext */}
|
||||
{(projectStates[focusedProjectId] === 'awaiting_reply' ||
|
||||
(projectQueues[focusedProjectId]?.length || 0) > 0) && (
|
||||
<View style={styles.queueBanner}>
|
||||
<Text style={styles.queueBannerText}>
|
||||
{projectStates[focusedProjectId] === 'awaiting_reply'
|
||||
? '❓ ARIA fragt nach — deine Eingabe beantwortet das'
|
||||
: `⏸ ${projectQueues[focusedProjectId]?.length || 0} in der Warteschlange`}
|
||||
</Text>
|
||||
</View>
|
||||
)}
|
||||
|
||||
{/* Eingabebereich */}
|
||||
<View style={styles.inputContainer}>
|
||||
{/* Datei-Buttons */}
|
||||
@@ -3466,6 +3598,19 @@ const styles = StyleSheet.create({
|
||||
fontSize: 14,
|
||||
marginTop: 4,
|
||||
},
|
||||
queueBanner: {
|
||||
paddingHorizontal: 12,
|
||||
paddingVertical: 6,
|
||||
backgroundColor: '#2A2410',
|
||||
borderTopWidth: 1,
|
||||
borderTopColor: '#4A3F14',
|
||||
},
|
||||
queueBannerText: {
|
||||
color: '#FFD60A',
|
||||
fontSize: 13,
|
||||
fontWeight: '600',
|
||||
textAlign: 'center',
|
||||
},
|
||||
inputContainer: {
|
||||
flexDirection: 'row',
|
||||
alignItems: 'flex-end',
|
||||
|
||||
Reference in New Issue
Block a user