@schlenkr/ragents 0.1.10 → 0.1.11

package/packages/ragents/src/plugin-types.ts

@@ -278,11 +278,11 @@ export interface PromptContribution {
   delivery?: "initial" | "on-demand";
   requiresTools?: readonly string[];
   render: (context: PromptRenderContext) => string | Promise<string>;
-  /** Hängt der Beitrag am einzelnen Run, ersetzt dieser Text den von `render`, undefined behält ihn - synchron, damit der Turn ihn ohne Warten hat. */
+  /** If the contribution depends on the individual run, this text replaces the one from `render`, undefined keeps it - synchronous so the turn has it without waiting. */
   renderForRun?: (runId: string) => string | undefined;
 }
 
-/** Ob die laufbezogenen Beiträge eines Plugins in einem Run gelten; der Host fragt je Run, ein Wurf lässt dessen Turn mit dieser Ursache scheitern. */
+/** Whether the run-related contributions of a plugin apply in a run; the host asks per run, a throw fails its turn with this cause. */
 export type RunCondition = (runId: string) => boolean;
 
 export type ModelProviderConfig = Parameters<ModelRuntime["registerProvider"]>[1];
@@ -296,7 +296,7 @@ export interface ProfileContribution {
   id: string;
   models: () => readonly CatalogModel[];
   profiles: () => readonly AgentProfile[];
-  /** Zusätzliche Modellanbieter, vor dem ersten Modellzugriff in der Modelllaufzeit registriert. */
+  /** Additional model providers, registered in the model runtime before the first model access. */
   providers?: () => readonly ModelProviderRegistration[] | Promise<readonly ModelProviderRegistration[]>;
 }
 
