@schlenkr/ragents 0.1.0 → 0.1.2

package/plugins/ragents.orchestration/contract.ts

@@ -2,87 +2,20 @@ import { canvasTileNodeOf } from "./tiled-layout.js";
 
 export const ORCHESTRATION_PLUGIN_ID = "ragents.orchestration";
 
-export const CANVAS_GROUP_KINDS = ["h", "v", "wrap-h", "wrap-v", "grid", "circle", "tree"] as const;
-export type CanvasGroupKind = typeof CANVAS_GROUP_KINDS[number];
-
-export const CANVAS_TREE_DIRECTIONS = ["right", "down"] as const;
-export type CanvasTreeDirection = typeof CANVAS_TREE_DIRECTIONS[number];
-
-export const CANVAS_SHAPE_KINDS = ["circle", "diamond"] as const;
-export type CanvasShapeKind = typeof CANVAS_SHAPE_KINDS[number];
-
-export const CANVAS_ARROWS = ["none", "end", "both"] as const;
-export type CanvasArrow = typeof CANVAS_ARROWS[number];
-
-export const CANVAS_LINE_STYLES = ["solid", "dashed"] as const;
-export type CanvasLineStyle = typeof CANVAS_LINE_STYLES[number];
-
-/** Default sizes of the shapes in px; a circle is measured by its diameter, a diamond by its width. */
-export const CANVAS_SHAPE_DEFAULT_SIZE: Record<CanvasShapeKind, number> = { circle: 120, diamond: 150 };
-const DIAMOND_ASPECT = 0.62;
-
 export type CanvasEntity =
   | { kind: "actor"; handle: string }
-  | { kind: "shape"; id: string }
   | { kind: "app"; id: string };
 
-type CanvasGroupBase = {
-  id: string;
-  parent?: string;
-  label?: string;
-  gap?: number;
-  frame: boolean;
-};
-
-/** The model sends one flat object per node; internally each group kind carries exactly its own parameters. */
-export type CanvasGroupNode =
-  | (CanvasGroupBase & { group: "h" | "v" | "circle" })
-  | (CanvasGroupBase & { group: "wrap-h"; width: number })
-  | (CanvasGroupBase & { group: "wrap-v"; height: number })
-  | (CanvasGroupBase & { group: "grid"; columns: number })
-  | (CanvasGroupBase & { group: "tree"; root: string; direction: CanvasTreeDirection });
-
-export type CanvasItemNode = {
-  entity: string;
-  parent?: string;
-  chatInput?: boolean;
-};
-
-export type CanvasLayoutNode = CanvasGroupNode | CanvasItemNode;
-
-export type CanvasShape = {
-  id: string;
-  kind: CanvasShapeKind;
-  text: string;
-  size: number;
-};
-
-export type CanvasLine = {
-  from: string;
-  to: string;
-  label?: string;
-  arrow: CanvasArrow;
-  style: CanvasLineStyle;
-};
-
 export type CanvasTileNode =
-  | { entity: string }
+  | { entity: string; chatInput?: boolean }
   | { direction: "horizontal" | "vertical"; weights: [number, number]; children: [CanvasTileNode, CanvasTileNode] };
 
 export type CanvasLayout = {
-  mode?: "free" | "tiled";
-  root?: CanvasTileNode | null;
-  nodes: CanvasLayoutNode[];
-  shapes: CanvasShape[];
-  lines: CanvasLine[];
+  root: CanvasTileNode | null;
 };
 
-export const isCanvasGroupNode = (node: CanvasLayoutNode): node is CanvasGroupNode => "group" in node;
-
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
-const isAbsent = (value: unknown) => value === undefined || value === null;
-
 const normalizedHandle = (value: string) => value.trim().replace(/^@/, "").toLowerCase();
 
 export const canvasEntityOf = (text: string): CanvasEntity => {
@@ -92,231 +25,28 @@ export const canvasEntityOf = (text: string): CanvasEntity => {
     if (!handle || /\s/.test(handle)) throw new Error(`Entität ${JSON.stringify(text)}: nach dem @ fehlt ein Handle`);
     return { kind: "actor", handle };
   }
-  const match = /^(shape|app):(.+)$/s.exec(trimmed);
+  const match = /^app:(.+)$/s.exec(trimmed);
   if (!match) {
-    throw new Error(`Entität ${JSON.stringify(text)}: erwartet @handle, shape:<id> oder app:<id>`);
+    throw new Error(`Entität ${JSON.stringify(text)}: erwartet @handle oder app:<id>`);
   }
-  const id = match[2].trim();
+  const id = match[1].trim();
   if (!id) throw new Error(`Entität ${JSON.stringify(text)}: die ID nach dem Doppelpunkt ist leer`);
-  return match[1] === "shape" ? { kind: "shape", id } : { kind: "app", id };
+  return { kind: "app", id };
 };
 
 export const canvasEntityKey = (entity: CanvasEntity): string =>
