Skip to content

The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.

10.4 KB
Raw Blame
import { create } from 'zustand'
import type { RunLane } from '../lib/run-lanes'

/**
 * Ephemeral per-conversation "a turn is generating" flags. Deliberately NOT
 * persisted — a crash mid-stream must never leave a stale "running" marker that
 * survives a restart.
 *
 * Why this exists (2026-06-12): the chat / agent / codex hooks each held a
 * single GLOBAL `isGenerating` boolean. The typing indicator (the 3 dots) and
 * the realtime counter were gated on that global, so generating in ONE chat lit
 * the dots in EVERY other chat you switched to ("die drei ladepunkte kommen in
 * vorherigen chats auch"). Binding the indicators to the conversation that is
 * actually generating fixes it — the dots show only in the chat whose turn is
 * in flight. The Coding Agent uses its own per-thread status (codexStore), so it
 * doesn't need this store; Chat + Agent (which share one useChat instance) do.
 *
 * ── AUFTRAG 2.1: DIE SPUR GEHOERT ZUM LAUF ───────────────────────────────
 *
 * Der Absatz darueber stand bis heute anders da: die Eingabe blieb absichtlich
 * GLOBAL, weil ein zweiter Auftrag aus einem anderen Chat die geteilten
 * Streaming-Refs zerschossen haette. Der Preis dafuer war, dass der
 * Senden-Knopf waehrend JEDES Laufs app-weit "Stop generation" hiess. Ein
 * zweiter Auftrag war nicht absendbar, ohne den ersten abzubrechen, auch in
 * einem voellig anderen Gespraech, und auch dann, wenn der erste Lauf in der
 * Wolke rechnete und mit der Maschine des Nutzers gar nichts zu tun hatte.
 *
 * Was hier dazukommt, ist die eine Tatsache, die dafuer fehlte: AUF WELCHER
 * SPUR ein Lauf rechnet. Cloud-Laeufe duerfen echt gleichzeitig laufen, denn
 * dort steht fremde Kapazitaet dahinter. Lokale Laeufe bleiben serialisiert,
 * weil zwei davon auf einer Karte kein Gewinn sind, sondern VRAM-Umladen; die
 * Begruendung steht ausgeschrieben in `lib/run-lanes.ts`. Der Unterschied
 * muss sichtbar sein, sonst ist er fuer den Kunden Willkuer, und sichtbar
 * machen kann ihn nur, wer ihn ablesen kann.
 *
 * ── DREI TATSACHEN, DREI ORTE, KEINE KOPIE ───────────────────────────────
 *
 * Das Muster, an dem dieses Haus am haeufigsten scheitert, ist "zwei Pfade,
 * einer gepflegt". Deshalb steht hier ausgeschrieben, welche Frage wo
 * beantwortet wird, und dass keine der drei aus einer anderen ableitbar ist:
 *
 *   `generating[id]`  Fliessen hier gerade Token? Der Zustand, an dem die
 *                     Punkte und der Stop-Knopf haengen. Ein wartender Lauf
 *                     hat ihn NICHT.
 *   `runs[id]`        Auf welcher Spur ist hier ein Lauf gebucht, und seit
 *                     wann? Gilt ab dem Anstellen, also schon bevor das
 *                     erste Token fliesst.
 *   `lib/run-lanes`   Wer haelt die eine lokale Spur, und wer wartet in
 *                     welcher Reihenfolge? Modulzustand, kein Spiegel hier.
 *
 * `runs[id]` ist ausdruecklich KEINE zweite Fassung von `generating[id]`. Ein
 * Wartender hat einen Eintrag und keine Fahne; ein Altbestands-Lauf, der
 * `setGenerating` ruft, ohne vorher zu buchen, hat eine Fahne und keinen
 * Eintrag. Wer die beiden zusammenlegt, verliert genau den Zustand, den
 * dieser Auftrag sichtbar machen soll.
 *
 * `bookRun` und `endRun` ruft nur `lib/run-slot.ts`, dieselbe Stelle, die die
 * Spur bei `run-lanes.ts` nimmt und zurueckgibt. Buchung und Platz entstehen
 * und vergehen damit zusammen. Die eine Ausnahme ist `abortConversation`
 * weiter unten: es raeumt das ganze Gespraech weg, also auch die Buchung, und
 * ist dafuer da, dass ein geloeschter Chat nichts hinterlaesst. Es nimmt
 * keinen Platz und gibt keinen zurueck; das bleibt beim `finally` in
 * `run-slot.ts`, auch auf diesem Weg.
 */