@@ -347,7 +347,7 @@ export interface SessionMetadataContext {
 
 export interface StartOptionContext {
   runId: string;
-  /** Der Benutzer, der gerade handelt: aus dem Zugang der Anfrage, null ohne Anmeldung. */
+  /** The user currently acting: from the access of the request, null without sign-in. */
   userId: string | null;
 }
 
@@ -358,11 +358,11 @@ export interface StartOptionContribution {
   defaultValue: (context: StartOptionContext) => JsonValue;
   accept: (value: JsonValue, context: StartOptionContext) => JsonValue;
   describe: (value: JsonValue, context: StartOptionContext) => JsonValue;
-  /** Zusätzliche Rechte, ohne die Liste und Wahl die Option nicht anbieten, etwa runs.inspect für technische Einsicht. */
+  /** Additional rights without which list and choice do not offer the option, such as runs.inspect for technical insight. */
   rights?: readonly string[];
-  /** Nach dem Start weiter wählbar: der Host schreibt jeden neuen Wert ins Journal, wer die Option liest, folgt dem jeweils gespeicherten. */
+  /** Still selectable after the start: the host writes every new value to the journal, whoever reads the option follows the currently stored one. */
   changeable?: boolean;
-  /** Ob nur der Eigentümer einen Run mit diesem Wert bedient; lesen und stoppen dürfen ihn alle, die ihn sehen. */
+  /** Whether only the owner operates a run with this value; everyone who sees it may read and stop it. */
   ownerOnly?: (value: JsonValue) => boolean;
 }
 
@@ -371,30 +371,30 @@ export interface RegisteredStartOption {
   option: StartOptionContribution;
 }
 
-/** Ein Chat-Ereignis zu einem Plugin-Zustand, ohne die Kennung, die die Projektion schon nennt. */
+/** A chat event for a plugin state, without the id that the projection already names. */
 export interface PluginChatEvent {
   type: string;
   payload?: unknown;
 }
 
-/** Was ein Zugang ohne runs.inspect von einem Plugin-Zustand und dessen Chat-Ereignissen sieht; ohne Projektion sieht er beides unverändert. */
+/** What an access without runs.inspect sees of a plugin state and its chat events; without a projection it sees both unchanged. */
 export interface AccessProjectionContribution {
-  /** Die Kennung des Zustands, wie sie im Journal (`pluginId`) und im Chat-Ereignis steht. */
+  /** The id of the state as it appears in the journal (`pluginId`) and in the chat event. */
   id: string;
-  /** Der sichtbare Zustand; undefined nimmt ihn aus der Run-Ansicht. */
+  /** The visible state; undefined removes it from the run view. */
   state: (entry: PluginState) => JsonValue | undefined;
-  /** Das sichtbare Chat-Ereignis; undefined unterdrückt es. */
+  /** The visible chat event; undefined suppresses it. */
   chatEvent: (event: PluginChatEvent) => PluginChatEvent | undefined;
 }
 
 export interface SessionMetadataContribution {
   id: string;
-  /** Ob `describe` den Arbeitsbereich des Runs erreicht; dann ruft der Host es nur für Aufrufer, die ihn erreichen dürfen. */
+  /** Whether `describe` reaches the workspace of the run; then the host calls it only for callers that may reach it. */
   requiresWorkspace?: boolean;
   describe: (context: SessionMetadataContext) => unknown | Promise<unknown>;
 }
 
-/** Die Angaben eines Runs je Beitrag; ein Beitrag ohne Wert steht mit seinem Grund in `unavailable`. */
+/** The details of a run per contribution; a contribution without a value appears with its reason in `unavailable`. */
 export interface SessionMetadata {
   readonly values: Readonly<Record<string, unknown>>;
   readonly unavailable: Readonly<Record<string, string>>;
@@ -440,7 +440,7 @@ export interface PluginRegistration {
   agentRuntime: (...contributions: readonly AgentContribution[]) => void;
   profiles: (...contributions: readonly ProfileContribution[]) => void;
   prompts: (...contributions: readonly PromptContribution[]) => void;
-  /** Prompts, Funktionen, Skills und Agent-Hooks dieses Plugins gelten nur in Runs, für die die Bedingung zutrifft; höchstens eine je Plugin. */
+  /** Prompts, functions, skills and agent hooks of this plugin apply only in runs for which the condition holds; at most one per plugin. */
   runCondition: (condition: RunCondition) => void;
   provide: <T>(token: ServiceToken<T>, service: T) => void;
   service: <T>(token: ServiceToken<T>) => T;
@@ -449,7 +449,7 @@ export interface PluginRegistration {
   skills: (...contributions: readonly SkillContribution[]) => void;
   startEntries: (...contributions: readonly StartEntryContribution[]) => void;
   startOptions: (...contributions: readonly StartOptionContribution[]) => void;
-  /** Wie Zugänge ohne runs.inspect die Zustände dieses Plugins und ihre Chat-Ereignisse sehen, je Kennung eines Zustands. */
+  /** How accesses without runs.inspect see the states of this plugin and their chat events, per state id. */
   accessProjections: (...contributions: readonly AccessProjectionContribution[]) => void;
   functions: (...functions: readonly (RunFunction | ToolContributor)[]) => void;
   script: (...contributions: readonly ScriptContribution[]) => void;

package/packages/ragents/src/rpc/contract.ts

@@ -1,6 +1,6 @@
 import type { Static, TSchema } from "typebox";
 
-/** Eine Anfrage mit Antwort; der Server führt sie aus, oder ein verbundener Client, wenn `implementedBy` das sagt. */
+/** A request with a response; the server executes it, or a connected client if `implementedBy` says so. */
 export interface OperationContract<I extends TSchema = TSchema, R extends TSchema = TSchema> {
   readonly kind: "operation";
   readonly id: string;
@@ -11,7 +11,7 @@ export interface OperationContract<I extends TSchema = TSchema, R extends TSchem
   readonly implementedBy: "server" | "client";
 }
 
-/** Ein Kanal liefert nach dem Abonnieren Nachrichten, bis das Abonnement endet. */
+/** After subscribing, a channel delivers messages until the subscription ends. */
 export interface ChannelContract<P extends TSchema = TSchema, M extends TSchema = TSchema> {
   readonly kind: "channel";
   readonly id: string;
@@ -32,7 +32,7 @@ export type ChannelMessage<C> = C extends ChannelContract<TSchema, infer M> ? St
 export const CONTRACT_ID = /^[a-z][a-z0-9-]*(?:\.[a-zA-Z][a-zA-Z0-9-]*)+$/;
 
 const assertContractId = (id: string): void => {
-  if (!CONTRACT_ID.test(id)) throw new Error(`Ungültige Vertrags-Id: ${id}`);
+  if (!CONTRACT_ID.test(id)) throw new Error(`Invalid contract id: ${id}`);
 };
 
 export const defineOperation = <I extends TSchema, R extends TSchema>(definition: {
@@ -44,7 +44,7 @@ export const defineOperation = <I extends TSchema, R extends TSchema>(definition
   implementedBy?: "server" | "client";
 }): OperationContract<I, R> => {
   assertContractId(definition.id);
-  if (!definition.description.trim()) throw new Error(`Operation ${definition.id} hat keine Beschreibung`);
+  if (!definition.description.trim()) throw new Error(`Operation ${definition.id} has no description`);
   return Object.freeze({
     kind: "operation",
     id: definition.id,
@@ -64,7 +64,7 @@ export const defineChannel = <P extends TSchema, M extends TSchema>(definition:
   message: M;
 }): ChannelContract<P, M> => {
   assertContractId(definition.id);
-  if (!definition.description.trim()) throw new Error(`Kanal ${definition.id} hat keine Beschreibung`);
+  if (!definition.description.trim()) throw new Error(`Channel ${definition.id} has no description`);
   return Object.freeze({
     kind: "channel",
     id: definition.id,

package/packages/ragents/src/rpc/contribution.ts

@@ -4,11 +4,11 @@ import type { JsonValue } from "../domain/json.ts";
 import type { ChannelContract, OperationContract, OperationInput, OperationResult } from "./contract.ts";
 import type { RpcCallOptions } from "./peer.ts";
 
-/** Die Verbindung, über die eine Anfrage kam; der Server ruft darüber auch den Client. */
+/** The connection a request came through; the server also calls the client through it. */
 export interface MethodConnection {
   readonly id: string;
   readonly userId: string | null;
-  /** Ohne Ereignisstrom kann der Server diese Verbindung nicht zurückrufen. */
+  /** Without an event stream the server cannot call back over this connection. */
   readonly streamless: boolean;
   call: <C extends OperationContract>(contract: C, input: OperationInput<C>, options?: RpcCallOptions) => Promise<OperationResult<C>>;
   onClose: (listener: () => void) => () => void;

package/packages/ragents/src/rpc/peer.ts

@@ -48,13 +48,13 @@ const CANCEL_GRACE_MS = 5_000;
 export const rpcFailureOf = (id: RpcId | null, error: unknown): RpcFailure => {
   if (error instanceof RpcError) return rpcFailure(id, error.code, error.message, error.data);
   if (error instanceof DomainError) return rpcFailure(id, RPC_ERROR_CODES.application, error.message, { code: error.code, status: error.status });
-  if (error instanceof Error && error.name === "AbortError") return rpcFailure(id, RPC_ERROR_CODES.cancelled, "Abgebrochen");
+  if (error instanceof Error && error.name === "AbortError") return rpcFailure(id, RPC_ERROR_CODES.cancelled, "Cancelled");
   return rpcFailure(id, RPC_ERROR_CODES.internal, error instanceof Error ? error.message : String(error));
 };
 
 export const rpcErrorOf = (failure: RpcFailure): RpcError => new RpcError(failure.error.code, failure.error.message, failure.error.data);
 
-/** Eine Seite einer JSON-RPC-Verbindung: schickt und beantwortet Anfragen, kennt Abbruch und Fortschritt, ohne Transport. */
+/** One side of a JSON-RPC connection: sends and answers requests, knows cancellation and progress, without transport. */
 export class RpcPeer {
   readonly #send: RpcPeerOptions["send"];
   readonly #pending = new Map<RpcId, PendingCall>();
@@ -75,17 +75,17 @@ export class RpcPeer {
 
   request(method: string, params: unknown, options: RpcCallOptions = {}): Promise<unknown> {
     if (this.#closed !== undefined) return Promise.reject(new RpcError(RPC_ERROR_CODES.connectionClosed, this.#closed));
-    if (options.signal?.aborted) return Promise.reject(new RpcError(RPC_ERROR_CODES.cancelled, "Abgebrochen"));
+    if (options.signal?.aborted) return Promise.reject(new RpcError(RPC_ERROR_CODES.cancelled, "Cancelled"));
     const id = this.#nextId++;
     return new Promise((resolve, reject) => {
       let grace: ReturnType<typeof setTimeout> | undefined;
       const timer = options.timeoutMs === undefined ? undefined : setTimeout(() => {
         this.notify(RPC_METHODS.cancel, { id } satisfies RpcCancelParams);
-        settle({ error: new RpcError(RPC_ERROR_CODES.timeout, `Keine Antwort auf ${method} innerhalb von ${options.timeoutMs} ms`) });
+        settle({ error: new RpcError(RPC_ERROR_CODES.timeout, `No response to ${method} within ${options.timeoutMs} ms`) });
       }, options.timeoutMs);
       const cancel = () => {
         this.notify(RPC_METHODS.cancel, { id } satisfies RpcCancelParams);
-        grace = setTimeout(() => settle({ error: new RpcError(RPC_ERROR_CODES.cancelled, "Abgebrochen") }), CANCEL_GRACE_MS);
+        grace = setTimeout(() => settle({ error: new RpcError(RPC_ERROR_CODES.cancelled, "Cancelled") }), CANCEL_GRACE_MS);
       };
       const settle: PendingCall["settle"] = (outcome) => {
         if (!this.#pending.delete(id)) return;
@@ -108,18 +108,18 @@ export class RpcPeer {
   }
 
   onRequest(method: string, handler: RpcRequestHandler): () => void {
-    if (this.#requestHandlers.has(method)) throw new Error(`Die Methode ${method} hat bereits einen Handler`);
+    if (this.#requestHandlers.has(method)) throw new Error(`The method ${method} already has a handler`);
     this.#requestHandlers.set(method, handler);
     return () => { if (this.#requestHandlers.get(method) === handler) this.#requestHandlers.delete(method); };
   }
 
   onNotification(method: string, handler: RpcNotificationHandler): () => void {
-    if (this.#notificationHandlers.has(method)) throw new Error(`Die Benachrichtigung ${method} hat bereits einen Handler`);
+    if (this.#notificationHandlers.has(method)) throw new Error(`The notification ${method} already has a handler`);
     this.#notificationHandlers.set(method, handler);
     return () => { if (this.#notificationHandlers.get(method) === handler) this.#notificationHandlers.delete(method); };
   }
 
-  /** Bearbeitet jede Anfrage ohne eigenen Handler, etwa der Dispatcher des Servers. */
+  /** Handles every request without its own handler, such as the dispatcher of the server. */
   fallback(handler: RpcFallbackHandler | undefined): void {
     this.#fallback = handler;
   }
@@ -152,10 +152,10 @@ export class RpcPeer {
       else pending.settle({ result: message.result });
       return;
     }
-    void this.#deliver(rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "Die Nachricht ist kein gültiges JSON-RPC")).catch(() => undefined);
+    void this.#deliver(rpcFailure(null, RPC_ERROR_CODES.invalidRequest, "The message is not valid JSON-RPC")).catch(() => undefined);
   }
 
-  /** Bricht alle laufenden Handler ab, etwa wenn der Strom weg ist, über den ihre Antwort ginge; eigene Aufrufe bleiben möglich. */
+  /** Cancels all running handlers, for example when the stream their response would go through is gone; own calls stay possible. */
   cancelIncoming(): void {
     for (const controller of this.#running.values()) controller.abort();
     this.#running.clear();
@@ -203,7 +203,7 @@ export class RpcPeer {
         ? await handler(request.params, context)
         : this.#fallback
           ? await this.#fallback(request.method, request.params, context)
-          : (() => { throw new RpcError(RPC_ERROR_CODES.methodNotFound, `Unbekannte Methode: ${request.method}`); })();
+          : (() => { throw new RpcError(RPC_ERROR_CODES.methodNotFound, `Unknown method: ${request.method}`); })();
       if (this.#closed === undefined) await this.#deliver({ jsonrpc: "2.0", id: request.id, result: result === undefined ? null : result });
     } catch (error) {
       if (this.#closed === undefined) await this.#deliver(rpcFailureOf(request.id, error)).catch(() => undefined);

package/packages/ragents/src/rpc/protocol.ts

@@ -47,7 +47,7 @@ export const RPC_ERROR_CODES = Object.freeze({
   timeout: -32003,
 });
 
-/** Feste Methoden der Nachrichtenschicht; alles andere sind registrierte Verträge. */
+/** Fixed methods of the message layer; everything else is a registered contract. */
 export const RPC_METHODS = Object.freeze({
   subscribe: "rpc.subscribe",
   unsubscribe: "rpc.unsubscribe",
@@ -84,7 +84,7 @@ export interface RpcProgressParams {
   value: unknown;
 }
 
-/** Ein Fehler der Gegenseite oder des Transports; `data` trägt bei Fachfehlern `code` und `status`. */
+/** An error of the other side or of the transport; for domain errors `data` carries `code` and `status`. */
 export class RpcError extends Error {
   readonly code: number;
   readonly data: unknown;

package/packages/ragents/src/runtime/decisions/turns.ts

@@ -202,7 +202,7 @@ export const recordToolCallSource =
         return [event(context, { type: "tool.call.source", payload: input })];
     };
 
-const failureText = (error: string | null | undefined) => error?.trim() || "Fehler ohne Ursache";
+const failureText = (error: string | null | undefined) => error?.trim() || "Error without a cause";
 
 export const failToolCall =
     (actorId: string, input: { turnId: string; toolCallId: string; name: string; error: string }): Decision =>

package/packages/ragents/src/runtime/journal.ts

@@ -159,7 +159,7 @@ const staleLockReason = (lockPath: string, staleAfterMs: number): string | null
     const owners = readdirSync(lockPath).filter((name) => name.startsWith("owner-") && name.endsWith(".json"));
 
     if (owners.length === 0)
-        return "kein Besitzer eingetragen";
+        return "no owner recorded";
 
     if (owners.length > 1)
         return null;
@@ -176,7 +176,7 @@ const staleLockReason = (lockPath: string, staleAfterMs: number): string | null
     const sameHost = typeof owner.hostname !== "string" || owner.hostname === hostname();
 
     if (sameHost && pid !== null && !processAlive(pid))
-        return `Prozess ${pid} lebt nicht mehr`;
+        return `process ${pid} is no longer alive`;
 
     const lastSeen = typeof owner.heartbeatAt === "string"
         ? owner.heartbeatAt
@@ -186,9 +186,9 @@ const staleLockReason = (lockPath: string, staleAfterMs: number): string | null
     if (!Number.isFinite(age) || age <= staleAfterMs)
         return null;
 
-    const who = sameHost ? `Prozess ${pid ?? "?"}` : `Prozess ${pid ?? "?"} auf ${String(owner.hostname)}`;
+    const who = sameHost ? `process ${pid ?? "?"}` : `process ${pid ?? "?"} on ${String(owner.hostname)}`;
 
-    return `${who} ohne Herzschlag seit ${Math.round(age / 1000)} s`;
+    return `${who} without heartbeat for ${Math.round(age / 1000)} s`;
 };
 
 const assertRunId = (runId: string) => {
@@ -280,7 +280,7 @@ export class Journal {
         this.#path = path === ":memory:" ? null : path;
         this.#services = services;
         this.#onListenerError = options.onListenerError ?? ((error) => console.error("Journal listener failed:", error));
-        this.#onLoadError = options.onLoadError ?? ((failure) => console.error(`Journal ${failure.runId} (${failure.path}) ist nicht verfügbar: ${failure.message}`));
+        this.#onLoadError = options.onLoadError ?? ((failure) => console.error(`Journal ${failure.runId} (${failure.path}) is not available: ${failure.message}`));
         this.#onStaleLock = options.onStaleLock ?? ((message) => console.warn(message));
         this.#heartbeatIntervalMs = options.writerHeartbeatIntervalMs ?? writerHeartbeatIntervalMs;
         this.#staleAfterMs = options.writerStaleAfterMs ?? writerStaleAfterMs;
@@ -367,7 +367,7 @@ export class Journal {
         const failure = this.failureOf(runId);
 
         if (failure)
-            throw new DomainError("journal-unavailable", `Journal für Run ${runId} ist nicht verfügbar: ${failure.message}`, 409);
+            throw new DomainError("journal-unavailable", `Journal for run ${runId} is not available: ${failure.message}`, 409);
     }
 
     load(runId: RunId) {
@@ -832,7 +832,7 @@ export class Journal {
                 try {
                     this.#onLoadError(failure);
                 } catch (reportError) {
-                    console.error(`Journal ${runId} (${path}) ist nicht verfügbar: ${failure.message}`, reportError);
+                    console.error(`Journal ${runId} (${path}) is not available: ${failure.message}`, reportError);
                 }
             }
         }
@@ -867,7 +867,7 @@ export class Journal {
 
     #assertLockHeld() {
         if (this.#lockLost)
-            throw new Error("Das Journal-Lock wurde von außen entfernt; dieses Journal nimmt keine Schreibvorgänge mehr an.");
+            throw new Error("The journal lock was removed from outside; this journal no longer accepts writes.");
     }
 
     #releaseWriterLock() {
@@ -920,7 +920,7 @@ export class Journal {
                 );
 
             removeLock(lockPath);
-            this.#onStaleLock(`Verwaistes Journal-Lock ${lockPath} übernommen: ${reason}.`);
+            this.#onStaleLock(`Took over orphaned journal lock ${lockPath}: ${reason}.`);
 
             if (!createLockDirectory(lockPath))
                 throw new Error(`Another runtime process took ${lockPath} while its stale lock was being replaced.`);
@@ -976,7 +976,7 @@ export class Journal {
                 this.#heartbeat = null;
             }
 
-            this.#onStaleLock(`Das Journal-Lock ${ownerPath} wurde von außen entfernt; dieses Journal nimmt keine Schreibvorgänge mehr an.`);
+            this.#onStaleLock(`The journal lock ${ownerPath} was removed from outside; this journal no longer accepts writes.`);
 
             return;
         }

package/packages/ragents/src/runtime/orchestration.ts

@@ -98,13 +98,13 @@ export class Orchestration {
 
     get actorPrograms() {
         const programs = this.#services.actorPrograms;
-        if (!programs) throw new Error("Für diese Laufzeit fehlt der Actor-Program-Executor.");
+        if (!programs) throw new Error("The actor program executor is missing for this runtime.");
         return programs;
     }
 
     get nativeTypeScriptExecutor() {
         const executor = this.#services.nativeTypeScriptExecutor;
-        if (!executor) throw new Error("Für diese Laufzeit fehlt der native TypeScript-Executor.");
+        if (!executor) throw new Error("The native TypeScript executor is missing for this runtime.");
         return executor;
     }
 
@@ -169,7 +169,7 @@ export class Orchestration {
             title: string;
             ownerHandle: string;
             ownerDisplayName: string;
-            /** Der angemeldete Benutzer, dem der Run gehört; ohne Anmeldung bleibt er offen. */
+            /** The signed-in user who owns the run; without sign-in it stays open. */
             ownerUserId?: string;
             runId?: string;
             initialPluginStates?: readonly { pluginId: string; state: JsonValue }[];
@@ -764,9 +764,9 @@ export class Orchestration {
                 continue;
 
             const content = alert.kind === "failed"
-                ? `[Automatische Meldung] Der Turn deines Actors @${child.handle} ist GESCHEITERT: ${alert.reason} `
-                    + "Prüfe den Zustand mit event_query und entscheide: neu beauftragen, reparieren oder stoppen."
-                : `[Automatische Meldung] Der Turn deines Actors @${child.handle} wurde unterbrochen: ${alert.reason}`;
+                ? `[Automatic notice] The turn of your actor @${child.handle} FAILED: ${alert.reason} `
+                    + "Check the state with event_query and decide: delegate again, repair or stop."
+                : `[Automatic notice] The turn of your actor @${child.handle} was interrupted: ${alert.reason}`;
 
             try {
                 this.enqueueInput(
@@ -843,7 +843,7 @@ export class Orchestration {
                         actor.id,
                         {
                             turnId: actor.lifecycle.turnId,
-                            reason: "Der Turn wurde durch einen Neustart der Runtime unterbrochen.",
+                            reason: "The turn was interrupted by a restart of the runtime.",
                         },
                     );
                 }
@@ -851,7 +851,7 @@ export class Orchestration {
                 if (!this.#journal.failureOf(runId))
                     throw error;
 
-                console.error(`Run ${runId} konnte beim Neustart nicht wiederhergestellt werden:`, error);
+                console.error(`Run ${runId} could not be restored on restart:`, error);
             }
         }
     }

package/packages/ragents/src/runtime/stop.ts

@@ -120,7 +120,7 @@ export class RunStopper {
         const journalFailures = journalResults
             .filter((result): result is PromiseRejectedResult => result.status === "rejected")
             .map((result) => result.reason);
-        throwFailures([boundaryFailure, ...journalFailures].filter((failure) => failure !== null), `Der Run ${runId} konnte nicht vollständig gestoppt werden.`);
+        throwFailures([boundaryFailure, ...journalFailures].filter((failure) => failure !== null), `The run ${runId} could not be stopped completely.`);
 
         return runtime.view(runId);
     }
@@ -156,6 +156,6 @@ export class RunStopper {
             failures.push(cleanupResult[0].reason);
 
         stopOwnedActors("after-cleanup");
-        throwFailures(failures, `Der Run ${runId} konnte nicht vollständig gestoppt werden.`);
+        throwFailures(failures, `The run ${runId} could not be stopped completely.`);
     }
 }