@schlenkr/ragents 0.1.10 → 0.1.11

package/apps/server/src/main.ts

@@ -4,12 +4,12 @@ import { configuredAnonymousUser, configuredUsers, loadConfigFile, missingEnviro
 const startupFailure = (error: unknown): never => {
   const message = error instanceof Error ? error.message : String(error);
   if (error instanceof Error && error.constructor !== Error && missingEnvironmentOf(error) === undefined) console.error(error.stack ?? message);
-  console.error(`\nRAgents startet nicht: ${message}`);
+  console.error(`\nRAgents does not start: ${message}`);
   reportMissingEnvironment(error, (line) => console.error(line));
   process.exit(1);
 };
 
-/** Startmodi: --stdio (JSON-RPC über stdin und stdout, ohne --port kein HTTP), --port 0 (privater Port mit Ansage auf stdout), --port N. */
+/** Start modes: --stdio (JSON-RPC over stdin and stdout, no HTTP without --port), --port 0 (private port announced on stdout), --port N. */
 const parseArguments = (argv: readonly string[]): { stdio: boolean; port: number | undefined } => {
   let stdio = false;
   let port: number | undefined;
@@ -18,12 +18,12 @@ const parseArguments = (argv: readonly string[]): { stdio: boolean; port: number
     if (argument === "--stdio") { stdio = true; continue; }
     if (argument === "--port") {
       const value = Number(argv[index + 1]);
-      if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`--port braucht eine ganze Zahl von 0 bis 65535, nicht ${argv[index + 1]}`);
+      if (!Number.isInteger(value) || value < 0 || value > 65535) throw new Error(`--port needs an integer from 0 to 65535, not ${argv[index + 1]}`);
       port = value;
       index += 1;
       continue;
     }
-    throw new Error(`Unbekanntes Argument: ${argument} (erlaubt: --stdio, --port <n>)`);
+    throw new Error(`Unknown argument: ${argument} (allowed: --stdio, --port <n>)`);
   }
   return { stdio, port };
 };
