@schlenkr/ragents 0.1.9 → 0.1.11

package/plugins/ragents.model-relay/server/index.ts

@@ -10,14 +10,14 @@ const modelRelayPlugin: RAgentsPlugin = {
   register: (host) => {
     const upstreams = host.service(modelUpstreamsToken);
     let resolved: readonly ResolvedAlias[] | undefined;
-    const aliases = (): readonly ResolvedAlias[] => resolved ??= resolveAliases(modelRelayConfig.aliases(), upstreams());
+    const aliases = (): readonly ResolvedAlias[] => resolved ??= resolveAliases(modelRelayConfig.aliases(), modelRelayConfig.upstreams(upstreams()));
     const log = new Protocol(host.storage.root("relay.log"));
     host.lifecycle({
       id: "ragents.model-relay",
       initialize: () => {
         const list = aliases();
         log.write(`=== Start: ${list.map((entry) => `${entry.alias}=${entry.upstream.id}/${entry.model.id}`).join(", ")} ===`);
-        console.log(`Modell-Relay: ${list.length} Aliasse unter /relay/v1 (${list.map((entry) => entry.alias).join(", ")})`);
+        console.log(`Model relay: ${list.length} aliases under /relay/v1 (${list.map((entry) => entry.alias).join(", ")})`);
       },
       shutdown: () => log.close(),
     });

package/plugins/ragents.model-relay/server/relay.ts

@@ -4,7 +4,7 @@ import { pipeline } from "node:stream/promises";
 import type { ReadableStream } from "node:stream/web";
 import type { HttpRouteContribution } from "@ragents/engine";
 import { PayloadTooLargeError, readBody, writeJson } from "@ragents/host/plugin-support/http.js";
-import type { ModelAlias } from "@ragents/host/plugin-support/model-aliases.js";
+import { validatedAliasModel, type ModelAlias } from "@ragents/host/plugin-support/model-aliases.js";
 import type { ModelUpstream } from "@ragents/host/plugin-support/model-upstreams.js";
 
 export const RELAY_PATH_PREFIX = "/relay/v1";
@@ -18,35 +18,36 @@ export interface ResolvedAlias {
   readonly alias: string;
   readonly upstream: ModelUpstream;
   readonly model: ModelUpstream["models"][number];
-  readonly compaction: ModelAlias["compaction"];
+  /** The model as the alias offers it: with its thinking levels and compaction values. */
+  readonly offered: ModelUpstream["models"][number];
 }
 
-/** Jeder Alias muss auf einen konfigurierten Anbieter und ein Modell aus dessen Katalog zeigen. */
+/** Every alias must point to a configured provider and a model from its catalog that its thinking levels and compaction values fit. */
 export const resolveAliases = (aliases: readonly ModelAlias[], upstreams: readonly ModelUpstream[]): readonly ResolvedAlias[] =>
   aliases.map((entry) => {
     const upstream = upstreams.find((candidate) => candidate.id === entry.upstream);
     if (!upstream) {
-      const available = upstreams.map((candidate) => candidate.id).join(", ") || "keiner";
-      throw new Error(`MODEL_ALIASES: der Anbieter ${entry.upstream} hinter ${entry.alias} ist auf diesem Server nicht konfiguriert (verfügbar: ${available})`);
+      const available = upstreams.map((candidate) => candidate.id).join(", ") || "none";
+      throw new Error(`MODEL_ALIASES: the provider ${entry.upstream} behind ${entry.alias} is not configured on this server (available: ${available})`);
     }
     const model = upstream.models.find((candidate) => candidate.id === entry.model);
-    if (!model) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);
-    return { alias: entry.alias, upstream, model, compaction: entry.compaction };
+    if (!model) throw new Error(`MODEL_ALIASES: the model ${entry.model} behind ${entry.alias} is missing from the catalog of ${entry.upstream}`);
+    return { alias: entry.alias, upstream, model, offered: validatedAliasModel(entry, model) };
   });
 
-/** Der Katalogeintrag nennt nur, was der Verbraucher für Draht und Kompaktierung braucht; Name, Anbieter und Kosten bleiben beim Server. */
+/** The catalog entry names only what the consumer needs for the wire and compaction; name, provider and costs stay with the server. */
 export const catalogEntryOf = (resolved: ResolvedAlias) => ({
   id: resolved.alias,
   object: "model" as const,
   owned_by: "relay",
   catalog: {
-    reasoning: resolved.model.reasoning,
-    ...(resolved.model.thinkingLevelMap ? { thinkingLevelMap: resolved.model.thinkingLevelMap } : {}),
-    input: [...resolved.model.input],
-    contextWindow: resolved.model.contextWindow,
-    maxTokens: resolved.model.maxTokens,
-    compaction: resolved.compaction,
-    ...(resolved.model.compat ? { compat: resolved.model.compat } : {}),
+    reasoning: resolved.offered.reasoning,
+    ...(resolved.offered.thinkingLevelMap ? { thinkingLevelMap: resolved.offered.thinkingLevelMap } : {}),
+    input: [...resolved.offered.input],
+    contextWindow: resolved.offered.contextWindow,
+    maxTokens: resolved.offered.maxTokens,
+    compaction: resolved.offered.compaction,
+    ...(resolved.offered.compat ? { compat: resolved.offered.compat } : {}),
   },
 });
 
@@ -55,7 +56,7 @@ interface Usage {
   readonly completion: number | undefined;
 }
 
-/** Ersetzt im durchgereichten Strom den echten Modellnamen durch den Alias, entfernt den Anbieter und merkt sich den letzten usage-Block. */
+/** Replaces the real model name with the alias in the forwarded stream, removes the provider and remembers the last usage block. */
 const responseRewriter = (alias: string) => {
   const decoder = new TextDecoder();
   let pending = "";
@@ -139,7 +140,7 @@ export const createRelayRoutes = (options: RelayRouteOptions): HttpRouteContribu
       matches: (request, url) => request.method === "POST" && url.pathname === completionsPath,
       requiredRights: [RELAY_RIGHT],
       handle: async ({ request, response, access }) => {
-        const user = access.user?.id ?? "anonym";
+        const user = access.user?.id ?? "anonymous";
         let text: string;
         try {
           text = await readBody(request, MAX_REQUEST_BYTES);
@@ -152,17 +153,17 @@ export const createRelayRoutes = (options: RelayRouteOptions): HttpRouteContribu
         try { parsed = JSON.parse(text); }
         catch { parsed = undefined; }
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-          writeJson(response, 400, openAiError("Der Anfragekörper ist kein JSON-Objekt", "invalid_request_error"));
+          writeJson(response, 400, openAiError("The request body is not a JSON object", "invalid_request_error"));
           return;
         }
         const alias = (parsed as { model?: unknown }).model;
         if (typeof alias !== "string" || !alias) {
-          writeJson(response, 400, openAiError("Die Anfrage nennt kein Modell", "invalid_request_error"));
+          writeJson(response, 400, openAiError("The request names no model", "invalid_request_error"));
           return;
         }
         const resolved = options.aliases().find((candidate) => candidate.alias === alias);
         if (!resolved) {
-          writeJson(response, 404, openAiError(`Das Modell ${alias} ist auf diesem Relay unbekannt`, "invalid_request_error"));
+          writeJson(response, 404, openAiError(`The model ${alias} is unknown on this relay`, "invalid_request_error"));
           return;
         }
         const controller = new AbortController();
@@ -179,8 +180,8 @@ export const createRelayRoutes = (options: RelayRouteOptions): HttpRouteContribu
         } catch (error) {
           if (controller.signal.aborted) return;
           const reason = error instanceof Error ? error.message : String(error);
-          options.log(`${user} ${alias} -> ${resolved.upstream.id}/${resolved.model.id}: nicht erreichbar (${reason})`);
-          writeJson(response, 502, openAiError(`Der Anbieter hinter ${alias} ist nicht erreichbar`, "server_error"));
+          options.log(`${user} ${alias} -> ${resolved.upstream.id}/${resolved.model.id}: unreachable (${reason})`);
+          writeJson(response, 502, openAiError(`The provider behind ${alias} is unreachable`, "server_error"));
           return;
         }
         response.writeHead(upstream.status, {

package/plugins/ragents.orchestration/contract.ts

@@ -21,15 +21,15 @@ export const surfaceEntityOf = (text: string): SurfaceEntity => {
   const trimmed = text.trim();
   if (trimmed.startsWith("@")) {
     const handle = handleKey(trimmed);
-    if (!handle || /\s/.test(handle)) throw new Error(`Entität ${JSON.stringify(text)}: nach dem @ fehlt ein Handle`);
+    if (!handle || /\s/.test(handle)) throw new Error(`Entity ${JSON.stringify(text)}: a handle is missing after the @`);
     return { kind: "actor", handle };
   }
   const match = /^app:(.+)$/s.exec(trimmed);
   if (!match) {
-    throw new Error(`Entität ${JSON.stringify(text)}: erwartet @handle oder app:<id>`);
+    throw new Error(`Entity ${JSON.stringify(text)}: expected @handle or app:<id>`);
   }
   const id = match[1].trim();
-  if (!id) throw new Error(`Entität ${JSON.stringify(text)}: die ID nach dem Doppelpunkt ist leer`);
+  if (!id) throw new Error(`Entity ${JSON.stringify(text)}: the ID after the colon is empty`);
   return { kind: "app", id };
 };
 
@@ -38,14 +38,14 @@ export const surfaceEntityKey = (entity: SurfaceEntity): string =>
 
 const LEGACY_KEYS = ["nodes", "shapes", "lines", "mode"] as const;
 
-/** Parses and validates a tile layout; throws a German error naming the first violation. */
+/** Parses and validates a tile layout; throws an error naming the first violation. */
 export const surfaceLayoutOf = (value: unknown): SurfaceLayout => {
-  if (!isRecord(value)) throw new Error("Die Anordnung muss ein Objekt mit root sein");
+  if (!isRecord(value)) throw new Error("The arrangement must be an object with root");
   const legacy = LEGACY_KEYS.filter((key) => key in value);
   if (legacy.length > 0) {
-    throw new Error(`Die Programmanordnung stammt aus der entfernten freien Fläche (${legacy.join(", ")}); `
-      + "canvas_layout_replace mit root setzt sie als Kachelaufteilung neu");
+    throw new Error(`The program arrangement comes from the removed free surface (${legacy.join(", ")}); `
+      + "canvas_layout_replace with root sets it anew as a tile layout");
   }
-  if (!("root" in value)) throw new Error("root fehlt; erwartet wird eine Kachel, eine Teilung oder null");
+  if (!("root" in value)) throw new Error("root is missing; expected a tile, a split or null");
   return { root: value.root === null ? null : surfaceTileNodeOf(value.root) };
 };

package/plugins/ragents.orchestration/server/index.ts

@@ -21,13 +21,13 @@ const orchestrationPlugin: RAgentsPlugin = {
     host.functions(createSurfaceToolContributor());
     host.functions(createRunStopContributor(
       (runId) => host.service(runManagementToken)().stop(runId),
-      (error) => console.error("Run-Stopp durch den Koordinator fehlgeschlagen", error),
+      (error) => console.error("Run stop by the coordinator failed", error),
     ));
     host.operations({
       id: "actor_input",
-      label: "Actor-Input einreihen",
-      description: "Reiht für einen Actor einen normalen Texteingang unter der gebundenen Identität ein - "
-        + "als Agent oder, aus einer App-Aktion, als Besitzer des Runs. Bestätigt nur das Einreihen. TypeScript-Actors verstehen ausschließlich ihr programmiertes Eingabeprotokoll, keine freien Aufträge.",
+      label: "Enqueue actor input",
+      description: "Enqueues a normal text input for an actor under the bound identity - "
+        + "as an agent or, from an app action, as the owner of the run. Only confirms the enqueueing. TypeScript actors understand only their programmed input protocol, no free-form tasks.",
       schema: actorInputSchema,
       resultSchema: eventResultSchemaOf("actor.input.enqueued"),
       operator: "direct",

package/plugins/ragents.orchestration/server/run-stop-tool.ts

@@ -4,15 +4,15 @@ import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
 
 const available = defineToolAvailability({
   availability: "conditional",
-  availabilityDetail: "Für den Primary-Actor mit execution.stopOwned im eigenen Run.",
+  availabilityDetail: "For the primary actor with execution.stopOwned in its own run.",
   requiredCapabilities: ["execution.stopOwned"],
 }, (actor, view) => actor.kind !== "human" && actor.id === view.primaryActorId && holdsUsable(actor, "execution.stopOwned"));
 
 export const createRunStopContributor = (stop: (runId: string) => Promise<void>, onError: (error: unknown) => void): ToolContributor => {
   const definition = defineRunFunction({
     name: "run_stop",
-    label: "Run stoppen",
-    description: "Leitet den vollständigen Stopp des eigenen Runs ein: laufende Turns, Werkzeuge, Unteragenten und Plugin-Dienste. Gespräch und Dateien bleiben erhalten. Bricht auch den eigenen Turn ab; die Annahme ist keine Bestätigung abgeschlossener Bereinigung. Bei Benutzerwunsch nach vollständigem Abbruch sofort verwenden, keine Abbruchnachricht an beschäftigte Agenten senden.",
+    label: "Stop run",
+    description: "Initiates the complete stop of your own run: running turns, tools, subagents and plugin services. Conversation and files are kept. Also cancels your own turn; acceptance is not a confirmation of completed cleanup. Use immediately when the user wants a complete cancellation; do not send a cancel message to busy agents.",
     schema: Type.Object({}, { additionalProperties: false }),
     resultSchema: Type.Object({ requested: Type.Literal(true) }, { additionalProperties: false }),
     available,

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

@@ -36,7 +36,7 @@ export const surfaceToolMetadata = {
 
 export const canDesignSurface = defineToolAvailability({
   availability: "conditional",
-  availabilityDetail: "Nur für Agenten und TypeScript-Actors mit der Capability plugin.state.write.",
+  availabilityDetail: "Only for agents and TypeScript actors with the capability plugin.state.write.",
   requiredCapabilities: ["plugin.state.write"],
 }, (actor) => actor.kind !== "human" && holdsUsable(actor, "plugin.state.write"));
 
@@ -72,15 +72,15 @@ const isStopped = (actor: RunView["actors"][number]) => actor.kind !== "human" &
 
 const surfaceActorOf = (view: RunView, reference: string, where: string) => {
   const entity = surfaceEntityOf(reference);
-  if (entity.kind !== "actor") throw invalid(`${where}: ${reference} ist kein Actor`);
+  if (entity.kind !== "actor") throw invalid(`${where}: ${reference} is not an actor`);
   const handle = entity.handle;
   const found = actorByHandle(view.actors, handle);
   if (!found) {
     const known = view.actors.filter((actor) => actor.kind !== "human").map((actor) => `@${actor.handle}`);
-    throw invalid(`${where}: @${handle} ist kein Actor dieses Runs. Vorhanden: ${known.join(", ") || "keine"}`);
+    throw invalid(`${where}: @${handle} is not an actor of this run. Present: ${known.join(", ") || "none"}`);
   }
   if (found.kind === "human") {
-    throw invalid(`${where}: @${handle} ist der Mensch im Chat; der Chat liegt fest links neben der Fläche`);
+    throw invalid(`${where}: @${handle} is the human in the chat; the chat is fixed to the left of the surface`);
   }
   return found;
 };
@@ -102,7 +102,7 @@ const resolveAppReferences = (view: RunView, layout: SurfaceLayout): SurfaceLayo
     try {
       return `app:${resolveActorView(programs, entity.id).view.id}`;
     } catch (error) {
-      throw invalid(`${where}: ${reference}: ${error instanceof Error ? error.message : String(error)} Flächenentitäten erhalten das Präfix app:.`);
+      throw invalid(`${where}: ${reference}: ${error instanceof Error ? error.message : String(error)} Surface entities get the prefix app:.`);
     }
   };
   return parsedLayout({ root: layout.root ? mapSurfaceTileEntities(layout.root, (entity) => resolve(entity, "root")) : null });

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

@@ -8,28 +8,28 @@ export const MAX_SURFACE_TILES = 64;
 export const surfaceTileNodeOf = (input: unknown): SurfaceTileNode => {
   const entities = new Set<string>();
   const parse = (value: unknown, where: string, depth: number): SurfaceTileNode => {
-    if (depth > MAX_SURFACE_TILE_DEPTH) throw new Error(`${where}: höchstens ${MAX_SURFACE_TILE_DEPTH} verschachtelte Teilungen sind erlaubt`);
-    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${where} muss eine Kachel oder Teilung sein`);
+    if (depth > MAX_SURFACE_TILE_DEPTH) throw new Error(`${where}: at most ${MAX_SURFACE_TILE_DEPTH} nested splits are allowed`);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${where} must be a tile or a split`);
     const node = value as Record<string, unknown>;
     if (Object.hasOwn(node, "entity")) {
-      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`);
+      if (Object.keys(node).some((key) => key !== "entity" && key !== "chatInput")) throw new Error(`${where}: a tile carries only entity and chatInput; a split direction, weights and children`);
+      if (typeof node.entity !== "string") throw new Error(`${where}.entity must be @handle or app:<name>/<view>`);
       const entity = surfaceEntityOf(node.entity);
       const key = surfaceEntityKey(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`);
+        throw new Error(`${where}.chatInput is only allowed for actors, as a boolean`);
       }
-      if (entities.has(key)) throw new Error(`${where}: ${key} ist mehr als einmal als Kachel platziert`);
+      if (entities.has(key)) throw new Error(`${where}: ${key} is placed as a tile more than once`);
       entities.add(key);
-      if (entities.size > MAX_SURFACE_TILES) throw new Error(`Höchstens ${MAX_SURFACE_TILES} Kacheln sind erlaubt`);
+      if (entities.size > MAX_SURFACE_TILES) throw new Error(`At most ${MAX_SURFACE_TILES} tiles are allowed`);
       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`);
+    if (Object.keys(node).some((key) => !["direction", "weights", "children"].includes(key))) throw new Error(`${where}: a split carries only direction, weights and children`);
+    if (node.direction !== "horizontal" && node.direction !== "vertical") throw new Error(`${where}.direction must be horizontal or vertical`);
     if (!Array.isArray(node.weights) || node.weights.length !== 2 || node.weights.some((weight) => typeof weight !== "number" || !Number.isFinite(weight) || weight <= 0)) {
-      throw new Error(`${where}.weights muss genau zwei endliche positive Zahlen enthalten`);
+      throw new Error(`${where}.weights must contain exactly two finite positive numbers`);
     }
-    if (!Array.isArray(node.children) || node.children.length !== 2) throw new Error(`${where}.children muss genau zwei Kacheln oder Teilungen enthalten`);
+    if (!Array.isArray(node.children) || node.children.length !== 2) throw new Error(`${where}.children must contain exactly two tiles or splits`);
     return {
       direction: node.direction,
       weights: [node.weights[0], node.weights[1]],

package/plugins/ragents.orchestration/web/ActorChat.tsx

@@ -14,7 +14,7 @@ export function ActorChat({ actor, view, presentation, display = presentation, p
   actor: RunActor;
   view: RunView;
   presentation: "surface" | "inspector";
-  /** Schlüssel der Anzeigefläche für den gemerkten Detailgrad; Default ist die Darstellung. */
+  /** Key of the display surface for the remembered detail level; defaults to the presentation. */
   display?: string;
   primaryMessages?: readonly Message[];
   conversation?: readonly Message[];
@@ -43,7 +43,7 @@ export function ActorChat({ actor, view, presentation, display = presentation, p
     <ChatMessages
     className={className}
     detailMode={detailMode}
-    emptyState={<Empty><EmptyHeader><EmptyTitle>{actor.kind === "script" ? "Noch kein Verlauf" : "Noch kein Gespräch"}</EmptyTitle><EmptyDescription>{actor.kind === "script" ? "Hier erscheinen Programmeingaben und ihre Verarbeitung." : "Schreibe eine Nachricht, um das Gespräch zu beginnen."}</EmptyDescription></EmptyHeader></Empty>}
+    emptyState={<Empty><EmptyHeader><EmptyTitle>{actor.kind === "script" ? "No history yet" : "No conversation yet"}</EmptyTitle><EmptyDescription>{actor.kind === "script" ? "Program inputs and their processing appear here." : "Write a message to start the conversation."}</EmptyDescription></EmptyHeader></Empty>}
     messages={messages}
     renderAction={renderAction}
     renderTool={renderTool}

package/plugins/ragents.orchestration/web/ActorChatControls.tsx

@@ -26,8 +26,8 @@ export function ActorChatControls({ actor, view, composerVisible = true, present
   const [stopError, setStopError] = useState<string>();
   const chatView = useChatViewSettings(view.id, actor.id, "agents", display);
   const attachments = useAttachmentCapabilities(view.id, actor.id, JSON.stringify(actor.execution?.driver.config));
-  const disabledReason = !writable ? "Du hast Lesezugriff auf diesen Run." : undefined;
-  const switches = <ChatViewSwitches collapsible={presentation === "surface"} settings={chatView} />;
+  const disabledReason = !writable ? "You have read access to this run." : undefined;
+  const switches = <ChatViewSwitches settings={chatView} />;
   if (!composerVisible || actor.kind === "human") return <div className={controlsClass}>{toolbarLeft}{switches}</div>;
   if (actor.kind === "script") return <div className={controlsClass}><p className={noteClass}>{programChatNotice}</p>{toolbarLeft}{switches}</div>;
   if (actor.lifecycle?.kind === "stopped") return <div className={presentation === "inspector" ? "flex-shrink-0 px-5 pt-2.5 pb-3.5" : undefined}>
@@ -47,11 +47,11 @@ export function ActorChatControls({ actor, view, composerVisible = true, present
       } : undefined}
       rows={1}
       running={running}
-      texts={{ placeholder: disabledReason ?? `Nachricht an @${actor.handle} ...` }}
+      texts={{ placeholder: disabledReason ?? `Message to @${actor.handle} ...` }}
       toolbarLeft={<>
         {toolbarLeft}
         {switches}
-        {presentation === "inspector" && <span className="truncate text-[0.7rem] text-muted-foreground">an @{actor.handle}</span>}
+        {presentation === "inspector" && <span className="truncate text-[0.7rem] text-muted-foreground">to @{actor.handle}</span>}
       </>}
       toolbarRight={toolbarRight}
     />

package/plugins/ragents.orchestration/web/ActorChatPreview.tsx

@@ -19,7 +19,7 @@ export const ActorChatPreview = memo(function ActorChatPreview({ actor, view, pr
     if (!element) return;
     element.tabIndex = 0;
     element.setAttribute("role", "region");
-    element.setAttribute("aria-label", `Chatverlauf von @${actor.handle}`);
+    element.setAttribute("aria-label", `Chat history of @${actor.handle}`);
   }, [actor.handle]);
   return <div className="flex min-h-[106px] w-full min-w-0 flex-1 flex-col overflow-hidden rounded-b-[16px] text-left" data-surface-scroll="true">
     <ChatPanel className="flex-1" composer={<ActorChatControls actor={actor} view={view} composerVisible={chatInput} presentation="surface" running={running} />}>

package/plugins/ragents.orchestration/web/ActorPopout.tsx

@@ -9,7 +9,7 @@ export function ActorPopout({ open, id, label, closeLabel, buttonRef, onClose, w
   closeLabel: string;
   buttonRef: RefObject<HTMLButtonElement | null>;
   onClose: (restoreFocus?: boolean) => void;
-  /** Pixel oder die ganze verfügbare Breite neben dem Anker. */
+  /** Pixels or the whole available width next to the anchor. */
   width: number | "available";
   height: number;
   placement?: "bottom" | "top";

package/plugins/ragents.orchestration/web/ActorShortcut.tsx

@@ -40,17 +40,17 @@ export function ActorShortcut({ actor, view, session, open, onToggle, onClose, v
   }, [onClose]);
 
   const inspect = (selection: FlowSelection) => {
-    if (!surface) throw new Error("Der Actor-Zugang benötigt den Flächen-Controller.");
+    if (!surface) throw new Error("The actor shortcut needs the surface controller.");
     surface.acceptSelection(selection);
     close();
   };
   const tone = actorTone(view, actor);
-  const label = actor.kind === "agent" ? `Chat mit @${actor.handle}` : `Actor-Ansicht von @${actor.handle}`;
-  const type = !technical ? "Agent" : actor.kind === "agent" ? "LLM-Agent" : "TypeScript-Actor";
+  const label = actor.kind === "agent" ? `Chat with @${actor.handle}` : `Actor view of @${actor.handle}`;
+  const type = !technical ? "Agent" : actor.kind === "agent" ? "LLM agent" : "TypeScript actor";
 
   return <div className="flex items-stretch [&[hidden]]:hidden" hidden={!visible}>
     <ToolbarItem as="button" aria-controls={visited ? panelId : undefined} aria-expanded={open} aria-haspopup="dialog"
-      aria-label={`${actor.displayName || actor.handle}. ${type}: ${label} öffnen`} className="font-bold"
+      aria-label={`${actor.displayName || actor.handle}. ${type}: open ${label}`} className="font-bold"
       data-tone={tone} data-staged={staged || undefined} onClick={() => { setVisited(true); onToggle(); }}
       draggable={technical} onDragStart={(event) => {
         if (!technical) { event.preventDefault(); return; }
@@ -58,11 +58,11 @@ export function ActorShortcut({ actor, view, session, open, onToggle, onClose, v
         event.dataTransfer.effectAllowed = "move";
         close();
       }}
-      ref={buttonRef} title={`${type}: ${label} öffnen${technical ? ". Zum Andocken auf eine Kachel ziehen." : ""}`} type="button">
+      ref={buttonRef} title={`${type}: open ${label}${technical ? ". Drag onto a tile to dock." : ""}`} type="button">
       <span className={cn(shortcutIconClass, staged && shortcutFillClass[tone])}>{actor.kind === "agent" ? <UsersIcon size={20} /> : <CodeIcon size={20} />}</span>
       <ToolbarCopy><ToolbarLabel>@{actor.handle}</ToolbarLabel><ToolbarText>{actor.displayName && actor.displayName !== actor.handle ? actor.displayName : type}</ToolbarText></ToolbarCopy>
     </ToolbarItem>
-    {visited && <ActorPopout open={open} id={panelId} label={label} closeLabel={`${label} schließen`}
+    {visited && <ActorPopout open={open} id={panelId} label={label} closeLabel={`Close ${label}`}
       buttonRef={buttonRef} keepMounted onClose={close} width={actor.kind === "agent" ? 784 : 560} height={640} role="dialog">
       <div className="min-h-0 min-w-0 flex-1 overflow-auto overscroll-contain">
         <FlowInspector actorConversations={session.actorConversations} canGoBack={false} chatDisplay="popout" composerVisible

package/plugins/ragents.orchestration/web/ActorSurfaceControls.tsx

@@ -20,13 +20,13 @@ export interface ActorSurfaceControlsProps {
 
 const nameClass = "min-w-0 max-w-full text-left font-semibold [overflow-wrap:anywhere]";
 
-const actorType = (actor: RunActor) => actor.kind === "human" ? "Benutzer" : actor.kind === "agent" ? "LLM-Agent" : "TypeScript-Actor";
-const actorStatus = (actor: RunActor) => actor.lifecycle?.kind === "running" ? "Arbeitet" : actor.lifecycle?.kind === "stopped" ? "Gestoppt" : actor.lifecycle?.kind === "idle" ? "Bereit" : "";
+const actorType = (actor: RunActor) => actor.kind === "human" ? "User" : actor.kind === "agent" ? "LLM agent" : "TypeScript actor";
+const actorStatus = (actor: RunActor) => actor.lifecycle?.kind === "running" ? "Working" : actor.lifecycle?.kind === "stopped" ? "Stopped" : actor.lifecycle?.kind === "idle" ? "Ready" : "";
 
 export function filterSurfaceActors(actors: readonly RunActor[], appActorIds: ReadonlySet<string>, query: string): readonly RunActor[] {
-  const words = query.trim().toLocaleLowerCase("de-DE").split(/\s+/).filter(Boolean);
+  const words = query.trim().toLocaleLowerCase("en-US").split(/\s+/).filter(Boolean);
   return actors.filter((actor) => {
-    const text = [`@${actor.handle}`, actor.displayName, actor.kind, actorType(actor), actor.lifecycle?.kind, actorStatus(actor), appActorIds.has(actor.id) ? "Mini-App" : ""].join(" ").toLocaleLowerCase("de-DE");
+    const text = [`@${actor.handle}`, actor.displayName, actor.kind, actorType(actor), actor.lifecycle?.kind, actorStatus(actor), appActorIds.has(actor.id) ? "Mini-app" : ""].join(" ").toLocaleLowerCase("en-US");
     return words.every((word) => text.includes(word));
   });
 }
@@ -46,7 +46,7 @@ export function ActorShortcuts({ session }: SessionHeaderContext) {
   }, [actors, close, openKey, session.session.id, shown]);
   if (!view || actors.length === 0) return null;
 
-  return <nav aria-label="Actors des Runs" className="flex min-w-0 flex-none items-stretch">
+  return <nav aria-label="Actors of the run" className="flex min-w-0 flex-none items-stretch">
     {actors.map((actor) => {
       const key = `${session.session.id}:${actor.id}`;
       return <ActorShortcut actor={actor} key={key} onClose={close}
@@ -63,9 +63,9 @@ export function ActorHeaderModeControl({ runId }: { runId: string }) {
   const mode = useActorHeaderMode(runId);
   const modes = inspect ? ACTOR_HEADER_MODES : PUBLIC_ACTOR_HEADER_MODES;
   const next = modes[(modes.indexOf(mode) + 1) % modes.length];
-  const label = `Actor-Anzeige: ${ACTOR_HEADER_MODE_LABELS[mode]}. Wechseln zu ${ACTOR_HEADER_MODE_LABELS[next]}`;
+  const label = `Actor display: ${ACTOR_HEADER_MODE_LABELS[mode]}. Switch to ${ACTOR_HEADER_MODE_LABELS[next]}`;
   return <ToolbarItem as="button" aria-label={label} className="w-[120px] max-w-[120px] min-w-[120px] flex-[0_0_120px]" onClick={() => saveActorHeaderMode(runId, next)} title={label} type="button">
-    <ToolbarCopy><ToolbarLabel>Anzeige</ToolbarLabel><ToolbarText>{ACTOR_HEADER_MODE_LABELS[mode]}</ToolbarText></ToolbarCopy>
+    <ToolbarCopy><ToolbarLabel>Display</ToolbarLabel><ToolbarText>{ACTOR_HEADER_MODE_LABELS[mode]}</ToolbarText></ToolbarCopy>
   </ToolbarItem>;
 }
 
@@ -90,15 +90,15 @@ export function ActorSurfaceControls({ session, appActorIds, preferences, onPref
       aria-label={label} title={label} onClick={() => setOpen((value) => !value)} type="button">
       <UsersIcon size={20} /><ToolbarText>Actors</ToolbarText>
     </ToolbarItem>
-    {open && <ActorPopout open id={panelId} label="Actors des Runs" closeLabel="Actorliste schließen"
+    {open && <ActorPopout open id={panelId} label="Actors of the run" closeLabel="Close actor list"
       buttonRef={buttonRef} onClose={close} width={460} height={460}
       placement="bottom" focusInput role="region">
       <div className="flex flex-none items-center gap-2.5 p-2.5">
-        <Input className="flex-1" aria-label="Actors durchsuchen" onChange={(event) => setQuery(event.target.value)} placeholder="Handle, Typ oder Status suchen ..." type="search" value={query} />
-        <span className="flex-none whitespace-nowrap text-[0.68rem] text-muted-foreground" role="status">{filtered.length} von {actors?.length ?? 0}</span>
+        <Input className="flex-1" aria-label="Search actors" onChange={(event) => setQuery(event.target.value)} placeholder="Search handle, type or status ..." type="search" value={query} />
+        <span className="flex-none whitespace-nowrap text-[0.68rem] text-muted-foreground" role="status">{filtered.length} of {actors?.length ?? 0}</span>
       </div>
       <ActorSurfaceList actors={filtered} appActorIds={appActorIds} primaryActorId={runView?.primaryActorId} onPreferencesChange={onPreferencesChange} preferences={preferences} />
-      <p className="flex-none border-t border-border-soft px-2.5 py-2.5 text-[0.68rem] text-muted-foreground">Persönliche Ansicht dieses Runs</p>
+      <p className="flex-none border-t border-border-soft px-2.5 py-2.5 text-[0.68rem] text-muted-foreground">Personal view of this run</p>
     </ActorPopout>}
   </div>;
 }
@@ -111,19 +111,19 @@ export function ActorSurfaceList({ actors, appActorIds, primaryActorId, onPrefer
   preferences: SurfaceViewPreferences;
 }) {
   return <div className="min-h-0 flex-1 overflow-auto overscroll-contain px-2.5">
-    {actors.length === 0 ? <p className="text-muted-foreground">Keine passenden Actors.</p> : <ul className="list-none">{actors.map((actor) => <li className="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-2.5 border-b border-border-soft py-1.5" key={actor.id}>
+    {actors.length === 0 ? <p className="text-muted-foreground">No matching actors.</p> : <ul className="list-none">{actors.map((actor) => <li className="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-2.5 border-b border-border-soft py-1.5" key={actor.id}>
       <div className="grid min-w-0 gap-0.5 leading-[1.3]">
         <div className="flex min-w-0 flex-wrap items-baseline gap-x-2 gap-y-0.5">
           <span className={nameClass}>@{actor.handle}</span>
           {actor.displayName !== actor.handle && <span className="min-w-0 max-w-full text-[0.7rem] [overflow-wrap:anywhere]">{actor.displayName}</span>}
         </div>
         <span className="flex flex-wrap items-center gap-x-2 gap-y-0.5 text-[0.66rem] text-muted-foreground">
-          <span>{actorType(actor)}</span>{actorStatus(actor) && <span>{actorStatus(actor)}</span>}{appActorIds.has(actor.id) && <span className="text-primary">Mini-App</span>}
+          <span>{actorType(actor)}</span>{actorStatus(actor) && <span>{actorStatus(actor)}</span>}{appActorIds.has(actor.id) && <span className="text-primary">Mini-app</span>}
         </span>
       </div>
       {actor.kind !== "human" && <label className="flex cursor-pointer items-center gap-[5px] whitespace-nowrap text-[0.68rem]">
-        <input aria-label={`@${actor.handle} auf der Fläche anzeigen`} checked={actorVisibleOnSurface(actor, appActorIds, preferences, primaryActorId)} onChange={(event) => onPreferencesChange({ ...preferences, actorVisibility: { ...preferences.actorVisibility, [actor.id]: event.target.checked } })} type="checkbox" />
-        <span>Fläche</span>
+        <input aria-label={`Show @${actor.handle} on the surface`} checked={actorVisibleOnSurface(actor, appActorIds, preferences, primaryActorId)} onChange={(event) => onPreferencesChange({ ...preferences, actorVisibility: { ...preferences.actorVisibility, [actor.id]: event.target.checked } })} type="checkbox" />
+        <span>Surface</span>
       </label>}
     </li>)}</ul>}
   </div>;

package/plugins/ragents.orchestration/web/ActorTile.tsx

@@ -12,7 +12,7 @@ export function ActorTile({ actor, view, cardSections, chatInput, session, navig
   navigation: SessionNavigation;
   onSelect: (selection: EntityReference) => void;
 }) {
-  return <div className="flex flex-col overflow-hidden has-[>[data-slot=card-sections]:not(:empty)]:min-h-[260px]">
+  return <div className="flex flex-col overflow-hidden has-[>[data-slot=card-sections]:not(:empty)]:min-h-[260px] has-[[data-chat=actions]:not(:empty)]:min-h-[260px]">
     <ActorChatPreview actor={actor} view={view} chatInput={chatInput} running={actor.lifecycle?.kind === "running"}
       conversation={session.actorConversations?.[actor.id]} historyError={session.conversationError}
       onNavigate={onSelect} primaryMessages={actor.id === view.primaryActorId ? session.messages : undefined} />

package/plugins/ragents.orchestration/web/Center.tsx

@@ -29,7 +29,7 @@ function RunOrchestrationCenter({
 }: SurfaceCenterContext) {
   const inspect = useAccess().can("runs.inspect");
   const surface = useSurfaceController();
-  if (!surface) throw new Error("Die Fläche braucht den Flächen-Controller des Orchestrierungs-Plugins.");
+  if (!surface) throw new Error("The surface needs the surface controller of the orchestration plugin.");
   const lastRunView = useRef<ReturnType<typeof runViewFrom>>(undefined);
   const parsedRunView = runViewFrom(session.runView);
   if (parsedRunView !== undefined) lastRunView.current = parsedRunView;
@@ -103,14 +103,14 @@ function RunOrchestrationCenter({
 
   return (
     <div className="relative flex h-full min-h-0 min-w-0 flex-1 overflow-clip" data-view="tiled">
-      {personalLayout && <StatusGroup container={statusContainer} label="Fläche" order={20}>
+      {personalLayout && <StatusGroup container={statusContainer} label="Surface" order={20}>
         <button className={statusControlClass} onClick={() => saveSurfacePresentation(session.session.id, null)}
-          title="Eigene Anordnung zurücksetzen und der Programmanordnung folgen" type="button">Programmvorgabe übernehmen</button>
+          title="Reset your own arrangement and follow the program arrangement" type="button">Apply program default</button>
       </StatusGroup>}
       {runToolbarContainer && createPortal(<><ActorHeaderModeControl runId={session.session.id} />{inspect && <ActorSurfaceControls session={session}
         appActorIds={appActorIds} preferences={preferences}
         onPreferencesChange={(next) => saveSurfaceViewPreferences(session.session.id, next)} />}</>, runToolbarContainer)}
-      <div aria-label="Fläche" className="relative min-h-0 min-w-0 flex-[1_1_360px] overflow-clip bg-[image:var(--surface-backdrop)]" ref={stageRef}>
+      <div aria-label="Surface" className="relative min-h-0 min-w-0 flex-[1_1_360px] overflow-clip bg-[image:var(--surface-backdrop)]" ref={stageRef}>
         <SurfaceGrain />
         {(programLayout.error || presentationError) && <p className="absolute inset-x-2 top-2 z-10 bg-secondary p-3 text-destructive" role="alert">{programLayout.error || presentationError}</p>}
         {runView && !showStartup && <div className="absolute inset-y-0 left-0 w-[var(--surface-visible-width,100%)] overflow-hidden">
@@ -124,7 +124,7 @@ function RunOrchestrationCenter({
   );
 }
 
-/** Feines Rauschen über der Fläche, damit das Material nicht glatt wirkt. */
+/** Fine noise over the surface so the material does not look smooth. */
 function SurfaceGrain() {
   return <svg aria-hidden="true" className="pointer-events-none absolute inset-0 size-full opacity-10" preserveAspectRatio="none" viewBox="0 0 180 180">
     <filter id="surface-grain"><feTurbulence baseFrequency=".76" numOctaves="3" stitchTiles="stitch" type="fractalNoise" /></filter>

package/plugins/ragents.orchestration/web/DocumentsSection.tsx

@@ -5,7 +5,7 @@ import { SectionLabel } from "@ragents/web/ui";
 
 const openDocument = (navigation: SessionNavigation, artifact: RunArtifact) => {
   if (navigation.revealEntity({ type: "artifact", id: artifact.id })) return;
-  throw new Error(`Kein Plugin kann das Dokument ${artifact.title} anzeigen`);
+  throw new Error(`No plugin can show the document ${artifact.title}`);
 };
 
 export function DocumentsSection({ actor, navigation, session }: CardSectionContext) {
@@ -18,7 +18,7 @@ export function DocumentsSection({ actor, navigation, session }: CardSectionCont
   return (
     <section className="grid gap-1.5">
       <SectionLabel>
-        <span>Dokumente</span>
+        <span>Documents</span>
         <small>{documents.length}</small>
       </SectionLabel>
       <ul className="grid list-none gap-1">