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.

9.4 KB
Raw Blame
import { create } from 'zustand'
import {
  applyTaskRing,
  isTerminal,
  taskAnswerDelivered,
  type AgentTask,
  type AgentTaskStatus,
} from '../lib/agent-tasks'

/**
 * Hintergrund-Agenten, je Konversation.
 *
 * NICHT PERSISTIERT, und das ist eine Aussage über Ehrlichkeit, nicht über
 * Bequemlichkeit. Eine laufende Aufgabe ist ein lebendes Versprechen: ein
 * offener Stream, ein AbortController, eine Zusage an einen Elternzug, den es
 * nach einem Neustart nicht mehr gibt. Eine wiederhergestellte Zeile mit
 * `status: 'running'` würde über den Zustand der Maschine lügen, und zwar
 * genau dort, wo der Nutzer einen Abbrechen-Knopf sieht, der nichts mehr
 * abbricht. Dieselbe Begründung wie bei toolAuditStore und generationStore.
 *
 * Der Ring steht in lib/agent-tasks.ts und wird bei JEDEM Zufügen angewandt.
 * Warum überhaupt einer: codexStore und toolAuditStore tragen beide denselben
 * Deckel, und der Kommentar im ersten sagt, was ohne ihn passiert — ungekappte
 * Werkzeugausgaben, "tens of megabytes held for as long as the app is open".
 * Eine Aufgabe hier hält ein ganzes Modellgespräch. Der dritte Anlauf desselben
 * Fehlers wäre keiner mehr, den man Zufall nennen kann.
 */

/** Abbruchsteuerung lebt außerhalb des Zustands: ein Controller ist kein Wert. */
const controllers = new Map<string, AbortController>()

interface AgentTaskState {
  byConv: Record<string, AgentTask[]>

  /**
   * `controller` ist PFLICHT, nicht Bequemlichkeit.
   *
   * Ein Wächter hat den Fall gefunden: eine laufende Zeile ohne Controller
   * zählt `cancelAll` nicht mit und `cancel` bricht sie nicht ab — das Panel
   * zeigt trotzdem einen Stopp-Knopf, weil der nur am Zustand 'running'
   * hängt. Ein Knopf, der nichts tut, ist schlimmer als keiner: er lässt den
   * Nutzer glauben, er habe gestoppt.
   *
   * Einen fehlenden hier ersatzweise selbst zu erzeugen wäre die falsche
   * Reparatur — dann bräche `cancel` ein Signal ab, auf das niemand hört, und
   * meldete Erfolg. Der Griff muss der des LAUFS sein. Also verlangt der Typ
   * ihn, und der schlechte Zustand ist nicht mehr baubar.
   */
  start: (task: Omit<AgentTask, 'status' | 'inbox' | 'reported' | 'toolCalls' | 'iterations'> & {
    controller: AbortController
    /**
     * Default `'running'`. Pass `'queued'` when the row exists before the
     * run is actually admitted to its resource lane (Folgeauftrag aus
     * bau/review-w2lane.md Runde 4: a background sub-agent is entered here
     * BEFORE `lib/run-slot.ts` says go, so `check_tasks` used to report a
     * merely-waiting task as running, with a clock that had been counting
     * since creation). Callers move it to `'running'` with `update()` once
     * the run truly starts.
     */
    status?: 'queued' | 'running'
  }) => void
  update: (id: string, patch: Partial<AgentTask>) => void
  finish: (id: string, patch: { status: AgentTaskStatus; output?: string; error?: string; endedAt: number }) => void
  /** Nachricht des Hauptagenten an eine laufende Aufgabe. */
  post: (id: string, message: string) => boolean
  /** Posteingang leeren und zurückgeben — der Lauf liest ihn genau einmal. */
  drainInbox: (id: string) => string[]
  cancel: (id: string) => boolean
  /** Alle Aufgaben einer Konversation abbrechen (der Elternlauf wurde gestoppt). */
  cancelAll: (convId: string) => number
  /** Fertige, noch nicht gemeldete Aufgaben — und sie gelten danach als gemeldet. */
  takeUnreported: (convId: string) => AgentTask[]
  get: (id: string) => AgentTask | undefined
  forConv: (convId: string) => AgentTask[]
  clearConv: (convId: string) => void
}

/** Die eine Stelle, an der eine Aufgabe über alle Konversationen gefunden wird. */
function locate(byConv: Record<string, AgentTask[]>, id: string): { convId: string; index: number } | null {
  for (const [convId, list] of Object.entries(byConv)) {
    const index = list.findIndex((t) => t.id === id)
    if (index >= 0) return { convId, index }
  }
  return null
}