-  entity.kind === "actor" ? `@${entity.handle}` : `${entity.kind}:${entity.id}`;
-
-export const canvasShapeSize = (shape: CanvasShape): { width: number; height: number } =>
-  shape.kind === "circle"
-    ? { width: shape.size, height: shape.size }
-    : { width: shape.size, height: Math.round(shape.size * DIAMOND_ASPECT) };
-
-const oneOf = <T extends string>(allowed: readonly T[], value: unknown, where: string): T => {
-  if (typeof value !== "string" || !allowed.includes(value as T)) {
-    throw new Error(`${where}: ${JSON.stringify(value)} ist unbekannt, erlaubt sind ${allowed.join(", ")}`);
-  }
-  return value as T;
-};
+  entity.kind === "actor" ? `@${entity.handle}` : `app:${entity.id}`;
 
-const optionalText = (value: unknown, where: string): string | undefined => {
-  if (isAbsent(value)) return undefined;
-  if (typeof value !== "string") throw new Error(`${where} muss ein Text sein`);
-  return value.trim() || undefined;
-};
-
-const requiredText = (value: unknown, where: string): string => {
-  if (typeof value !== "string" || !value.trim()) throw new Error(`${where} fehlt oder ist leer`);
-  return value.trim();
-};
-
-const positiveNumber = (value: unknown, where: string): number => {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new Error(`${where} muss eine positive Zahl sein`);
-  return value;
-};
-
-const optionalGap = (value: unknown, where: string): number | undefined => {
-  if (isAbsent(value)) return undefined;
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`${where} darf nicht negativ sein`);
-  return value;
-};
+const LEGACY_KEYS = ["nodes", "shapes", "lines", "mode"] as const;
 
