@hugpy/video-intelligence-ui 0.3.2 → 0.3.4

package/src/video/useOperatorHistory.ts

@@ -1,105 +1,15 @@
-// OPERATOR HISTORY HYDRATION (operator ask 2026-08-13): the superadmin gets
-// COMPLETE visibility of previous renders in the Session Library — not just
-// what this browser tab produced. The library itself stays a per-session
-// sessionStorage working set (by design); this hook back-fills it from the
-// SERVER record once per session for an operator principal:
+// OPERATOR HISTORY HYDRATION — RETIRED (2026-10-05).
 //
-//   * probe: GET keysVideoShareUrl — the same 200⇒operator / 401⇒guest probe
-//     SharePanel uses (members and share guests never hydrate; their lists
-//     stay owner-scoped server-side).
-//   * source: GET /video/jobs?all=1 for terminal done generate_image /
-//     generate_scene / generate_movie rows (the list projection strips
-//     results, so each job detail is fetched for its outputs). Clips
-//     (studio_i2v) already hydrate via useStudioClips poll — not repeated.
-//   * sink: addToLibrary — idempotent by uri, tombstone-respecting (an item
-//     the operator removed stays removed), genKind-tagged so the Generate
-//     station can filter the strips by its CURRENT SECTION.
-//
-// Once-per-session guard in sessionStorage; canned demo never hydrates.
-import { useEffect } from "react";
-import { request, okValue } from "../transport/client";
-import { hugpyConfig, jobStatusUrl } from "../config";
-import { addToLibrary, type LibraryGenKind } from "./mediaLibrary";
-import { getSessionId } from "../session";
-import { isCanned } from "../demo/mode";
-import type { MediaRef } from "./contract";
-
-// generate_studio_movie = CINEMA renders — hydrated too (mapped onto the
-// generate_movie library kind: same Videos shelf, no schema change).
-const GEN_KINDS: readonly string[] = [
-  "generate_image", "generate_scene", "generate_movie", "generate_studio_movie",
-];
-// v2 (2026-08-13): the once-per-session flag must change whenever the
-// HYDRATED KINDS change — a tab that hydrated v1 (no cinema jobs) kept its
-// flag through every reload and never saw generate_studio_movie history.
-const FLAG_PREFIX = "vi.operatorHistory.v2";
-const DETAIL_CAP = 150; // newest-first; enough history without hammering the API
-
-function flagKey(): string {
-  try { return `${FLAG_PREFIX}:${getSessionId()}`; } catch { return FLAG_PREFIX; }
-}
+// This hook back-filled the Session Library from the server record once per
+// session, but ONLY for a console operator, and it decided operator-ness by
+// probing GET /keys/video-share — the same 200⇒operator / 401⇒guest probe
+// SharePanel used. That route has no backend in this build: the probe only ever
+// 404'd, so the hydration never ran. With no operator signal to replace it (and
+// per the directive to drop the dead /keys/video-share calls), this is now a
+// no-op rather than a dead request fired on every page load. The exported
+// signature is kept so its one caller stays valid.
 
+/** No-op: operator history hydration is retired (see the file header). */
 export function useOperatorHistory(): void {
-  useEffect(() => {
-    if (isCanned()) return;
-    try { if (sessionStorage.getItem(flagKey())) return; } catch { /* no-op */ }
-    let cancelled = false;
-    void (async () => {
-      // Operator probe — non-operators (401/403) never hydrate.
-      const probe = await request<unknown>(hugpyConfig.keysVideoShareUrl, {
-        meta: { specKey: "media", operation: "operator.probe" },
-      });
-      if (cancelled || !probe.ok) return;
-      // jobStatusUrl("") = `${apiBase}/video/jobs/` — trim the slash and query
-      // the list route with terminal rows included.
-      const list = await request<unknown>(
-        `${jobStatusUrl("").replace(/\/$/, "")}?all=1&limit=300`,
-        { meta: { specKey: "media", operation: "history.jobs.list" } },
-      );
-      if (cancelled || !list.ok) return;
-      const jobs = ((okValue(list) as { jobs?: unknown[] })?.jobs ?? []) as Array<
-        Record<string, unknown>
-      >;
-      const wanted = jobs
-        .filter((j) => j?.status === "done" && GEN_KINDS.includes(String(j?.name)))
-        .slice(0, DETAIL_CAP);
-      for (const j of wanted) {
-        if (cancelled) return;
-        const id = String(j.job_id ?? j.id ?? "");
-        if (!id) continue;
-        const det = await request<unknown>(jobStatusUrl(id), {
-          meta: { specKey: "media", operation: "history.job.detail" },
-        });
-        if (!det.ok) continue;
-        const result = (okValue(det) as { result?: { outputs?: unknown[] } })?.result;
-        for (const o of (result?.outputs ?? []) as Array<Record<string, unknown>>) {
-          if (!o?.uri || !o?.asset_id) continue;
-          const ref = {
-            asset_id: String(o.asset_id),
-            kind: (o.kind === "video" ? "video" : "image"),
-            uri: String(o.uri),
-            mime: (o.mime as string) ?? (o.kind === "video" ? "video/mp4" : "image/png"),
-            width: (o.width as number) ?? null,
-            height: (o.height as number) ?? null,
-            duration_s: (o.duration_s as number) ?? null,
-            fps_native: (o.fps_native as number) ?? null,
-            channels: (o.channels as number) ?? null,
-            sample_rate: (o.sample_rate as number) ?? null,
-          } as MediaRef;
-          addToLibrary(ref, "history", `${String(j.name)} · ${id.slice(0, 8)}`, {
-            genKind: (j.name === "generate_studio_movie"
-              ? "generate_movie"
-              : j.name) as LibraryGenKind,
-            // groupId = the producing job: each historical run groups as its own
-            // work (like live pushes) instead of one giant shared "history" pile
-            // whose identical key collided ACROSS the type sections (expanding
-            // Videos/history also expanded Images/history).
-            groupId: id,
-          });
-        }
-      }
-      try { sessionStorage.setItem(flagKey(), String(Date.now())); } catch { /* no-op */ }
-    })();
-    return () => { cancelled = true; };
-  }, []);
+  /* intentionally empty — no /keys/video-share probe, no history back-fill */
 }

