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.
TypeScript agentai-chatai-studioall-in-onecoding-agentdesktop-appfluximage-generationlinuxllmlocal-ailocal-llmopen-sourceprivacyself-hostedstable-diffusionuncensoreduncensored-aivideo-generationwindows
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
}