-const withoutUndefined = <T extends object>(value: T): T =>
-  Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
-
-const GROUP_PARAMETERS: Record<CanvasGroupKind, readonly string[]> = {
-  "h": [],
-  "v": [],
-  "circle": [],
-  "wrap-h": ["width"],
-  "wrap-v": ["height"],
-  "grid": ["columns"],
-  "tree": ["direction", "root"],
-};
-
-const groupNodeOf = (value: Record<string, unknown>, index: number): CanvasGroupNode => {
-  const where = `nodes[${index}]`;
-  const group = oneOf(CANVAS_GROUP_KINDS, value.group, `${where}.group`);
-  const id = requiredText(value.id, `${where}.id (jede Gruppe braucht eine ID)`);
-  if (!isAbsent(value.entity)) {
-    throw new Error(`${where}: Gruppe ${id} darf kein entity tragen; Elemente sind eigene Knoten mit parent ${JSON.stringify(id)}`);
-  }
-  for (const parameter of ["width", "height", "columns", "direction", "root"]) {
-    if (!isAbsent(value[parameter]) && !GROUP_PARAMETERS[group].includes(parameter)) {
-      throw new Error(`${where}: Gruppe ${id} (${group}) kennt keinen Parameter ${parameter}`
-        + (parameter === "width" ? "; für Umbruch wrap-h nehmen" : parameter === "height" ? "; für Umbruch wrap-v nehmen" : ""));
-    }
-  }
-  if (!isAbsent(value.frame) && typeof value.frame !== "boolean") throw new Error(`${where}.frame muss true oder false sein`);
-  const base: CanvasGroupBase = withoutUndefined({
-    id,
-    parent: optionalText(value.parent, `${where}.parent`),
-    label: optionalText(value.label, `${where}.label`),
-    gap: optionalGap(value.gap, `${where}.gap`),
-    frame: value.frame === true,
-  });
-  switch (group) {
-    case "h":
-    case "v":
-    case "circle":
-      return { ...base, group };
-    case "wrap-h":
-      return { ...base, group, width: positiveNumber(value.width, `${where}.width (wrap-h braucht die Zeilenbreite)`) };
-    case "wrap-v":
-      return { ...base, group, height: positiveNumber(value.height, `${where}.height (wrap-v braucht die Spaltenhöhe)`) };
-    case "grid": {
-      const columns = value.columns;
-      if (typeof columns !== "number" || !Number.isInteger(columns) || columns < 1) {
-        throw new Error(`${where}.columns (grid braucht eine ganze Spaltenzahl ab 1)`);
-      }
-      return { ...base, group, columns };
-    }
-    case "tree": {
-      const entity = canvasEntityOf(requiredText(value.root, `${where}.root (tree braucht den @handle des Wurzel-Actors)`));
-      if (entity.kind !== "actor") throw new Error(`${where}.root: die Wurzel eines Baums ist ein Actor (@handle)`);
-      return {
-        ...base,
-        group,
-        root: canvasEntityKey(entity),
-        direction: isAbsent(value.direction) ? "right" : oneOf(CANVAS_TREE_DIRECTIONS, value.direction, `${where}.direction`),
-      };
-    }
-  }
-};
-
-const itemNodeOf = (value: Record<string, unknown>, index: number): CanvasItemNode => {
-  const where = `nodes[${index}]`;
-  if (typeof value.entity !== "string") {
-    throw new Error(`${where}: ein Knoten ist entweder eine Gruppe (group + id) oder ein Element (entity)`);
-  }
-  const entity = canvasEntityOf(value.entity);
-  if (value.chatInput !== undefined && (entity.kind !== "actor" || typeof value.chatInput !== "boolean")) {
-    throw new Error(`${where}.chatInput ist nur für Actors als Wahrheitswert erlaubt`);
-  }
-  return withoutUndefined({
-    entity: canvasEntityKey(entity),
-    parent: optionalText(value.parent, `${where}.parent`),
-    chatInput: value.chatInput as boolean | undefined,
-  });
-};
-
-const shapeOf = (value: unknown, index: number): CanvasShape => {
-  const where = `shapes[${index}]`;
-  if (!isRecord(value)) throw new Error(`${where} muss ein Objekt sein`);
-  const kind = oneOf(CANVAS_SHAPE_KINDS, value.kind, `${where}.kind`);
-  return {
-    id: requiredText(value.id, `${where}.id`),
-    kind,
-    text: requiredText(value.text, `${where}.text (jede Form trägt einen Text)`),
-    size: isAbsent(value.size) ? CANVAS_SHAPE_DEFAULT_SIZE[kind] : positiveNumber(value.size, `${where}.size`),
-  };
-};
-
-const lineOf = (value: unknown, index: number): CanvasLine => {
-  const where = `lines[${index}]`;
-  if (!isRecord(value)) throw new Error(`${where} muss ein Objekt sein`);
-  const from = canvasEntityKey(canvasEntityOf(requiredText(value.from, `${where}.from`)));
-  const to = canvasEntityKey(canvasEntityOf(requiredText(value.to, `${where}.to`)));
-  if (from === to) throw new Error(`${where}: eine Linie führt von einer Entität zu einer ANDEREN, nicht von ${from} zu sich selbst`);
-  return withoutUndefined({
-    from,
-    to,
-    label: optionalText(value.label, `${where}.label`),
-    arrow: isAbsent(value.arrow) ? "none" : oneOf(CANVAS_ARROWS, value.arrow, `${where}.arrow`),
-    style: isAbsent(value.style) ? "solid" : oneOf(CANVAS_LINE_STYLES, value.style, `${where}.style`),
-  });
-};
-
-const assertNoCycle = (groups: Map<string, CanvasGroupNode>) => {
-  for (const start of groups.values()) {
-    const seen = new Set<string>([start.id]);
-    let current = start;
-    while (current.parent) {
-      const next = groups.get(current.parent);
-      if (!next) throw new Error(`Gruppe ${current.id}: parent ${JSON.stringify(current.parent)} ist keine bekannte Gruppe`);
-      if (seen.has(next.id)) throw new Error(`Gruppe ${start.id} liegt über parent in sich selbst`);
-      seen.add(next.id);
-      current = next;
-    }
-  }
-};
-
-/** Parses and validates a canvas layout; throws a German error naming the first violation. */
+/** Parses and validates a tile layout; throws a German error naming the first violation. */
 export const canvasLayoutOf = (value: unknown): CanvasLayout => {
-  if (!isRecord(value)) throw new Error("Das Layout muss ein Objekt mit nodes, shapes und lines sein");
-  if (!Array.isArray(value.nodes)) throw new Error("nodes fehlt oder ist keine Liste");
-  const rawShapes = value.shapes ?? [];
-  const rawLines = value.lines ?? [];
-  if (!Array.isArray(rawShapes)) throw new Error("shapes muss eine Liste sein");
-  if (!Array.isArray(rawLines)) throw new Error("lines muss eine Liste sein");
-
-  const nodes = value.nodes.map((entry, index): CanvasLayoutNode => {
-    if (!isRecord(entry)) throw new Error(`nodes[${index}] muss ein Objekt sein`);
-    if (!isAbsent(entry.group) && entry.chatInput !== undefined) throw new Error(`nodes[${index}].chatInput ist nur für Actors erlaubt`);
-    return isAbsent(entry.group) ? itemNodeOf(entry, index) : groupNodeOf(entry, index);
-  });
-  const shapes = rawShapes.map(shapeOf);
-  const lines = rawLines.map(lineOf);
-
-  const groups = new Map<string, CanvasGroupNode>();
-  for (const node of nodes.filter(isCanvasGroupNode)) {
-    if (groups.has(node.id)) throw new Error(`Gruppen-ID ${JSON.stringify(node.id)} kommt mehrfach vor`);
-    groups.set(node.id, node);
-  }
-  assertNoCycle(groups);
-  for (const node of nodes) {
-    if (!node.parent) continue;
-    const parent = groups.get(node.parent);
-    if (!parent) throw new Error(`parent ${JSON.stringify(node.parent)} ist keine bekannte Gruppe`);
-    if (parent.group === "tree") {
-      throw new Error(`Gruppe ${parent.id} ist ein Baum und füllt sich aus der Abstammung von ${parent.root}; sie nimmt keine eigenen Kinder auf`);
-    }
-  }
-
-  const shapeIds = new Set<string>();
-  for (const shape of shapes) {
-    if (shapeIds.has(shape.id)) throw new Error(`Form-ID ${JSON.stringify(shape.id)} kommt mehrfach vor`);
-    shapeIds.add(shape.id);
-  }
-  const placed = new Set<string>();
-  for (const node of nodes) {
-    if (isCanvasGroupNode(node)) continue;
-    if (placed.has(node.entity)) throw new Error(`${node.entity} ist mehr als einmal platziert`);
-    placed.add(node.entity);
-  }
-  const assertKnownShape = (reference: string, where: string) => {
-    const entity = canvasEntityOf(reference);
-    if (entity.kind === "shape" && !shapeIds.has(entity.id)) {
-      throw new Error(`${where}: Form ${JSON.stringify(entity.id)} ist nicht in shapes definiert`);
-    }
-  };
-  for (const reference of placed) assertKnownShape(reference, "nodes");
-  for (const shape of shapes) {
-    if (!placed.has(`shape:${shape.id}`)) throw new Error(`Form ${JSON.stringify(shape.id)} ist nirgends platziert; jede Form braucht einen Knoten mit entity shape:${shape.id}`);
-  }
-  lines.forEach((line, index) => {
-    assertKnownShape(line.from, `lines[${index}].from`);
-    assertKnownShape(line.to, `lines[${index}].to`);
-  });
-
-  const mode = value.mode === undefined ? undefined : oneOf(["free", "tiled"] as const, value.mode, "mode");
-  const root = value.root === undefined ? undefined : value.root === null ? null : canvasTileNodeOf(value.root);
-  return withoutUndefined({ nodes, shapes, lines, mode, root });
+  if (!isRecord(value)) throw new Error("Die Anordnung muss ein Objekt mit root sein");
+  const legacy = LEGACY_KEYS.filter((key) => key in value);
+  if (legacy.length > 0) {
+    throw new Error(`Die Programmanordnung stammt aus dem entfernten freien Canvas (${legacy.join(", ")}); `
+      + "canvas_layout_replace mit root setzt sie als Kachelaufteilung neu");
+  }
+  if (!("root" in value)) throw new Error("root fehlt; erwartet wird eine Kachel, eine Teilung oder null");
+  return { root: value.root === null ? null : canvasTileNodeOf(value.root) };
 };