/**
 * Ein gebuchter Lauf: die Spur, auf der er rechnet, und seit wann er gebucht
 * ist. Kein Status, keine Fahne, kein Abbruchgriff, das steht alles daneben
 * und wird hier bewusst nicht noch einmal gefuehrt.
 */
export interface ActiveRun {
  conversationId: string
  /** Eigene Karte oder fremde Kapazitaet. Entschieden in `lib/run-lane-of-model.ts`. */
  lane: RunLane
  /**
   * ms-Zeitstempel der ERSTEN Buchung. Bleibt beim Nachbuchen stehen, damit
   * "wartet seit" nicht bei jeder Nachfrage von vorn anfaengt und ein lange
   * stehender Lauf nicht aussieht wie ein eben angekommener.
   */
  bookedAt: number
  /**
   * Wer hat das gebucht. Undurchsichtig, nur fuer den Identitaetsvergleich in
   * `endRun` gedacht (Blocker A, Opus-Review Runde 2): `run-slot.ts` bucht
   * jeden Lauf mit einem frischen Objekt, damit ein spaet kommendes `finally`
   * eines ALTEN Laufs (Stop, sofort neu gesendet) nicht die Buchung des NEUEN
   * Laufs derselben Unterhaltung wegraeumt.
   */
  runToken: unknown
}

interface GenerationState {
  /** conversationId → true while its turn is generating. Absent = idle. */
  generating: Record<string, boolean>
  setGenerating: (conversationId: string | null | undefined, on: boolean) => void
  /**
   * conversationId → abort callback for the in-flight turn (chat stream OR
   * agent loop). Lets a non-hook caller (deleting/closing a chat) stop the
   * work that the owning hook started.
   */
  aborters: Record<string, () => void>
  registerAborter: (conversationId: string | null | undefined, fn: () => void) => void
  clearAborter: (conversationId: string | null | undefined) => void
  /**
   * Abort the in-flight turn for a conversation and clear its flags. Called
   * when a chat is deleted/closed so its activity stops completely instead of
   * running on in the background (2026-06-15).
   */
  abortConversation: (conversationId: string | null | undefined) => void
  /**
   * conversationId → der gebuchte Lauf dieses Gespraechs, mit seiner Spur.
   *
   * Gebucht und beendet nur von `lib/run-slot.ts`, das auch die Spur bei
   * `lib/run-lanes.ts` nimmt und zurueckgibt; dazu weggeraeumt von
   * `abortConversation`, wenn das ganze Gespraech verschwindet. Ein dritter
   * Schreiber waere genau der Pfad, der irgendwann nicht mehr gepflegt wird.
   */
  runs: Record<string, ActiveRun>
  /**
   * Diesen Lauf mit seiner Spur eintragen. Zweite Buchung behaelt `bookedAt`,
   * wenn die Spur gleich bleibt, uebernimmt aber IMMER den neuen `runToken`
   * (Blocker A): sonst zeigt der Eintrag nach einem Stop-dann-neu-Senden
   * weiter auf den alten Lauf, und dessen `endRun` raeumt die Buchung des
   * neuen weg, obwohl der neue noch laeuft.
   */
  bookRun: (conversationId: string | null | undefined, lane: RunLane, runToken?: unknown) => void
  /**
   * Der Lauf ist vorbei. Raeumt nur den Eintrag, nicht die Fahne, und nur,
   * wenn `runToken` noch zum aktuellen Eintrag passt (Blocker A): ein spaet
   * kommendes `finally` eines abgeloesten Laufs darf die Buchung des Laufs,
   * der die Unterhaltung inzwischen uebernommen hat, nicht wegraeumen.
   */
  endRun: (conversationId: string | null | undefined, runToken?: unknown) => void
}

