Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

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].tsx
index 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.tsx
index 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.ts
index 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, agentKin
revisionAtStart: 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, agentKin
liveRevision: null,
};
request.current = null;
+ paidRequest.current = null;
setResult(null);
}
const run = observed.current;
@@ -76,6 +90,7 @@ export function usePromptRecommendation({ ownerId, deviceId, sessionId, agentKin
run.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