@@ -31,8 +31,8 @@ const parseArguments = (argv: readonly string[]): { stdio: boolean; port: number
 try {
   if (!process.env.PRODUCT_PROFILE) {
     throw new Error(
-      "PRODUCT_PROFILE ist nicht gesetzt. scripts/start.sh <profil> setzt das Profil; "
-      + "für pnpm start vorher export PRODUCT_PROFILE=<profil>.",
+      "PRODUCT_PROFILE is not set. scripts/start.sh <profile> sets the profile; "
+      + "for pnpm start, run export PRODUCT_PROFILE=<profile> first.",
     );
   }
   const arguments_ = parseArguments(process.argv.slice(2));

package/apps/server/src/missing-environment.ts

@@ -1,11 +1,11 @@
-/** Eine Konfiguration nennt env("NAME") für eine Umgebungsvariable, die der Prozess nicht hat; dazu, wofür sie gebraucht wird. */
+/** A configuration names env("NAME") for an environment variable the process does not have; plus what it is needed for. */
 export interface MissingEnvironment {
   readonly variable: string;
   readonly section: string;
   readonly key: string;
 }
 
-/** Derselbe Fehler wie bisher, nur trägt er den Namen mit, statt ihn im Satz zu verstecken. */
+/** The same error as before, except that it carries the name instead of hiding it in the sentence. */
 export class MissingEnvironmentError extends Error {
   constructor(readonly missing: MissingEnvironment, message: string) {
     super(message);
@@ -23,14 +23,14 @@ const asMissingEnvironment = (value: unknown): MissingEnvironment | undefined =>
   return { variable: missing.variable, section: missing.section, key: missing.key };
 };
 
-/** Der Befund an einem Fehler; geprüft wird sein Inhalt, nicht seine Klasse, denn er kommt auch aus einem anderen Modul. */
+/** The finding on an error; its content is checked, not its class, because it also comes from another module. */
 export const missingEnvironmentOf = (error: unknown): MissingEnvironment | undefined =>
   asMissingEnvironment((error as { missing?: unknown } | null | undefined)?.missing);
 
-/** Die Zeile, mit der ein Kindprozess den Befund an den weitergibt, der ihn gestartet hat; sein Text bleibt daneben stehen. */
+/** The line with which a child process passes the finding on to whoever started it; its text stays alongside. */
 export const missingEnvironmentNotice = (missing: MissingEnvironment): string => NOTICE + JSON.stringify(missing);
 
-/** Der Befund aus einer Ausgabezeile; alles andere ist keiner. */
+/** The finding from an output line; anything else is none. */
 export const parseMissingEnvironmentNotice = (line: string): MissingEnvironment | undefined => {
   if (!line.startsWith(NOTICE)) return undefined;
   try {
@@ -40,7 +40,7 @@ export const parseMissingEnvironmentNotice = (line: string): MissingEnvironment
   }
 };
 
-/** Was ein Prozess zusätzlich ausgibt, wenn er an einer fehlenden Umgebungsvariablen scheitert. */
+/** What a process additionally prints when it fails because of a missing environment variable. */
 export const reportMissingEnvironment = (error: unknown, write: (line: string) => void): void => {
   const missing = missingEnvironmentOf(error);
   if (missing) write(missingEnvironmentNotice(missing));

package/apps/server/src/parent-watch.ts

@@ -3,12 +3,12 @@ const CHECK_INTERVAL_MS = 5_000;
 export interface ParentWatch {
   readonly parentPid: string | undefined;
   readonly onGone: (pid: number) => void;
-  /** Nur für Tests: die Lebendprüfung und der Takt des Wächters. */
+  /** Tests only: the liveness check and the watcher's interval. */
   readonly alive?: (pid: number) => boolean;
   readonly intervalMs?: number;
 }
 
-/** Lebt der Prozess noch? ESRCH heißt weg, EPERM heißt lebendig unter fremdem Besitzer. */
+/** Is the process still alive? ESRCH means gone, EPERM means alive under another owner. */
 export const processAlive = (pid: number): boolean => {
   try {
     process.kill(pid, 0);
@@ -18,12 +18,12 @@ export const processAlive = (pid: number): boolean => {
   }
 };
 
-/** Beendet den Host, sobald der Prozess aus RAGENTS_PARENT_PID verschwindet; ohne die Variable gibt es keinen Wächter. */
+/** Ends the host as soon as the process from RAGENTS_PARENT_PID disappears; without the variable there is no watcher. */
 export const watchParentProcess = (watch: ParentWatch): (() => void) | undefined => {
   const given = watch.parentPid;
   if (given === undefined) return undefined;
   if (!/^\d+$/.test(given) || !Number.isSafeInteger(Number(given)) || Number(given) <= 0) {
-    throw new Error(`RAGENTS_PARENT_PID nennt die Prozesskennung des Aufrufers; ${JSON.stringify(given)} ist keine positive ganze Zahl.`);
+    throw new Error(`RAGENTS_PARENT_PID names the caller's process id; ${JSON.stringify(given)} is not a positive integer.`);
   }
   const pid = Number(given);
   const alive = watch.alive ?? processAlive;

package/apps/server/src/plugin-build/build.ts

@@ -86,8 +86,8 @@ const hostModuleShim = (specifier: string, names: readonly string[]): string =>
 const HOST_READ_SOURCE = [
   `export const read = (specifier, name) => {`,
   `  const module = globalThis[${JSON.stringify(HOST_MODULES_GLOBAL)}]?.[specifier];`,
-  `  if (module === undefined) throw new Error(\`Der Host stellt \${specifier} nicht bereit\`);`,
-  `  if (!(name in module)) throw new Error(\`Der Host stellt \${name} aus \${specifier} nicht bereit; das Bundle ist gegen einen neueren Host gebaut\`);`,
+  `  if (module === undefined) throw new Error(\`The host does not provide \${specifier}\`);`,
+  `  if (!(name in module)) throw new Error(\`The host does not provide \${name} from \${specifier}; the bundle was built against a newer host\`);`,
   `  return module[name];`,
   `};`,
 ].join("\n");
@@ -119,15 +119,15 @@ export const pluginCodeProblems = (file: string, text: string, id: string, asset
   };
   const visit = (node: ts.Node): void => {
     if (ts.isMetaProperty(node) && node.keywordToken === ts.SyntaxKind.ImportKeyword) {
-      report(node, "import.meta ist im Bundle nicht erlaubt; Dateien des Plugins gehen über pluginAsset(id, name) oder pluginFolder(id)");
+      report(node, "import.meta is not allowed in a bundle; the plugin's files go through pluginAsset(id, name) or pluginFolder(id)");
     } else if (ts.isIdentifier(node) && ["__dirname", "__filename", "createRequire"].includes(node.text)) {
-      report(node, `${node.text} ist im Bundle nicht erlaubt; Dateien des Plugins gehen über pluginAsset(id, name) oder pluginFolder(id)`);
+      report(node, `${node.text} is not allowed in a bundle; the plugin's files go through pluginAsset(id, name) or pluginFolder(id)`);
     } else if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" && node.name.text === "resolve") {
-      report(node, "require.resolve ist im Bundle nicht erlaubt; Dateien des Plugins gehen über pluginAsset(id, name) oder pluginFolder(id)");
+      report(node, "require.resolve is not allowed in a bundle; the plugin's files go through pluginAsset(id, name) or pluginFolder(id)");
     } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pluginAsset") {
       const [owner, name] = node.arguments;
       if (owner && name && ts.isStringLiteralLike(owner) && ts.isStringLiteralLike(name) && owner.text === id && !coveredByAssets(assets, name.text)) {
-        report(name, `pluginAsset nennt ${name.text}, das nicht ins Bundle kommt; unter assets in ragents-plugin.json nennen`);
+        report(name, `pluginAsset names ${name.text}, which does not go into the bundle; name it under assets in ragents-plugin.json`);
       }
     }
     ts.forEachChild(node, visit);
@@ -153,10 +153,10 @@ const platformProblem = (packageRoot: string): string | undefined => {
     name?: string; os?: unknown; cpu?: unknown; optionalDependencies?: Record<string, string>;
   };
   const name = manifest.name ?? path.basename(packageRoot);
-  if (manifest.os !== undefined || manifest.cpu !== undefined) return `Das Paket ${name} ist an Betriebssystem oder Prozessor gebunden (os/cpu in package.json)`;
+  if (manifest.os !== undefined || manifest.cpu !== undefined) return `The package ${name} is bound to an operating system or processor (os/cpu in package.json)`;
   const platformDependencies = Object.keys(manifest.optionalDependencies ?? {}).filter((dependency) => PLATFORM_PACKAGE.test(dependency));
   if (platformDependencies.length > 0) {
-    return `Das Paket ${name} hat plattformabhängige optionale Abhängigkeiten (${platformDependencies.join(", ")}); Natives stellt der Host bereit oder die Provisionierung holt es`;
+    return `The package ${name} has platform-dependent optional dependencies (${platformDependencies.join(", ")}); native code is provided by the host or fetched by the provisioning`;
   }
   return undefined;
 };
@@ -188,8 +188,8 @@ const boundaryPlugin = (
 
     /** The executor contribution loads in every process without the host's loader, the VS Code extension included. */
     const outsideContribution = (specifier: string) => ({ errors: [{
-      text: `${specifier}: der Executor-Beitrag lädt in jedem Node-Prozess ohne die Auflösung des Hosts; er importiert nur node:*, eigene Dateien, `
-        + "gebündelte Bibliotheken und vom Host Typen (import type), alles andere bekommt er über die Maschine",
+      text: `${specifier}: the executor contribution loads in every Node process without the host's resolution; it imports only node:*, its own files, `
+        + "bundled libraries and types from the host (import type), everything else it gets through the machine",
     }] });
 
     const crossImport = (owner: string, name: string) => {
@@ -211,7 +211,7 @@ const boundaryPlugin = (
     }));
 
     build.onResolve({ filter: /\.node$/ }, (args) => ({
-      errors: [{ text: `${args.path} ist eine plattformabhängige Binärdatei; Natives stellt der Host bereit oder die Provisionierung holt es nach <Datenordner>/tools/${id}/` }],
+      errors: [{ text: `${args.path} is a platform-dependent binary; native code is provided by the host or fetched by the provisioning into <data-folder>/tools/${id}/` }],
     }));
 
     build.onResolve({ filter: /.*/ }, async (args) => {
@@ -221,35 +221,35 @@ const boundaryPlugin = (
       if (specifier.startsWith("node:") || isBuiltin(specifier)) {
         return half === "server"
           ? { path: specifier, external: true }
-          : { errors: [{ text: `${specifier} ist ein Node-Modul und gibt es im Browser nicht` }] };
+          : { errors: [{ text: `${specifier} is a Node module and does not exist in the browser` }] };
       }
       if (isBare(specifier)) {
         const cross = /^@ragents\/plugins\/([^/]+)\/(.+)$/.exec(specifier);
         if (cross) {
           const [, owner, rawName] = cross as unknown as [string, string, string];
           const name = normalizedSpecifier(rawName);
-          if (owner === id) return { errors: [{ text: `${specifier} importiert das eigene Plugin über den Paketnamen; eigene Dateien relativ importieren` }] };
+          if (owner === id) return { errors: [{ text: `${specifier} imports the plugin itself through the package name; import own files relatively` }] };
           const other = environment.catalog(owner);
-          if (!other) return { errors: [{ text: `Das Plugin ${owner} aus ${specifier} liegt weder neben ${id} noch im Host` }] };
+          if (!other) return { errors: [{ text: `The plugin ${owner} from ${specifier} is neither next to ${id} nor in the host` }] };
           if (!other.description.exports[half].includes(name)) {
-            return { errors: [{ text: `${owner} exportiert ${name} für die ${half}-Hälfte nicht; der Export gehört in dessen ragents-plugin.json unter exports.${half}` }] };
+            return { errors: [{ text: `${owner} does not export ${name} for the ${half} half; the export belongs in its ragents-plugin.json under exports.${half}` }] };
           }
           return crossImport(owner, name);
         }
         if (selfContained && (providedByHost(half, specifier) || hostOnly(specifier))) return outsideContribution(specifier);
         if (providedByHost(half, specifier)) {
           if (args.kind === "dynamic-import" && (half === "web" || !isLibrary(half, specifier))) {
-            return { errors: [{ text: `import() von ${specifier}: ein Modul des Hosts wird statisch importiert, damit der Bau jeden Namen gegen die Host-API prüft` }] };
+            return { errors: [{ text: `import() of ${specifier}: a host module is imported statically so that the build checks every name against the host API` }] };
           }
           if (args.kind === "require-call" && half === "server") {
-            return { errors: [{ text: `require(${JSON.stringify(specifier)}): der Host liefert ${specifier} nur per import; im Bundle gäbe es sonst eine zweite Kopie oder keine` }] };
+            return { errors: [{ text: `require(${JSON.stringify(specifier)}): the host provides ${specifier} only through import; otherwise the bundle would get a second copy or none` }] };
           }
           return half === "server"
             ? { path: specifier, external: true }
             : { path: normalizedSpecifier(specifier), namespace: HOST_NAMESPACE, sideEffects: false };
         }
         if (hostOnly(specifier)) {
-          return { errors: [{ text: `${specifier} steht nicht in der ${half}-Liste der Host-API (apps/server/src/host-api.ts); ein Plugin bezieht vom Host nur, was dort steht` }] };
+          return { errors: [{ text: `${specifier} is not in the ${half} list of the host API (apps/server/src/host-api.ts); a plugin gets from the host only what is listed there` }] };
         }
         return undefined;
       }
@@ -258,19 +258,19 @@ const boundaryPlugin = (
       if (resolved.errors.length > 0) return { errors: resolved.errors };
       const owner = owningPluginFolder(resolved.path);
       if (owner === source.folder) return { path: resolved.path, sideEffects: resolved.sideEffects };
-      if (!owner) return { errors: [{ text: `${specifier} liegt außerhalb des Plugin-Ordners (${resolved.path}); ein Plugin importiert relativ nur eigene Dateien` }] };
+      if (!owner) return { errors: [{ text: `${specifier} is outside the plugin folder (${resolved.path}); a plugin imports only its own files relatively` }] };
       const other = readPluginSource(owner);
       const name = exportOfFile(other, half, resolved.path);
       if (!name) {
         const relative = path.relative(owner, resolved.path).split(path.sep).join("/").replace(/\.(ts|tsx)$/, "");
-        return { errors: [{ text: `${other.description.id} exportiert ${relative} für die ${half}-Hälfte nicht; der Export gehört in dessen ragents-plugin.json unter exports.${half}` }] };
+        return { errors: [{ text: `${other.description.id} does not export ${relative} for the ${half} half; the export belongs in its ragents-plugin.json under exports.${half}` }] };
       }
       return crossImport(other.description.id, name);
     });
 
     build.onLoad({ filter: /.*/, namespace: HOST_NAMESPACE }, (args) => {
       const names = environment.record.web[args.path];
-      if (!names) return { errors: [{ text: `host-api.json kennt ${args.path} nicht; pnpm update:host-api` }] };
+      if (!names) return { errors: [{ text: `host-api.json does not know ${args.path}; pnpm update:host-api` }] };
       return { contents: hostModuleShim(args.path, names), loader: "js" };
     });
     build.onLoad({ filter: /.*/, namespace: HOST_VALUE_NAMESPACE }, (args) => {
@@ -293,7 +293,7 @@ const boundaryPlugin = (
       const located = LIBRARY_LOCATIONS.filter(([pattern]) => pattern.test(text)).map(([, name]) => name);
       const errors = [
         ...(platform ? [{ text: platform }] : []),
-        ...(located.length > 0 ? [{ text: `${path.relative(packageRoot, args.path)} in ${path.basename(packageRoot)} sucht Dateien über den eigenen Ort (${located.join(", ")}); im Bundle gibt es diesen Ort nicht` }] : []),
+        ...(located.length > 0 ? [{ text: `${path.relative(packageRoot, args.path)} in ${path.basename(packageRoot)} locates files through its own location (${located.join(", ")}); in the bundle this location does not exist` }] : []),
       ];
       return errors.length > 0 ? { errors } : { contents: text, loader };
     });
@@ -329,7 +329,7 @@ const serverHostImports = (file: string, text: string, record: HostApiRecord): S
   const problems: string[] = [];
   const take = (specifier: string, name: string, offered: readonly string[]): void => {
     if (offered.includes(name)) names.push([normalizedSpecifier(specifier), name]);
-    else problems.push(`${file} importiert ${name} aus ${specifier}, das die Host-API nicht anbietet (host-api.json)`);
+    else problems.push(`${file} imports ${name} from ${specifier}, which the host API does not offer (host-api.json)`);
   };
   for (const statement of source.statements) {
     if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
@@ -338,7 +338,7 @@ const serverHostImports = (file: string, text: string, record: HostApiRecord): S
       if (!offered) continue;
       const clause = statement.exportClause;
       if (clause && ts.isNamedExports(clause)) for (const element of clause.elements) take(specifier, (element.propertyName ?? element.name).text, offered);
-      else if (!isLibrary("server", specifier)) problems.push(`${file} reicht ${specifier} ganz weiter; aus einem Modul des Hosts nur einzelne Namen importieren`);
+      else if (!isLibrary("server", specifier)) problems.push(`${file} re-exports ${specifier} as a whole; import only individual names from a host module`);
       continue;
     }
     if (!ts.isImportDeclaration(statement)) continue;
@@ -352,7 +352,7 @@ const serverHostImports = (file: string, text: string, record: HostApiRecord): S
       for (const element of bindings.elements) take(specifier, (element.propertyName ?? element.name).text, offered);
     } else if (bindings && ts.isNamespaceImport(bindings) && !isLibrary("server", specifier)) {
       const reads = namespaceReads(source, bindings.name);
-      if (reads.escapes) problems.push(`${file} benutzt den Namensraum ${bindings.name.text} aus ${specifier} als Ganzes; aus einem Modul des Hosts nur einzelne Namen lesen, damit der Bau sie prüft`);
+      if (reads.escapes) problems.push(`${file} uses the namespace ${bindings.name.text} from ${specifier} as a whole; read only individual names from a host module so that the build checks them`);
       for (const name of new Set(reads.names)) take(specifier, name, offered);
     }
   }
@@ -461,9 +461,9 @@ const tailwindCandidates = (source: PluginSource, metafile: Metafile): readonly
 
 const copyAsset = async (from: string, to: string, name: string): Promise<void> => {
   const stats = lstatSync(from);
-  if (stats.isSymbolicLink()) throw new Error(`Das Asset ${name} enthält eine Verknüpfung (${from}); ein Bundle enthält nur Dateien`);
+  if (stats.isSymbolicLink()) throw new Error(`The asset ${name} contains a link (${from}); a bundle contains only files`);
   if (stats.isDirectory()) {
-    if (path.basename(from) === "node_modules") throw new Error(`Das Asset ${name} enthält node_modules; ein Bundle bringt keine Abhängigkeiten mit`);
+    if (path.basename(from) === "node_modules") throw new Error(`The asset ${name} contains node_modules; a bundle brings no dependencies`);
     await mkdir(to, { recursive: true });
     for (const entry of readdirSync(from).sort()) {
       if (!SKIPPED_ASSET_FILES.has(entry)) await copyAsset(path.join(from, entry), path.join(to, entry), name);
@@ -497,7 +497,7 @@ const buildPlugin = async (folder: string, environment: BuildEnvironment, typeEr
     in: sourceFileOf(path.join(source.folder, name))!,
     out: `exports/${name}`,
   }));
-  if (!serverEntry) return failed(["server/index.ts fehlt; jedes Plugin hat eine Server-Hälfte mit dem Modulvertrag"]);
+  if (!serverEntry) return failed(["server/index.ts is missing; every plugin has a server half with the module contract"]);
   const hasWeb = webEntry !== undefined || source.description.exports.web.length > 0;
   const results = await Promise.all([
     buildHalf(source, "server", [{ in: provision ? "ragents-entry:server" : serverEntry, out: "index" }, ...exportEntries("server")], environment, assets),
@@ -511,7 +511,7 @@ const buildPlugin = async (folder: string, environment: BuildEnvironment, typeEr
   const target = path.join(environment.out, id);
   const relativeOf = (file: OutputFile): string => path.relative(target, file.path).split(path.sep).join("/");
   const strayCss = files.map(relativeOf).filter((name) => name.endsWith(".css") && name !== "web/index.css");
-  if (strayCss.length > 0) return failed(strayCss.map((name) => `${name}: CSS gibt es nur über den Web-Einstieg (web/index.css)`));
+  if (strayCss.length > 0) return failed(strayCss.map((name) => `${name}: CSS exists only through the web entry (web/index.css)`));
   const serverImports = files.filter((file) => relativeOf(file).startsWith("server/") && file.path.endsWith(".js"))
     .map((file) => serverHostImports(relativeOf(file), file.text, environment.record));
   const importProblems = serverImports.flatMap((imports) => imports.problems);
@@ -573,7 +573,7 @@ interface HostBuildContext {
 const hostContextFor = (folders: readonly string[], options: Pick<PluginBuildOptions, "out" | "root">): HostBuildContext => {
   const ids = folders.map((folder) => path.basename(path.resolve(folder)));
   const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
-  if (duplicate) throw new Error(`Das Plugin ${duplicate} ist mehrfach genannt`);
+  if (duplicate) throw new Error(`The plugin ${duplicate} is named more than once`);
   const root = options.root ?? hostRoot();
   return { root, record: checkedHostApiRecord(root), out: path.resolve(options.out) };
 };
@@ -654,7 +654,7 @@ export const watchPlugins = async (
       running = current;
       pending.add(current);
     };
-    // Beim Start nur Veraltetes, damit ein Server, der gerade mit diesen Bundles startet, keine getauschten Dateien sieht.
+    // At startup only outdated ones, so that a server that is just starting with these bundles sees no swapped files.
     run(true);
     watchers.push(watch(folder, { recursive: true }, (_event, name) => {
       const changed = name ? path.join(folder, name.toString()) : folder;

package/apps/server/src/plugin-build/host-api-names.ts

@@ -23,7 +23,7 @@ const parsedConfig = (file: string): ts.ParsedCommandLine => {
       throw new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, " "));
     },
   });
-  if (!parsed) throw new Error(`${file} ist keine gültige tsconfig`);
+  if (!parsed) throw new Error(`${file} is not a valid tsconfig`);
   return parsed;
 };
 
@@ -40,7 +40,7 @@ export const typeViews = (half: HostApiHalf, root = hostRoot()): ReadonlyMap<str
   const importer = path.join(root, place.importer);
   const resolved = hostApiModules(half).map((specifier) => {
     const module = ts.resolveModuleName(specifier, importer, options, ts.sys).resolvedModule;
-    if (!module) throw new Error(`${specifier} ist für die ${half}-Hälfte nicht auflösbar`);
+    if (!module) throw new Error(`${specifier} cannot be resolved for the ${half} half`);
     return { specifier, module };
   });
   const probe = path.join(path.dirname(importer), "__host-api-probe__.ts");
@@ -55,7 +55,7 @@ export const typeViews = (half: HostApiHalf, root = hostRoot()): ReadonlyMap<str
   const imports = program.getSourceFile(probe)!.statements.filter(ts.isImportDeclaration);
   return new Map(resolved.map(({ specifier, module }, index) => {
     const symbol = checker.getSymbolAtLocation(imports[index]!.moduleSpecifier);
-    if (!symbol) throw new Error(`${specifier}: ${module.resolvedFileName} hat kein Modulsymbol`);
+    if (!symbol) throw new Error(`${specifier}: ${module.resolvedFileName} has no module symbol`);
     const values = checker.getExportsOfModule(symbol).filter((exported) => {
       const target = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
       return (target.flags & ts.SymbolFlags.Value) !== 0;
@@ -120,7 +120,7 @@ const webRuntimeNames = async (specifiers: readonly string[], root: string): Pro
   const document = { createElement: () => ({}) };
   vm.runInNewContext(code, { module, exports: module.exports, console, setTimeout, clearTimeout, queueMicrotask, TextEncoder, TextDecoder, URL, document });
   const modules = module.exports.hostModules;
-  if (!modules) throw new Error("Das Register der Web-Hälfte liefert keine Module");
+  if (!modules) throw new Error("The web half's register yields no modules");
   return Object.fromEntries(Object.entries(modules).map(([specifier, namespace]) => [specifier, Object.keys(namespace)]));
 };
 
@@ -129,12 +129,12 @@ const listedNames = (half: HostApiHalf, specifier: string, view: TypeView): read
   const listed = hostApi[half][specifier]!;
   const hostCode = specifier.startsWith("@ragents/");
   if (listed === LIBRARY) {
-    if (hostCode) throw new Error(`${specifier} ist Code des Hosts, keine Bibliothek; host-api.ts nennt seine Namen einzeln`);
+    if (hostCode) throw new Error(`${specifier} is host code, not a library; host-api.ts names its names individually`);
     return LIBRARY;
   }
-  if (!hostCode) throw new Error(`${specifier} ist eine Bibliothek; host-api.ts gibt sie ganz frei`);
+  if (!hostCode) throw new Error(`${specifier} is a library; host-api.ts releases it as a whole`);
   const missing = listed.filter((name) => !view.names.includes(name));
-  if (missing.length > 0) throw new Error(`host-api.ts nennt für ${specifier} ${missing.join(", ")}, das Modul exportiert es nicht als Wert`);
+  if (missing.length > 0) throw new Error(`host-api.ts names ${missing.join(", ")} for ${specifier}, but the module does not export it as a value`);
   return [...listed].sort();
 };
 

package/apps/server/src/plugin-build/plugin-description.ts

@@ -25,7 +25,7 @@ const HALVES = new Set(["server", "web"]);
 
 const stringList = (value: unknown, where: string): readonly string[] => {
   if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
-    throw new Error(`${where} muss eine Liste von Pfaden sein`);
+    throw new Error(`${where} must be a list of paths`);
   }
   return value as readonly string[];
 };
@@ -33,7 +33,7 @@ const stringList = (value: unknown, where: string): readonly string[] => {
 /** A relative path inside the plugin folder, written with forward slashes and without leaving the folder. */
 const insidePath = (value: string, where: string): string => {
   if (path.isAbsolute(value) || value.includes("\\") || value.split("/").some((part) => part === ".." || part === "." || part === "")) {
-    throw new Error(`${where}: ${value} ist kein relativer Pfad im Plugin-Ordner`);
+    throw new Error(`${where}: ${value} is not a relative path in the plugin folder`);
   }
   return value;
 };
@@ -46,42 +46,42 @@ export const sourceFileOf = (stem: string): string | undefined =>
 export const readPluginDescription = (folder: string): PluginDescription => {
   const file = path.join(folder, PLUGIN_DESCRIPTION_FILE);
   if (!existsSync(file)) {
-    throw new Error(`${folder} hat keine ${PLUGIN_DESCRIPTION_FILE}; ein Plugin beschreibt sich dort mit { "id": "${path.basename(folder)}" }`);
+    throw new Error(`${folder} has no ${PLUGIN_DESCRIPTION_FILE}; a plugin describes itself there with { "id": "${path.basename(folder)}" }`);
   }
   const raw = JSON.parse(readFileSync(file, "utf8")) as unknown;
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error(`${file} muss ein Objekt enthalten`);
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error(`${file} must contain an object`);
   const record = raw as Record<string, unknown>;
   const unknown = Object.keys(record).filter((key) => !DESCRIPTION_KEYS.has(key));
-  if (unknown.length > 0) throw new Error(`${file}: unbekannte Felder ${unknown.join(", ")}; erlaubt sind id, exports und assets`);
+  if (unknown.length > 0) throw new Error(`${file}: unknown fields ${unknown.join(", ")}; allowed are id, exports and assets`);
   const id = record.id;
-  if (typeof id !== "string" || !ID_PATTERN.test(id)) throw new Error(`${file}: id muss eine Kennung wie acme.tickets sein`);
-  if (id !== path.basename(folder)) throw new Error(`${file}: die Kennung ${id} weicht vom Ordnernamen ${path.basename(folder)} ab`);
+  if (typeof id !== "string" || !ID_PATTERN.test(id)) throw new Error(`${file}: id must be an id such as acme.tickets`);
+  if (id !== path.basename(folder)) throw new Error(`${file}: the id ${id} differs from the folder name ${path.basename(folder)}`);
   const exportsValue = record.exports ?? {};
   if (typeof exportsValue !== "object" || exportsValue === null || Array.isArray(exportsValue)) {
-    throw new Error(`${file}: exports muss ein Objekt mit server und web sein`);
+    throw new Error(`${file}: exports must be an object with server and web`);
   }
   const halves = Object.keys(exportsValue).filter((half) => !HALVES.has(half));
-  if (halves.length > 0) throw new Error(`${file}: exports kennt nur server und web, nicht ${halves.join(", ")}`);
+  if (halves.length > 0) throw new Error(`${file}: exports knows only server and web, not ${halves.join(", ")}`);
   const exportsOf = (half: HostApiHalf): readonly string[] => {
     const names = stringList((exportsValue as Record<string, unknown>)[half] ?? [], `${file}: exports.${half}`)
       .map((name) => insidePath(name, `${file}: exports.${half}`));
     for (const name of names) {
-      if (/\.(js|ts|tsx|mjs)$/.test(name)) throw new Error(`${file}: der Export ${name} wird ohne Endung genannt`);
-      if (!sourceFileOf(path.join(folder, name))) throw new Error(`${file}: der Export ${name} für ${half} hat keine Quelldatei`);
+      if (/\.(js|ts|tsx|mjs)$/.test(name)) throw new Error(`${file}: the export ${name} is named without an extension`);
+      if (!sourceFileOf(path.join(folder, name))) throw new Error(`${file}: the export ${name} for ${half} has no source file`);
     }
     return names;
   };
   const assets = stringList(record.assets ?? [], `${file}: assets`).map((name) => insidePath(name, `${file}: assets`));
   for (const name of assets) {
-    if (RESERVED_ASSET_ROOTS.has(name.split("/")[0]!)) throw new Error(`${file}: das Asset ${name} liegt unter ${name.split("/")[0]}, das schreibt das Bauwerkzeug selbst`);
-    if (!existsSync(path.join(folder, name))) throw new Error(`${file}: das Asset ${name} fehlt im Plugin-Ordner`);
+    if (RESERVED_ASSET_ROOTS.has(name.split("/")[0]!)) throw new Error(`${file}: the asset ${name} is under ${name.split("/")[0]}, which the build tool writes itself`);
+    if (!existsSync(path.join(folder, name))) throw new Error(`${file}: the asset ${name} is missing in the plugin folder`);
   }
   return { id, exports: { server: exportsOf("server"), web: exportsOf("web") }, assets };
 };
 
 export const readPluginSource = (folder: string): PluginSource => {
   const given = path.resolve(folder);
-  if (!statSync(given, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${given} ist kein Ordner`);
+  if (!statSync(given, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`${given} is not a folder`);
   const real = realpathSync.native(given);
   return { folder: real, description: readPluginDescription(real) };
 };
@@ -110,7 +110,7 @@ export const pluginCatalog = (folders: readonly string[], builtIn = pluginsRoot)
     if (known.has(id)) return known.get(id);
     const found = roots.map((root) => path.join(root, id)).filter((folder) => existsSync(path.join(folder, PLUGIN_DESCRIPTION_FILE)));
     const distinct = [...new Set(found.map((folder) => realpathSync.native(folder)))];
-    if (distinct.length > 1) throw new Error(`Das Plugin ${id} gibt es mehrfach: ${distinct.join(", ")}`);
+    if (distinct.length > 1) throw new Error(`The plugin ${id} exists more than once: ${distinct.join(", ")}`);
     const source = distinct[0] ? readPluginSource(distinct[0]) : undefined;
     known.set(id, source);
     return source;

package/apps/server/src/plugin-build/typecheck.ts

@@ -26,7 +26,7 @@ const configOptions = (file: string): ts.CompilerOptions => {
       throw new Error(ts.flattenDiagnosticMessageText(diagnostic.messageText, " "));
     },
   });
-  if (!parsed) throw new Error(`${file} ist keine gültige tsconfig`);
+  if (!parsed) throw new Error(`${file} is not a valid tsconfig`);
   return parsed.options;
 };
 

package/apps/server/src/plugin-support/actor-programs/app-project.ts

@@ -26,7 +26,7 @@ const libraryDirectory = (name: string): string => {
       if (existsSync(file) && (JSON.parse(readFileSync(file, "utf8")) as { name?: string }).name === name) return directory;
       directory = path.dirname(directory);
     }
-    throw new Error(`Das installierte Paket ${name} besitzt keine Paketmetadaten.`);
+    throw new Error(`The installed package ${name} has no package metadata.`);
   }
 };
 const json = (value: unknown): string => `${JSON.stringify(value, null, 2)}\n`;
@@ -34,7 +34,7 @@ const link = async (source: string, target: string): Promise<void> => {
   await mkdir(path.dirname(target), { recursive: true });
   await symlink(source, target).catch(async (error: NodeJS.ErrnoException) => {
     if (error.code !== "EEXIST") throw error;
-    if (await realpath(target) !== await realpath(source)) throw new Error(`Die vorbereitete Bibliothek ${target} hat einen anderen Ursprung.`);
+    if (await realpath(target) !== await realpath(source)) throw new Error(`The prepared library ${target} has a different origin.`);
   });
 };
 export const prepareAppDependencies = async (directory: string): Promise<void> => {
@@ -96,15 +96,15 @@ export function createTestContextWithContracts(options, contracts) {
   const controller = new AbortController();
   const statePort = {read:()=>structuredClone(state),replace:value=>{state=structuredClone(value);}};
   const declared = new Map(contracts.map(contract=>[contract.id,contract]));
-  for (const name of Object.keys(options.functions ?? {})) if (!declared.has(name)) throw new Error("Unbekannte Testfunktion "+name);
+  for (const name of Object.keys(options.functions ?? {})) if (!declared.has(name)) throw new Error("Unknown test function "+name);
   const capabilities = {descriptors:()=>contracts,call:async(name,input)=>{
     const contract=declared.get(name);
     const call=options.functions?.[name];
-    if(!call)throw new Error("Im Test fehlt die Funktion "+name);
-    if(!Value.Check(contract.schema,input))throw new Error("Testeingabe verletzt den Vertrag von "+name+": "+schemaComplaints(contract.schema,input));
+    if(!call)throw new Error("The test is missing the function "+name);
+    if(!Value.Check(contract.schema,input))throw new Error("Test input violates the contract of "+name+": "+schemaComplaints(contract.schema,input));
     const result=await call(input);
-    assertJsonValue(result,"Testantwort von "+name);
-    if(!Value.Check(contract.resultSchema,result))throw new Error("Testantwort verletzt den Vertrag von "+name+": "+schemaComplaints(contract.resultSchema,result,"result"));
+    assertJsonValue(result,"Test response of "+name);
+    if(!Value.Check(contract.resultSchema,result))throw new Error("Test response violates the contract of "+name+": "+schemaComplaints(contract.resultSchema,result,"result"));
     return result;
   }};
   return {...createRunContext({runId:"test",invocationId:"test",invocationKind:"tool",principal:{id:"test",kind:"service"},state:statePort,capabilities,log:()=>{},signal:controller.signal}),
@@ -163,7 +163,7 @@ const workflowSdkFiles = () => workflowSdk ??= (async () => {
   const diagnostics = ts.getPreEmitDiagnostics(program);
   if (diagnostics.length) throw new Error(diagnostics.map(diagnostic => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")).join("\n"));
   const emitted = program.emit(undefined, (name, content) => { if (name.endsWith("index.d.ts")) declarations = content; if (name.endsWith("prompt-reader.d.ts")) promptDeclarations = content; });
-  if (emitted.emitSkipped || !declarations) throw new Error("Workflow-SDK-Deklarationen konnten nicht erzeugt werden.");
+  if (emitted.emitSkipped || !declarations) throw new Error("Workflow SDK declarations could not be generated.");
   const runtime = await build({ entryPoints: [workflowSource], bundle: true, write: false, platform: "neutral", format: "esm", target: "es2022", logLevel: "silent" });
   const promptRuntime = await build({ entryPoints: [promptSource], bundle: true, write: false, platform: "node", format: "esm", target: "es2022", logLevel: "silent" });
   return { javaScript: runtime.outputFiles[0]!.text, declarations, promptReader: promptRuntime.outputFiles[0]!.text, promptDeclarations };
@@ -215,10 +215,10 @@ export const prepareAppProject = async (directory: string): Promise<void> => {
 
 export const readAppPackage = async (directory: string): Promise<AppPackage> => {
   const pkg = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8")) as Record<string, unknown>;
-  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error(`package.json.ragents ist ungültig: ${schemaComplaints(appPackageSchema, pkg.ragents, "ragents")}`);
-  if (!pkg.ragents.backend && !pkg.ragents.views?.length) throw new Error("Ein Actor-Paket braucht ein Backend oder mindestens eine Ansicht.");
+  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error(`package.json.ragents is invalid: ${schemaComplaints(appPackageSchema, pkg.ragents, "ragents")}`);
+  if (!pkg.ragents.backend && !pkg.ragents.views?.length) throw new Error("An actor package needs a backend or at least one view.");
   const views = pkg.ragents.views ?? [];
-  if (new Set(views.map((view) => view.id)).size !== views.length) throw new Error("Ansichtsnamen müssen eindeutig sein.");
+  if (new Set(views.map((view) => view.id)).size !== views.length) throw new Error("View names must be unique.");
   return pkg.ragents;
 };
 
@@ -228,7 +228,7 @@ export const projectSourceFiles = async (directory: string): Promise<{ path: str
     for (const entry of await readdir(path.join(directory, relative), { withFileTypes: true })) {
       if (["node_modules", ".build", "dist", ".git"].includes(entry.name)) continue;
       const name = path.join(relative, entry.name);
-      if (entry.isSymbolicLink()) throw new Error(`App-Quelldateien dürfen keine Symlinks enthalten: ${name}`);
+      if (entry.isSymbolicLink()) throw new Error(`App source files must not contain symlinks: ${name}`);
       if (entry.isDirectory()) await walk(name);
       else if (entry.isFile()) files.push({ path: name, content: await readFile(path.join(directory, name), "utf8") });
     }
@@ -255,18 +255,18 @@ export const compileAppBackend = async (options: {
 }): Promise<{ contract: AppContract; javaScript: string; hash: string }> => {
   const signal = AbortSignal.any([...(options.signal ? [options.signal] : []), AbortSignal.timeout(15_000)]);
   const entry = path.resolve(options.directory, options.backend);
-  if (!entry.startsWith(`${options.directory}${path.sep}`)) throw new Error("Der Backend-Einstieg liegt außerhalb der App.");
+  if (!entry.startsWith(`${options.directory}${path.sep}`)) throw new Error("The backend entry lies outside the app.");
   const result = await build({
     stdin: { contents: `import actor from ${JSON.stringify(`./${options.backend}`)};
 export const describe = () => {
-  for (const name of Object.keys(actor.contract.functions ?? {})) if (typeof actor.functions?.[name] !== 'function') throw new Error('Fehlende Funktion ' + name);
-  if (Boolean(actor.contract.input) !== (typeof actor.onInput === 'function')) throw new Error('input und onInput müssen gemeinsam vorhanden sein.');
+  for (const name of Object.keys(actor.contract.functions ?? {})) if (typeof actor.functions?.[name] !== 'function') throw new Error('Missing function ' + name);
+  if (Boolean(actor.contract.input) !== (typeof actor.onInput === 'function')) throw new Error('input and onInput must be present together.');
   return JSON.parse(JSON.stringify(actor.contract));
 };
 export const handle = (request, context) => {
-  if (request.kind === 'input') { if (!actor.onInput) throw new Error('Dieser Actor verarbeitet keine Eingaben.'); return actor.onInput(request.input, context); }
+  if (request.kind === 'input') { if (!actor.onInput) throw new Error('This actor does not process input.'); return actor.onInput(request.input, context); }
   const handler = actor.functions[request.functionId];
-  if (typeof handler !== 'function') throw new Error('Unbekannte Actor-Funktion ' + request.functionId);
+  if (typeof handler !== 'function') throw new Error('Unknown actor function ' + request.functionId);
   return handler(request.input, context);
 };`, resolveDir: options.directory, sourcefile: "actor-entry.ts", loader: "ts" },
     absWorkingDir: options.directory, platform: "node", format: "esm", target: "node22", bundle: true, packages: "external", write: false,
@@ -277,7 +277,7 @@ export const handle = (request, context) => {
     program: { entry: "server.mjs", files: [{ fileName: "server.mjs", text: javaScript }], exportName: "describe" },
     input: {}, state: {}, cwd: options.directory,
     context: { runId: options.runId, invocationId: "app-contract", invocationKind: "tool", principal: { id: "app-build", kind: "service" }, capabilities: [] },
-  }, { signal, call: async () => { throw new Error("Beim Laden des App-Vertrags sind Run-Aufrufe nicht verfügbar."); }, log: () => undefined });
-  if (!Value.Check(appContractSchema, described.result)) throw new Error(`Der Backend-Export braucht defineActor({state, functions, input?}, {functions, onInput?}) mit gültigen Aktionsverträgen: ${schemaComplaints(appContractSchema, described.result, "contract")}`);
+  }, { signal, call: async () => { throw new Error("Run calls are not available while loading the app contract."); }, log: () => undefined });
+  if (!Value.Check(appContractSchema, described.result)) throw new Error(`The backend export needs defineActor({state, functions, input?}, {functions, onInput?}) with valid action contracts: ${schemaComplaints(appContractSchema, described.result, "contract")}`);
   return { contract: described.result, javaScript, hash: canonicalHash({ javaScript }) };
 };