export const useAgentTaskStore = create<AgentTaskState>((set, get) => ({
  byConv: {},

  start: ({ controller, status, ...task }) => {
    controllers.set(task.id, controller)
    set((s) => {
      const list = s.byConv[task.convId] ?? []
      const voll: AgentTask = {
        ...task,
        status: status ?? 'running',
        inbox: [],
        reported: false,
        toolCalls: 0,
        iterations: 0,
      }
      return { byConv: { ...s.byConv, [task.convId]: applyTaskRing([...list, voll]) } }
    })
  },

  update: (id, patch) => set((s) => {
    const wo = locate(s.byConv, id)
    if (!wo) return s
    const list = s.byConv[wo.convId].slice()
    list[wo.index] = { ...list[wo.index], ...patch }
    return { byConv: { ...s.byConv, [wo.convId]: list } }
  }),

  finish: (id, patch) => {
    controllers.delete(id)
    set((s) => {
      const wo = locate(s.byConv, id)
      if (!wo) return s
      const list = s.byConv[wo.convId].slice()
      // Der Posteingang wird beim Beenden geleert: was niemand mehr liest,
      // soll auch nicht als ungelesen dastehen.
      list[wo.index] = { ...list[wo.index], ...patch, inbox: [] }
      return { byConv: { ...s.byConv, [wo.convId]: applyTaskRing(list) } }
    })
  },

  post: (id, message) => {
    const t = get().get(id)
    if (!t || isTerminal(t.status)) return false
    get().update(id, { inbox: [...t.inbox, message] })
    return true
  },

  drainInbox: (id) => {
    const t = get().get(id)
    if (!t || !t.inbox.length) return []
    const posteingang = t.inbox
    get().update(id, { inbox: [] })
    return posteingang
  },

  cancel: (id) => {
    const c = controllers.get(id)
    // Der Zustand wird hier NICHT auf 'cancelled' gesetzt. Das tut der Lauf
    // selbst, wenn sein Signal feuert — sonst zeigte das Panel "abgebrochen",
    // während im Hintergrund noch gerechnet wird. Eine Anzeige, die dem
    // Wunsch statt der Wirklichkeit folgt, ist schlimmer als gar keine.
    if (!c) return false
    c.abort()
    return true
  },

  cancelAll: (convId) => {
    let n = 0
    for (const t of get().forConv(convId)) {
      // 'queued' zaehlt hier mit (Folgeauftrag, bau/review-w2lane.md Runde 4):
      // vor der 'queued'-Einfuehrung deckte 'running' JEDEN nicht fertigen
      // Zustand ab, eine wartende Aufgabe hatte keinen anderen.
      //
      // `stopAllBackgroundWork` selbst bleibt davon unberuehrt: es findet eine
      // noch wartende Aufgabe ohnehin ueber `generationStore.runs` (die
      // `bookRun` in lib/run-slot.ts setzt, sobald sich der Lauf anstellt, vor
      // jeder Buchung) und ruft zusaetzlich `abortConversation`, das ueber
      // `run-lanes.ts`s Abbruchgriff sogar richtig aus der Schlange nimmt,
      // siehe background-shutdown.ts. Aber die beiden Kopf-Knoepfe hier im
      // Panel ("Stop every running agent", die Leiste fuer andere
      // Unterhaltungen) riefen bis hierher NUR `cancelAll`, ohne dieses
      // zweite Paar: eine wartende Aufgabe blieb dort unberuehrt liegen und
      // rief spaeter doch noch das Modell, nachdem der Nutzer auf genau
      // diesen Knopf gedrueckt hatte.
      if ((t.status === 'running' || t.status === 'queued') && get().cancel(t.id)) n++
    }
    return n
  },

  takeUnreported: (convId) => {
    // `taskAnswerDelivered` und nicht `!t.reported`: eine VORDERGRUNDzeile hat
    // ihre Antwort als Rueckgabewert des Werkzeugaufrufs abgeliefert, lange
    // bevor jemand hier nachsieht, und traegt `reported` trotzdem ewig auf
    // `false`. Am rohen Merker gemessen ginge dieselbe Antwort ein zweites Mal
    // an das Modell, diesmal als `[background-task]`. Die volle Begruendung
    // steht bei der Funktion in lib/agent-tasks.ts.
    const fertig = get().forConv(convId).filter((t) => isTerminal(t.status) && !taskAnswerDelivered(t))
    if (!fertig.length) return []
    set((s) => ({
      byConv: {
        ...s.byConv,
        [convId]: (s.byConv[convId] ?? []).map((t) =>
          fertig.some((f) => f.id === t.id) ? { ...t, reported: true } : t,
        ),
      },
    }))
    // Die zurueckgegebenen Zeilen tragen `reported: true`, nicht den Stand von
    // vor dem Schreiben. Vorher waren es Schnappschuesse mit `false` darin —
    // heute harmlos, weil renderTaskReport nur id/status/output/error liest,
    // aber ein Aufrufer, der die Objekte behaelt, laese eine Zahl, die im
    // Store schon nicht mehr gilt. Eine Rueckgabe, die dem Speicher
    // widerspricht, ist eine Falle mit Verfallsdatum.
    return fertig.map((t) => ({ ...t, reported: true }))
  },

  get: (id) => {
    const wo = locate(get().byConv, id)
    return wo ? get().byConv[wo.convId][wo.index] : undefined
  },

  forConv: (convId) => get().byConv[convId] ?? [],

  clearConv: (convId) => {
    // ABBRECHEN, dann vergessen — in dieser Reihenfolge.
    //
    // Die erste Fassung loeschte nur die Controller-Eintraege. Ein Agent, der
    // gerade Werkzeuge auf der Maschine des Nutzers fuhr, lief dann weiter,
    // waehrend seine Zeile aus dem Panel verschwand: kein Stopp-Knopf mehr,
    // keine Spur, und beim Beenden schreibt er in einen Store, der ihn nicht
    // mehr kennt. Ein geloeschter Chat muss seine Agenten mitnehmen.
    for (const t of get().forConv(convId)) {
      if (t.status === 'running') controllers.get(t.id)?.abort()
      controllers.delete(t.id)
    }
    set((s) => {
      const rest = { ...s.byConv }
      delete rest[convId]
      return { byConv: rest }
    })
  },
}))

/** Nur für Tests: die Controller-Karte ist Modulzustand, kein Store-Zustand. */
export function _controllerCount(): number {
  return controllers.size
}