@schlenkr/ragents 0.1.5 → 0.1.6

package/plugins/ragents.orchestration/web/run-panel/addressee-tree.ts

@@ -0,0 +1,165 @@
+import { chatPrimaryId, type RunActor, type RunView } from "@ragents/web/run-view";
+
+export interface AddresseeActorNode {
+  kind: "actor";
+  actor: RunActor;
+  children: AddresseeNode[];
+}
+
+export interface AddresseeGroupNode {
+  kind: "group";
+  key: string;
+  label: string;
+  members: AddresseeActorNode[];
+}
+
+export type AddresseeNode = AddresseeActorNode | AddresseeGroupNode;
+
+export type AddresseeStatus = "running" | "input" | "waiting" | "stopped";
+
+/** Ab so vielen gleichartigen Geschwistern fasst der Baum sie zu einer Gruppe zusammen. */
+export const ADDRESSEE_GROUP_MIN = 4;
+/** Erst bei mehr Einträgen erscheint die Suche. */
+export const ADDRESSEE_SEARCH_ABOVE = 12;
+const SUMMARY_LENGTH = 90;
+
+const STATUS_WORDS: Readonly<Record<AddresseeStatus, readonly [one: string, many: string]>> = {
+  running: ["arbeitet", "arbeiten"],
+  input: ["wartet auf Eingabe", "warten auf Eingabe"],
+  waiting: ["wartet", "warten"],
+  stopped: ["gestoppt", "gestoppt"],
+};
+const STATUS_ORDER: readonly AddresseeStatus[] = ["running", "input", "waiting", "stopped"];
+
+const lower = (text: string) => text.toLocaleLowerCase("de-DE");
+
+const shortened = (text: string): string => {
+  const line = text.split("\n").map((entry) => entry.replace(/\s+/g, " ").trim()).find((entry) => entry !== "") ?? "";
+  if (line.length <= SUMMARY_LENGTH) return line;
+  const cut = line.slice(0, SUMMARY_LENGTH - 3);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > SUMMARY_LENGTH / 2 ? cut.slice(0, space) : cut).trimEnd()}...`;
+};
+
+export const addresseeStatus = (view: RunView, actor: RunActor): AddresseeStatus =>
+  actor.lifecycle?.kind === "stopped" ? "stopped"
+    : view.actions.some((action) => action.status === "pending" && action.askedBy === actor.id) ? "input"
+      : actor.lifecycle?.kind === "running" ? "running" : "waiting";
+
+export const addresseeStatusWord = (status: AddresseeStatus, count = 1): string => STATUS_WORDS[status][count === 1 ? 0 : 1];
+
+/** Zählt die Zustände einer Gruppe in fester Reihenfolge, etwa "3 arbeiten, 34 warten". */
+export const addresseeStatusCounts = (view: RunView, actors: readonly RunActor[]): string => {
+  const counts = new Map<AddresseeStatus, number>();
+  for (const status of actors.map((actor) => addresseeStatus(view, actor))) counts.set(status, (counts.get(status) ?? 0) + 1);
+  return STATUS_ORDER.flatMap((status) => {
+    const count = counts.get(status) ?? 0;
+    return count > 0 ? [`${count} ${addresseeStatusWord(status, count)}`] : [];
+  }).join(", ");
+};
+
+/** Die Kurzbeschreibung je Actor: die beim Erzeugen gesetzte, sonst der gekürzte erste Auftrag, sonst ein abweichender Anzeigename. */
+export const addresseeSummaries = (view: RunView): ((actor: RunActor) => string | undefined) => {
+  const firstInputs = new Map<string, { sequence: number; content: string }>();
+  for (const input of view.inputs) {
+    if (input.subscriptionId !== null || input.presentation === "background" || input.content.trim() === "") continue;
+    const known = firstInputs.get(input.actorId);
+    if (!known || input.sequence < known.sequence) firstInputs.set(input.actorId, { sequence: input.sequence, content: input.content });
+  }
+  return (actor) => {
+    const described = actor.description?.trim();
+    if (described) return described;
+    const first = firstInputs.get(actor.id);
+    if (first) return shortened(first.content);
+    const name = actor.displayName.trim();
+    return name !== "" && lower(name) !== lower(actor.handle) ? name : undefined;
+  };
+};
+
+/** Der nächste Erzeuger nach `createdBy`, der selbst im Baum steht; ein Mensch oder ein unbekannter Erzeuger macht den Actor zur Wurzel. */
+export const addresseeParentId = (byId: ReadonlyMap<string, RunActor>, included: ReadonlySet<string>, actor: RunActor): string | null => {
+  const visited = new Set([actor.id]);
+  let current = actor.createdBy;
+  while (current !== undefined && !visited.has(current)) {
+    if (included.has(current)) return current;
+    const creator = byId.get(current);
+    if (!creator || creator.kind === "human") return null;
+    visited.add(current);
+    current = creator.createdBy;
+  }
+  return null;
+};
+
+const handleStem = (handle: string) => lower(handle).replace(/-\d+$/, "").split(/[-_.]/)[0] ?? "";
+
+const groupLabel = (handles: readonly string[]): string => {
+  const first = handles[0] ?? "";
+  const length = handles.reduce((common, handle) => {
+    let index = 0;
+    while (index < common && handle[index] === first[index]) index += 1;
+    return index;
+  }, first.length);
+  const prefix = first.slice(0, length);
+  const cut = prefix.search(/[-_.][^-_.]*$/);
+  const stem = /[-_.]$/.test(prefix) || handles.includes(prefix) || cut < 0 ? prefix : prefix.slice(0, cut + 1);
+  return `@${stem}*`;
+};
+
+/** Wer hat wen erzeugt: Koordinator oben, Unteragenten darunter, gleichartige Geschwister (Art und Handle-Stamm) als Gruppe. */
+export const addresseeTree = (view: RunView, actors: readonly RunActor[]): AddresseeNode[] => {
+  const byId = new Map(view.actors.map((actor) => [actor.id, actor]));
+  const included = new Set(actors.map((actor) => actor.id));
+  const primaryId = chatPrimaryId(view);
+  const siblings = new Map<string | null, RunActor[]>();
+  for (const actor of actors) {
+    const parent = addresseeParentId(byId, included, actor);
+    siblings.set(parent, [...siblings.get(parent) ?? [], actor]);
+  }
+  const branch = (actor: RunActor): AddresseeActorNode => ({ kind: "actor", actor, children: level(actor.id) });
+  const level = (parentId: string | null): AddresseeNode[] => {
+    const entries = siblings.get(parentId) ?? [];
+    const ordered = parentId === null ? [...entries.filter((actor) => actor.id === primaryId), ...entries.filter((actor) => actor.id !== primaryId)] : entries;
+    const keyOf = (actor: RunActor) => actor.id === primaryId ? null : `${parentId ?? ""}/${actor.kind}/${handleStem(actor.handle)}`;
+    const members = new Map<string, RunActor[]>();
+    for (const actor of ordered) {
+      const key = keyOf(actor);
+      if (key !== null) members.set(key, [...members.get(key) ?? [], actor]);
+    }
+    const emitted = new Set<string>();
+    return ordered.flatMap((actor): AddresseeNode[] => {
+      const key = keyOf(actor);
+      const group = key === null ? undefined : members.get(key);
+      if (key === null || !group || group.length < ADDRESSEE_GROUP_MIN) return [branch(actor)];
+      if (emitted.has(key)) return [];
+      emitted.add(key);
+      return [{ kind: "group", key, label: groupLabel(group.map((member) => member.handle)), members: group.map(branch) }];
+    });
+  };
+  return level(null);
+};
+
+/** Die Actors, die zur Suche passen, samt ihren Erzeugern im Baum, damit jeder Treffer an seinem Platz steht. */
+export const addresseeMatches = (view: RunView, actors: readonly RunActor[], query: string, summary: (actor: RunActor) => string | undefined): RunActor[] => {
+  const words = lower(query).trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [...actors];
+  const byId = new Map(view.actors.map((actor) => [actor.id, actor]));
+  const included = new Set(actors.map((actor) => actor.id));
+  const kept = new Set<string>();
+  for (const actor of actors) {
+    const text = lower(`@${actor.handle} ${actor.displayName} ${summary(actor) ?? ""}`);
+    if (!words.every((word) => text.includes(word))) continue;
+    let current: RunActor | undefined = actor;
+    while (current && !kept.has(current.id)) {
+      kept.add(current.id);
+      const parentId = addresseeParentId(byId, included, current);
+      current = parentId === null ? undefined : byId.get(parentId);
+    }
+  }
+  return actors.filter((actor) => kept.has(actor.id));
+};
+
+/** Ob ein Actor in einem Zweig steckt, etwa damit eine Gruppe mit dem gewählten Actor offen startet. */
+export const addresseeNodeContains = (node: AddresseeNode, actorId: string): boolean =>
+  node.kind === "actor"
+    ? node.actor.id === actorId || node.children.some((child) => addresseeNodeContains(child, actorId))
+    : node.members.some((member) => addresseeNodeContains(member, actorId));

package/plugins/ragents.orchestration/web/{column/column-actors.ts → run-panel/run-panel-actors.ts}

@@ -1,23 +1,24 @@
-import type { CanvasElementDefinition } from "@aicontainer/web/PluginRegistry";
+import type { SurfaceElementDefinition } from "@ragents/web/PluginRegistry";
 import { actorVisibleInHeader, type ActorHeaderMode } from "../actor-header-settings";
-import type { RunActor, RunView } from "../run-view";
+import { chatPrimaryId, type RunActor, type RunView } from "@ragents/web/run-view";
 
 /** Die Actors der Chip-Reihe: Koordinator zuerst, dann in Anlegereihenfolge; ohne Prüfrecht nur LLM-Agenten. */
-export const columnActors = (view: RunView, inspect: boolean): RunActor[] => {
+export const runPanelActors = (view: RunView, inspect: boolean): RunActor[] => {
   const candidates = view.actors.filter((actor) => actor.kind !== "human" && (inspect || actor.kind === "agent"));
-  const primary = candidates.filter((actor) => actor.id === view.primaryActorId);
-  return [...primary, ...candidates.filter((actor) => actor.id !== view.primaryActorId)];
+  const primaryId = chatPrimaryId(view);
+  const primary = candidates.filter((actor) => actor.id === primaryId);
+  return [...primary, ...candidates.filter((actor) => actor.id !== primaryId)];
 };
 
-export interface ColumnActorFilter {
+export interface RunPanelActorFilter {
   mode: ActorHeaderMode;
   onStage: (actor: RunActor) => boolean;
   primaryId: string | null | undefined;
   selectedId: string | undefined;
 }
 
-/** Sichtbar nach der Actor-Anzeige des Canvas; der Koordinator und der gewählte Actor bleiben immer als Chip da. */
-export const partitionColumnActors = (actors: readonly RunActor[], filter: ColumnActorFilter): { shown: RunActor[]; hidden: RunActor[] } => {
+/** Sichtbar nach der Actor-Anzeige der Fläche; der Koordinator und der gewählte Actor bleiben immer als Chip da. */
+export const partitionRunPanelActors = (actors: readonly RunActor[], filter: RunPanelActorFilter): { shown: RunActor[]; hidden: RunActor[] } => {
   const shown: RunActor[] = [];
   const hidden: RunActor[] = [];
   for (const actor of actors) {
@@ -30,9 +31,9 @@ export const partitionColumnActors = (actors: readonly RunActor[], filter: Colum
 export const pendingInputCount = (view: RunView, actorId: string): number =>
   view.inputs.filter((input) => input.actorId === actorId && input.lifecycle.kind === "pending").length;
 
-export const pendingQuestionCount = (view: RunView, askedBy: string): number =>
-  view.actions.filter((action) => action.kind === "question" && action.status === "pending" && action.askedBy === askedBy).length;
+export const pendingActionCount = (view: RunView, askedBy: string): number =>
+  view.actions.filter((action) => action.status === "pending" && action.askedBy === askedBy).length;
 
-/** Ein Chip trägt ein Ausrufezeichen, wenn eine Host-Bestätigung oder eine Rückfrage des Actors auf eine Antwort wartet. */
-export const elementNeedsAttention = (view: RunView | undefined, definition: CanvasElementDefinition, confirmationPending: boolean): boolean =>
-  confirmationPending || (view !== undefined && definition.anchorActorId !== undefined && pendingQuestionCount(view, definition.anchorActorId) > 0);
+/** Ein Chip trägt ein Ausrufezeichen, wenn eine Host-Bestätigung oder eine Aktion des Actors auf eine Eingabe wartet. */
+export const elementNeedsAttention = (view: RunView | undefined, definition: SurfaceElementDefinition, confirmationPending: boolean): boolean =>
+  confirmationPending || (view !== undefined && definition.anchorActorId !== undefined && pendingActionCount(view, definition.anchorActorId) > 0);

package/plugins/ragents.orchestration/web/run-panel/run-panel-settings.ts

@@ -0,0 +1,47 @@
+import { createLocalStorageSetting } from "@ragents/web/lib/local-storage-setting";
+
+/** Verhalten des Run-Panels: ab welcher Breite der Chat neben der Mini-App liegt und wie das Sheet auf die Maus reagiert. */
+export interface RunPanelSettings {
+  sideWidth: number;
+  openDelay: number;
+  closeDelay: number;
+}
+
+export const DEFAULT_RUN_PANEL_SETTINGS: RunPanelSettings = Object.freeze({ sideWidth: 900, openDelay: 160, closeDelay: 150 });
+export const RUN_PANEL_SETTINGS_STORAGE_KEY = "ragents.orchestration.run-panel-settings";
+export const RUN_PANEL_SETTINGS_LIMITS = Object.freeze({
+  sideWidth: { min: 400, max: 4000 },
+  openDelay: { min: 0, max: 5000 },
+  closeDelay: { min: 0, max: 10000 },
+});
+
+const inRange = (value: unknown, range: { min: number; max: number }): value is number =>
+  typeof value === "number" && Number.isInteger(value) && value >= range.min && value <= range.max;
+
+export function parseRunPanelSettings(raw: string | null): RunPanelSettings {
+  if (raw === null) return DEFAULT_RUN_PANEL_SETTINGS;
+  const value: unknown = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || Object.keys(value).some((key) => !["sideWidth", "openDelay", "closeDelay"].includes(key))
+    || !("sideWidth" in value) || !inRange(value.sideWidth, RUN_PANEL_SETTINGS_LIMITS.sideWidth)
+    || !("openDelay" in value) || !inRange(value.openDelay, RUN_PANEL_SETTINGS_LIMITS.openDelay)
+    || !("closeDelay" in value) || !inRange(value.closeDelay, RUN_PANEL_SETTINGS_LIMITS.closeDelay)) {
+    throw new Error("Die Einstellungen des Run-Panels sind ungültig: Breite 400 bis 4000 Pixel, Verzögerungen 0 bis 5000 beziehungsweise 10000 Millisekunden, ganze Zahlen.");
+  }
+  return value as RunPanelSettings;
+}
+
+const setting = createLocalStorageSetting({
+  changeEvent: "ragents-run-panel-settings-change",
+  matchesKey: (key) => key === RUN_PANEL_SETTINGS_STORAGE_KEY,
+  parse: parseRunPanelSettings,
+  serialize: JSON.stringify,
+});
+
+export function useRunPanelSettings(): RunPanelSettings {
+  return setting.useValue(RUN_PANEL_SETTINGS_STORAGE_KEY);
+}
+
+export function saveRunPanelSettings(value: RunPanelSettings) {
+  setting.save(RUN_PANEL_SETTINGS_STORAGE_KEY, value);
+}

package/plugins/ragents.orchestration/web/run-panel/run-panel-startup.ts

@@ -0,0 +1,30 @@
+import { useEffect, useState } from "react";
+import type { Message } from "quassel/events";
+import type { SurfaceStartupState } from "../surface-startup";
+
+/** So lange überbrückt der Ladezustand eine beendete Arbeit, bis die Run-Ansicht dem Startstatus nachgezogen hat. */
+export const STARTUP_SETTLE_MS = 1500;
+
+/** Gesprächsbeiträge und Rückfragen beenden den Aufbau; Systemzeilen und Arbeitsschritte gehören noch zu ihm. */
+export const chatShowsContent = (messages: readonly Message[]): boolean => messages.some((message) =>
+  message.role === "user" || message.role === "action"
+  || (message.role === "assistant" && (message.text.trim() !== "" || (message.attachments?.length ?? 0) > 0)));
+
+/** Der Ladezustand des Run-Panels bis zum ersten Inhalt; danach kommt er für diesen Run nicht wieder. */
+export function useRunPanelStartup(state: SurfaceStartupState | undefined, connected: boolean, content: boolean): SurfaceStartupState | undefined {
+  const [contentSeen, setContentSeen] = useState(content);
+  const [held, setHeld] = useState<SurfaceStartupState>();
+  const working = connected && state?.kind === "working" ? state : undefined;
+  const title = working?.title;
+  const detail = working?.detail;
+  useEffect(() => { if (content) setContentSeen(true); }, [content]);
+  useEffect(() => {
+    if (title !== undefined && detail !== undefined) {
+      setHeld({ kind: "working", title, detail });
+      return;
+    }
+    const timer = window.setTimeout(() => setHeld(undefined), STARTUP_SETTLE_MS);
+    return () => window.clearTimeout(timer);
+  }, [detail, title]);
+  return content || contentSeen ? undefined : state ?? held;
+}

package/plugins/ragents.orchestration/web/run-panel/run-panel-state.ts

@@ -0,0 +1,71 @@
+import { createLocalStorageSetting } from "@ragents/web/lib/local-storage-setting";
+
+/** Die gewählte Ansicht des Run-Panels: nur Chat, Chat unten als Sheet oder Chat rechts, sofern das Run-Panel breit genug ist. */
+export type RunPanelChatMode = "chat" | "bottom" | "side";
+
+/** Wie der Chat zur Mini-App liegt: allein, daneben oder als Sheet darüber. */
+export type ChatLayout = "full" | "side" | "floating";
+
+/** Persönlicher Zustand je Run: Mini-App, Actor, Chat-Lage, Seitenbreite und ausgeklappte Sheet-Höhe. */
+export interface RunPanelState {
+  element: string | null;
+  actor: string | null;
+  chat: RunPanelChatMode;
+  chatWidth: number;
+  sheetExpandedHeight: number | null;
+}
+
+export const CHAT_MIN_WIDTH = 280;
+export const CHAT_DEFAULT_WIDTH = 380;
+/** Neben dem Chat bleibt immer Platz für ein Stück Mini-App. */
+export const STAGE_MIN_WIDTH = 300;
+
+export const DEFAULT_RUN_PANEL_STATE: RunPanelState = Object.freeze({ element: null, actor: null, chat: "side", chatWidth: CHAT_DEFAULT_WIDTH, sheetExpandedHeight: null });
+
+export const runPanelStorageKey = (runId: string) => `ragents.orchestration.run-panel:${runId}`;
+
+const isTextOrNull = (value: unknown): value is string | null => value === null || typeof value === "string";
+/** Frühere Zustände kannten `auto`, `floating` und `docked` sowie eine Bühnenhöhe; sie werden auf die heutigen Lagen abgebildet. */
+const chatModeOf = (value: unknown): RunPanelChatMode | undefined =>
+  value === undefined || value === "side" || value === "auto" ? "side"
+    : value === "chat" ? "chat"
+      : value === "bottom" || value === "floating" || value === "docked" ? "bottom" : undefined;
+
+export function parseRunPanelState(raw: string | null): RunPanelState {
+  if (raw === null) return DEFAULT_RUN_PANEL_STATE;
+  const value: unknown = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || Object.keys(value).some((key) => !["element", "stageHeight", "actor", "chat", "chatWidth", "sheetExpandedHeight", "sheetPeekExtra"].includes(key))
+    || !("element" in value) || !isTextOrNull(value.element)
+    || !("actor" in value) || !isTextOrNull(value.actor)
+    || chatModeOf("chat" in value ? value.chat : undefined) === undefined
+    || ("chatWidth" in value && (typeof value.chatWidth !== "number" || !Number.isFinite(value.chatWidth) || value.chatWidth < CHAT_MIN_WIDTH))
+    || ("sheetExpandedHeight" in value && value.sheetExpandedHeight !== null && (typeof value.sheetExpandedHeight !== "number" || !Number.isFinite(value.sheetExpandedHeight) || value.sheetExpandedHeight <= 0))
+    || ("sheetPeekExtra" in value && (typeof value.sheetPeekExtra !== "number" || !Number.isFinite(value.sheetPeekExtra) || value.sheetPeekExtra < 0))) {
+    throw new Error("Der gespeicherte Panelzustand ist ungültig.");
+  }
+  const stored = value as { element: string | null; actor: string | null; chat?: unknown; chatWidth?: number; sheetExpandedHeight?: number | null };
+  return { element: stored.element, actor: stored.actor, chat: chatModeOf(stored.chat) ?? "side", chatWidth: stored.chatWidth ?? CHAT_DEFAULT_WIDTH, sheetExpandedHeight: stored.sheetExpandedHeight ?? null };
+}
+
+/** Ohne Mini-App und in der Ansicht "Nur Chat" füllt der Chat das Run-Panel; sonst liegt er rechts, wenn Platz ist, und unten, wenn nicht. */
+export const chatLayoutFor = ({ chat, hasElement, narrow }: { chat: RunPanelChatMode; hasElement: boolean; narrow: boolean }): ChatLayout =>
+  !hasElement || chat === "chat" ? "full" : !narrow && chat === "side" ? "side" : "floating";
+
+export const clampChatWidth = (width: number, available: number): number =>
+  Math.max(CHAT_MIN_WIDTH, Math.min(Math.round(width), Math.max(CHAT_MIN_WIDTH, available - STAGE_MIN_WIDTH)));
+
+const setting = createLocalStorageSetting({
+  changeEvent: "ragents-run-panel-change",
+  matchesKey: (key) => key.startsWith("ragents.orchestration.run-panel:"),
+  parse: parseRunPanelState,
+  serialize: JSON.stringify,
+});
+
+export function useRunPanelState(runId: string): RunPanelState {
+  return setting.useValue(runPanelStorageKey(runId));
+}
+
+export function saveRunPanelState(runId: string, state: RunPanelState) {
+  setting.save(runPanelStorageKey(runId), state);
+}

package/plugins/ragents.orchestration/web/{column → run-panel}/sheet-status.ts

@@ -1,9 +1,9 @@
-import type { Message } from "@aicontainer/web/chat/types";
+import type { Message } from "quassel/events";
 
 /** Die eine Zeile des zugeschobenen Sheets: was der Chat gerade tut oder zuletzt gesagt hat. */
 export interface SheetStatus {
   text: string;
-  kind: "idle" | "working" | "question";
+  kind: "idle" | "working" | "waiting";
 }
 
 const firstLine = (text: string, limit = 160): string => {
@@ -16,8 +16,8 @@ const senderOf = (message: Message, handle: string): string =>
 
 export function sheetStatus(messages: readonly Message[], working: boolean, handle: string): SheetStatus {
   const last = messages[messages.length - 1];
-  const question = [...messages].reverse().find((message) => message.role === "question" && !message.closed);
-  if (question) return { kind: "question", text: `Rückfrage: ${firstLine(question.text) || "Antwort erwartet"}` };
+  const waiting = [...messages].reverse().find((message) => message.role === "action" && message.action?.status === undefined);
+  if (waiting) return { kind: "waiting", text: `Wartet auf Eingabe: ${firstLine(waiting.text) || "Antwort erwartet"}` };
   if (working) {
     if (last?.role === "thinking" && !last.closed) return { kind: "working", text: `@${handle} denkt ...` };
     if (last?.role === "tool" && last.tool && last.tool.result === undefined) return { kind: "working", text: `@${handle} nutzt ${last.tool.name} ...` };

package/plugins/ragents.orchestration/web/{canvas-stage.ts → surface-entities.ts}

@@ -9,13 +9,13 @@ const subscribe = (listener: () => void) => {
   return () => listeners.delete(listener);
 };
 
-export function publishStageEntities(runId: string, entities: ReadonlySet<string> | undefined) {
+export function publishSurfaceEntities(runId: string, entities: ReadonlySet<string> | undefined) {
   if (entities) stages.set(runId, entities);
   else stages.delete(runId);
   listeners.forEach((listener) => listener());
 }
 
-export function useStageEntities(runId: string): ReadonlySet<string> {
+export function useSurfaceEntities(runId: string): ReadonlySet<string> {
   const read = () => stages.get(runId) ?? empty;
   return useSyncExternalStore(subscribe, read, read);
 }

package/plugins/ragents.orchestration/web/{canvas-startup.ts → surface-startup.ts}

@@ -1,19 +1,16 @@
-import type { ChatStartupStatus } from "@aicontainer/server/chat-events";
-import { isPendingRunActorInput, type RunView } from "./run-view";
+import type { ChatStartupStatus } from "quassel/events";
+import type { StartupNoticeState } from "@ragents/web/ui";
+import { isPendingRunActorInput, type RunView } from "@ragents/web/run-view";
 
-export interface CanvasStartupState {
-  kind: "working" | "error" | "waiting" | "stopped";
-  title: string;
-  detail: string;
-}
+export type SurfaceStartupState = StartupNoticeState;
 
-export function canvasStartupState({ view, startup, connected, running, error }: {
+export function surfaceStartupState({ view, startup, connected, running, error }: {
   view: RunView | undefined;
   startup: ChatStartupStatus | undefined;
   connected: boolean;
   running: boolean;
   error: string | undefined;
-}): CanvasStartupState | undefined {
+}): SurfaceStartupState | undefined {
   if (startup?.status === "failed") return { kind: "error", title: "Der Run konnte nicht vorbereitet werden", detail: startup.message };
   if (error) return { kind: "error", title: "Der Run-Status ist nicht erreichbar", detail: error };
   if (startup?.status === "preparing") return { kind: "working", title: "Run wird vorbereitet", detail: startup.message };
@@ -21,7 +18,7 @@ export function canvasStartupState({ view, startup, connected, running, error }:
   const activeActors = actors.filter((actor) => actor.lifecycle?.kind !== "stopped");
   if (actors.length && !activeActors.length) return { kind: "stopped", title: "Der Run wurde gestoppt", detail: "Es wird keine weitere Arbeit ausgeführt." };
   if (view?.actions.some((action) => action.status === "pending")) return {
-    kind: "waiting", title: "Deine Antwort wird benötigt", detail: "Im Chat wartet eine Rückfrage auf Dich.",
+    kind: "waiting", title: "Deine Eingabe wird benötigt", detail: "Im Chat wartet eine Aktion auf Deine Eingabe.",
   };
   const activeIds = new Set(activeActors.map((actor) => actor.id));
   const working = running || activeActors.some((actor) => actor.lifecycle?.kind === "running")

package/plugins/ragents.orchestration/web/surface-view-settings.ts

@@ -0,0 +1,42 @@
+import { createLocalStorageSetting } from "@ragents/web/lib/local-storage-setting";
+import type { RunActor } from "@ragents/web/run-view";
+
+export interface SurfaceViewPreferences {
+  actorVisibility: Readonly<Record<string, boolean>>;
+}
+
+export const DEFAULT_SURFACE_VIEW_PREFERENCES: SurfaceViewPreferences = Object.freeze({ actorVisibility: Object.freeze({}) });
+export const surfaceViewStorageKey = (runId: string) => `ragents.orchestration.actor-visibility:${runId}`;
+
+export function parseSurfaceViewPreferences(raw: string | null): SurfaceViewPreferences {
+  if (raw === null) return DEFAULT_SURFACE_VIEW_PREFERENCES;
+  const value: unknown = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || Object.keys(value).some((key) => key !== "actorVisibility")
+    || !("actorVisibility" in value) || !value.actorVisibility || typeof value.actorVisibility !== "object"
+    || Array.isArray(value.actorVisibility) || Object.values(value.actorVisibility).some((visible) => typeof visible !== "boolean")) {
+    throw new Error("Die gespeicherte Actor-Sichtbarkeit ist ungültig.");
+  }
+  return value as SurfaceViewPreferences;
+}
+
+export const actorVisibleOnSurface = (actor: RunActor, appActorIds: ReadonlySet<string>, preferences: SurfaceViewPreferences, primaryActorId?: string | null): boolean => {
+  if (actor.kind === "human") return false;
+  const override = Object.hasOwn(preferences.actorVisibility, actor.id) ? preferences.actorVisibility[actor.id] : undefined;
+  return override ?? (actor.id !== primaryActorId && !appActorIds.has(actor.id));
+};
+
+const setting = createLocalStorageSetting({
+  changeEvent: "ragents-actor-visibility-change",
+  matchesKey: (key) => key.startsWith("ragents.orchestration.actor-visibility:"),
+  parse: parseSurfaceViewPreferences,
+  serialize: JSON.stringify,
+});
+
+export function useSurfaceViewPreferences(runId: string): SurfaceViewPreferences {
+  return setting.useValue(surfaceViewStorageKey(runId));
+}
+
+export function saveSurfaceViewPreferences(runId: string, preferences: SurfaceViewPreferences) {
+  setting.save(surfaceViewStorageKey(runId), preferences);
+}

package/plugins/ragents.orchestration/web/tile-docking.ts

@@ -1,6 +1,6 @@
-import type { CanvasTileNode } from "../tiled-layout";
+import type { SurfaceTileNode } from "../tiled-layout";
 
-export const CANVAS_TILE_DRAG_TYPE = "application/x-ragents-canvas-tile";
+export const SURFACE_TILE_DRAG_TYPE = "application/x-ragents-surface-tile";
 export const TILE_DIVIDER_SIZE = 8;
 export const TILE_MIN_WIDTH = 220;
 export const TILE_MIN_HEIGHT = 160;
@@ -15,17 +15,17 @@ export interface TileDivider extends TileRect {
   span: number;
 }
 
-export function tileEntities(root: CanvasTileNode | null): string[] {
+export function tileEntities(root: SurfaceTileNode | null): string[] {
   return root === null ? [] : "entity" in root ? [root.entity] : root.children.flatMap(tileEntities);
 }
 
-function tileLeaf(root: CanvasTileNode | null, entity: string): CanvasTileNode | undefined {
+function tileLeaf(root: SurfaceTileNode | null, entity: string): SurfaceTileNode | undefined {
   if (root === null) return undefined;
   if ("entity" in root) return root.entity === entity ? root : undefined;
   return tileLeaf(root.children[0], entity) ?? tileLeaf(root.children[1], entity);
 }
 
-export function removeTile(root: CanvasTileNode | null, entity: string): CanvasTileNode | null {
+export function removeTile(root: SurfaceTileNode | null, entity: string): SurfaceTileNode | null {
   if (root === null || "entity" in root) return root?.entity === entity ? null : root;
   const first = removeTile(root.children[0], entity);
   const second = removeTile(root.children[1], entity);
@@ -34,24 +34,24 @@ export function removeTile(root: CanvasTileNode | null, entity: string): CanvasT
   return first === root.children[0] && second === root.children[1] ? root : { ...root, children: [first, second] };
 }
 
-export function dockTile(root: CanvasTileNode | null, entity: string, target: string | null, side: TileDockSide): CanvasTileNode | null {
+export function dockTile(root: SurfaceTileNode | null, entity: string, target: string | null, side: TileDockSide): SurfaceTileNode | null {
   if ((root && "entity" in root && root.entity === entity && target === null) || entity === target || (target !== null && !tileEntities(root).includes(target))) return root;
   const remaining = removeTile(root, entity);
-  const leaf: CanvasTileNode = tileLeaf(root, entity) ?? { entity };
+  const leaf: SurfaceTileNode = tileLeaf(root, entity) ?? { entity };
   if (!remaining) return leaf;
-  const wrap = (node: CanvasTileNode): CanvasTileNode => ({
+  const wrap = (node: SurfaceTileNode): SurfaceTileNode => ({
     direction: side === "left" || side === "right" ? "horizontal" : "vertical",
     weights: [1, 1],
     children: side === "left" || side === "top" ? [leaf, node] : [node, leaf],
   });
   if (target === null) return wrap(remaining);
-  const insert = (node: CanvasTileNode): CanvasTileNode => "entity" in node
+  const insert = (node: SurfaceTileNode): SurfaceTileNode => "entity" in node
     ? node.entity === target ? wrap(node) : node
     : { ...node, children: [insert(node.children[0]), insert(node.children[1])] };
   return insert(remaining);
 }
 
-export function tileMinimum(root: CanvasTileNode): { width: number; height: number } {
+export function tileMinimum(root: SurfaceTileNode): { width: number; height: number } {
   if ("entity" in root) return { width: TILE_MIN_WIDTH, height: TILE_MIN_HEIGHT };
   const first = tileMinimum(root.children[0]);
   const second = tileMinimum(root.children[1]);
@@ -60,7 +60,7 @@ export function tileMinimum(root: CanvasTileNode): { width: number; height: numb
     : { width: Math.max(first.width, second.width), height: first.height + second.height + TILE_DIVIDER_SIZE };
 }
 
-export function resizeTile(root: CanvasTileNode, path: readonly number[], ratio: number): CanvasTileNode {
+export function resizeTile(root: SurfaceTileNode, path: readonly number[], ratio: number): SurfaceTileNode {
   if ("entity" in root) return root;
   if (path.length === 0) {
     const bounded = Math.max(0.001, Math.min(0.999, ratio));
@@ -68,15 +68,15 @@ export function resizeTile(root: CanvasTileNode, path: readonly number[], ratio:
   }
   const branch = path[0];
   if (branch !== 0 && branch !== 1) return root;
-  const children: [CanvasTileNode, CanvasTileNode] = [...root.children];
+  const children: [SurfaceTileNode, SurfaceTileNode] = [...root.children];
   children[branch] = resizeTile(children[branch], path.slice(1), ratio);
   return { ...root, children };
 }
 
-export function tileGeometry(root: CanvasTileNode, bounds: TileRect): { leaves: Map<string, TileRect>; dividers: TileDivider[] } {
+export function tileGeometry(root: SurfaceTileNode, bounds: TileRect): { leaves: Map<string, TileRect>; dividers: TileDivider[] } {
   const leaves = new Map<string, TileRect>();
   const dividers: TileDivider[] = [];
-  const visit = (node: CanvasTileNode, rect: TileRect, path: readonly number[]) => {
+  const visit = (node: SurfaceTileNode, rect: TileRect, path: readonly number[]) => {
     if ("entity" in node) { leaves.set(node.entity, rect); return; }
     const horizontal = node.direction === "horizontal";
     const span = Math.max(0, (horizontal ? rect.width : rect.height) - TILE_DIVIDER_SIZE);