package/src/video/usePromptAssist.ts

@@ -37,7 +37,7 @@ export type AssistMode = "detail" | "generate";
 export type AssistBusyMode = AssistMode | "spread" | "negative";
 
 /** The active sub-mode, sent as `context.kind` so video modes get motion/camera phrasing. */
-export type AssistKind = "image" | "scene" | "movie";
+export type AssistKind = "image" | "scene" | "movie" | "clip";
 
 /** The `specKey` a host's telemetry rides under (matches the host's other calls). */
 type SpecKey = "generate" | "studio";
@@ -53,8 +53,13 @@ export interface UsePromptAssistOptions {
 export interface AssistModel {
   /** Catalog key sent back as `body.model`. */
   model: string;
-  /** Seated on a worker right now (answers in ~1s) vs present but cold (first call loads it). */
+  /** Seated on a worker right now. */
   serving: boolean;
+  /** Present on a worker, but not necessarily loaded. */
+  held?: 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" | "unknown";
   framework?: string | null;
   /** True for the fleet default — used when the user has never chosen. */
   default?: boolean;
@@ -154,6 +159,61 @@ 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
+  if (value?.pending === false) return res; // current orbit returns the completed result with its ticket
+  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 +306,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 +349,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 +379,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);

package/src/video/useToks.ts

@@ -15,8 +15,8 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { hugpyConfig } from "../config";
 import { request, okValue } from "../transport/client";
+import { subscribeJobStream } from "./jobStream";
 
-const POLL_MS = 2000;
 const RECENT_LIMIT = 100;
 
 /** One recent inference sample (omit-when-unset tolerated on the wire). */
@@ -127,22 +127,30 @@ export function useToks(): {
     setLive(recent.ok || report.ok);
   }, []);
 
+  // Seed once, then refresh on PUSH: the shared job stream fires on every
+  // worker-reported transition (coalesced), so the tok/s tail tracks live work
+  // without a 2s timer. No job activity → the last-good snapshot simply stands.
   useEffect(() => {
     mounted.current = true;
     void load();
-    const id = window.setInterval(() => void load(), POLL_MS);
+    let coalesce: number | null = null;
+    const unsub = subscribeJobStream(() => {
+      if (coalesce != null) return;
+      coalesce = window.setTimeout(() => {
+        coalesce = null;
+        void load();
+      }, 400);
+    });
     return () => {
       mounted.current = false;
-      window.clearInterval(id);
+      if (coalesce != null) window.clearTimeout(coalesce);
+      unsub();
     };
   }, [load]);
 
   return { entries, groups, live };
 }
 
-/** The poll cadence, exported so the panel header can label it ("every 2s"). */
-export const TOKS_POLL_MS = POLL_MS;
-
 /** "12s ago" / "3m ago" from an epoch-seconds ts, "" when unknown. */
 export function tokAgo(ts: number | null, nowMs: number): string {
   if (ts == null) return "";

package/src/video/watchVideoJob.ts

@@ -0,0 +1,43 @@
+/** One status seed followed by pushed job transitions. No periodic GET loop. */
+import { videoJobUrl } from "../config";
+import { request, okValue } from "../transport/client";
+import { subscribeJobStream } from "./jobStream";
+
+export function watchVideoJob(
+  jobId: string,
+  onJob: (job: Record<string, unknown>) => boolean | void,
+  onTimeout: () => void,
+  timeoutMs: number,
+): () => void {
+  let active = true;
+  let pushed = false;
+  let unsubscribe: (() => void) | null = null;
+  const deadline = Date.now() + timeoutMs;
+  const timer = window.setTimeout(() => {
+    if (!active || Date.now() < deadline) return;
+    stop();
+    onTimeout();
+  }, timeoutMs);
+  const stop = () => {
+    if (!active) return;
+    active = false;
+    window.clearTimeout(timer);
+    unsubscribe?.();
+    unsubscribe = null;
+  };
+  const deliver = (row: unknown) => {
+    if (!active || !row || typeof row !== "object") return;
+    if (onJob(row as Record<string, unknown>) === true) stop();
+  };
+  unsubscribe = subscribeJobStream((ev) => {
+    if (ev.job_id !== jobId || !ev.job) return;
+    pushed = true;
+    deliver(ev.job);
+  });
+  void request<unknown>(videoJobUrl(jobId), {
+    meta: { specKey: "studio", operation: "video.job.seed" },
+  }).then((res) => {
+    if (res.ok && !pushed) deliver(okValue(res));
+  });
+  return stop;
+}