@hugpy/video-intelligence-ui 0.3.2 → 0.3.3

package/src/video/usePromptAssist.ts

@@ -55,6 +55,9 @@ export interface AssistModel {
   model: string;
   /** Seated on a worker right now (answers in ~1s) vs present but cold (first call loads it). */
   serving: boolean;
+  /** Canonical residency (STATE-MODEL.md #4): serving|loaded = ready; hot = on a
+   *  worker drive (pays a t_load); cold = central only (pays a download + load). */
+  state?: "serving" | "loaded" | "hot" | "cold";
   framework?: string | null;
   /** True for the fleet default — used when the user has never chosen. */
   default?: boolean;
@@ -154,6 +157,60 @@ function readAssistPrompt(value: unknown): string | null {
   return null;
 }
 
+// Ticket flow (2026-08-28): a cold model load measured 6m12s on the live
+// fleet, and a held browser connection dies long before that (ClientGone) —
+// killing the load, which restarts on the next click, forever. POST with
+// {async:true} returns {ticket} immediately and the generation keeps running
+// server-side; we poll the ticket until the prompt lands. No connection has
+// to survive the load. An old server without the ticket route answers the
+// POST with the direct result, which passes through unchanged.
+const TICKET_POLL_MS = 3_000;
+const TICKET_CEILING_MS = 12 * 60_000;
+
+async function assistCall(
+  body: Record<string, unknown>,
+  specKey: string | undefined,
+  operation: string,
+): Promise<ReturnType<typeof request<unknown>>> {
+  const res = await request<unknown>(hugpyConfig.promptAssistUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...body, async: true }),
+    timeoutMs: 30_000,
+    meta: { specKey, operation },
+  });
+  if (!res.ok) return res;
+  const value = okValue(res) as { ticket?: string; pending?: boolean } | null;
+  const ticket = value?.ticket;
+  if (!ticket) return res; // direct (non-ticket) result — serve as-is
+  const deadline = Date.now() + TICKET_CEILING_MS;
+  for (;;) {
+    await new Promise((r) => setTimeout(r, TICKET_POLL_MS));
+    const poll = await request<unknown>(
+      `${hugpyConfig.promptAssistUrl}/ticket/${encodeURIComponent(ticket)}`,
+      {
+        method: "GET",
+        timeoutMs: 15_000,
+        meta: { specKey, operation: `${operation}.poll` },
+      },
+    );
+    if (!poll.ok) return poll;
+    const row = okValue(poll) as { pending?: boolean } | null;
+    if (!row?.pending) return poll;
+    if (Date.now() >= deadline) {
+      return {
+        ok: false,
+        error: {
+          kind: "timeout",
+          message:
+            "the assistant is still working after 12 minutes — the model may be stuck loading; try again",
+          requestId: `assist-ticket-${ticket.slice(0, 8)}`,
+        },
+      } as Awaited<ReturnType<typeof request<unknown>>>;
+    }
+  }
+}
+
 export function usePromptAssist({ kind, specKey }: UsePromptAssistOptions): PromptAssistApi {
   // One in-flight call at a time: `assistBusy` holds the ACTIVE mode or null when idle —
   // it both blocks concurrent calls and drives which button shows its loading label.
@@ -246,13 +303,10 @@ export function usePromptAssist({ kind, specKey }: UsePromptAssistOptions): Prom
         context: { kind, ...(extra?.context ?? {}) },
       };
 
-      const res = await request<unknown>(hugpyConfig.promptAssistUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        timeoutMs: 90_000, // a few seconds typically; generous for an on-demand worker
-        meta: { specKey, operation: `prompt.assist.${mode}` },
-      });
+      // Ticket flow — see assistCall: the POST returns immediately and we poll,
+      // so a cold model load (measured 6m12s) can finish without the browser
+      // holding a connection through it.
+      const res = await assistCall(body, specKey, `prompt.assist.${mode}`);
       if (!res.ok) {
         setAssistError(describeAppError(errorOf(res)));
         setAssistBusy(null);
@@ -292,13 +346,7 @@ export function usePromptAssist({ kind, specKey }: UsePromptAssistOptions): Prom
       const negModel = opts.extra?.model ?? assistModel;
       if (negModel) body.model = negModel;
 
-      const res = await request<unknown>(hugpyConfig.promptAssistUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        timeoutMs: 90_000,
-        meta: { specKey, operation: "prompt.assist.negative" },
-      });
+      const res = await assistCall(body, specKey, "prompt.assist.negative");
       if (!res.ok) {
         setAssistError(describeAppError(errorOf(res)));
         setAssistBusy(null);
@@ -328,15 +376,9 @@ export function usePromptAssist({ kind, specKey }: UsePromptAssistOptions): Prom
       setAssistError(null);
       setAssistBusy("spread");
       const payload = { ...body, ...(assistModel ? { model: assistModel } : {}) };
-      const res = await request<unknown>(hugpyConfig.promptAssistUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(payload),
-        // A spread writes N paragraphs in one generation, so it is the longest assist
-        // call there is — and on a cold generator it pays a model load first.
-        timeoutMs: 180_000,
-        meta: { specKey, operation: "prompt.assist.spread" },
-      });
+      // A spread writes N paragraphs in one generation, the longest assist call
+      // there is — the ticket flow means a cold generator's load can't kill it.
+      const res = await assistCall(payload, specKey, "prompt.assist.spread");
       if (!res.ok) {
         setAssistError(describeAppError(errorOf(res)));
         setAssistBusy(null);