package/plugins/ragents.orchestration/server/canvas-tool.ts

@@ -12,38 +12,26 @@ import {
 import { toolDescriptorFrom } from "@aicontainer/server/plugin-support/agent-tool.js";
 import { ACTOR_PROGRAMS_STATE_ID, resolveActorView, type ActorProgramState } from "@aicontainer/plugins/ragents.actor-programs/contract.js";
 import {
-  CANVAS_ARROWS,
-  CANVAS_GROUP_KINDS,
-  CANVAS_LINE_STYLES,
-  CANVAS_SHAPE_KINDS,
-  CANVAS_TREE_DIRECTIONS,
   ORCHESTRATION_PLUGIN_ID,
   canvasEntityOf,
   canvasLayoutOf,
-  isCanvasGroupNode,
   type CanvasLayout,
 } from "../contract.js";
 import { canvasTileEntities, mapCanvasTileEntities } from "../tiled-layout.js";
 
-const ENTITY = "@handle names an actor, shape:<id> one of the shapes of this call, "
-  + "app:@handle/view-key or app:program-name/view-key an activated actor view. "
-  + "Use the actor handle or program name and view key you chose; the server resolves the view ID";
-
 export const canvasToolMetadata = {
   name: "canvas_layout_replace",
   label: "Replace Canvas Layout",
-  description: "Arrange actors and mini-apps on the free canvas or in a viewport-filling tiled layout with nested, weighted splits.",
-  longDescription: "Free mode is the default. Set mode: 'tiled' and root to a recursive tree: "
-    + "{entity:'@helper'} or {direction:'horizontal',weights:[2,1],children:[{entity:'app:@workspace/main'},{entity:'@helper'}]}. "
-    + "horizontal means left/right; vertical means top/bottom. Weights [1,1] split equally. "
-    + "Every split has two children, which may themselves be splits. Tiled mode has draggable dividers and no canvas pan or zoom. "
-    + "Mode/root-only calls preserve the free layout; mode:'free' restores it. Personal user arrangements take precedence until reset. "
-    + "In free mode the canvas draws NO lines by itself; "
-    + "a relation is visible only when you add a line here. Actors you do not place appear below your "
-    + "layout as lineage trees. Approximate sizes in px for planning wrap widths: an actor card is 150 to "
-    + "320 wide and 44 high without card sections, with sections (documents, to-dos, tools) 360 to 640 wide "
-    + "and 100 to 300 high; an actor view uses its declared canvas placement (280 to 960 by 180 to 720); "
-    + "a circle shape is 120 wide, a diamond 150 by 94 by default.",
+  description: "Arrange actors and mini-apps as tiles on the viewport-filling work surface, using a binary tree of weighted splits.",
+  longDescription: "root is the whole arrangement and replaces the stored one. A tile is {entity:'@helper'} or "
+    + "{entity:'app:@workspace/main'}; a split is {direction:'horizontal',weights:[1,1],children:[tile,tile]}. "
+    + "horizontal means left/right, vertical means top/bottom, and weights give the ratio of the two children. "
+    + "App left, chat right at 50:50: {root:{direction:'horizontal',weights:[1,1],children:["
+    + "{entity:'app:@workspace/main'},{entity:'@helper'}]}}. One tile above two tiles at 2:1: "
+    + "{root:{direction:'vertical',weights:[2,1],children:[{entity:'@lead'},"
+    + "{direction:'horizontal',weights:[1,1],children:[{entity:'@first'},{entity:'@second'}]}]}}. "
+    + "root:null clears the surface. Dividers are draggable, so do not resend a layout to fight a personal arrangement. "
+    + "Participants you do not place stay reachable through the run header.",
 } as const;
 
 export const canDesignCanvas = defineToolAvailability({
@@ -52,11 +40,12 @@ export const canDesignCanvas = defineToolAvailability({
   requiredCapabilities: ["plugin.state.write"],
 }, (actor) => actor.kind !== "human" && holdsUsable(actor, "plugin.state.write"));
 
-const literals = <T extends string>(values: readonly T[]) => values.map((value) => Type.Literal(value));
-
 const tileSchema = Type.Cyclic({
   CanvasTile: Type.Union([
-    Type.Object({ entity: Type.String({ minLength: 1, description: "Actor @handle or activated mini-app app:@handle/view-key; no shapes" }) }, { additionalProperties: false }),
+    Type.Object({
+      entity: Type.String({ minLength: 1, description: "Actor @handle or activated mini-app app:@handle/view-key or app:program-name/view-key; the server resolves the view ID" }),
+      chatInput: Type.Optional(Type.Boolean({ description: "Actor tiles only: false hides the chat composer in the tile; default true. Does not change permissions or the inspector" })),
+    }, { additionalProperties: false }),
     Type.Object({
       direction: Type.Union([Type.Literal("horizontal"), Type.Literal("vertical")]),
       weights: Type.Tuple([Type.Number({ exclusiveMinimum: 0 }), Type.Number({ exclusiveMinimum: 0 })]),
@@ -66,40 +55,7 @@ const tileSchema = Type.Cyclic({
 }, "CanvasTile");
 
 const canvasLayoutSchema = Type.Object({
-  mode: Type.Optional(Type.Union([Type.Literal("free"), Type.Literal("tiled")], { description: "free is the default; tiled fills the viewport, disables pan/zoom and uses root" })),
-  root: Type.Optional(Type.Union([tileSchema, Type.Null()], { description: "Tiled layout: an actor/app leaf or a binary split. Maximum 64 unique leaves and 16 nested splits. null clears the tiles; omitted preserves them" })),
-  nodes: Type.Optional(Type.Array(Type.Object({
-    id: Type.Optional(Type.String({ minLength: 1, description: "Groups only: an id you choose; member nodes name it in parent" })),
-    group: Type.Optional(Type.Union(literals(CANVAS_GROUP_KINDS), {
-      description: "Makes the node a group. h = row, v = column, wrap-h = row wrapping at width, "
-        + "wrap-v = column wrapping at height, grid = columns by rows, circle = members on a ring "
-        + "(actors talking to each other), tree = the root actor and everything it spawned",
-    })),
-    entity: Type.Optional(Type.String({ minLength: 1, description: `Items only: ${ENTITY}` })),
-    chatInput: Type.Optional(Type.Boolean({ description: "Actor items only: false hides the chat composer on free canvas and tiles; default true. Does not change permissions or the inspector" })),
-    parent: Type.Optional(Type.String({ minLength: 1, description: "Id of the enclosing group; omitted = top level (top-level nodes stack vertically)" })),
-    label: Type.Optional(Type.String({ description: "Groups: caption above the members, shown with or without frame" })),
-    frame: Type.Optional(Type.Boolean({ description: "Groups: true draws a dashed outline around the members; default false, no outline" })),
-    gap: Type.Optional(Type.Number({ minimum: 0, description: "Groups: minimum distance between members in px, default 44; labelled connections may increase it to leave room for their text" })),
-    width: Type.Optional(Type.Number({ exclusiveMinimum: 0, description: "wrap-h only and required there: row width in px before wrapping" })),
-    height: Type.Optional(Type.Number({ exclusiveMinimum: 0, description: "wrap-v only and required there: column height in px before wrapping" })),
-    columns: Type.Optional(Type.Integer({ minimum: 1, description: "grid only and required there" })),
-    direction: Type.Optional(Type.Union(literals(CANVAS_TREE_DIRECTIONS), { description: "tree only: where the children go, default right" })),
-    root: Type.Optional(Type.String({ minLength: 1, description: "tree only and required there: @handle of the root actor" })),
-  }))),
-  shapes: Type.Optional(Type.Array(Type.Object({
-    id: Type.String({ minLength: 1, description: "Your id; place the shape as an item with entity shape:<id>" }),
-    kind: Type.Union(literals(CANVAS_SHAPE_KINDS)),
-    text: Type.String({ minLength: 1, description: "Text inside the shape; keep it to a few words" }),
-    size: Type.Optional(Type.Number({ exclusiveMinimum: 0, description: "Diameter of a circle or width of a diamond in px; default 120 and 150" })),
-  }))),
-  lines: Type.Optional(Type.Array(Type.Object({
-    from: Type.String({ minLength: 1, description: ENTITY }),
-    to: Type.String({ minLength: 1, description: `${ENTITY}; must differ from from` }),
-    label: Type.Optional(Type.String({ description: "Short caption on the line" })),
-    arrow: Type.Optional(Type.Union(literals(CANVAS_ARROWS), { description: "none = plain line (default), end = arrow at to, both = arrows at both ends" })),
-    style: Type.Optional(Type.Union(literals(CANVAS_LINE_STYLES), { description: "solid (default) or dashed" })),
-  }))),
+  root: Type.Union([tileSchema, Type.Null()], { description: "The whole arrangement: a tile or a binary split. Maximum 64 unique tiles and 16 nested splits. null clears the surface" }),
 });
 
 const invalid = (message: string) => new DomainError("invalid-canvas-layout", message, 400);
@@ -130,21 +86,6 @@ const actorByHandle = (view: RunView, reference: string, where: string) => {
   return found;
 };
 
-const descendantsOf = (view: RunView, actorId: string): string[] => {
-  const result: string[] = [];
-  const queue = [actorId];
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    for (const actor of view.actors) {
-      if (actor.kind !== "human" && actor.createdBy === current && !result.includes(actor.id)) {
-        result.push(actor.id);
-        queue.push(actor.id);
-      }
-    }
-  }
-  return result;
-};
-
 const isActorReference = (reference: string) => canvasEntityOf(reference).kind === "actor";
 
 const resolveAppReferences = (view: RunView, layout: CanvasLayout): CanvasLayout => {
@@ -165,50 +106,15 @@ const resolveAppReferences = (view: RunView, layout: CanvasLayout): CanvasLayout
       throw invalid(`${where}: ${reference}: ${error instanceof Error ? error.message : String(error)} Canvas-Entitäten erhalten das Präfix app:.`);
     }
   };
-  return parsedLayout({
-    ...layout,
-    ...(layout.root ? { root: mapCanvasTileEntities(layout.root, (entity) => resolve(entity, "root")) } : {}),
-    nodes: layout.nodes.map((node, index) => isCanvasGroupNode(node)
-      ? node : { ...node, entity: resolve(node.entity, `nodes[${index}].entity`) }),
-    lines: layout.lines.map((line, index) => ({
-      ...line,
-      from: resolve(line.from, `lines[${index}].from`),
-      to: resolve(line.to, `lines[${index}].to`),
-    })),
-  });
+  return parsedLayout({ root: layout.root ? mapCanvasTileEntities(layout.root, (entity) => resolve(entity, "root")) : null });
 };
 
-/** Resolve app names and validate entities and actor ancestry before any layout is stored. */
+/** Resolve app names and validate the placed actors before any layout is stored. */
 export const checkLayoutAgainstRun = (view: RunView, input: CanvasLayout): CanvasLayout => {
   const layout = resolveAppReferences(view, input);
   for (const reference of canvasTileEntities(layout.root)) {
     if (isActorReference(reference)) actorByHandle(view, reference, "root");
   }
-  const placed = new Map<string, string>();
-  layout.nodes.forEach((node, index) => {
-    if (isCanvasGroupNode(node) || !isActorReference(node.entity)) return;
-    const actor = actorByHandle(view, node.entity, `nodes[${index}]`);
-    placed.set(actor.id, node.entity);
-  });
-  const trees = layout.nodes.flatMap((node, index) =>
-    isCanvasGroupNode(node) && node.group === "tree"
-      ? [{ node, root: actorByHandle(view, node.root, `nodes[${index}].root`) }]
-      : []);
-  for (const { node, root } of trees) {
-    if (placed.has(root.id)) {
-      throw invalid(`Baum ${node.id}: die Wurzel ${node.root} ist zusätzlich einzeln platziert`);
-    }
-    for (const id of descendantsOf(view, root.id)) {
-      const reference = placed.get(id);
-      if (reference) throw invalid(`Baum ${node.id}: ${reference} gehört zur Abstammung von ${node.root} und ist zusätzlich einzeln platziert`);
-      const other = trees.find((tree) => tree.root.id === id);
-      if (other) throw invalid(`Baum ${other.node.id}: ${other.node.root} liegt schon im Baum ${node.id} von ${node.root}`);
-    }
-  }
-  layout.lines.forEach((line, index) => {
-    if (isActorReference(line.from)) actorByHandle(view, line.from, `lines[${index}].from`);
-    if (isActorReference(line.to)) actorByHandle(view, line.to, `lines[${index}].to`);
-  });
   return layout;
 };
 
@@ -220,18 +126,7 @@ export const createCanvasTool = (): RunFunction =>
     available: canDesignCanvas,
     run: ({ runtime, caller, context, eventsFor }, toolCallId, input) => {
       const view = runtime.view(caller.runId);
-      if (input.nodes === undefined && input.mode === undefined && input.root === undefined) throw invalid("nodes oder mode/root muss angegeben werden");
-      if (input.nodes === undefined && (input.shapes !== undefined || input.lines !== undefined)) throw invalid("shapes und lines ersetzen den freien Canvas zusammen mit nodes");
-      const currentState = view.pluginStates.find((entry) => entry.pluginId === ORCHESTRATION_PLUGIN_ID && entry.scope.kind === "run");
-      const current = currentState ? parsedLayout(currentState.state) : { nodes: [], shapes: [], lines: [] };
-      const checked = checkLayoutAgainstRun(view, parsedLayout({ ...input, nodes: input.nodes ?? [] }));
-      const layout: CanvasLayout = {
-        ...current,
-        ...checked,
-        ...(input.nodes === undefined ? { nodes: current.nodes, shapes: current.shapes, lines: current.lines } : {}),
-        ...(input.mode !== undefined || input.root !== undefined || current.mode !== undefined
-          ? { mode: input.mode ?? (input.root !== undefined ? "tiled" : "free") } : {}),
-      };
+      const layout = checkLayoutAgainstRun(view, parsedLayout(input));
       runtime.replacePluginState(context(toolCallId), caller.runId, {
         pluginId: ORCHESTRATION_PLUGIN_ID,
         scope: { kind: "run" },

package/plugins/ragents.orchestration/tiled-layout.ts

@@ -12,15 +12,17 @@ export const canvasTileNodeOf = (input: unknown): CanvasTileNode => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${where} muss eine Kachel oder Teilung sein`);
     const node = value as Record<string, unknown>;
     if (Object.hasOwn(node, "entity")) {
-      if (Object.keys(node).some((key) => key !== "entity")) throw new Error(`${where}: eine Kachel trägt nur entity; eine Teilung direction, weights und children`);
+      if (Object.keys(node).some((key) => key !== "entity" && key !== "chatInput")) throw new Error(`${where}: eine Kachel trägt nur entity und chatInput; eine Teilung direction, weights und children`);
       if (typeof node.entity !== "string") throw new Error(`${where}.entity muss @handle oder app:<name>/<view> sein`);
       const entity = canvasEntityOf(node.entity);
-      if (entity.kind === "shape") throw new Error(`${where}: Kacheln zeigen Actors (@handle) oder Mini-Apps (app:<name>/<view>), keine Formen`);
       const key = canvasEntityKey(entity);
+      if (node.chatInput !== undefined && (entity.kind !== "actor" || typeof node.chatInput !== "boolean")) {
+        throw new Error(`${where}.chatInput ist nur für Actors als Wahrheitswert erlaubt`);
+      }
       if (entities.has(key)) throw new Error(`${where}: ${key} ist mehr als einmal als Kachel platziert`);
       entities.add(key);
       if (entities.size > MAX_CANVAS_TILES) throw new Error(`Höchstens ${MAX_CANVAS_TILES} Kacheln sind erlaubt`);
-      return { entity: key };
+      return node.chatInput === undefined ? { entity: key } : { entity: key, chatInput: node.chatInput as boolean };
     }
     if (Object.keys(node).some((key) => !["direction", "weights", "children"].includes(key))) throw new Error(`${where}: eine Teilung trägt nur direction, weights und children`);
     if (node.direction !== "horizontal" && node.direction !== "vertical") throw new Error(`${where}.direction muss horizontal oder vertical sein`);
@@ -37,11 +39,17 @@ export const canvasTileNodeOf = (input: unknown): CanvasTileNode => {
   return parse(input, "root", 0);
 };
 
+/** A tile hides the chat composer of its actor only when its leaf says chatInput: false. */
+export const canvasTileChatInput = (root: CanvasTileNode | null | undefined, entity: string): boolean =>
+  !root ? true : "entity" in root
+    ? root.entity !== entity || root.chatInput !== false
+    : canvasTileChatInput(root.children[0], entity) && canvasTileChatInput(root.children[1], entity);
+
 export const canvasTileEntities = (root: CanvasTileNode | null | undefined): string[] =>
   !root ? [] : "entity" in root ? [root.entity] : root.children.flatMap(canvasTileEntities);
 
 export const mapCanvasTileEntities = (root: CanvasTileNode, resolve: (entity: string) => string): CanvasTileNode =>
-  "entity" in root ? { entity: resolve(root.entity) } : {
+  "entity" in root ? { ...root, entity: resolve(root.entity) } : {
     ...root,
     children: [mapCanvasTileEntities(root.children[0], resolve), mapCanvasTileEntities(root.children[1], resolve)],
   };