@schlenkr/ragents 0.1.10 → 0.1.11

package/plugins/ragents.actor-programs/server/controls-template.ts

@@ -2,11 +2,11 @@ import type { ActorProgramTemplate } from "./templates";
 
 export const controlsTemplate: ActorProgramTemplate = {
   id: "controls",
-  title: "UI-Controls ausprobieren",
-  description: "Lokale Demo mit Formular, Tabelle, Dateien, Aufgaben, Ablaufdiagramm, SVG-Verbindungen, Nachrichten, Dokument und Diff ohne Funktionsaufrufe.",
+  title: "Try UI controls",
+  description: "Local demo with form, table, files, tasks, flow diagram, SVG connections, messages, document, and diff without function calls.",
   ragents: {
-    title: "UI-Controls ausprobieren",
-    description: "Eine lokale Demo der vorhandenen Mini-App-Controls. Werte und Dateien bleiben in dieser Ansicht.",
+    title: "Try UI controls",
+    description: "A local demo of the available mini-app controls. Values and files stay in this view.",
     views: [{ id: "main", client: "src/client.tsx" }],
   },
   files: {
@@ -17,67 +17,67 @@ import * as UI from "@ragents/client/ui";
 type FormValues = Parameters<typeof UI.Form>[0]["values"];
 type Row = { id: string; name: string; count: number };
 const rows: Row[] = [
-  { id: "analysis", name: "Analyse", count: 12 },
+  { id: "analysis", name: "Analysis", count: 12 },
   { id: "review", name: "Review", count: 4 },
-  { id: "notes", name: "Dokumentation", count: 8 },
+  { id: "notes", name: "Documentation", count: 8 },
 ];
 
 const App = () => {
-  const [values, setValues] = React.useState<FormValues>({ title: "Ergebnisse prüfen", notes: "", count: 3, mode: "review", approved: false });
+  const [values, setValues] = React.useState<FormValues>({ title: "Review results", notes: "", count: 3, mode: "review", approved: false });
   const [selected, setSelected] = React.useState<string[]>([]);
   const [files, setFiles] = React.useState<File[]>([]);
-  const [result, setResult] = React.useState("Noch keine Formularwerte übernommen.");
+  const [result, setResult] = React.useState("No form values applied yet.");
   const [messages, setMessages] = React.useState<Parameters<typeof UI.MessageList>[0]["messages"]>([
-    { key: "editorial", sender: "Redaktion", text: "Der Hinweis soll **kurz und verständlich** bleiben." },
-    { key: "review", sender: "Textprüfung", text: "Öffnungszeiten und Reparaturhinweis bleiben erhalten." },
+    { key: "editorial", sender: "Editorial", text: "The notice should stay **short and clear**." },
+    { key: "review", sender: "Text review", text: "Opening hours and the repair notice are kept." },
   ]);
   const [done, setDone] = React.useState(false);
-  return <UI.AppLayout title="UI-Controls ausprobieren" description="Lokale Demo: keine Agenten, Uploads oder Serveraktionen. Werte und Dateiauswahl bleiben nur in dieser Ansicht und werden beim Neuladen zurückgesetzt.">
+  return <UI.AppLayout title="Try UI controls" description="Local demo: no agents, uploads, or server actions. Values and file selection stay only in this view and are reset on reload.">
     <UI.Stack gap="large">
-      <UI.Form title="Formular" fields={[
-        { id: "title", label: "Auftrag", type: "text", placeholder: "Was soll bearbeitet werden?", required: true },
-        { id: "notes", label: "Hinweise", type: "textarea", rows: 3, placeholder: "Was soll bei der Bearbeitung berücksichtigt werden?", hint: "Mehrzeiliger Text bleibt im Formular ausgerichtet." },
-        { id: "count", label: "Anzahl", type: "number", placeholder: "Anzahl der Ergebnisse", hint: "1 bis 10 Ergebnisse.", required: true, min: 1, max: 10 },
-        { id: "mode", label: "Modus", type: "select", options: [{ value: "review", label: "Prüfen" }, { value: "draft", label: "Entwerfen" }] },
-        { id: "approved", label: "Auswahl bestätigt", type: "checkbox", required: true },
-      ]} values={values} onChange={setValues} onSubmit={async (next) => { setResult(JSON.stringify(next, null, 2)); }} submitLabel="Werte lokal anzeigen" />
+      <UI.Form title="Form" fields={[
+        { id: "title", label: "Task", type: "text", placeholder: "What should be worked on?", required: true },
+        { id: "notes", label: "Notes", type: "textarea", rows: 3, placeholder: "What should be taken into account while working on it?", hint: "Multi-line text stays aligned in the form." },
+        { id: "count", label: "Count", type: "number", placeholder: "Number of results", hint: "1 to 10 results.", required: true, min: 1, max: 10 },
+        { id: "mode", label: "Mode", type: "select", options: [{ value: "review", label: "Review" }, { value: "draft", label: "Draft" }] },
+        { id: "approved", label: "Selection confirmed", type: "checkbox", required: true },
+      ]} values={values} onChange={setValues} onSubmit={async (next) => { setResult(JSON.stringify(next, null, 2)); }} submitLabel="Show values locally" />
       <UI.Stack gap="small">
-        <UI.DataTable<Row> title="Datentabelle" rows={rows} rowKey={(row) => row.id} filterable
+        <UI.DataTable<Row> title="Data table" rows={rows} rowKey={(row) => row.id} filterable
           selectedKeys={selected} onSelectionChange={setSelected}
-          columns={[{ id: "name", label: "Arbeit", value: (row) => row.name, sortable: true }, { id: "count", label: "Ergebnisse", value: (row) => row.count, sortable: true }]}
-          actions={[{ id: "select", label: "Auswählen", onClick: (row) => { setSelected([row.id]); } }]} />
-        <p aria-live="polite">{selected.length} Zeilen ausgewählt</p>
+          columns={[{ id: "name", label: "Work", value: (row) => row.name, sortable: true }, { id: "count", label: "Results", value: (row) => row.count, sortable: true }]}
+          actions={[{ id: "select", label: "Select", onClick: (row) => { setSelected([row.id]); } }]} />
+        <p aria-live="polite">{selected.length} rows selected</p>
       </UI.Stack>
-      <UI.FilePicker label="Lokale Dateiauswahl" files={files} onChange={setFiles} maxFiles={5} maxBytes={10 * 1024 * 1024} />
+      <UI.FilePicker label="Local file selection" files={files} onChange={setFiles} maxFiles={5} maxBytes={10 * 1024 * 1024} />
       <UI.Stack gap="small">
-        <UI.TaskProgress title="Beispielaufgaben" tasks={[
-          { id: "read", label: "Unterlagen lesen", status: "done" },
-          { id: "review", label: "Ergebnisse prüfen", status: done ? "done" : "pending", description: "Lokaler Beispielstatus, kein laufender Actor." },
+        <UI.TaskProgress title="Example tasks" tasks={[
+          { id: "read", label: "Read documents", status: "done" },
+          { id: "review", label: "Review results", status: done ? "done" : "pending", description: "Local example status, no running actor." },
         ]} />
-        <UI.Stack direction="row"><UI.Button onClick={() => setDone((current) => !current)}>Beispielstatus umschalten</UI.Button></UI.Stack>
+        <UI.Stack direction="row"><UI.Button onClick={() => setDone((current) => !current)}>Toggle example status</UI.Button></UI.Stack>
       </UI.Stack>
       <UI.Stack gap="small">
-        <h2>Ablaufdiagramm</h2>
-        <p>Das Diagramm erhält seinen Zustand aus denselben Daten wie die Aufgabenliste.</p>
-        <UI.FlowDiagram label={done ? "Eingang, Prüfung fertig, Ergebnis bereit" : "Eingang, Prüfung läuft, Ergebnis ausstehend"}
+        <h2>Flow diagram</h2>
+        <p>The diagram gets its state from the same data as the task list.</p>
+        <UI.FlowDiagram label={done ? "Intake, review done, result ready" : "Intake, review running, result pending"}
           nodes={[
-            { id: "input", label: "Eingang", detail: "Unterlagen liegen vor", status: "done", kind: "service" },
-            { id: "check", label: "Prüfung", detail: done ? "Prüfung abgeschlossen" : "Unterlagen werden geprüft", status: done ? "done" : "active", kind: "agent" },
-            { id: "result", label: "Ergebnis", detail: done ? "Ergebnis bereit" : "Wartet auf die Prüfung", status: done ? "done" : "pending", kind: "actor" },
+            { id: "input", label: "Intake", detail: "Documents are available", status: "done", kind: "service" },
+            { id: "check", label: "Review", detail: done ? "Review completed" : "Documents are being reviewed", status: done ? "done" : "active", kind: "agent" },
+            { id: "result", label: "Result", detail: done ? "Result ready" : "Waiting for the review", status: done ? "done" : "pending", kind: "actor" },
           ]}
           edges={[{ source: "input", target: "check" }, { source: "check", target: "result" }]} />
       </UI.Stack>
       <UI.Stack gap="small">
-        <h2>SVG-Verbindungen</h2>
-        <p>SvgEdge zeichnet die Kanten. Knoten, Beschriftungen und Positionen stehen im Code dieser Ansicht.</p>
-        <svg viewBox="0 0 360 160" role="img" aria-label={done ? "Eingang fertig, Prüfung abgeschlossen, Ergebnis bereit" : "Eingang fertig, Prüfung läuft, Ergebnis offen"}
+        <h2>SVG connections</h2>
+        <p>SvgEdge draws the edges. Nodes, labels, and positions are in the code of this view.</p>
+        <svg viewBox="0 0 360 160" role="img" aria-label={done ? "Intake done, review completed, result ready" : "Intake done, review running, result open"}
           className="block h-auto w-full text-[13px]">
           <UI.SvgEdge d="M112 42 L144 42" tone={done ? "success" : "warning"} active={!done} />
           <UI.SvgEdge d="M252 42 C320 42 320 118 252 118" arrow={done ? "end" : "none"} tone={done ? "success" : "neutral"} lineStyle={done ? "solid" : "dashed"} />
           <UI.SvgEdge d="M144 118 C64 118 64 96 64 72" arrow="both" tone="accent" />
-          {[{ x: 8, y: 12, label: "Eingang", status: "Fertig" },
-            { x: 148, y: 12, label: "Prüfung", status: done ? "Fertig" : "Läuft" },
-            { x: 148, y: 88, label: "Ergebnis", status: done ? "Bereit" : "Offen" }].map((node) => <g key={node.label}>
+          {[{ x: 8, y: 12, label: "Intake", status: "Done" },
+            { x: 148, y: 12, label: "Review", status: done ? "Done" : "Running" },
+            { x: 148, y: 88, label: "Result", status: done ? "Ready" : "Open" }].map((node) => <g key={node.label}>
               <rect x={node.x} y={node.y} width="104" height="56" rx="8" className="fill-background stroke-border-strong" />
               <text x={node.x + 52} y={node.y + 23} textAnchor="middle" className="fill-foreground font-semibold">{node.label}</text>
               <text x={node.x + 52} y={node.y + 42} textAnchor="middle" className="fill-muted-foreground text-[11px]">{node.status}</text>
@@ -85,20 +85,20 @@ const App = () => {
         </svg>
       </UI.Stack>
       <UI.Stack gap="small">
-        <UI.MessageList messages={messages} label="Lokale Redaktionsnotizen" />
+        <UI.MessageList messages={messages} label="Local editorial notes" />
         <UI.Stack direction="row"><UI.Button onClick={() => setMessages((current) => [...current, {
-          key: "note-" + current.length, sender: current.length % 2 ? "Textprüfung" : "Redaktion",
-          text: "Lokale Beispielnotiz " + (current.length - 1) + ": Diese Nachricht wurde gerade ergänzt.",
-        }])}>Lokale Nachricht ergänzen</UI.Button></UI.Stack>
+          key: "note-" + current.length, sender: current.length % 2 ? "Text review" : "Editorial",
+          text: "Local example note " + (current.length - 1) + ": This message was just added.",
+        }])}>Add local message</UI.Button></UI.Stack>
       </UI.Stack>
-      <UI.DocumentViewer title="Lokales Formularergebnis" format="text" content={result} />
-      <UI.DiffViewer title="Beispieländerung" patch={"--- a/result.txt\\n+++ b/result.txt\\n@@ -1 +1 @@\\n-Status: offen\\n+Status: geprüft"} />
+      <UI.DocumentViewer title="Local form result" format="text" content={result} />
+      <UI.DiffViewer title="Example change" patch={"--- a/result.txt\\n+++ b/result.txt\\n@@ -1 +1 @@\\n-Status: open\\n+Status: reviewed"} />
     </UI.Stack>
   </UI.AppLayout>;
 };
 
 const root = document.getElementById("root");
-if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+if (!root) throw new Error("The #root element is missing.");
 createRoot(root).render(<App />);
 `,
   },

package/plugins/ragents.actor-programs/server/controls-tool.ts

@@ -4,10 +4,10 @@ import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
 import { readClientUiComponentNames, readClientUiComponentContracts } from "@ragents/host/plugin-support/actor-programs/client-contracts.js";
 import { actorProgramGuide } from "./prompts.js";
 
-const available = defineToolAvailability({ availability: "always", availabilityDetail: "Typisierte UI-Referenz des installierten Actor-Programm-Plugins." }, () => true);
+const available = defineToolAvailability({ availability: "always", availabilityDetail: "Typed UI reference of the installed actor program plugin." }, () => true);
 const metadata = {
   name: "actor_program_controls",
-  label: "Actor-Programm-Anleitung und Controls nachschlagen",
+  label: "Look up actor program guide and controls",
   description: "Read Mini-App control contracts or the actor-program authoring guide.",
   longDescription: "With topic: guide, explain the TypeScript package workflow through actor_program_activate. Otherwise list control names, or select one component (for example Form) for only its TypeScript props and supporting types. Import controls from @ragents/client/ui and use these exact props.",
 };
@@ -15,7 +15,7 @@ const metadata = {
 export const describeClientControls = (component?: string) => {
   const components = readClientUiComponentNames();
   if (component === undefined) return { components };
-  if (!components.includes(component)) throw new Error(`Unbekanntes Control ${component}. Gültig: ${components.join(", ")}`);
+  if (!components.includes(component)) throw new Error(`Unknown control ${component}. Valid: ${components.join(", ")}`);
   return { files: readClientUiComponentContracts(component) };
 };
 
@@ -36,7 +36,7 @@ export const createControlsToolContributor = (): ToolContributor => ({
     ]),
     run: async (_scope, _call, input) => {
       if (input.topic === "guide") {
-        if (input.component !== undefined) throw new Error("component ist nur bei topic: controls oder ohne topic erlaubt; für topic: guide lasse component weg.");
+        if (input.component !== undefined) throw new Error("component is only allowed with topic: controls or without topic; for topic: guide, omit component.");
         return { guide: await actorProgramGuide.render({}) };
       }
       return describeClientControls(input.component);

package/plugins/ragents.actor-programs/server/limits.ts

@@ -11,12 +11,12 @@ export const jsonValue = <T>(value: T, label: string): T & JsonValue => {
   assertJsonValue(value, label);
   const text = JSON.stringify(value);
   if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES)
-    throw new Error(`${label} ist größer als ${MAX_JSON_BYTES} Byte.`);
+    throw new Error(`${label} is larger than ${MAX_JSON_BYTES} bytes.`);
   const pending: Array<{ value: unknown; depth: number }> = [{ value, depth: 0 }];
   while (pending.length > 0) {
     const current = pending.pop()!;
     if (current.depth > MAX_JSON_DEPTH)
-      throw new Error(`${label} ist tiefer als ${MAX_JSON_DEPTH} Ebenen verschachtelt.`);
+      throw new Error(`${label} is nested deeper than ${MAX_JSON_DEPTH} levels.`);
     if (Array.isArray(current.value)) {
       current.value.forEach((entry) => pending.push({ value: entry, depth: current.depth + 1 }));
       continue;
@@ -24,7 +24,7 @@ export const jsonValue = <T>(value: T, label: string): T & JsonValue => {
     if (current.value && typeof current.value === "object") {
       Object.entries(current.value).forEach(([key, entry]) => {
         if (key.length > MAX_JSON_KEY_LENGTH)
-          throw new Error(`${label} enthält einen Schlüssel mit mehr als ${MAX_JSON_KEY_LENGTH} Zeichen.`);
+          throw new Error(`${label} contains a key with more than ${MAX_JSON_KEY_LENGTH} characters.`);
         pending.push({ value: entry, depth: current.depth + 1 });
       });
     }

package/plugins/ragents.actor-programs/server/methods.ts

@@ -23,7 +23,7 @@ const guarded = <T>(code: string, status: number, work: () => T): T => {
 
 const checkedInput = (input: unknown): unknown => {
   if (Buffer.byteLength(JSON.stringify(input ?? null), "utf8") > MAX_INPUT_BYTES)
-    throw new DomainError("input-too-large", `Die Aktionseingabe ist größer als ${MAX_INPUT_BYTES} Byte.`, 413);
+    throw new DomainError("input-too-large", `The action input is larger than ${MAX_INPUT_BYTES} bytes.`, 413);
   return input;
 };
 

package/plugins/ragents.actor-programs/server/project-diagnostics.ts

@@ -30,7 +30,7 @@ const errorLines = (error: unknown): string[] => {
   const complete = error instanceof Error ? (error as { lines?: unknown }).lines : undefined;
   if (Array.isArray(complete) && complete.every((line) => typeof line === "string")) return [...new Set(complete as string[])];
   const lines = messageOf(error).split("\n").map((line) => line.trim()).filter(Boolean);
-  const issues = lines.filter((line) => !/^(Build failed with \d+ errors?:|.*(?:Typprüfung|Typecheck|Diagnostik).*:)$/i.test(line));
+  const issues = lines.filter((line) => !/^(Build failed with \d+ errors?:|.*(?:Typecheck|Diagnostics).*:)$/i.test(line));
   return [...new Set(issues.length ? issues : lines)];
 };
 const allErrors = (snapshot: ProjectDiagnosticsSnapshot): string[] => Object.entries(snapshot.programs)
@@ -71,7 +71,7 @@ export const createProjectDiagnostics = (options: ProjectDiagnosticsOptions) =>
           let fingerprint: string;
           let errors: string[] = [];
           try {
-            if (entry.isSymbolicLink()) throw new Error("Actor-Projekte dürfen keine Symlinks sein.");
+            if (entry.isSymbolicLink()) throw new Error("Actor projects must not be symlinks.");
             fingerprint = fingerprintOf(await projectSourceFiles(path.join(directory, entry.name)));
           } catch (error) {
             errors = errorLines(error);
@@ -108,13 +108,13 @@ export const createProjectDiagnostics = (options: ProjectDiagnosticsOptions) =>
       const after = new Set(allErrors(next));
       const added = [...after].filter((error) => !before.has(error));
       const resolved = [...before].filter((error) => !after.has(error));
-      const changes = [...added.map((error) => `Neu: ${error}`), ...resolved.map((error) => `Behoben: ${error}`)];
+      const changes = [...added.map((error) => `New: ${error}`), ...resolved.map((error) => `Fixed: ${error}`)];
       const lines = changes.slice(0, maxDeltaLines).map((line) => line.length > maxLineLength ? `${line.slice(0, maxLineLength - 3)}...` : line);
       const omitted = changes.length - lines.length;
       return [
-        `Actor-Programm-Projektprüfung (TypeScript und Build): ${after.size} Fehler in ${Object.keys(next.programs).length} Projekten; ${added.length} neu, ${resolved.length} behoben.`,
+        `Actor program project check (TypeScript and build): ${after.size} errors in ${Object.keys(next.programs).length} projects; ${added.length} new, ${resolved.length} fixed.`,
         ...lines,
-        ...(omitted > 0 ? [`${omitted} weitere Änderungen. Vollständiger letzter Stand: actor_program_diagnostics.`] : []),
+        ...(omitted > 0 ? [`${omitted} more changes. Complete last state: actor_program_diagnostics.`] : []),
       ].join("\n");
     },
   };
@@ -122,11 +122,11 @@ export const createProjectDiagnostics = (options: ProjectDiagnosticsOptions) =>
     contribution,
     latest(runId: string, actorId: string, programName?: string): string {
       const snapshot = snapshots.get(runId)?.get(actorId);
-      if (!snapshot) return "Noch kein Actor-Programm-Projektstand für diesen Agenten geprüft.";
+      if (!snapshot) return "No actor program project state checked for this agent yet.";
       const programs = Object.entries(snapshot.programs).filter(([id]) => programName === undefined || id === programName);
-      if (programs.length === 0) return programName ? `Kein geprüfter Projektstand für ${programName}.` : "Keine Actor-Programm-Projekte vorhanden.";
+      if (programs.length === 0) return programName ? `No checked project state for ${programName}.` : "No actor program projects exist.";
       return programs.sort(([left], [right]) => left.localeCompare(right)).map(([id, program]) =>
-        [`${id}: ${program.errors.length} Fehler`, ...program.errors].join("\n")).join("\n\n");
+        [`${id}: ${program.errors.length} errors`, ...program.errors].join("\n")).join("\n\n");
     },
     forget(runId: string): void { snapshots.delete(runId); },
   };

package/plugins/ragents.actor-programs/server/routes.ts

@@ -18,11 +18,11 @@ const escapeForwarder = `
 
 const themeReceiver = `
   const applyHostTheme = (theme) => {
-    if (theme !== "light" && theme !== "dark") throw new Error("Das Host-Theme muss light oder dark sein.");
+    if (theme !== "light" && theme !== "dark") throw new Error("The host theme must be light or dark.");
     document.documentElement.dataset.theme = theme;
   };`;
 
-// Die Vorfahren decken den Browser und die Webviews von VS Code ab (Desktop: vscode-file und vscode-cdn.net, ältere Fassungen: vscode-webview).
+// The ancestors cover the browser and the VS Code webviews (desktop: vscode-file and vscode-cdn.net, older versions: vscode-webview).
 export const frameContentSecurityPolicy = (nonce: string): string =>
   `sandbox allow-scripts allow-forms allow-downloads; default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; img-src 'self' data: blob:; font-src data:; connect-src 'none'; media-src 'self' data: blob:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self' https://*.vscode-cdn.net vscode-file: vscode-webview:`;
 
@@ -67,7 +67,7 @@ globalThis.__ragentsAppContext = (() => {
     if (!waiter || !terminal.has(message.invocation.status)) return;
     pending.delete(id);
     if (message.invocation.status === "succeeded") waiter.resolve(message.invocation.result);
-    else waiter.reject(new Error(message.invocation.error || "Die App-Aktion wurde nicht abgeschlossen."));
+    else waiter.reject(new Error(message.invocation.error || "The app action was not completed."));
   };
   port.onmessage = ({ data }) => {
     if (data?.version !== 1) return;
@@ -129,7 +129,7 @@ globalThis.__ragentsAppContext = (() => {
     );
   }
   return Object.freeze({
-    get actor() { if (!currentApp) throw new Error("Die Actor-Ansicht ist noch nicht bereit."); return Object.freeze({id:currentApp.actorId,handle:currentApp.actorHandle}); },
+    get actor() { if (!currentApp) throw new Error("The actor view is not ready yet."); return Object.freeze({id:currentApp.actorId,handle:currentApp.actorHandle}); },
     ready: ready.then(() => undefined),
     run: Object.freeze({ id: "current" }),
     principal: Object.freeze({ id: "operator", kind: "operator" }),
@@ -175,7 +175,7 @@ globalThis.__ragentsAppContext = (() => {
       call: async (actionId, input = {}) => {
         await ready;
         if (!(currentApp?.actions ?? []).some((action) => action.id === actionId)) {
-          throw new Error("Die angeforderte App-Aktion ist nicht installiert.");
+          throw new Error("The requested app action is not installed.");
         }
         return send({
           type: "ragents.app.invoke",
@@ -195,7 +195,7 @@ export const frameHtml = (
   nonce: string,
 ): string => {
   const head = /<head(?:\s[^>]*)?>/i;
-  if (!head.test(frame.html)) throw new Error("Die installierte App besitzt keinen gültigen head.");
+  if (!head.test(frame.html)) throw new Error("The installed app has no valid head.");
   const client = `<script nonce="${nonce}" type="module">await globalThis.__ragentsAppContext.ready;${escapedScript(frame.clientJavaScript)}</script>`;
   return frame.html.replace(head, (value) => `${value}${typedBridgeSdk(nonce, `${browserRuntimeStyles}\n${frame.styles}`)}${client}`);
 };
@@ -205,7 +205,7 @@ export interface MiniAppFrameOptions {
   runtime: ActorProgramRuntime;
 }
 
-/** Die einzige Auslieferungsroute des Plugins: das HTML des Mini-App-Frames; alles andere sind Methoden. */
+/** The plugin's only delivery route: the HTML of the mini-app frame; everything else is methods. */
 export const createMiniAppFrameRoutes = (options: MiniAppFrameOptions): HttpRouteContribution[] => [
   {
     id: "ragents.actor-programs.frame",
@@ -213,7 +213,7 @@ export const createMiniAppFrameRoutes = (options: MiniAppFrameOptions): HttpRout
     matches: (request, url) => request.method === "GET" && framePattern.test(url.pathname),
     handle: async ({ request, response, url }) => {
       const match = url.pathname.match(framePattern);
-      if (!match) throw new Error("Ungültige App-Route.");
+      if (!match) throw new Error("Invalid app route.");
       const [, runId, appId] = match;
       await guardedJsonRoute({
         request,