Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(mobile): stabilize prompt recommendation completion and recovery (#5291)
DavidShenXDf18d51d378cc
diff --git a/apps/mobile/app/sessions/[sessionId].tsx b/apps/mobile/app/sessions/[sessionId].tsxindex 6ea50560d8..463be0c08a 100644--- a/apps/mobile/app/sessions/[sessionId].tsx+++ b/apps/mobile/app/sessions/[sessionId].tsx@@ -1387,6 +1387,8 @@ export default function SessionScreen() {const [voiceState, setVoiceStateInternal] = useState<MobileVoiceState>('idle');const { prompt: promptRecommendation, dismiss: dismissPromptRecommendation } = usePromptRecommendation({ownerId: auth.user?.id, deviceId, sessionId, maker,+ available: remoteHistoryAvailable && !revokedDevices.has(deviceId) && !unresponsiveDevices.has(deviceId),+ connectionEpoch,agentKind: recommendationSession ? agentKindForSession(recommendationSession) : null,revision: recommendationSession?.lastTurnEndedAt, running: remoteSessionRunning,composerSource: composerDraftSource,diff --git a/apps/mobile/src/__tests__/usePromptRecommendation.test.tsx b/apps/mobile/src/__tests__/usePromptRecommendation.test.tsxindex 3ef18b1f19..c6ab0758ba 100644--- a/apps/mobile/src/__tests__/usePromptRecommendation.test.tsx+++ b/apps/mobile/src/__tests__/usePromptRecommendation.test.tsx@@ -161,6 +161,120 @@ it('old hosts without the channel fail silently', async () => {expect(value.prompt).toBeNull();});+it('keeps live completion eligibility when its timestamp settles during debounce', async () => {+ await render({ running: true });+ await render({ running: false, revision: 20 });+ await act(async () => vi.advanceTimersByTimeAsync(18));+ await render({ revision: 38 });+ await advance();+ expect(request).toHaveBeenCalledTimes(1);+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({+ cacheOnly: false, completionRevision: 38,+ }));+ expect(value.prompt).toBe('Suggested next step');+ await render({ revision: 50 }); await advance();+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({ cacheOnly: true }));+});++it('waits for connectivity before requesting a just-completed turn', async () => {+ await render({ running: true, available: false });+ await render({ running: false, revision: 20 }); await advance();+ expect(request).not.toHaveBeenCalled();+ await render({ available: true }); await advance();+ expect(request).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({+ completionRevision: 20, cacheOnly: false,+ }));+ expect(value.prompt).toBe('Suggested next step');+});++it('recovers a failed live request from host cache after reconnect without paying twice', async () => {+ request.mockRejectedValueOnce(new Error('DEVICE_LINK_NOT_CONNECTED'));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ expect(value.prompt).toBeNull();+ await render({ available: false });+ await render({ available: true }); await advance();+ expect(request).toHaveBeenCalledTimes(2);+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({+ completionRevision: 20, cacheOnly: true,+ }));+ expect(value.prompt).toBe('Suggested next step');+});++it('recovers when the old request fails after a new connection is already ready', async () => {+ let reject!: (reason: Error) => void;+ request.mockImplementationOnce(() => new Promise((_resolve, fail) => { reject = fail; }));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ await render({ connectionEpoch: 1 }); await advance();+ expect(request).toHaveBeenCalledTimes(1);+ await act(async () => reject(new Error('INVOKE_TIMEOUT')));+ await advance();+ expect(request).toHaveBeenCalledTimes(2);+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({ cacheOnly: true }));+ expect(value.prompt).toBe('Suggested next step');+});++it('does not retry link failures on timers, ordinary transport refreshes or draft interaction', async () => {+ request.mockRejectedValue(new Error('INVOKE_TIMEOUT'));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ await render({ maker: { predictNextPrompt: request } });+ await render({ hasAttachments: true });+ await render({ hasAttachments: false });+ await act(async () => vi.advanceTimersByTimeAsync(60_000));+ expect(request).toHaveBeenCalledTimes(1);+ await render({ connectionEpoch: 1 }); await advance();+ await act(async () => vi.advanceTimersByTimeAsync(60_000));+ expect(request).toHaveBeenCalledTimes(2);+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({ cacheOnly: true }));+});++it('keeps a deferred recovery cache-only when input cancels its debounce', async () => {+ request.mockRejectedValueOnce(new Error('INVOKE_TIMEOUT'));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ await render({ connectionEpoch: 1 });+ await render({ hasAttachments: true }); await advance();+ await render({ hasAttachments: false }); await advance();+ expect(request).toHaveBeenCalledTimes(2);+ expect(request).toHaveBeenLastCalledWith(expect.objectContaining({ cacheOnly: true }));+});++it('retains an in-flight success through reconnect without another request', async () => {+ let resolve!: (result: { prompt: string }) => void;+ request.mockImplementationOnce(() => new Promise((done) => { resolve = done; }));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ await render({ available: false });+ await render({ available: true, connectionEpoch: 1 }); await advance();+ await act(async () => resolve({ prompt: 'Recovered result' }));+ expect(request).toHaveBeenCalledTimes(1);+ expect(value.prompt).toBe('Recovered result');+});++it('does not restore dismissed recommendations after a failed request and reconnect', async () => {+ request.mockRejectedValueOnce(new Error('INVOKE_TIMEOUT'));+ await render({ running: true });+ await render({ running: false, revision: 20 }); await advance();+ await act(async () => value.dismiss());+ await render({ connectionEpoch: 1 }); await advance();+ expect(request).toHaveBeenCalledTimes(1);+ expect(value.prompt).toBeNull();+});++it('resumes cache lookup after connectivity interrupts a bounded cache retry', async () => {+ request.mockResolvedValueOnce({ prompt: null });+ await render(); await advance();+ await render({ available: false });+ await act(async () => vi.advanceTimersByTimeAsync(10_000));+ expect(request).toHaveBeenCalledTimes(1);+ await render({ available: true }); await advance();+ expect(request).toHaveBeenCalledTimes(2);+ expect(request.mock.calls.every(([args]) => args.cacheOnly === true)).toBe(true);+ expect(value.prompt).toBe('Suggested next step');+});+it('consumes terminal failures without predicting, but permits the next successful turn', async () => {await render({ running: true });await render({ running: false, revision: 20, hasTerminalError: true });diff --git a/apps/mobile/src/session/usePromptRecommendation.ts b/apps/mobile/src/session/usePromptRecommendation.tsindex a3bbbb6408..f7bdeb64d1 100644--- a/apps/mobile/src/session/usePromptRecommendation.ts+++ b/apps/mobile/src/session/usePromptRecommendation.ts@@ -9,13 +9,16 @@ const subscribeEmptyComposer = () => () => {};const CACHE_RETRY_DELAYS_MS = [1_000, 3_000, 5_000];export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKind, revision, running, maker,- composerSource, hasAttachments = false, hasTerminalError = false, voiceIsBusy = false, queueEditing = false }: {+ composerSource, hasAttachments = false, hasTerminalError = false, voiceIsBusy = false, queueEditing = false,+ available = true, connectionEpoch = 0 }: {ownerId?: string;deviceId: string;sessionId: string;agentKind: MobileAgentKind | null;revision?: number | null;running: boolean;+ available?: boolean;+ connectionEpoch?: number;composerSource?: ComposerDraftSource;hasAttachments?: boolean;hasTerminalError?: boolean;@@ -38,7 +41,12 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKin// latest callable without treating that refresh as a new recommendation run.const makerRef = useRef(maker);makerRef.current = maker;- const request = useRef<{ scope: string; revision: number; cacheOnly: boolean } | null>(null);+ const request = useRef<{+ scope: string; revision: number; cacheOnly: boolean; recoveryGeneration: number; failed: boolean;+ } | null>(null);+ const connection = useRef({ available, connectionEpoch, generation: 0 });+ const paidRequest = useRef<{ scope: string; revision: number } | null>(null);+ const [settledAttempt, setSettledAttempt] = useState(0);useEffect(() => () => { request.current = null; }, []);const observed = useRef({scope,@@ -47,14 +55,19 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKinrevisionAtStart: 0,liveRevision: null as number | null,});- const current = useRef({ scope, revision, running, blocked, hasTerminalError });- current.current = { scope, revision, running, blocked, hasTerminalError };+ const current = useRef({ scope, revision, running, blocked, hasTerminalError, available });+ current.current = { scope, revision, running, blocked, hasTerminalError, available };const dismiss = useCallback(() => {if (revision) consumedRevisions.set(scope, revision);+ observed.current.sawRunning = false;+ observed.current.liveRevision = null;setResult(null);}, [scope, revision]);useEffect(() => {+ if (connection.current.available !== available || connection.current.connectionEpoch !== connectionEpoch) {+ connection.current = { available, connectionEpoch, generation: connection.current.generation + 1 };+ }if (observed.current.scope !== scope) {observed.current = {scope,@@ -64,6 +77,7 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKinliveRevision: null,};request.current = null;+ paidRequest.current = null;setResult(null);}const run = observed.current;@@ -76,6 +90,7 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKinrun.revisionAtStart = revision ?? 0;run.liveRevision = null;request.current = null;+ paidRequest.current = null;setResult(null);}run.running = true;@@ -83,25 +98,33 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKin}run.running = false;// Only an observed run can authorize a paid prediction. Keep waiting if- // stopped arrives before its revision, then bind that run to one completion.- // Later metadata refreshes must not inherit permission from an older run.+ // stopped arrives before its revision. The completion timestamp can settle+ // more than once during debounce; consume the live run only on dispatch.+ // Later metadata refreshes cannot authorize a second paid request.if (run.sawRunning && revision != null && revision > run.revisionAtStart) {run.liveRevision = revision;- run.sawRunning = false;}if (!deviceId || !sessionId || !agentKind || !revision || consumedRevisions.get(scope) === revision) return;if (hasTerminalError) {// Failed turns are ineligible; ordinary composer interaction only hides.+ run.sawRunning = false;+ run.liveRevision = null;consumedRevisions.set(scope, revision);setResult(null);return;}- if (blocked || (result?.scope === scope && result.revision === revision)) return;+ if (!available || blocked || (result?.scope === scope && result.revision === revision)) return;// Historical navigation only reuses a host result; it never starts a paid prediction.const cacheOnly = run.liveRevision !== revision;- if (request.current?.scope === scope && request.current.revision === revision- && request.current.cacheOnly === cacheOnly) return;- const attempt = { scope, revision, cacheOnly };+ const previous = request.current;+ const recovering = previous?.scope === scope && previous.revision === revision+ && previous.cacheOnly === cacheOnly;+ if (recovering && (!previous.failed || previous.recoveryGeneration === connection.current.generation)) return;+ // A lost response does not mean the host did not generate a recommendation.+ // Retry only after connectivity changes, and only read the host's cache.+ const requestCacheOnly = cacheOnly+ || (paidRequest.current?.scope === scope && paidRequest.current.revision === revision);+ const attempt = { scope, revision, cacheOnly, recoveryGeneration: connection.current.generation, failed: false };request.current = attempt;let cancelled = false;let started = false;@@ -114,17 +137,32 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKin};const predict = () => {if (cancelled || (!started && current.current.blocked) || !isCurrent()) return;+ if (!current.current.available) {+ attempt.failed = true;+ return;+ }started = true;- void makerRef.current.predictNextPrompt({ sessionId, agentKind, turnGen: 0, completionRevision: revision, cacheOnly })+ if (!requestCacheOnly) {+ run.sawRunning = false;+ paidRequest.current = { scope, revision };+ }+ void makerRef.current.predictNextPrompt({ sessionId, agentKind, turnGen: 0, completionRevision: revision, cacheOnly: requestCacheOnly }).then(({ prompt }) => {if (!isCurrent()) return;if (prompt) setResult({ scope, revision, prompt });- else if (cacheOnly && retry < CACHE_RETRY_DELAYS_MS.length) {+ else if (requestCacheOnly && retry < CACHE_RETRY_DELAYS_MS.length) {// A peer may create the cache just after our first lookup. Never- // promote history to a paid request, and never retry link errors.+ // promote history to a paid request. Link errors wait for recovery+ // instead of entering this timed retry loop.timer = setTimeout(predict, CACHE_RETRY_DELAYS_MS[retry++]);}- }).catch(() => { /* Old hosts and unavailable predictions remain silent. */ });+ }).catch(() => {+ if (!isCurrent()) return;+ attempt.failed = true;+ // The old request can settle after reconnect. Recheck that already+ // observed recovery without replaying requests on ordinary renders.+ setSettledAttempt((value) => value + 1);+ });};timer = setTimeout(predict, 500);return () => {@@ -137,7 +175,8 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKin}if (!started && request.current === attempt) request.current = null;};- }, [scope, deviceId, sessionId, agentKind, revision, running, blocked, hasTerminalError, result]);+ }, [scope, deviceId, sessionId, agentKind, revision, running, blocked, hasTerminalError, result,+ available, connectionEpoch, settledAttempt]);return {prompt: !running && !displayBlocked && result?.scope === scope && result.revision === revision