Default client RPC waits to 60 seconds (#1789)

* fix(client): wait longer for session responses

* fix(client): default RPC waits to sixty seconds

* fix(app): preserve detached stream scroll on delayed history

Code drift: longer client RPC waits let delayed timeline responses arrive after a user scroll-away, so web stream anchoring must not reattach on transient scroll-top resets.

Restore the 15s connect deadline and leave app initialization slack above the default 60s session RPC wait.

* fix(client): keep helper waits within caller deadlines

Review fix: the 60s default session RPC wait leaked into wait previews and waitForAgentUpsert helper fetches. Bound those helper RPCs to the caller deadline or a short best-effort preview timeout, and allow small scroll ranges to reattach at bottom.

* fix(client): respect caller timeout budgets

* fix(cli): keep diagnostic probes responsive

* Refactor daemon client request options

* Preserve daemon client legacy overloads

packages/app/src/hooks/use-agent-commands-query.test.ts

@@ -1,12 +1,11 @@
 import { describe, expect, it } from "vitest";
-import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import {
   type AgentCommandsClient,
   type DraftCommandConfig,
   fetchAgentCommands,
 } from "./use-agent-commands-query";
 
-type ListCommands = DaemonClient["listCommands"];
+type ListCommands = AgentCommandsClient["listCommands"];
 type ListCommandsResult = Awaited<ReturnType<ListCommands>>;
 
 interface ListCommandsCall {
@@ -22,15 +21,8 @@ function createClient(response: ListCommandsResult): FakeAgentCommandsClient {
   const calls: ListCommandsCall[] = [];
   return {
     calls,
-    listCommands: (async (
-      agentId: string,
-      requestIdOrOptions?: string | { draftConfig?: DraftCommandConfig },
-    ) => {
-      const options =
-        typeof requestIdOrOptions === "object" && requestIdOrOptions !== null
-          ? requestIdOrOptions
-          : undefined;
-      calls.push({ agentId, draftConfig: options?.draftConfig });
+    listCommands: (async (options: Parameters<ListCommands>[0]) => {
+      calls.push({ agentId: options.agentId, draftConfig: options.draftConfig });
       return response;
     }) as ListCommands,
   };

packages/app/src/hooks/use-agent-commands-query.ts

@@ -16,14 +16,22 @@ export interface AgentSlashCommand {
 
 export type DraftCommandConfig = AgentCommandsDraftConfig;
 
-export type AgentCommandsClient = Pick<DaemonClient, "listCommands">;
+interface ListAgentCommandsOptions {
+  agentId: string;
+  draftConfig?: DraftCommandConfig;
+}
+
+export interface AgentCommandsClient {
+  listCommands(options: ListAgentCommandsOptions): ReturnType<DaemonClient["listCommands"]>;
+}
 
 export async function fetchAgentCommands(input: {
   client: AgentCommandsClient;
   agentId: string;
   draftConfig?: DraftCommandConfig;
 }): Promise<AgentSlashCommand[]> {
-  const response = await input.client.listCommands(input.agentId, {
+  const response = await input.client.listCommands({
+    agentId: input.agentId,
     draftConfig: input.draftConfig,
   });
   return response.commands as AgentSlashCommand[];

packages/app/src/hooks/use-agent-initialization.test.ts

@@ -5,6 +5,7 @@ import { getInitDeferred, getInitKey, resolveInitDeferred } from "@/utils/agent-
 import {
   createSetAgentInitializing,
   ensureAgentIsInitialized,
+  refreshAgentInitializationTimeout,
   refreshAgent,
 } from "./use-agent-initialization";
 
@@ -80,7 +81,7 @@ describe("ensureAgentIsInitialized", () => {
     expect(getInitDeferred(getInitKey(serverId, agentId))?.requestDirection).toBe("tail");
   });
 
-  it("times out initialization after 30 seconds", async () => {
+  it("times out initialization after 65 seconds", async () => {
     vi.useFakeTimers();
     const client = makeClient();
     useSessionStore.getState().initializeSession(serverId, client as never);
@@ -92,18 +93,50 @@ describe("ensureAgentIsInitialized", () => {
       setAgentInitializing: bindSetAgentInitializing(),
     });
 
-    vi.advanceTimersByTime(29_999);
+    vi.advanceTimersByTime(64_999);
     expect(getInitDeferred(getInitKey(serverId, agentId))).toBeDefined();
 
     vi.advanceTimersByTime(1);
 
-    await expect(promise).rejects.toThrow("History sync timed out after 30s");
+    await expect(promise).rejects.toThrow("History sync timed out after 65s");
     expect(getInitDeferred(getInitKey(serverId, agentId))).toBeUndefined();
     expect(useSessionStore.getState().sessions[serverId]?.initializingAgents.get(agentId)).toBe(
       false,
     );
     vi.useRealTimers();
   });
+
+  it("refreshes the initialization timeout after paged catch-up progress", async () => {
+    vi.useFakeTimers();
+    const client = makeClient();
+    useSessionStore.getState().initializeSession(serverId, client as never);
+    const setAgentInitializing = bindSetAgentInitializing();
+    const key = getInitKey(serverId, agentId);
+
+    const promise = ensureAgentIsInitialized({
+      serverId,
+      agentId,
+      client: client as never,
+      setAgentInitializing,
+    });
+
+    vi.advanceTimersByTime(64_999);
+    refreshAgentInitializationTimeout({ key, agentId, setAgentInitializing });
+
+    vi.advanceTimersByTime(1);
+    expect(getInitDeferred(key)).toBeDefined();
+
+    const rejection = expect(promise).rejects.toThrow("History sync timed out after 65s");
+
+    vi.advanceTimersByTime(64_998);
+    expect(getInitDeferred(key)).toBeDefined();
+
+    vi.advanceTimersByTime(1);
+
+    await rejection;
+    expect(getInitDeferred(key)).toBeUndefined();
+    vi.useRealTimers();
+  });
 });
 
 describe("refreshAgent", () => {

packages/app/src/hooks/use-agent-initialization.ts

@@ -3,19 +3,36 @@ import { useTranslation } from "react-i18next";
 import type { DaemonClient } from "@getpaseo/client/internal/daemon-client";
 import { useSessionStore } from "@/stores/session-store";
 import {
-  attachInitTimeout,
   createInitDeferred,
   getInitDeferred,
   getInitKey,
+  INIT_TIMEOUT_MS,
   rejectInitDeferred,
+  refreshInitTimeout,
 } from "@/utils/agent-initialization";
 import { planInitialAgentTimelineSync, planTimelineTailFetch } from "@/timeline/timeline-sync-plan";
 import { i18n } from "@/i18n/i18next";
 
-export const INIT_TIMEOUT_MS = 30_000;
-
 export type SetAgentInitializing = (agentId: string, initializing: boolean) => void;
 
+export function createHistorySyncTimeoutError(): Error {
+  return new Error(`History sync timed out after ${Math.round(INIT_TIMEOUT_MS / 1000)}s`);
+}
+
+export function refreshAgentInitializationTimeout(input: {
+  key: string;
+  agentId: string;
+  setAgentInitializing: SetAgentInitializing;
+}): void {
+  refreshInitTimeout({
+    key: input.key,
+    onTimeout: () => {
+      input.setAgentInitializing(input.agentId, false);
+      rejectInitDeferred(input.key, createHistorySyncTimeoutError());
+    },
+  });
+}
+
 export interface EnsureAgentIsInitializedInput {
   serverId: string;
   agentId: string;
@@ -38,14 +55,7 @@ export function ensureAgentIsInitialized(input: EnsureAgentIsInitializedInput):
   const timelineRequest = planInitialAgentTimelineSync({ cursor, hasAuthoritativeHistory });
 
   const deferred = createInitDeferred(key, timelineRequest.direction);
-  const timeoutId = setTimeout(() => {
-    setAgentInitializing(agentId, false);
-    rejectInitDeferred(
-      key,
-      new Error(`History sync timed out after ${Math.round(INIT_TIMEOUT_MS / 1000)}s`),
-    );
-  }, INIT_TIMEOUT_MS);
-  attachInitTimeout(key, timeoutId);
+  refreshAgentInitializationTimeout({ key, agentId, setAgentInitializing });
 
   setAgentInitializing(agentId, true);