@schlenkr/ragents 0.1.9 → 0.1.11

package/packages/ragents/src/script/mediators.ts

@@ -46,7 +46,7 @@ const strippedOf = (value: string) => value.trim().replace(/^@/, "");
 
 const referenceOf = (what: string, value: unknown): string => {
     if (typeof value !== "string" || !strippedOf(value))
-        throw new ScriptError(`${where}: ${what} muss eine Actor-ID oder ein Handle als nicht leerer Text sein.`);
+        throw new ScriptError(`${where}: ${what} must be an actor ID or a handle as non-empty text.`);
 
     return strippedOf(value);
 };
@@ -55,7 +55,7 @@ const keysOf = (references: readonly string[]): MediatorKeys => {
     const folded = new Map(references.map((reference) => [handleKey(reference), reference] as const));
 
     if (folded.size !== references.length)
-        throw new ScriptError(`${where}: table nennt denselben Beteiligten doppelt.`);
+        throw new ScriptError(`${where}: table names the same participant twice.`);
 
     return { all: references, exact: new Set(references), folded };
 };
@@ -70,9 +70,9 @@ const senderKeyOf = (keys: MediatorKeys, event: MediatorEvent): string | null =>
 
 const unknownTarget = (what: string, reference: string, keys: MediatorKeys): never => {
     throw new ScriptError(
-        `${where}: ${what} steht nicht als Schlüssel in der Tabelle. `
-        + `Die Tabelle kennt: ${keys.all.join(", ")}. `
-        + `Ein reiner Empfänger gehört als "${reference}": null in die Tabelle.`,
+        `${where}: ${what} is not a key in the table. `
+        + `The table knows: ${keys.all.join(", ")}. `
+        + `A pure recipient belongs in the table as "${reference}": null.`,
     );
 };
 
@@ -81,17 +81,17 @@ const targetsOf = (sender: string, value: unknown, keys: MediatorKeys): Mediator
 
     if (!Array.isArray(value))
         throw new ScriptError(
-            `${where}: die Ziele von ${sender} müssen eine Liste von Actor-IDs oder Handles, eine Funktion oder null sein.`,
+            `${where}: the targets of ${sender} must be a list of actor IDs or handles, a function or null.`,
         );
 
     const ids = value.map((entry) => {
-        const reference = referenceOf(`ein Ziel von ${sender}`, entry);
+        const reference = referenceOf(`a target of ${sender}`, entry);
 
-        return keyOf(keys, reference) ?? unknownTarget(`das Ziel ${reference} von ${sender}`, reference, keys);
+        return keyOf(keys, reference) ?? unknownTarget(`the target ${reference} of ${sender}`, reference, keys);
     });
 
     if (new Set(ids).size !== ids.length)
-        throw new ScriptError(`${where}: die Ziele von ${sender} nennen denselben Empfänger doppelt.`);
+        throw new ScriptError(`${where}: the targets of ${sender} name the same recipient twice.`);
 
     return { kind: "list", ids };
 };
@@ -100,10 +100,10 @@ const tableOf = (value: unknown): { readonly table: ReadonlyMap<string, Mediator
     const record = recordOf(value);
 
     if (!record)
-        throw new ScriptError(`${where}: table muss eine Routing-Tabelle von Absender auf Ziele sein.`);
+        throw new ScriptError(`${where}: table must be a routing table from sender to targets.`);
 
     const entries = Object.entries(record)
-        .map(([reference, targets]) => [referenceOf("jeder Schlüssel von table", reference), targets] as const);
+        .map(([reference, targets]) => [referenceOf("every key of table", reference), targets] as const);
     const keys = keysOf(entries.map(([key]) => key));
     const table = new Map<string, MediatorTargets>();
 
@@ -114,7 +114,7 @@ const tableOf = (value: unknown): { readonly table: ReadonlyMap<string, Mediator
     }
 
     if (table.size === 0)
-        throw new ScriptError(`${where}: table muss mindestens einen Absender enthalten.`);
+        throw new ScriptError(`${where}: table must contain at least one sender.`);
 
     return { table, keys };
 };
