@schlenkr/ragents 0.1.9 → 0.1.11

package/apps/server/src/plugin-support/actor-programs/client-compiler.ts

@@ -34,7 +34,7 @@ const actionMap = (actions: readonly ClientActionContract[]): string => {
   const fields = [...actions]
     .sort((left, right) => left.id.localeCompare(right.id))
     .map((action) => {
-      if (seen.has(action.id)) throw new Error(`App-Aktion ${action.id} ist doppelt deklariert.`);
+      if (seen.has(action.id)) throw new Error(`App action ${action.id} is declared twice.`);
       seen.add(action.id);
       return [
         `  readonly ${JSON.stringify(action.id)}: {`,
@@ -81,7 +81,7 @@ export const clientApiDeclarations = (): string => clientTypeDeclarations("Recor
 
 export const clientSdkSource = `import { useSyncExternalStore } from "react";
 export const context = globalThis.__ragentsAppContext;
-if (!context) throw new Error("Die Host-Bridge der Actor-Ansicht fehlt.");
+if (!context) throw new Error("The host bridge of the actor view is missing.");
 export const useAppState = () => useSyncExternalStore(context.state.subscribe, context.state.read, context.state.read);
 `;
 
@@ -136,7 +136,7 @@ export const compileClientProject = async (request: ClientProjectRequest, signal
   const directory = await realpath(request.directory);
   const declarations = clientDeclarations(request);
   const installed = await readFile(path.join(directory, "node_modules/@ragents/client/index.d.ts"), "utf8");
-  if (installed !== declarations) throw new Error("Die Client-SDK-Typen sind nicht aktuell. Das Actor-Projekt muss neu vorbereitet werden.");
+  if (installed !== declarations) throw new Error("The client SDK types are out of date. The actor project must be prepared again.");
   const configPath = path.join(directory, "tsconfig.client.json");
   const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
   if (configFile.error) throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
@@ -156,7 +156,7 @@ export const compileClientProject = async (request: ClientProjectRequest, signal
         minify: true,
       });
       const output = result.outputFiles.find((file) => file.path.endsWith(".js") || file.path === "<stdout>");
-      if (!output) throw new Error("Der Client-Build hat kein JavaScript erzeugt.");
+      if (!output) throw new Error("The client build produced no JavaScript.");
       javaScript = output.text;
     } catch (cause) {
       if (cause && typeof cause === "object" && "errors" in cause && Array.isArray(cause.errors)) {

package/apps/server/src/plugin-support/actor-programs/client-contracts.ts

@@ -12,15 +12,15 @@ function readContracts(repoRoot: string): { names: string[]; files: Record<strin
   };
   const program = ts.createProgram([filename], options);
   const source = program.getSourceFile(filename);
-  if (!source) throw new Error("Der öffentliche UI-Vertrag fehlt.");
+  if (!source) throw new Error("The public UI contract is missing.");
   const checker = program.getTypeChecker();
   const module = checker.getSymbolAtLocation(source);
-  if (!module) throw new Error("Der öffentliche UI-Vertrag ist kein Modul.");
+  if (!module) throw new Error("The public UI contract is not a module.");
   const names = checker.getExportsOfModule(module).filter((entry) => {
     const symbol = entry.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(entry) : entry;
     return /^[A-Z]/.test(entry.name) && (symbol.flags & ts.SymbolFlags.Value) && checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration ?? source).getCallSignatures().length > 0;
   }).map((entry) => entry.name).sort((a, b) => a.localeCompare(b, "en"));
-  if (!names.length) throw new Error("Der öffentliche UI-Vertrag exportiert keine Komponenten.");
+  if (!names.length) throw new Error("The public UI contract exports no components.");
   const files: Record<string, string> = {};
   const visited = new Set<string>();
   const diagnostics: ts.Diagnostic[] = [...program.getOptionsDiagnostics()];
@@ -28,13 +28,13 @@ function readContracts(repoRoot: string): { names: string[]; files: Record<strin
     if (visited.has(file.fileName)) return;
     visited.add(file.fileName);
     const relative = path.relative(repoRoot, file.fileName).replaceAll(path.sep, "/");
-    if (relative.startsWith("../") || relative.includes("node_modules/")) throw new Error("Ein lokaler UI-Typverweis verlässt die öffentlichen Repository-Quellen.");
+    if (relative.startsWith("../") || relative.includes("node_modules/")) throw new Error("A local UI type reference leaves the public repository sources.");
     diagnostics.push(...program.getSyntacticDiagnostics(file), ...program.getSemanticDiagnostics(file));
     let text = file.isDeclarationFile ? file.text : "";
     if (!file.isDeclarationFile) {
       const emitted = program.emit(file, (filename, content) => { if (filename.endsWith(".d.ts")) text = content; }, undefined, true);
       diagnostics.push(...emitted.diagnostics);
-      if (!text) throw new Error(`UI-Typdeklarationen fehlen: ${relative}`);
+      if (!text) throw new Error(`UI type declarations are missing: ${relative}`);
     }
     files[relative.replace(/(?<!\.d)\.tsx?$/, ".d.ts")] = text;
     const declaration = ts.createSourceFile(file.fileName, text, ts.ScriptTarget.Latest, true);
@@ -43,17 +43,17 @@ function readContracts(repoRoot: string): { names: string[]; files: Record<strin
       if (!reference.fileName.startsWith(".")) continue;
       const resolved = ts.resolveModuleName(reference.fileName, file.fileName, options, ts.sys).resolvedModule;
       const dependency = resolved && program.getSourceFile(resolved.resolvedFileName);
-      if (!dependency) throw new Error(`Nicht auflösbarer lokaler UI-Typverweis: ${relative}: ${reference.fileName}`);
+      if (!dependency) throw new Error(`Unresolvable local UI type reference: ${relative}: ${reference.fileName}`);
       collect(dependency);
     }
     for (const reference of declaration.referencedFiles) {
       const dependency = program.getSourceFile(path.resolve(path.dirname(file.fileName), reference.fileName));
-      if (!dependency) throw new Error(`Nicht auflösbarer UI-Typdateiverweis: ${relative}: ${reference.fileName}`);
+      if (!dependency) throw new Error(`Unresolvable UI type file reference: ${relative}: ${reference.fileName}`);
       collect(dependency);
     }
   };
   collect(source);
-  if (diagnostics.length) throw new Error(`Der öffentliche UI-Vertrag kann nicht geprüft werden: ${diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")).join("; ")}`);
+  if (diagnostics.length) throw new Error(`The public UI contract cannot be checked: ${diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")).join("; ")}`);
   return { names, files: Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b, "en"))) };
 }
 
@@ -71,7 +71,7 @@ export function readClientUiComponentNames(repoRoot?: string): string[] {
 }
 
 export function readClientUiComponentContracts(component: string, repoRoot?: string): Record<string, string> {
-  if (!contracts(repoRoot).names.includes(component)) throw new Error(`Unbekanntes Control ${component}. Gültig: ${contracts(repoRoot).names.join(", ")}`);
+  if (!contracts(repoRoot).names.includes(component)) throw new Error(`Unknown control ${component}. Valid: ${contracts(repoRoot).names.join(", ")}`);
   return readClientUiExportContracts(component, repoRoot);
 }
 
@@ -109,7 +109,7 @@ export function readClientUiExportContracts(component: string, repoRoot?: string
     visitedExports.add(key);
     const module = checker.getSymbolAtLocation(file);
     const symbol = module && checker.getExportsOfModule(module).find((item) => item.name === name);
-    if (!symbol) throw new Error(`UI-Typverweis fehlt: ${file.fileName}: ${name}`);
+    if (!symbol) throw new Error(`UI type reference is missing: ${file.fileName}: ${name}`);
     const target = resolve(symbol);
     const declaration = target.declarations?.find((item) => local(item.getSourceFile()));
     if (!declaration) return;
@@ -153,7 +153,7 @@ export function readClientUiExportContracts(component: string, repoRoot?: string
     }
   };
   const source = program.getSourceFile(entry);
-  if (!source) throw new Error("Der öffentliche UI-Vertrag fehlt.");
+  if (!source) throw new Error("The public UI contract is missing.");
   exportFrom(source, component);
   const printer = ts.createPrinter();
   const result: Record<string, string> = {};

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

@@ -55,11 +55,11 @@ export const resolveActorView = (programs: readonly ActorProgramDefinition[], re
   const named = views.filter(({ program, view }) => [view.id, `${program.name}/${view.key}`, `@${program.actorHandle}/${view.key}`]
     .some((name) => name.toLowerCase() === normalized));
   const matches = named.length > 0 ? named : views.filter(({ view }) => view.title.toLowerCase() === normalized);
-  const names = (entries: typeof views) => entries.map(({ program, view }) => `${program.name}/${view.key} (@${program.actorHandle}/${view.key})`).join(", ") || "keine";
+  const names = (entries: typeof views) => entries.map(({ program, view }) => `${program.name}/${view.key} (@${program.actorHandle}/${view.key})`).join(", ") || "none";
   if (matches.length === 0) {
-    throw new Error(`${reference} ist keine aktive Actor-Ansicht dieses Runs. Zuerst das Programm aktivieren. Vorhanden: ${names(views)}`);
+    throw new Error(`${reference} is not an active actor view of this run. Activate the program first. Available: ${names(views)}`);
   }
-  if (matches.length > 1) throw new Error(`${reference} ist mehrdeutig. Verwende einen eindeutigen Namen: ${names(matches)}`);
+  if (matches.length > 1) throw new Error(`${reference} is ambiguous. Use a unique name: ${names(matches)}`);
   return matches[0]!;
 };
 
@@ -118,21 +118,21 @@ export interface ActorLocalTool {
   targets: { actorId: string; handle: string | null }[];
 }
 
-const runId = Type.String({ pattern: "^[A-Za-z0-9_-]{1,64}$", description: "Kennung des Runs" });
-const viewId = Type.String({ pattern: "^[a-z][a-z0-9_-]{0,129}$", description: "Kennung der Actor-Ansicht oder des Programms" });
-const actorHandle = Type.String({ pattern: "^[a-z][a-z0-9-]{0,63}$", description: "Handle des Actors ohne @" });
-const functionId = Type.String({ pattern: "^[a-zA-Z][a-zA-Z0-9_-]{0,63}$", description: "Kennung der Funktion" });
-const invocationId = Type.String({ pattern: "^[A-Za-z0-9_-]{1,100}$", description: "Kennung des Funktionsaufrufs" });
-const revision = Type.String({ pattern: "^[a-f0-9]{64}$", description: "Revision des aktiven Actor-Pakets" });
-const requestId = Type.String({ minLength: 1, maxLength: 200, description: "Eigene Kennung des Aufrufers; wiederholte Aufrufe liefern denselben Aufruf" });
-const functionInput = Type.Unknown({ description: "Eingabe der Funktion nach ihrem eigenen Schema" });
+const runId = Type.String({ pattern: "^[A-Za-z0-9_-]{1,64}$", description: "Identifier of the run" });
+const viewId = Type.String({ pattern: "^[a-z][a-z0-9_-]{0,129}$", description: "Identifier of the actor view or the program" });
+const actorHandle = Type.String({ pattern: "^[a-z][a-z0-9-]{0,63}$", description: "Handle of the actor without @" });
+const functionId = Type.String({ pattern: "^[a-zA-Z][a-zA-Z0-9_-]{0,63}$", description: "Identifier of the function" });
+const invocationId = Type.String({ pattern: "^[A-Za-z0-9_-]{1,100}$", description: "Identifier of the function call" });
+const revision = Type.String({ pattern: "^[a-f0-9]{64}$", description: "Revision of the active actor package" });
+const requestId = Type.String({ minLength: 1, maxLength: 200, description: "The caller's own identifier; repeated calls return the same call" });
+const functionInput = Type.Unknown({ description: "Input of the function according to its own schema" });
 
 const invocationSchema = openJson<ActorFunctionInvocation>("ActorFunctionInvocation");
 
 export const actorProgramContracts = {
   apps: defineOperation({
     id: "ragents.actor-programs.apps",
-    description: "Die Actor-Ansichten eines Runs mit Zustand und Aufrufen; die Werkzeugliste bleibt ohne runs.inspect leer.",
+    description: "The actor views of a run with state and calls; the tool list stays empty without runs.inspect.",
     rights: ["runs.read"],
     input: Type.Object({ runId }, { additionalProperties: false }),
     result: Type.Object({
@@ -142,7 +142,7 @@ export const actorProgramContracts = {
   }),
   source: defineOperation({
     id: "ragents.actor-programs.source",
-    description: "Den Quellcode eines Actor-Programms lesen.",
+    description: "Read the source code of an actor program.",
     rights: ["runs.read", "runs.inspect"],
     input: Type.Object({ runId, moduleId: viewId }, { additionalProperties: false }),
     result: Type.Object({
@@ -151,28 +151,28 @@ export const actorProgramContracts = {
   }),
   action: defineOperation({
     id: "ragents.actor-programs.action",
-    description: "Eine Funktion einer Actor-Ansicht starten; die Antwort ist der eingereihte Aufruf.",
+    description: "Start a function of an actor view; the response is the queued call.",
     rights: ["runs.read", "runs.write"],
     input: Type.Object({ runId, appId: viewId, revision, actionId: functionId, requestId, input: functionInput }, { additionalProperties: false }),
     result: invocationSchema,
   }),
   invocation: defineOperation({
     id: "ragents.actor-programs.invocation",
-    description: "Den Stand eines Aufrufs einer Actor-Ansicht lesen.",
+    description: "Read the state of a call of an actor view.",
     rights: ["runs.read"],
     input: Type.Object({ runId, appId: viewId, invocationId }, { additionalProperties: false }),
     result: invocationSchema,
   }),
   function: defineOperation({
     id: "ragents.actor-programs.function",
-    description: "Eine Funktion eines Actors unabhängig von seinen Ansichten starten.",
+    description: "Start a function of an actor independently of its views.",
     rights: ["runs.read", "runs.write", "runs.inspect"],
     input: Type.Object({ runId, actorHandle, revision, functionId, requestId, input: functionInput }, { additionalProperties: false }),
     result: invocationSchema,
   }),
   functionInvocation: defineOperation({
     id: "ragents.actor-programs.function-invocation",
-    description: "Den Stand eines Aufrufs einer Actor-Funktion lesen.",
+    description: "Read the state of a call of an actor function.",
     rights: ["runs.read", "runs.inspect"],
     input: Type.Object({ runId, actorHandle, invocationId }, { additionalProperties: false }),
     result: invocationSchema,

package/apps/server/src/plugin-support/actor-programs/runtime-libraries.ts

@@ -1,4 +1,4 @@
-/** Diese Bibliotheken verlinkt der Actor-Arbeitsbereich zur Laufzeit; sie werden nicht importiert, sondern über ihren Namen aufgelöst. */
+/** The actor workspace links these libraries at runtime; they are not imported but resolved by their name. */
 export const webRuntimeLibraries = ["react", "react-dom", "@types/react", "@types/react-dom", "@base-ui/react", "class-variance-authority", "cn", "lucide-react"] as const;
 
 export const runtimeLibraries = [...webRuntimeLibraries, "@types/node", "typescript", "tsx", "typebox", "esbuild"] as const;

package/apps/server/src/plugin-support/actor-programs/workflow/index.ts

@@ -41,16 +41,16 @@ export interface WorkflowGraph {
 }
 
 function text(value: unknown, name: string): asserts value is string {
-  if (typeof value !== "string" || !value.trim()) throw new Error(`${name} muss ein nicht leerer Text sein.`);
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${name} must be a non-empty text.`);
 }
 function object(value: unknown, name: string): asserts value is Record<string, unknown> {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} muss ein Objekt sein.`);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object.`);
 }
 function positiveInteger(value: unknown, name: string) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new Error(`${name} muss eine positive ganze Zahl sein.`);
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) throw new Error(`${name} must be a positive integer.`);
 }
 function optionalText(value: unknown, name: string) {
-  if (value !== undefined && typeof value !== "string") throw new Error(`${name} muss Text sein.`);
+  if (value !== undefined && typeof value !== "string") throw new Error(`${name} must be text.`);
 }
 export function validatePromptReference(value: unknown) {
   text(value, "Prompt reference");
@@ -62,7 +62,7 @@ function has(object: object, key: string) { return Object.prototype.hasOwnProper
 
 export function defineWorkflow<const Definition extends WorkflowDefinition>(definition: Definition): Definition {
   object(definition, "Workflow");
-  text(definition.id, "Workflow-ID");
+  text(definition.id, "Workflow ID");
   text(definition.title, "Workflow title");
   object(definition.roles, "Roles");
   if (Object.keys(definition.roles).length === 0) throw new Error("A workflow requires roles.");

package/apps/server/src/plugin-support/actor-programs/workflow/prompt-reader.ts

@@ -7,9 +7,9 @@ export function createPromptReader(directory: string): (reference: string) => Pr
     validatePromptReference(reference);
     const root = await realpath(directory);
     const filename = await realpath(path.join(root, reference));
-    if (!filename.startsWith(`${root}${path.sep}`)) throw new Error(`Promptdatei liegt außerhalb des Actor-Pakets: ${reference}`);
+    if (!filename.startsWith(`${root}${path.sep}`)) throw new Error(`Prompt file lies outside the actor package: ${reference}`);
     const content = await readFile(filename, "utf8");
-    if (!content.trim()) throw new Error(`Promptdatei ist leer: ${reference}`);
+    if (!content.trim()) throw new Error(`Prompt file is empty: ${reference}`);
     return content;
   };
 }

package/apps/server/src/plugin-support/chat-display-policy.ts

@@ -28,14 +28,14 @@ const flag = (env: ChatDisplayEnvironment, key: ChatDisplayKey, fallback: boolea
   if (value === undefined || value === "") return fallback;
   if (value === "1") return true;
   if (value === "0") return false;
-  throw new Error(`${key} muss "0" oder "1" sein, nicht "${value}"`);
+  throw new Error(`${key} must be "0" or "1", not "${value}"`);
 };
 
 const mode = (env: ChatDisplayEnvironment, key: ChatDisplayKey, fallback: ChatDetailMode): ChatDetailMode => {
   const value = env.optional(key);
   if (value === undefined || value === "") return fallback;
   if (!CHAT_DETAIL_MODES.includes(value as ChatDetailMode)) {
-    throw new Error(`${key} muss einer der Werte ${CHAT_DETAIL_MODES.join(", ")} sein, nicht "${value}"`);
+    throw new Error(`${key} must be one of ${CHAT_DETAIL_MODES.join(", ")}, not "${value}"`);
   }
   return value as ChatDetailMode;
 };

package/apps/server/src/plugin-support/front-matter.ts

@@ -5,9 +5,9 @@ export const fieldsOf = (file: string, block: string): Map<string, string> => {
   for (const line of block.split("\n")) {
     if (!line.trim()) continue;
     const separator = line.indexOf(":");
-    if (separator < 0) throw new Error(`${file}: "${line.trim()}" ist kein Schlüssel-Wert-Paar`);
+    if (separator < 0) throw new Error(`${file}: "${line.trim()}" is not a key-value pair`);
     const key = line.slice(0, separator).trim();
-    if (fields.has(key)) throw new Error(`${file}: ${key} steht mehrfach im Kopf`);
+    if (fields.has(key)) throw new Error(`${file}: ${key} appears more than once in the header`);
     fields.set(key, line.slice(separator + 1).trim().replace(/^"(.*)"$/, "$1"));
   }
   return fields;
@@ -17,13 +17,13 @@ export const flag = (file: string, key: string, value: string | undefined, fallb
   if (value === undefined || value === "") return fallback;
   if (value === "true" || value === "1") return true;
   if (value === "false" || value === "0") return false;
-  throw new Error(`${file}: ${key} muss true oder false sein, nicht "${value}"`);
+  throw new Error(`${file}: ${key} must be true or false, not "${value}"`);
 };
 
 export const numberOf = (file: string, key: string, value: string | undefined): number | undefined => {
   if (value === undefined || value === "") return undefined;
   const parsed = Number(value);
-  if (!Number.isFinite(parsed)) throw new Error(`${file}: ${key} muss eine Zahl sein, nicht "${value}"`);
+  if (!Number.isFinite(parsed)) throw new Error(`${file}: ${key} must be a number, not "${value}"`);
   return parsed;
 };
 
@@ -31,7 +31,7 @@ export const tagsOf = (file: string, value: string | undefined): readonly string
   if (value === undefined) return undefined;
   const tags = value.split(",").map((tag) => tag.trim());
   if (tags.some((tag) => !tag) || new Set(tags).size !== tags.length) {
-    throw new Error(`${file}: tags müssen eindeutige, nicht leere Schlagworte sein`);
+    throw new Error(`${file}: tags must be unique, non-empty keywords`);
   }
   return tags;
 };
@@ -39,6 +39,6 @@ export const tagsOf = (file: string, value: string | undefined): readonly string
 /** Splits a markdown file into its front matter fields and the body after the closing marker. */
 export const frontMatterOf = (file: string, raw: string, required: string): { fields: Map<string, string>; body: string } => {
   const head = FRONT_MATTER.exec(raw);
-  if (!head) throw new Error(`${file}: es fehlt der ---Kopf mit ${required}`);
+  if (!head) throw new Error(`${file}: the --- header with ${required} is missing`);
   return { fields: fieldsOf(file, head[1]), body: raw.slice(head[0].length) };
 };

package/apps/server/src/plugin-support/http.ts

@@ -5,7 +5,7 @@ export const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
 
 export class PayloadTooLargeError extends DomainError {
   constructor(maxBytes: number) {
-    super("payload_too_large", `Der Request ist größer als ${maxBytes} Byte`, 413);
+    super("payload_too_large", `The request is larger than ${maxBytes} bytes`, 413);
   }
 }
 
@@ -32,7 +32,7 @@ export const readBody = async (
 export const readJsonBody = async <T>(
   request: IncomingMessage,
   validate: (body: unknown) => T,
-  invalidJsonMessage = "Der Request enthält kein gültiges JSON",
+  invalidJsonMessage = "The request does not contain valid JSON",
   maxBytes = DEFAULT_MAX_BODY_BYTES,
 ): Promise<T> => {
   const text = await readBody(request, maxBytes);

package/apps/server/src/plugin-support/language-server/contract.ts

@@ -12,13 +12,13 @@ export type {
   LanguageServerState,
 } from "@ragents/workspace-executor";
 
-const runIdSchema = Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" });
+const runIdSchema = Type.String({ minLength: 1, maxLength: 64, description: "Identifier of the run" });
 
-/** Je Sprachserver-Plugin eine Methode; die Rechte tragen seine Kennung. */
+/** One method per language server plugin; the rights carry its identifier. */
 export const languageServerSnapshotContract = (pluginId: string) =>
   defineOperation({
     id: `${pluginId}.snapshot`,
-    description: `Zustand und Diagnosen des Sprachservers ${pluginId} in einem Run. Rechte: runs.read und ${pluginId}.read.`,
+    description: `State and diagnostics of the language server ${pluginId} in a run. Rights: runs.read and ${pluginId}.read.`,
     rights: ["runs.read", `${pluginId}.read`],
     input: Type.Object({
       runId: runIdSchema,
@@ -29,7 +29,7 @@ export const languageServerSnapshotContract = (pluginId: string) =>
 export const languageServerSolutionsContract = (pluginId: string) =>
   defineOperation({
     id: `${pluginId}.solutions`,
-    description: `Die Solutions im Arbeitsbereich eines Runs und welche davon ${pluginId} geöffnet hat. Rechte: runs.read und ${pluginId}.read.`,
+    description: `The solutions in the workspace of a run and which of them ${pluginId} has opened. Rights: runs.read and ${pluginId}.read.`,
     rights: ["runs.read", `${pluginId}.read`],
     input: Type.Object({
       runId: runIdSchema,
@@ -40,15 +40,15 @@ export const languageServerSolutionsContract = (pluginId: string) =>
 export const languageServerSwitchContract = (pluginId: string) =>
   defineOperation({
     id: `${pluginId}.switch`,
-    description: `Lädt eine Solution in ${pluginId} und beendet alle anderen Instanzen des Runs; null beendet alle. `
-      + `Wartet nicht auf das Laden. Rechte: runs.read, runs.write, ${pluginId}.read und ${pluginId}.write.`,
+    description: `Loads a solution in ${pluginId} and ends all other instances of the run; null ends all of them. `
+      + `Does not wait for the load. Rights: runs.read, runs.write, ${pluginId}.read and ${pluginId}.write.`,
     rights: ["runs.read", "runs.write", `${pluginId}.read`, `${pluginId}.write`],
     input: Type.Object({
       runId: runIdSchema,
       root: Type.Union([
-        Type.String({ minLength: 1, maxLength: 1024, description: "Die Solution relativ zur Wurzel des Arbeitsbereichs" }),
+        Type.String({ minLength: 1, maxLength: 1024, description: "The solution relative to the workspace root" }),
         Type.Null(),
-      ], { description: "null beendet alle Instanzen" }),
+      ], { description: "null ends all instances" }),
     }, { additionalProperties: false }),
     result: openJson<LanguageServerSolutions>("LanguageServerSolutions"),
   });

package/apps/server/src/plugin-support/language-server/plugin.ts

@@ -7,11 +7,11 @@ import { createLanguageServerToolContributor } from "./tools.js";
 
 export interface LanguageServerPluginOptions {
   id: string;
-  /** Beschreibt den Sprachserver für Werkzeuge und Reiter; gestartet wird er im Executor aus dem Beitrag des Plugins. */
+  /** Describes the language server for tools and tabs; the executor starts it from the plugin's contribution. */
   languageServer: LanguageServerDescription;
   tabLabel?: string;
   configDescriptors?: readonly PluginConfigDescriptor[];
-  /** Nach jedem erfolgreichen Öffnen über Werkzeug oder Umschalten, mit dem Run. */
+  /** After every successful open via tool or switch, with the run. */
   onOpened?: (runId: string) => void;
 }
 

package/apps/server/src/plugin-support/language-server/snapshot-method.ts

@@ -13,7 +13,7 @@ export interface LanguageServerMethodOptions {
   pluginId: string;
   adapterId: string;
   sandbox: SandboxServices;
-  /** Die Sprachserver arbeiten im Arbeitsbereich des Runs; wer ihn nicht sehen darf, sieht auch ihren Stand nicht. */
+  /** The language servers work in the run's workspace; whoever may not see it does not see their state either. */
   ensureWorkspaceAccess: (access: AccessContext, runId: string) => void;
   opened: (runId: string) => void;
 }

package/apps/server/src/plugin-support/language-server/tools.ts

@@ -14,21 +14,21 @@ import { alwaysAvailable } from "../tool-availability.js";
 import type { SandboxServices } from "../workspace-sandbox-host.js";
 
 const stateLabels: Readonly<Record<LanguageServerState, string>> = {
-  opening: "wird geladen",
-  ready: "bereit",
-  failed: "fehlgeschlagen",
-  suspended: "nach Leerlauf beendet",
+  opening: "loading",
+  ready: "ready",
+  failed: "failed",
+  suspended: "ended after idle",
 };
 
 export const formatSolutions = (label: string, listing: LanguageServerSolutions): string => {
-  const source = listing.source === "git" ? "aus git ls-files" : "aus der Verzeichnissuche, kein Git-Arbeitsverzeichnis";
-  if (listing.solutions.length === 0) return `Keine Solution im Arbeitsbereich (${source})`;
+  const source = listing.source === "git" ? "from git ls-files" : "from the directory search, not a git working directory";
+  if (listing.solutions.length === 0) return `No solution in the workspace (${source})`;
   const lines = listing.solutions.map((solution) =>
     `- ${solution.path}${solution.state === null ? "" : ` (${label}: ${stateLabels[solution.state]})`}`);
-  return [`${listing.solutions.length} Solution${listing.solutions.length === 1 ? "" : "s"} im Arbeitsbereich (${source}):`, ...lines].join("\n");
+  return [`${listing.solutions.length} Solution${listing.solutions.length === 1 ? "" : "s"} in the workspace (${source}):`, ...lines].join("\n");
 };
 
-/** Beschreibung und Weiterreichung: der Sprachserver läuft im Executor des Runs, nicht in diesem Plugin. */
+/** Description and forwarding: the language server runs in the run's executor, not in this plugin. */
 export const createLanguageServerToolContributor = (
   pluginId: string,
   languageServer: LanguageServerDescription,
@@ -59,7 +59,7 @@ export const createLanguageServerToolContributor = (
   } as const;
   const openTool = defineRunFunction({
     ...openMetadata,
-    label: `${label} öffnen`,
+    label: `Open ${label}`,
     schema: Type.Object({
       root: Type.String({ description: `${rootDescription}, relative to the workspace root` }),
     }),
@@ -77,7 +77,7 @@ export const createLanguageServerToolContributor = (
   });
   const diagnosticsTool = defineRunFunction({
     ...diagnosticsMetadata,
-    label: `${label} Diagnostik`,
+    label: `${label} diagnostics`,
     schema: Type.Object({
       paths: Type.Optional(Type.Array(Type.String(), {
         description: "Files relative to the workspace root; omit for all changed files",
@@ -116,7 +116,7 @@ export const createLanguageServerToolContributor = (
   });
   const closeTool = defineRunFunction({
     ...closeMetadata,
-    label: `${label} schließen`,
+    label: `Close ${label}`,
     schema: Type.Object({
       root: Type.Optional(Type.String({ description: "The open root to stop; omit for every instance of this run" })),
     }),

package/apps/server/src/plugin-support/model-aliases.ts

@@ -1,15 +1,16 @@
-import { aliasedModel, compactionProblem, type ModelAlias as RuntimeModelAlias } from "@ragents/agent";
+import { aliasedModel, compactionProblem, thinkingLevelsProblem, type ModelAlias as RuntimeModelAlias } from "@ragents/agent";
 import { getSupportedThinkingLevels, type Api, type Model } from "@ragents/ai";
 import { getBuiltinModels, type BuiltinProvider } from "@ragents/ai/providers/all";
 import { isThinkingLevel, type ThinkingLevel } from "@ragents/engine";
+import { configuredModelProviders } from "./model-providers.js";
 import { declaredEnvironment } from "./plugin-config.js";
 
-/** Ein Alias des Profils mit Ziel und Kompaktierungswerten und optional der Denktiefe, die gilt, solange niemand eine andere wählt. */
+/** An alias of the profile with target and compaction values and optionally the thinking level that applies as long as nobody chooses another one. */
 export interface ModelAlias extends RuntimeModelAlias {
   readonly thinking?: ThinkingLevel;
 }
 
-/** Der Anbieter, unter dem die Aliasse des Profils stehen; er ist kein echter Anbieter und erscheint in keiner Anzeige. */
+/** The provider under which the profile's aliases are listed; it is not a real provider and appears in no display. */
 export const ALIAS_PROVIDER = "alias";
 
 export const modelAliasEnvDescriptors = [
@@ -17,12 +18,12 @@ export const modelAliasEnvDescriptors = [
 ] as const;
 
 const ALIAS = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-const ENTRY_KEYS: readonly string[] = ["alias", "model", "thinking", "compaction"];
+const ENTRY_KEYS: readonly string[] = ["alias", "model", "thinking", "thinkingLevels", "compaction"];
 
 const aliasOf = (value: unknown, index: number): ModelAlias => {
   const location = `MODEL_ALIASES[${index}]`;
   if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${location} must be an object with alias, model, compaction and optionally thinking`);
+    throw new Error(`${location} must be an object with alias, model, compaction and optionally thinking and thinkingLevels`);
   }
   const entry = value as Record<string, unknown>;
   const unknown = Object.keys(entry).find((key) => !ENTRY_KEYS.includes(key));
@@ -36,18 +37,19 @@ const aliasOf = (value: unknown, index: number): ModelAlias => {
   if (entry.thinking !== undefined && !isThinkingLevel(entry.thinking)) {
     throw new Error(`${location}.thinking of ${entry.alias} names the unknown thinking level "${String(entry.thinking)}"`);
   }
-  const problem = compactionProblem(entry.compaction);
+  const problem = thinkingLevelsProblem(entry.thinkingLevels) ?? compactionProblem(entry.compaction);
   if (problem) throw new Error(`${location}, ${entry.alias}: ${problem}`);
   return {
     alias: entry.alias,
     upstream: target.slice(0, slash),
     model: target.slice(slash + 1),
     ...(entry.thinking === undefined ? {} : { thinking: entry.thinking }),
+    ...(entry.thinkingLevels === undefined ? {} : { thinkingLevels: entry.thinkingLevels as ModelAlias["thinkingLevels"] }),
     compaction: entry.compaction as ModelAlias["compaction"],
   };
 };
 
-/** MODEL_ALIASES: eine Liste von { alias, model: "anbieter/modell", thinking?, compaction }; der Alias ist der einzige Name, den Oberfläche, Journal und Relay-Clients sehen. */
+/** MODEL_ALIASES: a list of { alias, model: "provider/model", thinking?, thinkingLevels?, compaction }; the alias is the only name that the UI, the journal and relay clients see. */
 export const parseModelAliases = (entries: unknown): readonly ModelAlias[] => {
   if (!Array.isArray(entries)) throw new Error("MODEL_ALIASES must be a list of aliases");
   const aliases = entries.map(aliasOf);
@@ -58,7 +60,7 @@ export const parseModelAliases = (entries: unknown): readonly ModelAlias[] => {
 
 const env = declaredEnvironment(modelAliasEnvDescriptors);
 
-/** Die Aliasse des Profils; in der Umgebung steht MODEL_ALIASES als JSON der Liste aus der Profildatei. */
+/** The profile's aliases; the environment holds MODEL_ALIASES as JSON of the list from the profile file. */
 export const configuredModelAliases = (): readonly ModelAlias[] => {
   const value = env.optional("MODEL_ALIASES");
   if (value === undefined || value === "") return [];
@@ -71,34 +73,42 @@ export const configuredModelAliases = (): readonly ModelAlias[] => {
   return parseModelAliases(parsed);
 };
 
-/** Der Katalog der Aliasse aus den eingebauten Katalogen ihrer Anbieter, so wie die Modelllaufzeit sie anbietet. */
+/** The model the alias offers over its target, checked against the target's thinking levels and limits; the default thinking level must be an offered level. */
+export const validatedAliasModel = (entry: ModelAlias, target: Model<Api>): Model<Api> => {
+  const problem = thinkingLevelsProblem(entry.thinkingLevels, target) ?? compactionProblem(entry.compaction, target);
+  if (problem) throw new Error(`MODEL_ALIASES: ${entry.alias} on ${entry.upstream}/${entry.model}: ${problem}`);
+  const offered = aliasedModel(ALIAS_PROVIDER, entry, target);
+  const levels = getSupportedThinkingLevels(offered);
+  if (entry.thinking !== undefined && !levels.includes(entry.thinking)) {
+    throw new Error(`MODEL_ALIASES: the thinking level ${entry.thinking} does not exist for ${entry.alias} (valid: ${levels.join(", ")})`);
+  }
+  return offered;
+};
+
+/** The catalog of the aliases from the catalogs of their providers (MODEL_PROVIDERS, otherwise built in), as the model runtime offers them. */
 export const aliasCatalog = (aliases: readonly ModelAlias[] = configuredModelAliases()): readonly Model<Api>[] => {
   if (aliases.length === 0) throw new Error(`The provider ${ALIAS_PROVIDER} needs MODEL_ALIASES in the host section`);
+  const providers = configuredModelProviders();
   return aliases.map((entry) => {
-    const target = getBuiltinModels(entry.upstream as BuiltinProvider).find((model) => model.id === entry.model);
+    const catalog = providers.find((provider) => provider.id === entry.upstream)?.models ?? getBuiltinModels(entry.upstream as BuiltinProvider);
+    const target = catalog.find((model) => model.id === entry.model);
     if (!target) throw new Error(`MODEL_ALIASES: the model ${entry.model} behind ${entry.alias} is missing from the catalog of ${entry.upstream}`);
-    const supported = getSupportedThinkingLevels(target);
-    if (entry.thinking !== undefined && !supported.includes(entry.thinking)) {
-      throw new Error(`MODEL_ALIASES: the thinking level ${entry.thinking} does not exist for ${entry.alias} (valid: ${supported.join(", ")})`);
-    }
-    const problem = compactionProblem(entry.compaction, target);
-    if (problem) throw new Error(`MODEL_ALIASES: ${entry.alias} on ${entry.upstream}/${entry.model}: ${problem}`);
-    return aliasedModel(ALIAS_PROVIDER, entry, target);
+    return validatedAliasModel(entry, target);
   });
 };
 
-/** Die Aliasse des Profils, geprüft gegen die Kataloge ihrer Ziele samt Denktiefe und Kompaktierungswerten. */
+/** The profile's aliases, checked against the catalogs of their targets including thinking level and compaction values. */
 export const validatedModelAliases = (): readonly ModelAlias[] => {
   const aliases = configuredModelAliases();
   if (aliases.length > 0) aliasCatalog(aliases);
   return aliases;
 };
 
-/** Die Denktiefe, die der Alias mitbringt; andere Anbieter und Aliasse ohne Angabe haben keine. */
+/** The thinking level the alias brings along; other providers and aliases without one have none. */
 export const modelDefaultThinking = (provider: string, model: string): ThinkingLevel | undefined =>
   provider === ALIAS_PROVIDER ? configuredModelAliases().find((entry) => entry.alias === model)?.thinking : undefined;
 
-/** Der Anbieter, wie eine Anzeige ihn nennt: bei Aliassen keiner. */
+/** The provider as a display names it: none for aliases. */
 export const displayProvider = (provider: string): string => provider === ALIAS_PROVIDER ? "" : provider;
 
 export const modelLabel = (provider: string, model: string): string => {