/**
 * Auf welcher Spur laeuft das Gespraech gerade, falls ueberhaupt?
 *
 * Fuer Aufrufer ohne React. In einer Komponente stattdessen
 * `useGenerationStore((s) => s.runs[id]?.lane)`, sonst malt sie nicht neu,
 * wenn der Lauf die Spur wechselt oder endet.
 */
export function runLaneOf(conversationId: string | null | undefined): RunLane | undefined {
  if (!conversationId) return undefined
  return useGenerationStore.getState().runs[conversationId]?.lane
}

export const useGenerationStore = create<GenerationState>((set, get) => ({
  generating: {},
  aborters: {},
  runs: {},
  setGenerating: (conversationId, on) =>
    set((state) => {
      if (!conversationId) return state
      // No-op when the flag is already in the requested state — avoids an
      // unnecessary store update (and re-render) on every stream tick.
      if (!!state.generating[conversationId] === on) return state
      const next = { ...state.generating }
      if (on) next[conversationId] = true
      else delete next[conversationId]
      return { generating: next }
    }),

  registerAborter: (conversationId, fn) =>
    set((state) => {
      if (!conversationId) return state
      return { aborters: { ...state.aborters, [conversationId]: fn } }
    }),

  clearAborter: (conversationId) =>
    set((state) => {
      if (!conversationId || !state.aborters[conversationId]) return state
      const next = { ...state.aborters }
      delete next[conversationId]
      return { aborters: next }
    }),

  abortConversation: (conversationId) => {
    if (!conversationId) return
    const fn = get().aborters[conversationId]
    if (fn) {
      try { fn() } catch { /* best-effort — the turn is going away anyway */ }
    }
    set((state) => {
      const nextAborters = { ...state.aborters }
      delete nextAborters[conversationId]
      const nextGenerating = { ...state.generating }
      delete nextGenerating[conversationId]
      // Die Buchung geht mit. Bliebe sie stehen, zeigte der abgebrochene Chat
      // weiter "wartet auf die Grafikkarte", fuer einen Lauf, den es nicht
      // mehr gibt. Die Spur selbst gibt `lib/run-slot.ts` in seinem `finally`
      // zurueck, und zwar auch auf diesem Weg.
      const nextRuns = { ...state.runs }
      delete nextRuns[conversationId]
      return { aborters: nextAborters, generating: nextGenerating, runs: nextRuns }
    })
  },

  bookRun: (conversationId, lane, runToken) =>
    set((state) => {
      if (!conversationId) return state
      const vorhanden = state.runs[conversationId]
      // Gleiche Spur, gleicher Lauf (gleicher `runToken`): reines Nachfragen,
      // nichts zu tun. Gleiche Spur, ANDERER Lauf: `bookedAt` bleibt (siehe
      // oben), aber `runToken` MUSS auf den neuen Lauf zeigen, sonst raeumt
      // dessen `endRun` spaeter die Buchung des neuen Laufs weg.
      if (vorhanden && vorhanden.lane === lane && vorhanden.runToken === runToken) return state
      return {
        runs: {
          ...state.runs,
          [conversationId]: {
            conversationId,
            lane,
            runToken,
            bookedAt: vorhanden && vorhanden.lane === lane ? vorhanden.bookedAt : Date.now(),
          },
        },
      }
    }),

  endRun: (conversationId, runToken) =>
    set((state) => {
      if (!conversationId) return state
      const vorhanden = state.runs[conversationId]
      if (!vorhanden || vorhanden.runToken !== runToken) return state
      const next = { ...state.runs }
      delete next[conversationId]
      return { runs: next }
    }),
}))