@@ -123,7 +123,7 @@ const startOf = (value: unknown, keys: MediatorKeys): MediatorStart => {
     const start = recordOf(value);
 
     if (!start || typeof start.text !== "string" || !start.text.trim())
-        throw new ScriptError(`${where}: start braucht text als erste Zeile des Protokolls und to als Empfänger.`);
+        throw new ScriptError(`${where}: start needs text as the first line of the protocol and to as the recipient.`);
 
     const to = referenceOf("start.to", start.to);
 
@@ -132,13 +132,13 @@ const startOf = (value: unknown, keys: MediatorKeys): MediatorStart => {
 
 const hookOf = (name: string, value: unknown, required: boolean): MediatorHook | null => {
     if (value === undefined || value === null) {
-        if (required) throw new ScriptError(`${where}: ${name} muss eine Funktion sein.`);
+        if (required) throw new ScriptError(`${where}: ${name} must be a function.`);
 
         return null;
     }
 
     if (typeof value !== "function")
-        throw new ScriptError(`${where}: ${name} muss eine Funktion sein.`);
+        throw new ScriptError(`${where}: ${name} must be a function.`);
 
     return value as MediatorHook;
 };
@@ -147,17 +147,17 @@ const configOf = (value: unknown): MediatorConfig => {
     const config = recordOf(value);
 
     if (!config)
-        throw new ScriptError(`${where} erwartet ein Konfigurationsobjekt.`);
+        throw new ScriptError(`${where} expects a configuration object.`);
 
     const label = config.label;
 
     if (label !== "handle" && label !== "none")
-        throw new ScriptError(`${where}: label muss "handle" oder "none" sein.`);
+        throw new ScriptError(`${where}: label must be "handle" or "none".`);
 
     const maxEntries = config.maxEntries;
 
     if (typeof maxEntries !== "number" || !Number.isSafeInteger(maxEntries) || maxEntries < 1)
-        throw new ScriptError(`${where}: maxEntries muss eine ganze Zahl ab 1 sein.`);
+        throw new ScriptError(`${where}: maxEntries must be an integer of at least 1.`);
 
     const { table, keys } = tableOf(config.table);
 
@@ -177,7 +177,7 @@ const entryOf = (value: unknown): MediatorEntry => {
     const entry = recordOf(value);
 
     if (!entry || (entry.from !== null && typeof entry.from !== "string") || typeof entry.text !== "string")
-        throw new ScriptError("Der Zustand des Vermittlers enthält einen Eintrag ohne from und text.");
+        throw new ScriptError("The state of the mediator contains an entry without from and text.");
 
     return { from: entry.from as string | null, text: entry.text };
 };
@@ -188,7 +188,7 @@ const stateOf = (value: unknown): MediatorState | null => {
     const state = recordOf(value);
 
     if (!state || !Array.isArray(state.entries) || typeof state.done !== "boolean")
-        throw new ScriptError("Der Zustand des Vermittlers gehört nicht zu dieser Bibliothek.");
+        throw new ScriptError("The state of the mediator does not belong to this library.");
 
     return { entries: state.entries.map(entryOf), done: state.done };
 };
@@ -200,7 +200,7 @@ const eventOf = (value: unknown): MediatorEvent | null => {
 
     if (!event || typeof event.type !== "string" || typeof event.sourceActorId !== "string"
         || typeof event.sourceActorHandle !== "string")
-        throw new ScriptError("Das zugestellte Event trägt keinen Typ und keinen Absender.");
+        throw new ScriptError("The delivered event carries no type and no sender.");
 
     return { type: event.type, sourceActorId: event.sourceActorId, sourceActorHandle: event.sourceActorHandle };
 };
@@ -209,7 +209,7 @@ const inputOf = (value: unknown): MediatorInput => {
     const input = recordOf(value);
 
     if (!input || typeof input.content !== "string")
-        throw new ScriptError("Der Vermittler hat keinen ActorInput mit Textfeld content bekommen.");
+        throw new ScriptError("The mediator did not receive an ActorInput with the text field content.");
 
     return { content: input.content, event: eventOf(input.event) };
 };
@@ -219,7 +219,7 @@ const lastLineOf = (content: string, from: string): string => {
     const last = lines[lines.length - 1];
 
     if (last === undefined)
-        throw new ScriptError(`Die Antwort von @${from} enthält keine nicht-leere Zeile.`);
+        throw new ScriptError(`The answer from @${from} contains no non-empty line.`);
 
     return last;
 };
@@ -237,7 +237,7 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
         try {
             await run(...args);
         } catch (error) {
-            throw new ScriptError(`Der Hook ${name} des Vermittlers ist gescheitert: ${messageOf(error)}`);
+            throw new ScriptError(`The hook ${name} of the mediator failed: ${messageOf(error)}`);
         }
     };
 
@@ -248,7 +248,7 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
 
         if (!Array.isArray(values))
             throw new ScriptError(
-                `Die Zielfunktion für ${sender} muss eine Actor-ID, ein Handle, eine Liste davon oder null liefern.`,
+                `The target function for ${sender} must return an actor ID, a handle, a list of them or null.`,
             );
 
         return values.map((id) => {
@@ -256,8 +256,8 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
 
             if (key === null)
                 throw new ScriptError(
-                    `Die Zielfunktion für ${sender} nennt das unbekannte Ziel ${String(id)}. `
-                    + `Die Tabelle kennt: ${config.keys.all.join(", ")}.`,
+                    `The target function for ${sender} names the unknown target ${String(id)}. `
+                    + `The table knows: ${config.keys.all.join(", ")}.`,
                 );
 
             return key;
@@ -268,7 +268,7 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
         try {
             return await run(entry);
         } catch (error) {
-            throw new ScriptError(`Die Zielfunktion für ${sender} ist gescheitert: ${messageOf(error)}`);
+            throw new ScriptError(`The target function for ${sender} failed: ${messageOf(error)}`);
         }
     };
 
@@ -305,7 +305,7 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
 
         if (input.event === null) {
             if (current)
-                throw new ScriptError("Der Vermittler ist bereits eingerichtet; ein zweiter direkter ActorInput ist nicht vorgesehen.");
+                throw new ScriptError("The mediator is already set up; a second direct ActorInput is not intended.");
 
             await binding.capabilities.call("event_subscribe", {
                 sourceActorIds: [...config.table.keys()],
@@ -317,24 +317,24 @@ const mediatorHandler = (binding: MediatorBinding, value: unknown) => {
         }
 
         if (!current)
-            throw new ScriptError("Der Vermittler ist noch nicht eingerichtet; der erste ActorInput muss ohne Event kommen.");
+            throw new ScriptError("The mediator is not set up yet; the first ActorInput must come without an event.");
 
         if (current.done) return;
 
         const event = input.event;
 
         if (event.type !== mediatorEventType)
-            throw new ScriptError(`Der Vermittler nimmt nur ${mediatorEventType} an, hier kam ${event.type}.`);
+            throw new ScriptError(`The mediator only accepts ${mediatorEventType}, here ${event.type} arrived.`);
 
         const senderKey = senderKeyOf(config.keys, event);
         const targets = senderKey === null ? undefined : config.table.get(senderKey);
 
         if (senderKey === null || !targets)
             throw new ScriptError(
-                `Der Absender ${event.sourceActorId} mit dem Handle ${event.sourceActorHandle} `
-                + `kommt in der Tabelle nicht als Absender vor. `
-                + `Absender sind: ${[...config.table.keys()].join(", ")}. `
-                + `Ein Schlüssel darf die Actor-ID, der Handle oder @handle sein.`,
+                `The sender ${event.sourceActorId} with the handle ${event.sourceActorHandle} `
+                + `does not appear in the table as a sender. `
+                + `Senders are: ${[...config.table.keys()].join(", ")}. `
+                + `A key may be the actor ID, the handle or @handle.`,
             );
 
         const entry: MediatorEntry = {

package/packages/ragents/src/typescript/async-compiler.ts

@@ -136,12 +136,12 @@ const acquireWorker = (
     };
     const onAbort = (): void => fail(new VirtualTypeScriptWorkerError(
         "ABORTED",
-        "Die TypeScript-Kompilierung wurde abgebrochen.",
+        "The TypeScript compilation was cancelled.",
         { cause: signal?.reason },
     ));
     const timer = setTimeout(() => fail(new VirtualTypeScriptWorkerError(
         "TIMEOUT",
-        `Der TypeScript-Compiler hat die Zeitgrenze von ${timeoutMs} ms überschritten.`,
+        `The TypeScript compiler exceeded the timeout of ${timeoutMs} ms.`,
     )), Math.max(0, deadline - performance.now()));
 
     signal?.addEventListener("abort", onAbort, { once: true });
@@ -151,7 +151,7 @@ const acquireWorker = (
         catch (error) {
             fail(new VirtualTypeScriptWorkerError(
                 "WORKER_FAILURE",
-                "Der TypeScript-Compiler-Worker konnte nicht gestartet werden.",
+                "The TypeScript compiler worker could not be started.",
                 { cause: error },
             ));
         }
@@ -192,7 +192,7 @@ const isWorkerMessage = (value: unknown): value is CompilerWorkerMessage => {
 const timeoutOf = (options: CompileVirtualTypeScriptAsyncOptions | undefined): number => {
     const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_TIMEOUT_MS) {
-        throw new RangeError(`TypeScript-Compiler-Timeout muss zwischen 1 und ${MAX_TIMEOUT_MS} ms liegen.`);
+        throw new RangeError(`TypeScript compiler timeout must be between 1 and ${MAX_TIMEOUT_MS} ms.`);
     }
     return timeoutMs;
 };
@@ -200,12 +200,12 @@ const timeoutOf = (options: CompileVirtualTypeScriptAsyncOptions | undefined): n
 const validateRequestSize = (request: CompileVirtualTypeScriptRequest): void => {
     const files = [...request.sources, ...(request.declarations ?? [])];
     if (files.length > MAX_COMPILER_FILES)
-        throw new RangeError(`Eine TypeScript-Kompilierung darf höchstens ${MAX_COMPILER_FILES} Dateien enthalten.`);
+        throw new RangeError(`A TypeScript compilation may contain at most ${MAX_COMPILER_FILES} files.`);
     const bytes = files.reduce((size, file) =>
         size + Buffer.byteLength(file.fileName, "utf8") + Buffer.byteLength(file.text, "utf8"),
     Buffer.byteLength(request.contract ?? "", "utf8"));
     if (bytes > MAX_COMPILER_INPUT_BYTES)
-        throw new RangeError(`Die TypeScript-Compiler-Eingabe darf höchstens ${MAX_COMPILER_INPUT_BYTES} Byte groß sein.`);
+        throw new RangeError(`The TypeScript compiler input may be at most ${MAX_COMPILER_INPUT_BYTES} bytes.`);
 };
 
 const remoteError = (error: SerializedWorkerError): Error => {
@@ -253,7 +253,7 @@ export const compileVirtualTypeScriptAsync = async (
                 () => reject(result.error),
                 (terminationError: unknown) => reject(new VirtualTypeScriptWorkerError(
                     "WORKER_FAILURE",
-                    "Der TypeScript-Compiler-Worker konnte nicht sauber beendet werden.",
+                    "The TypeScript compiler worker could not be terminated cleanly.",
                     { cause: terminationError },
                 )),
             );
@@ -262,7 +262,7 @@ export const compileVirtualTypeScriptAsync = async (
             if (!isWorkerMessage(message)) {
                 finish({ error: new VirtualTypeScriptWorkerError(
                     "WORKER_FAILURE",
-                    "Der TypeScript-Compiler-Worker hat eine ungültige Antwort geliefert.",
+                    "The TypeScript compiler worker returned an invalid response.",
                 ) });
                 return;
             }
@@ -273,41 +273,41 @@ export const compileVirtualTypeScriptAsync = async (
             }
             finish({ error: new VirtualTypeScriptWorkerError(
                 "COMPILER_EXCEPTION",
-                `Der TypeScript-Compiler ist fehlgeschlagen: ${message.error.message}`,
+                `The TypeScript compiler failed: ${message.error.message}`,
                 { cause: remoteError(message.error) },
             ), keepWorker: true });
         };
         const onMessageError = (error: Error): void => finish({
             error: new VirtualTypeScriptWorkerError(
                 "WORKER_FAILURE",
-                "Die Antwort des TypeScript-Compiler-Workers konnte nicht gelesen werden.",
+                "The response of the TypeScript compiler worker could not be read.",
                 { cause: error },
             ),
         });
         const onError = (error: Error): void => finish({
             error: new VirtualTypeScriptWorkerError(
                 "WORKER_FAILURE",
-                `Der TypeScript-Compiler-Worker ist fehlgeschlagen: ${error.message}`,
+                `The TypeScript compiler worker failed: ${error.message}`,
                 { cause: error },
             ),
         });
         const onExit = (code: number): void => finish({
             error: new VirtualTypeScriptWorkerError(
                 "WORKER_FAILURE",
-                `Der TypeScript-Compiler-Worker wurde ohne Ergebnis beendet (Exit-Code ${code}).`,
+                `The TypeScript compiler worker exited without a result (exit code ${code}).`,
             ),
         });
         const onAbort = (): void => finish({
             error: new VirtualTypeScriptWorkerError(
                 "ABORTED",
-                "Die TypeScript-Kompilierung wurde abgebrochen.",
+                "The TypeScript compilation was cancelled.",
                 { cause: options?.signal?.reason },
             ),
         });
         const timer = setTimeout(() => finish({
             error: new VirtualTypeScriptWorkerError(
                 "TIMEOUT",
-                `Der TypeScript-Compiler hat die Zeitgrenze von ${timeoutMs} ms überschritten.`,
+                `The TypeScript compiler exceeded the timeout of ${timeoutMs} ms.`,
             ),
         }), Math.max(0, deadline - performance.now()));
 

package/packages/ragents/src/typescript/compiler-worker.ts

@@ -37,12 +37,12 @@ const serializedError = (error: unknown): SerializedWorkerError => {
 };
 
 if (parentPort === null) {
-    throw new Error("Der TypeScript-Compiler-Worker benötigt einen übergeordneten Thread.");
+    throw new Error("The TypeScript compiler worker needs a parent thread.");
 }
 
 const port = parentPort;
 port.on("message", (message: CompilerWorkerRequest) => {
-    if (message?.kind !== "compile") throw new Error("Der TypeScript-Compiler-Worker hat eine unbekannte Anfrage erhalten.");
+    if (message?.kind !== "compile") throw new Error("The TypeScript compiler worker received an unknown request.");
     try {
         const compilation = compileVirtualTypeScript(message.request);
         port.postMessage({ kind: "result", requestId: message.requestId, compilation } satisfies CompilerWorkerMessage);

package/packages/ragents/src/typescript/compiler.ts

@@ -107,19 +107,19 @@ const libraryContent = (source: string): { readonly text: string; readonly hash:
 
 const normalizeFileName = (fileName: string, kind: VirtualFileKind): string => {
     if (!fileName.trim() || fileName.includes("\0") || fileName.includes("\\")) {
-        throw new TypeError(`Ungültiger virtueller TypeScript-Pfad: ${fileName}`);
+        throw new TypeError(`Invalid virtual TypeScript path: ${fileName}`);
     }
 
     const normalized = path.posix.normalize(`/${fileName}`).replace(/^\/+(?=.)/, "/");
     if (normalized === VIRTUAL_ROOT || normalized.startsWith("/__ragents__/")) {
-        throw new TypeError(`Reservierter virtueller TypeScript-Pfad: ${fileName}`);
+        throw new TypeError(`Reserved virtual TypeScript path: ${fileName}`);
     }
 
     if (kind === "source" && ((!normalized.endsWith(".ts") && !normalized.endsWith(".tsx")) || normalized.endsWith(".d.ts"))) {
-        throw new TypeError(`Virtuelle TypeScript-Quelle muss auf .ts oder .tsx enden: ${fileName}`);
+        throw new TypeError(`Virtual TypeScript source must end in .ts or .tsx: ${fileName}`);
     }
     if (kind === "declaration" && !normalized.endsWith(".d.ts")) {
-        throw new TypeError(`Virtuelle TypeScript-Deklaration muss auf .d.ts enden: ${fileName}`);
+        throw new TypeError(`Virtual TypeScript declaration must end in .d.ts: ${fileName}`);
     }
 
     return normalized;
@@ -137,7 +137,7 @@ const normalizedFiles = (
 const assertUniqueFiles = (files: readonly NormalizedFile[]): void => {
     const names = new Set<string>();
     for (const file of files) {
-        if (names.has(file.fileName)) throw new TypeError(`Virtuelle Datei doppelt deklariert: ${file.fileName}`);
+        if (names.has(file.fileName)) throw new TypeError(`Virtual file declared twice: ${file.fileName}`);
         names.add(file.fileName);
     }
 };
@@ -239,9 +239,9 @@ const diagnosticsOf = (diagnostics: readonly ts.Diagnostic[]): VirtualTypeScript
 export const compileVirtualTypeScript = (
     request: CompileVirtualTypeScriptRequest,
 ): VirtualTypeScriptCompilation => {
-    if (request.sources.length === 0) throw new TypeError("Mindestens eine TypeScript-Quelle ist erforderlich.");
+    if (request.sources.length === 0) throw new TypeError("At least one TypeScript source is required.");
     const emit = request.emit ?? "none";
-    if (!["none", "browser", "node"].includes(emit)) throw new TypeError(`Unbekannter TypeScript-Emitmodus: ${String(emit)}`);
+    if (!["none", "browser", "node"].includes(emit)) throw new TypeError(`Unknown TypeScript emit mode: ${String(emit)}`);
     const sources = normalizedFiles(request.sources, "source");
     const declarations = normalizedFiles(request.declarations ?? [], "declaration");
     const libraries: LoadedLibrary[] = (request.libraries ?? []).map((library) => ({

package/packages/ragents/src/typescript/snippet.ts

@@ -37,7 +37,7 @@ export class TypeScriptSnippetCompilationError extends Error {
                 ...(diagnostic.end ? { end: { ...diagnostic.end, line: Math.max(1, diagnostic.end.line - 1) } } : {}),
             } : {}),
         }));
-        super(`TypeScript-Snippet wurde nicht ausgeführt:\n${original.map((diagnostic) =>
+        super(`TypeScript snippet was not executed:\n${original.map((diagnostic) =>
             `${diagnostic.fileName ?? "TypeScript"}${diagnostic.start ? `:${diagnostic.start.line}:${diagnostic.start.column}` : ""} TS${diagnostic.code}: ${diagnostic.message}`,
         ).join("\n")}`);
         this.name = "TypeScriptSnippetCompilationError";
@@ -47,7 +47,7 @@ export class TypeScriptSnippetCompilationError extends Error {
 
 export const compileTypeScriptSnippet = async (source: TypeScriptSnippetSource): Promise<NativeTypeScriptProgram> => {
     source.signal?.throwIfAborted();
-    if (!source.code.trim()) throw new Error("Das TypeScript-Snippet darf nicht leer sein.");
+    if (!source.code.trim()) throw new Error("The TypeScript snippet must not be empty.");
     const compiled = await compileVirtualTypeScriptAsync({
         sources: [{ fileName: snippetFile, text: `export async function handle(_input: unknown, context: RunContext) {\n${source.code}\n}\n` }],
         declarations: [{ fileName: "snippet-context.d.ts", text: typeScriptSnippetDeclarations(source.capabilities) }],
@@ -77,7 +77,7 @@ export class TypeScriptSnippetExecutionError extends Error {
     readonly logs: readonly string[];
 
     constructor(cause: unknown, logs: readonly string[]) {
-        super(`TypeScript-Snippet fehlgeschlagen: ${cause instanceof Error ? cause.message : String(cause)}${logs.length > 0 ? `\nLogs vor dem Fehler:\n${logs.join("\n")}` : ""}`, { cause });
+        super(`TypeScript snippet failed: ${cause instanceof Error ? cause.message : String(cause)}${logs.length > 0 ? `\nLogs before the error:\n${logs.join("\n")}` : ""}`, { cause });
         this.name = "TypeScriptSnippetExecutionError";
         this.logs = [...logs];
     }
@@ -105,7 +105,7 @@ export const executeTypeScriptSnippet = async (execution: TypeScriptSnippetExecu
         });
         execution.signal?.throwIfAborted();
         const returned = output.result === undefined ? null : output.result;
-        assertJsonValue(returned, "TypeScript-Snippet result");
+        assertJsonValue(returned, "TypeScript snippet result");
         const result: JsonValue = JSON.parse(JSON.stringify(returned));
         return { result, logs };
     } catch (error) {
@@ -115,7 +115,7 @@ export const executeTypeScriptSnippet = async (execution: TypeScriptSnippetExecu
         try {
             await execution.executor.stopInstance(execution.context.runId, instanceId);
         } catch (error) {
-            if (failure) throw new AggregateError([failure, error], `${failure.message}\nDie Snippet-Instanz konnte nicht vollständig beendet werden: ${error instanceof Error ? error.message : String(error)}`);
+            if (failure) throw new AggregateError([failure, error], `${failure.message}\nThe snippet instance could not be terminated completely: ${error instanceof Error ? error.message : String(error)}`);
             throw new TypeScriptSnippetExecutionError(error, logs);
         }
     }

package/packages/workspace-executor/src/bash-launch.ts

@@ -2,39 +2,39 @@ import { accessSync, constants, existsSync, statSync } from "node:fs";
 import path from "node:path";
 import { getShellConfig } from "@ragents/agent";
 
-/** Ein Befehl des Werkzeugs bash, so wie er startet: Programm, Argumente und Umgebung. */
+/** A command of the bash tool as it starts: program, arguments and environment. */
 export interface BashLaunch {
   readonly command: string;
   readonly args: readonly string[];
   readonly env: NodeJS.ProcessEnv;
 }
 
-/** Was der Executor dem Werkzeug bash mitgibt: die Bash selbst und rg; ohne Angabe gilt jeweils das des Systems. */
+/** What the executor passes to the bash tool: bash itself and rg; without a value the system's one applies. */
 export interface BashPrograms {
   readonly bash: string | undefined;
   readonly rg: string | undefined;
 }
 
-/** Unter Windows sucht RAgents keine Bash; der Executor nennt die mitgebrachte. */
+/** On Windows RAgents does not search for a bash; the executor names the bundled one. */
 const missingWindowsBash = (): Error => new Error(
-  "Unter Windows arbeitet das Werkzeug bash nur mit der Bash, die RAgents mitbringt, und für diesen Executor ist keine genannt. "
-  + "Die VS-Code-Erweiterung bringt sie in ihrer Windows-Fassung (win32-x64, win32-arm64) unter dist/bash/<plattform>/usr/bin/bash.exe mit "
-  + "und reicht sie an Arbeitsplatz und lokalen Host weiter; ein Host oder Arbeitsplatz ohne Erweiterung braucht RAGENTS_BASH mit dem Pfad dieser bash.exe.",
+  "On Windows the bash tool only works with the bash that RAgents bundles, and none is named for this executor. "
+  + "The VS Code extension bundles it in its Windows build (win32-x64, win32-arm64) under dist/bash/<platform>/usr/bin/bash.exe "
+  + "and passes it on to the workspace and the local host; a host or workspace without the extension needs RAGENTS_BASH with the path of this bash.exe.",
 );
 
 const missingRipgrep = (rg: string): Error =>
-  new Error(`Das rg dieses Executors fehlt: ${rg}. Es gehört zur Erweiterung (dist/rg/<plattform>) oder steht in RAGENTS_RG.`);
+  new Error(`The rg of this executor is missing: ${rg}. It belongs to the extension (dist/rg/<platform>) or is set in RAGENTS_RG.`);
 
 const pathModule = (platform: NodeJS.Platform): path.PlatformPath => platform === "win32" ? path.win32 : path.posix;
 
-/** Die Namen der PATH-Variablen; unter Windows zählt jede Schreibweise (`Path`). */
+/** The names of the PATH variables; on Windows every spelling counts (`Path`). */
 const pathNames = (env: NodeJS.ProcessEnv, platform: NodeJS.Platform): readonly string[] =>
   platform === "win32" ? Object.keys(env).filter((name) => name.toUpperCase() === "PATH") : ["PATH"];
 
 const currentPath = (env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | undefined =>
   pathNames(env, platform).map((name) => env[name]).find((value) => value !== undefined && value !== "");
 
-/** Die Ordner vorn im PATH, als eine Variable PATH; MSYSTEM gehört unter Windows einer Git-Bash-Anmeldung und fällt weg. */
+/** The folders at the front of PATH, as one PATH variable; on Windows MSYSTEM belongs to a Git Bash login and is dropped. */
 const withPathFront = (env: NodeJS.ProcessEnv, directories: readonly string[], platform: NodeJS.Platform): NodeJS.ProcessEnv => {
   if (directories.length === 0) return env;
   const names = pathNames(env, platform);
@@ -53,7 +53,7 @@ const isExecutableFile = (file: string, platform: NodeJS.Platform): boolean => {
   }
 };
 
-/** Ob die Bash dieses Executors rg findet: das genannte, sonst eines im PATH; ein genanntes, das fehlt, ist ein Fehler. */
+/** Whether the bash of this executor finds rg: the named one, otherwise one in PATH; a named one that is missing is an error. */
 export const ripgrepAvailable = (rg: string | undefined, env: NodeJS.ProcessEnv, platform: NodeJS.Platform = process.platform): boolean => {
   if (rg !== undefined) {
     if (!existsSync(rg)) throw missingRipgrep(rg);
@@ -64,7 +64,7 @@ export const ripgrepAvailable = (rg: string | undefined, env: NodeJS.ProcessEnv,
     .some((directory) => isExecutableFile(path.join(directory, file), platform));
 };
 
-/** Wie ein Befehl in der Bash dieses Executors startet: das Verzeichnis von rg vorn im PATH, unter Windows dahinter das usr/bin der Bash, damit find.exe und sort.exe aus System32 nicht gewinnen. */
+/** How a command starts in the bash of this executor: the directory of rg at the front of PATH, on Windows followed by the usr/bin of the bash so that find.exe and sort.exe from System32 do not win. */
 export const bashLaunch = (
   { bash, rg }: BashPrograms,
   command: string,
@@ -73,11 +73,11 @@ export const bashLaunch = (
 ): BashLaunch => {
   if (platform === "win32" && bash === undefined) throw missingWindowsBash();
   if (bash !== undefined && !existsSync(bash)) {
-    throw new Error(`Die Bash dieses Executors fehlt: ${bash}. Unter Windows gehört sie zur Erweiterung (dist/bash/<plattform>) oder steht in RAGENTS_BASH.`);
+    throw new Error(`The bash of this executor is missing: ${bash}. On Windows it belongs to the extension (dist/bash/<platform>) or is set in RAGENTS_BASH.`);
   }
   if (rg !== undefined && !existsSync(rg)) throw missingRipgrep(rg);
   const shell = getShellConfig(bash, platform);
-  if (!/bash(\.exe)?$/i.test(shell.shell)) throw new Error(`${shell.shell} ist keine Bash; das Werkzeug heißt bash und der Prompt beschreibt bash`);
+  if (!/bash(\.exe)?$/i.test(shell.shell)) throw new Error(`${shell.shell} is not a bash; the tool is called bash and the prompt describes bash`);
   const paths = pathModule(platform);
   const front = [
     ...(rg === undefined ? [] : [paths.dirname(rg)]),