@schlenkr/ragents 0.1.10 → 0.1.11

package/plugins/ragents.ask/server/ask-tool.ts

@@ -5,22 +5,22 @@ import type { AskService } from "./contract.js";
 
 export const askToolMetadata = {
   name: "ask_user",
-  label: "Rückfrage",
-  description: "Holt eine nötige Benutzerentscheidung mit Antwortoptionen ein und wartet auf die Antwort.",
-  longDescription: "Nutze dieses Werkzeug immer, wenn du eine Entscheidung des Benutzers brauchst "
-    + "(z.B. Auswahl eines Branches oder eines Zeitraums), statt die Frage nur als Text zu stellen. "
-    + "Mit multi=true darf der Benutzer mehrere Optionen wählen; die Antwort ist dann mit '; ' verbunden. "
-    + "Der Benutzer kann statt einer Option auch immer frei antworten - rechne also damit, "
-    + "dass die Antwort beliebiger Text sein kann.",
+  label: "Question",
+  description: "Asks the user for a required decision with answer options and waits for the answer.",
+  longDescription: "Always use this tool when you need a decision from the user "
+    + "(e.g. choosing a branch or a time range), instead of only asking the question as text. "
+    + "With multi=true the user may choose several options; the answer is then joined with '; '. "
+    + "Instead of choosing an option, the user can always answer freely - so expect "
+    + "the answer to be arbitrary text.",
 } as const;
 
 export const createAskTool = (service: AskService): RunFunction =>
   defineRunFunction({
     ...askToolMetadata,
     schema: Type.Object({
-      question: Type.String({ description: "Die Frage an den Benutzer, kurz und konkret" }),
-      options: Type.Array(Type.String(), { description: "Antwortoptionen (2 bis 6 Stück)" }),
-      multi: Type.Optional(Type.Boolean({ description: "true = Mehrfachauswahl erlaubt" })),
+      question: Type.String({ description: "The question to the user, short and concrete" }),
+      options: Type.Array(Type.String(), { description: "Answer options (2 to 6)" }),
+      multi: Type.Optional(Type.Boolean({ description: "true = multiple choice allowed" })),
     }),
     resultSchema: Type.String(),
     available: facesOperator,

package/plugins/ragents.ask/server/contract.ts

@@ -1,11 +1,11 @@
 import { serviceToken, type ServiceToken } from "@ragents/engine";
 
-/** Die Antwort, die `ask` liefert, wenn der Benutzer die Frage verwirft. */
-export const DISMISSED_ANSWER = "Der Benutzer hat die Frage verworfen.";
+/** The answer `ask` returns when the user dismisses the question. */
+export const DISMISSED_ANSWER = "The user dismissed the question.";
 
 export interface AskCall {
   runId: string;
-  /** Wer fragt: ein Agent in seinem laufenden Turn, ohne Turn der Eigentümer des Runs. */
+  /** Who asks: an agent in its running turn, without a turn the run owner. */
   agentId: string;
   turnId: string | null;
   commandId: string;
@@ -17,13 +17,13 @@ export interface AskRequest {
   multi?: boolean;
   description?: string;
   parameters?: Record<string, string>;
-  /** Der Actor, dem eine Antwort zugeht, auf die niemand mehr wartet; ohne Angabe der Fragende. */
+  /** The actor that receives an answer nobody waits for anymore; if omitted, the asker. */
   recipient?: string;
 }
 
 export interface AskService {
   ask: (call: AskCall, request: AskRequest, signal: AbortSignal | undefined) => Promise<string>;
-  /** Verwirft eine offene Frage: ein wartender Aufruf bekommt DISMISSED_ANSWER, niemand bekommt einen Input. */
+  /** Dismisses an open question: a waiting call gets DISMISSED_ANSWER, nobody gets an input. */
   withdraw: (runId: string, actionId: string) => void;
 }
 

package/plugins/ragents.ask/web/AskActionView.tsx

@@ -26,7 +26,7 @@ export function AskActionView({ action, session, text }: ActionViewContext) {
         answer={action.status === undefined
           ? undefined
           : action.status === "approved" ? answerTextOf(action.result)
-          : supersedingInputOf(action.result) !== undefined ? SUPERSEDED_ANSWER : "Der Benutzer hat die Frage verworfen."}
+          : supersedingInputOf(action.result) !== undefined ? SUPERSEDED_ANSWER : "The user dismissed the question."}
         onAnswer={access.can("runs.write") ? answer : undefined}
         question={question}
         text={text}

package/plugins/ragents.ask/web/QuestionCard.tsx

@@ -7,8 +7,8 @@ const cardClasses = "gap-2.5 bg-background px-3.5 text-sm";
 const optionClasses = "h-auto w-full justify-start gap-2 px-3 py-1.5 text-left text-sm font-normal whitespace-normal";
 
 /**
- * Rückfrage-Karte: Optionen untereinander, wahlweise Einzel- oder Mehrfachauswahl
- * (question.multi), dazu immer eine freie Antwortzeile. Nach der Antwort nur noch Beleg.
+ * Question card: options stacked, either single or multiple choice
+ * (question.multi), plus always a free answer line. After the answer only the record remains.
  */
 export function QuestionCard({
   text,
@@ -21,8 +21,8 @@ export function QuestionCard({
   answer?: string;
   onAnswer?: (text: string) => void;
 }) {
-  const [gewaehlt, setGewaehlt] = useState<string[]>([]);
-  const [frei, setFrei] = useState("");
+  const [selected, setSelected] = useState<string[]>([]);
+  const [freeText, setFreeText] = useState("");
 
   if (answer !== undefined) {
     return (
@@ -45,13 +45,13 @@ export function QuestionCard({
     );
   }
 
-  const umschalten = (option: string) =>
-    setGewaehlt((bisher) =>
-      bisher.includes(option) ? bisher.filter((o) => o !== option) : [...bisher, option]);
+  const toggle = (option: string) =>
+    setSelected((previous) =>
+      previous.includes(option) ? previous.filter((o) => o !== option) : [...previous, option]);
 
-  const freiSenden = () => {
-    const wert = frei.trim();
-    if (wert) onAnswer(wert);
+  const sendFreeText = () => {
+    const value = freeText.trim();
+    if (value) onAnswer(value);
   };
 
   return (
@@ -61,15 +61,15 @@ export function QuestionCard({
         {question.options.map((option) =>
           question.multi ? (
             <Button
-              aria-pressed={gewaehlt.includes(option)}
+              aria-pressed={selected.includes(option)}
               className={cn(optionClasses, "aria-pressed:border-primary aria-pressed:bg-accent")}
               data-question="option"
               key={option}
-              onClick={() => umschalten(option)}
+              onClick={() => toggle(option)}
               variant="outline"
             >
               <span className="inline-flex size-3.5 flex-none items-center justify-center rounded-sm border border-border text-primary group-aria-pressed/button:border-primary">
-                {gewaehlt.includes(option) && <CheckIcon size={10} />}
+                {selected.includes(option) && <CheckIcon size={10} />}
               </span>
               {option}
             </Button>
@@ -83,25 +83,25 @@ export function QuestionCard({
       {question.multi && (
         <Button
           className="self-start"
-          disabled={gewaehlt.length === 0}
-          onClick={() => onAnswer(gewaehlt.join("; "))}
+          disabled={selected.length === 0}
+          onClick={() => onAnswer(selected.join("; "))}
           size="sm"
         >
-          Auswahl übernehmen
+          Apply selection
         </Button>
       )}
       <div className="flex gap-1.5">
         <Input
           className="flex-1"
-          onChange={(event) => setFrei(event.target.value)}
+          onChange={(event) => setFreeText(event.target.value)}
           onKeyDown={(event) => {
-            if (event.key === "Enter") freiSenden();
+            if (event.key === "Enter") sendFreeText();
           }}
-          placeholder="... oder frei antworten"
-          value={frei}
+          placeholder="... or answer freely"
+          value={freeText}
         />
-        <Button disabled={frei.trim() === ""} onClick={freiSenden} size="sm" variant="outline">
-          Antworten
+        <Button disabled={freeText.trim() === ""} onClick={sendFreeText} size="sm" variant="outline">
+          Answer
         </Button>
       </div>
     </Card>

package/plugins/ragents.ask/web/index.tsx

@@ -21,8 +21,8 @@ const attentionFor = (session: SessionContext) => {
   return {
     active: true as const,
     label: rest.length === 0
-      ? `@${askerHandle(view, askPayloadOf(first.payload)?.recipient ?? first.askedBy)} fragt`
-      : `${rest.length + 1} Rückfragen offen`,
+      ? `@${askerHandle(view, askPayloadOf(first.payload)?.recipient ?? first.askedBy)} asks`
+      : `${rest.length + 1} open questions`,
   };
 };
 

package/plugins/ragents.browser/executor/contract.ts

@@ -12,7 +12,7 @@ export const BROWSER_OPERATIONS = {
   close: "browser.close",
 } as const;
 
-/** Nennt einen eigenen Chrome; auf einem Server setzt ihn die Profilsektion `ragents.browser`, auf einem Arbeitsplatz seine Umgebung. */
+/** Names a custom Chrome; on a server the profile section `ragents.browser` sets it, on a workspace its environment. */
 export const BROWSER_EXECUTABLE_VARIABLE = "BROWSER_EXECUTABLE_PATH";
 
 export interface BrowserTarget {
@@ -48,23 +48,23 @@ export interface BrowserCheck {
   noErrors?: boolean;
 }
 
-/** Was eine bestandene Prüfung belegt; die Zeit setzt, wer die Evidenz des Runs hält. */
+/** What a passed check proves; the time is set by whoever holds the run's evidence. */
 export interface BrowserCheckResult {
   url: string;
   assertions: string[];
 }
 
-/** Der Stand der Seite nach einer Operation; der Aufrufer hält daraus die Evidenz des Runs. */
+/** The page state after an operation; the caller derives the run's evidence from it. */
 export interface BrowserPageState {
   url: string;
-  /** Seit der letzten Aktion oder Navigation hat eine Prüfung bestanden. */
+  /** A check has passed since the last action or navigation. */
   checked: boolean;
   errors: string[];
-  /** Die Kennungen der Aufnahmen seit der letzten Aktion oder Navigation, so wie der Aufrufer sie vergeben hat. */
+  /** The ids of the screenshots since the last action or navigation, as the caller assigned them. */
   screenshots: string[];
 }
 
-/** Das Ergebnis einer Operation an der Seite und der Stand, in dem sie die Seite hinterlässt. */
+/** The result of an operation on the page and the state it leaves the page in. */
 export interface BrowserStep<T> {
   result: T;
   page: BrowserPageState;

package/plugins/ragents.browser/executor/index.ts

@@ -1,5 +1,5 @@
 import type { WorkspaceExecutorContribution } from "@ragents/workspace-executor";
 import { browserModule } from "./module.js";
 
-/** Der Browser läuft dort, wo der Arbeitsbereich des Runs liegt: im Executor des Servers oder in dem des Arbeitsplatzes. */
+/** The browser runs where the run's workspace lives: in the server's executor or in the workspace's. */
 export const executor: WorkspaceExecutorContribution = (machine) => ({ modules: [browserModule(machine)] });

package/plugins/ragents.browser/executor/module.ts

@@ -7,33 +7,33 @@ import { launchChromium } from "./playwright.js";
 const BROWSER_TIMEOUT_MS = 15_000;
 
 export interface BrowserModuleOptions {
-  /** Startet den Browser eines Runs; ohne Angabe Chrome über playwright-core aus dem Host dieser Maschine. */
+  /** Starts a run's browser; if omitted, Chrome via playwright-core from this machine's host. */
   launch?: (runId: string) => Promise<Browser>;
   timeoutMs?: number;
   checkTimeoutMs?: number;
 }
 
-/** Der Browser eines Runs auf dieser Maschine: Seite, Aktionen, Prüfungen und Aufnahmen; Evidenz und Ablage hält der Aufrufer. */
+/** A run's browser on this machine: page, actions, checks and screenshots; the caller holds evidence and storage. */
 export const browserModule = (machine: WorkspaceExecutorMachine, options: BrowserModuleOptions = {}): WorkspaceModuleFactory => (host) => {
   const invalid = (message: string): Error => machine.operationError("browser-input-invalid", message, 400);
   const fieldsOf = (input: unknown): Readonly<Record<string, unknown>> => {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("Die Eingabe einer Browseroperation ist ein Objekt");
+    if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("The input of a browser operation is an object");
     return input as Readonly<Record<string, unknown>>;
   };
   const textOf = (input: unknown, key: string): string => {
     const value = fieldsOf(input)[key];
-    if (typeof value !== "string") throw invalid(`Die Browseroperation braucht ${key} als Text`);
+    if (typeof value !== "string") throw invalid(`The browser operation needs ${key} as text`);
     return value;
   };
   const targetOf = (input: unknown): BrowserTarget => {
     const value = fieldsOf(input).target;
-    if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("Die Browseroperation braucht ein Ziel");
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("The browser operation needs a target");
     return value as BrowserTarget;
   };
   const viewportOf = (input: unknown): BrowserViewport => {
     const { width, height } = fieldsOf(input);
     if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-      throw invalid("Ein Viewport braucht Breite und Höhe als positive ganze Zahlen");
+      throw invalid("A viewport needs width and height as positive integers");
     }
     return { width, height };
   };

package/plugins/ragents.browser/executor/pages.ts

@@ -17,7 +17,7 @@ interface BrowserSession {
   closed: boolean;
   checked: boolean;
   errors: string[];
-  /** Adressen, deren fehlgeschlagene Anfrage schon gemeldet ist; HTTP-Status, Konsole und Netzwerk melden dieselbe Ursache nur einmal. */
+  /** Addresses whose failed request is already reported; HTTP status, console and network report the same cause only once. */
   failedRequests: Set<string>;
   screenshots: string[];
 }
@@ -29,9 +29,9 @@ export interface BrowserPagesOptions {
 }
 
 const errorText = (error: unknown): string => error instanceof Error ? error.message : String(error);
-const endedError = (): Error => new Error("Der Browserdienst dieses Executors ist beendet.");
+const endedError = (): Error => new Error("The browser service of this executor has ended.");
 const maxSnapshotLength = 40_000;
-const ambiguityHint = "Wähle mit nth (0-basiert) oder first: true im Ziel einen Treffer, oder prüfe die Anzahl mit count in browser_check.";
+const ambiguityHint = "Pick one match with nth (0-based) or first: true in the target, or check the number with count in browser_check.";
 
 const withAmbiguityHint = (error: unknown): never => {
   if (error instanceof Error && error.message.includes("strict mode violation")) throw new Error(`${error.message}\n${ambiguityHint}`, { cause: error });
@@ -41,9 +41,9 @@ const withAmbiguityHint = (error: unknown): never => {
 export const browserLocator = (page: Page, target: BrowserTarget): Locator => {
   const selectors = [target.role, target.label, target.text, target.testId, target.css].filter((value) => value !== undefined);
   if (selectors.length !== 1 || (target.name !== undefined && target.role === undefined)) {
-    throw new Error("Ein Browserziel braucht genau role (optional name), label, text, testId oder css.");
+    throw new Error("A browser target needs exactly one of role (optional name), label, text, testId or css.");
   }
-  if (target.nth !== undefined && target.first) throw new Error("Ein Browserziel verwendet entweder nth oder first, nicht beides.");
+  if (target.nth !== undefined && target.first) throw new Error("A browser target uses either nth or first, not both.");
   const root = target.frame ? page.frameLocator(target.frame) : page;
   const base = target.role ? root.getByRole(target.role as Parameters<Page["getByRole"]>[0], { name: target.name, exact: true })
     : target.label ? root.getByLabel(target.label, { exact: true })
@@ -53,7 +53,7 @@ export const browserLocator = (page: Page, target: BrowserTarget): Locator => {
   return target.first ? base.first() : target.nth !== undefined ? base.nth(target.nth) : base;
 };
 
-/** Je Run ein Browser mit einer Seite auf dieser Maschine; die Aktionen eines Runs laufen der Reihe nach. */
+/** One browser with one page per run on this machine; a run's actions run one after another. */
 export class BrowserPages {
   readonly #options: BrowserPagesOptions;
   readonly #sessions = new Map<string, BrowserSession>();
@@ -66,13 +66,13 @@ export class BrowserPages {
   async open(runId: string, url: string, viewport: BrowserViewport, signal?: AbortSignal): Promise<BrowserStep<BrowserSnapshot>> {
     if (this.#shutDown) throw endedError();
     const parsed = new URL(url);
-    if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("browser_open braucht eine HTTP- oder HTTPS-Adresse.");
+    if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("browser_open needs an HTTP or HTTPS address.");
     signal?.throwIfAborted();
     if (!this.#sessions.has(runId)) this.#start(runId, viewport);
     return this.#perform(runId, signal, async (session, page) => {
       this.#resetEvidence(session);
       const response = await page.goto(parsed.href, { waitUntil: "domcontentloaded" });
-      if (response && !response.ok()) throw new Error(`Browsernavigation fehlgeschlagen: HTTP ${response.status()} (${page.url()}).`);
+      if (response && !response.ok()) throw new Error(`Browser navigation failed: HTTP ${response.status()} (${page.url()}).`);
       return this.#snapshot(session, page);
     });
   }
@@ -108,45 +108,45 @@ export class BrowserPages {
     return this.#perform(runId, signal, async (session, page) => {
       session.checked = false;
       if (!input.target && input.text === undefined && input.url === undefined && input.noErrors !== true) {
-        throw new Error("browser_check braucht mindestens target, text, url oder noErrors: true.");
+        throw new Error("browser_check needs at least target, text, url or noErrors: true.");
       }
       if (input.count !== undefined && (!input.target || input.target.nth !== undefined || input.target.first)) {
-        throw new Error("count in browser_check braucht ein target ohne nth oder first und zählt dessen sichtbare Treffer.");
+        throw new Error("count in browser_check needs a target without nth or first and counts its visible matches.");
       }
       const timeout = this.#options.checkTimeoutMs;
       const assertions: string[] = [];
       if (input.target && input.count !== undefined) {
         const visible = browserLocator(page, input.target).filter({ visible: true });
         const found = await this.#waitForCount(visible, input.count, timeout);
-        if (found !== input.count) throw new Error(`Erwartet ${input.count} sichtbare Treffer, gefunden ${found}.`);
-        assertions.push(`${input.count} sichtbare Treffer`);
+        if (found !== input.count) throw new Error(`Expected ${input.count} visible matches, found ${found}.`);
+        assertions.push(`${input.count} visible matches`);
       } else if (input.target) {
         const locator = browserLocator(page, input.target);
         await locator.waitFor({ state: "visible", timeout }).catch(withAmbiguityHint);
-        assertions.push("Ziel ist sichtbar");
+        assertions.push("Target is visible");
         if (input.text !== undefined) {
           try { await locator.filter({ hasText: input.text }).waitFor({ state: "visible", timeout }); }
-          catch (error) { throw new Error(`Erwarteter Text fehlt im Ziel: ${input.text}`, { cause: error }); }
-          assertions.push(`Text im Ziel: ${input.text}`);
+          catch (error) { throw new Error(`Expected text is missing in the target: ${input.text}`, { cause: error }); }
+          assertions.push(`Text in target: ${input.text}`);
         }
       } else if (input.text !== undefined) {
         await page.getByText(input.text, { exact: false }).first().waitFor({ state: "visible", timeout });
-        assertions.push(`Sichtbarer Text: ${input.text}`);
+        assertions.push(`Visible text: ${input.text}`);
       }
       if (input.url !== undefined) {
         await page.waitForURL(input.url, { timeout });
-        assertions.push(`Adresse: ${input.url}`);
+        assertions.push(`Address: ${input.url}`);
       }
       if (input.noErrors !== false) {
-        if (session.errors.length > 0) throw new Error(`Browserfehler: ${session.errors.join("\n")}`);
-        assertions.push("Keine erfassten Browser- oder Netzwerkfehler seit der Navigation");
+        if (session.errors.length > 0) throw new Error(`Browser errors: ${session.errors.join("\n")}`);
+        assertions.push("No captured browser or network errors since the navigation");
       }
       session.checked = true;
       return { url: page.url(), assertions };
     });
   }
 
-  /** Nimmt die Seite als PNG auf und liefert es Base64-kodiert; `id` merkt sich die Seite als aktuelle Aufnahme. */
+  /** Captures the page as PNG and returns it Base64-encoded; the page remembers `id` as the current screenshot. */
   screenshot(runId: string, id: string, fullPage: boolean, signal?: AbortSignal): Promise<BrowserStep<string>> {
     return this.#perform(runId, signal, async (session, page) => {
       const image = await page.screenshot({ fullPage, type: "png", timeout: this.#options.timeoutMs });
@@ -155,7 +155,7 @@ export class BrowserPages {
     });
   }
 
-  /** Der Stand der Seite, ohne auf laufende Aktionen zu warten; ohne offene Seite `null`. */
+  /** The page state without waiting for running actions; `null` without an open page. */
   state(runId: string): BrowserPageState | null {
     const session = this.#sessions.get(runId);
     return session && !session.closed && session.page ? this.#stateOf(session, session.page) : null;
@@ -171,7 +171,7 @@ export class BrowserPages {
     await session.queue;
   }
 
-  /** Schließt jeden Browser; danach startet keiner mehr, weil niemand ihn schließen würde. */
+  /** Closes every browser; afterwards none starts anymore because nobody would close it. */
   async shutdown(): Promise<void> {
     this.#shutDown = true;
     const results = await Promise.allSettled([...this.#sessions.keys()].map((runId) => this.close(runId)));
@@ -219,10 +219,10 @@ export class BrowserPages {
   }
 
   async #page(session: BrowserSession): Promise<Page> {
-    if (session.closed) throw new Error("Der Browser wurde beendet.");
+    if (session.closed) throw new Error("The browser was closed.");
     if (session.page) return session.page;
     const browser = await session.browser;
-    if (session.closed) throw new Error("Der Browser wurde beendet.");
+    if (session.closed) throw new Error("The browser was closed.");
     const context = await browser.newContext({ viewport: session.viewport });
     context.setDefaultTimeout(this.#options.timeoutMs);
     context.setDefaultNavigationTimeout(this.#options.timeoutMs);
@@ -239,16 +239,16 @@ export class BrowserPages {
     page.on("console", (message) => {
       if (message.type() !== "error") return;
       const source = message.text().startsWith("Failed to load resource") ? message.location().url : "";
-      if (source) addRequestError(source, `Konsole: ${message.text()} (${source})`);
-      else addError(`Konsole: ${message.text()}`);
+      if (source) addRequestError(source, `Console: ${message.text()} (${source})`);
+      else addError(`Console: ${message.text()}`);
     });
     page.on("pageerror", (error) => addError(`JavaScript: ${error.message}`));
-    page.on("requestfailed", (request) => addRequestError(request.url(), `Netzwerk: ${request.method()} ${request.url()} ${request.failure()?.errorText}`));
+    page.on("requestfailed", (request) => addRequestError(request.url(), `Network: ${request.method()} ${request.url()} ${request.failure()?.errorText}`));
     page.on("response", (response) => { if (response.status() >= 400) addRequestError(response.url(), `HTTP ${response.status()}: ${response.url()}`); });
     page.on("framenavigated", (frame) => { if (frame === page.mainFrame()) this.#resetEvidence(session); });
     page.on("popup", (popup) => {
-      addError(`Die Anwendung hat ein neues Fenster geöffnet: ${popup.url()}. Popups werden nicht bedient.`);
-      void popup.close().catch((error) => addError(`Fenster schließen: ${errorText(error)}`));
+      addError(`The application opened a new window: ${popup.url()}. Popups are not operated.`);
+      void popup.close().catch((error) => addError(`Closing window: ${errorText(error)}`));
     });
     session.page = page;
     return page;
@@ -257,17 +257,17 @@ export class BrowserPages {
   #perform<T>(runId: string, signal: AbortSignal | undefined, action: (session: BrowserSession, page: Page) => Promise<T>): Promise<BrowserStep<T>> {
     if (this.#shutDown) return Promise.reject(endedError());
     const session = this.#sessions.get(runId);
-    if (!session || session.closed) return Promise.reject(new Error("Für diesen Run ist kein Browser offen. Zuerst browser_open aufrufen."));
+    if (!session || session.closed) return Promise.reject(new Error("No browser is open for this run. Call browser_open first."));
     const pending = session.queue.then(async () => {
       signal?.throwIfAborted();
-      const abort = () => { void this.close(runId).catch((error) => console.error("Browserstopp fehlgeschlagen:", errorText(error))); };
+      const abort = () => { void this.close(runId).catch((error) => console.error("Browser stop failed:", errorText(error))); };
       signal?.addEventListener("abort", abort, { once: true });
       try {
         const page = await this.#page(session);
         signal?.throwIfAborted();
         const result = await action(session, page);
         signal?.throwIfAborted();
-        if (session.closed) throw new Error("Der Browser wurde beendet.");
+        if (session.closed) throw new Error("The browser was closed.");
         return { result, page: this.#stateOf(session, page) };
       } finally {
         signal?.removeEventListener("abort", abort);

package/plugins/ragents.browser/executor/playwright.ts

@@ -7,26 +7,26 @@ import { BROWSER_EXECUTABLE_VARIABLE } from "./contract.js";
 
 type Playwright = typeof import("playwright-core");
 
-/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Beitrag. */
+/** playwright-core lives in the node_modules of this machine's host and is loaded only on call, never with the contribution. */
 export const hostPlaywright = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined): Promise<Playwright> => {
   const loaded = await import(pathToFileURL(machine.hostPackageFile(hostRoot, "playwright-core")).href) as { default: Playwright };
   return loaded.default;
 };
 
-/** Der Chrome dieser Maschine: der aus ihrer Umgebung, sonst das Chromium, das die Provisionierung für playwright-core holt. */
+/** This machine's Chrome: the one from its environment, otherwise the Chromium that provisioning fetches for playwright-core. */
 export const browserExecutable = async (playwright: Playwright, environment: NodeJS.ProcessEnv = process.env): Promise<string> => {
   const configured = environment[BROWSER_EXECUTABLE_VARIABLE];
   const candidate = configured ? configured : playwright.chromium.executablePath();
   if (await access(candidate, constants.X_OK).then(() => true, () => false)) return candidate;
   throw new Error((configured
-    ? `${BROWSER_EXECUTABLE_VARIABLE} nennt ${configured}; dort gibt es auf diesem Rechner keinen ausführbaren Browser. `
-    : `Auf diesem Rechner gibt es keinen ausführbaren Browser: ${BROWSER_EXECUTABLE_VARIABLE} ist nicht gesetzt und Chromium fehlt unter ${candidate}. `)
-    + "Ein Arbeitsplatz holt Chromium mit pnpm provision --workspace, ein Server mit pnpm provision <profil>; "
-    + `${BROWSER_EXECUTABLE_VARIABLE} nennt einen vorhandenen Chrome, auf einem Server in der Profilsektion ragents.browser, `
-    + "auf einem Arbeitsplatz in seiner Umgebung.");
+    ? `${BROWSER_EXECUTABLE_VARIABLE} names ${configured}; there is no executable browser there on this machine. `
+    : `There is no executable browser on this machine: ${BROWSER_EXECUTABLE_VARIABLE} is not set and Chromium is missing at ${candidate}. `)
+    + "A workspace fetches Chromium with pnpm provision --workspace, a server with pnpm provision <profile>; "
+    + `${BROWSER_EXECUTABLE_VARIABLE} names an existing Chrome, on a server in the profile section ragents.browser, `
+    + "on a workspace in its environment.");
 };
 
-/** Startet Chrome headless mit der Umgebung dieser Maschine und dem Marker des Runs, damit die Prozessanzeige ihn zuordnet. */
+/** Starts Chrome headless with this machine's environment and the run's marker so the process view can attribute it. */
 export const launchChromium = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
   const playwright = await hostPlaywright(machine, hostRoot);
   return playwright.chromium.launch({

package/plugins/ragents.browser/provision.ts

@@ -18,30 +18,30 @@ const install = (log: (line: string) => void): Promise<void> => new Promise((res
   const child = spawn(process.execPath, [playwrightCli(), "install", ...(process.platform === "linux" ? ["--with-deps"] : []), "chromium"], { stdio: ["ignore", "pipe", "pipe"] });
   for (const stream of [child.stdout, child.stderr]) stream.on("data", (chunk: Buffer) => log(chunk.toString().trimEnd()));
   child.once("error", reject);
-  child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`playwright-core install chromium endete mit Code ${code}`)));
+  child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`playwright-core install chromium exited with code ${code}`)));
 });
 
-// Playwright verwaltet seinen Browsercache selbst; der Werkzeugordner des Plugins bleibt leer.
+// Playwright manages its browser cache itself; the plugin's tool folder stays empty.
 export const createBrowserProvision = (): PluginProvision => ({
   check: async () => {
     const configured = process.env[BROWSER_EXECUTABLE_VARIABLE];
     if (configured) {
       return await executable(configured)
         ? provisionReady
-        : provisionGap("browser", `${BROWSER_EXECUTABLE_VARIABLE} nennt ${configured}; dort gibt es keinen ausführbaren Browser`, false);
+        : provisionGap("browser", `${BROWSER_EXECUTABLE_VARIABLE} names ${configured}; there is no executable browser there`, false);
     }
     const bundled = chromium.executablePath();
     return await executable(bundled)
       ? provisionReady
-      : provisionGap("chromium", `Chromium fehlt unter ${bundled}; entweder ${BROWSER_EXECUTABLE_VARIABLE} auf einen vorhandenen Chrome `
-        + "setzen (auf einem Server in der Profilsektion ragents.browser, auf einem Arbeitsplatz in seiner Umgebung) oder die "
-        + "Provisionierung den Browser laden lassen", true);
+      : provisionGap("chromium", `Chromium is missing at ${bundled}; either set ${BROWSER_EXECUTABLE_VARIABLE} to an existing Chrome `
+        + "(on a server in the profile section ragents.browser, on a workspace in its environment) or let "
+        + "provisioning download the browser", true);
   },
   apply: async (_target, log) => {
     const state = await createBrowserProvision().check("");
     if (state.kind === "ready") return;
     if (!state.installable) throw new Error(state.instruction);
-    log("Chromium für playwright-core laden");
+    log("Downloading Chromium for playwright-core");
     await install(log);
   },
 });