@schlenkr/ragents 0.1.10 → 0.1.12

package/apps/server/src/config-file.ts

@@ -15,7 +15,7 @@ import { defaultDataDirectory } from "./data-directory.js";
 import { MissingEnvironmentError } from "./missing-environment.js";
 import { isPluginPath, pluginFolderFor } from "./plugin-support/plugins-root.js";
 
-// Der Befund über eine fehlende Umgebungsvariable gehört zum Laden der Konfiguration; main.ts holt ihn darum von hier.
+// The finding about a missing environment variable belongs to loading the configuration; that is why main.ts gets it from here.
 export { missingEnvironmentOf, reportMissingEnvironment } from "./missing-environment.js";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
@@ -55,33 +55,33 @@ const resolveUserToken = (
 ): string | undefined => {
   if (raw === undefined) return undefined;
   if (!isEnvironmentReference(raw) || typeof raw.name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw.name)) {
-    throw new Error(`${location}.token braucht env("ENV_NAME"); ein Token steht nie im Klartext in der Profildatei`);
+    throw new Error(`${location}.token needs env("ENV_NAME"); a token never appears in plain text in the profile file`);
   }
-  // Ein Benutzer meldet sich weiter mit seinem Passwort an; ohne gesetzte Variable hat er nur keinen persönlichen Token.
+  // A user still signs in with their password; without the variable set they just have no personal token.
   const token = environment[raw.name];
   if (!token) return undefined;
-  // $ und ! sind tabu, weil der Verbraucher den Token als API-Schlüssel mit Vorlagen- und Befehlssyntax auswertet.
+  // $ and ! are off limits because the consumer evaluates the token as an API key with template and command syntax.
   if (token.length < MIN_TOKEN_LENGTH || token.length > MAX_TOKEN_LENGTH || !/^[\x21-\x7e]+$/.test(token) || /[$!]/.test(token)) {
-    throw new Error(`${location}.token (${raw.name}) braucht ${MIN_TOKEN_LENGTH} bis ${MAX_TOKEN_LENGTH} druckbare ASCII-Zeichen ohne Leerzeichen, $ und !`);
+    throw new Error(`${location}.token (${raw.name}) needs ${MIN_TOKEN_LENGTH} to ${MAX_TOKEN_LENGTH} printable ASCII characters without spaces, $ and !`);
   }
   return token;
 };
 
 const resolveIdentity = (location: string, entry: Record<string, unknown>): AccessUser => {
   if (typeof entry.id !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(entry.id)) {
-    throw new Error(`${location}.id braucht 1 bis 64 Zeichen: Buchstaben, Ziffern, Punkt, Unterstrich oder Bindestrich`);
+    throw new Error(`${location}.id needs 1 to 64 characters: letters, digits, period, underscore or hyphen`);
   }
   if (entry.label !== undefined && (typeof entry.label !== "string" || !entry.label.trim() || entry.label.length > 120)) {
-    throw new Error(`${location}.label braucht 1 bis 120 Zeichen`);
+    throw new Error(`${location}.label needs 1 to 120 characters`);
   }
   if (!Array.isArray(entry.rights) || !entry.rights.every(isAccessRight)) {
-    throw new Error(`${location}.rights braucht gültige Rechte als Strings oder "*" für alle Rechte`);
+    throw new Error(`${location}.rights needs valid rights as strings or "*" for all rights`);
   }
-  if (new Set(entry.rights).size !== entry.rights.length) throw new Error(`${location}.rights enthält doppelte Rechte`);
+  if (new Set(entry.rights).size !== entry.rights.length) throw new Error(`${location}.rights contains duplicate rights`);
   if (entry.startEntries !== undefined && (!Array.isArray(entry.startEntries)
     || !entry.startEntries.every((id) => typeof id === "string" && START_ENTRY_ID.test(id))
     || new Set(entry.startEntries).size !== entry.startEntries.length)) {
-    throw new Error(`${location}.startEntries braucht eindeutige Vorlagenkennungen als Strings`);
+    throw new Error(`${location}.startEntries needs unique template ids as strings`);
   }
   return Object.freeze({
     id: entry.id,
@@ -94,19 +94,19 @@ const resolveIdentity = (location: string, entry: Record<string, unknown>): Acce
 export const resolveAnonymousUser = (source: string, raw: unknown): AccessUser | undefined => {
   if (raw === undefined) return undefined;
   const location = `${source}: anonymousUser`;
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${location} ist kein Benutzer`);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`${location} is not a user`);
   const entry = raw as Record<string, unknown>;
   if (Object.keys(entry).some((key) => !["id", "label", "rights", "startEntries"].includes(key))) {
-    throw new Error(`${location} erlaubt nur id, label, rights und startEntries`);
+    throw new Error(`${location} allows only id, label, rights and startEntries`);
   }
   return resolveIdentity(location, entry);
 };
 
-/** Die Vorlage, die ein neuer Run ohne Auswahl nimmt; ob sie registriert ist, prüft der PluginHost beim Start. */
+/** The template a new run takes without a choice; whether it is registered is checked by the PluginHost at startup. */
 export const resolveDefaultStartEntry = (source: string, raw: unknown): string | undefined => {
   if (raw === undefined) return undefined;
   if (typeof raw !== "string" || !START_ENTRY_ID.test(raw)) {
-    throw new Error(`${source}: defaultStartEntry braucht eine Vorlagenkennung als String, etwa "acme.tasks.setup"`);
+    throw new Error(`${source}: defaultStartEntry needs a template id as a string, such as "acme.tasks.setup"`);
   }
   return raw;
 };
@@ -118,30 +118,30 @@ export const resolveProfileUsers = (
 ): readonly ResolvedProfileUser[] | undefined => {
   if (raw === undefined) return undefined;
   if (!Array.isArray(raw) || raw.length === 0) {
-    throw new Error(`${source}: users muss eine nicht leere Liste sein; ohne users ist die Anmeldung ausgeschaltet`);
+    throw new Error(`${source}: users must be a non-empty list; without users, sign-in is turned off`);
   }
   const ids = new Set<string>();
   const tokens = new Map<string, string>();
   return raw.map((value: unknown, index: number) => {
     const location = `${source}: users[${index}]`;
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${location} ist kein Benutzer`);
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${location} is not a user`);
     const entry = value as Record<string, unknown>;
     if (Object.keys(entry).some((key) => !["id", "label", "password", "token", "rights", "startEntries"].includes(key))) {
-      throw new Error(`${location} erlaubt nur id, label, password, token, rights und startEntries`);
+      throw new Error(`${location} allows only id, label, password, token, rights and startEntries`);
     }
     const user = resolveIdentity(location, entry);
-    if (ids.has(user.id)) throw new Error(`${location}.id ist doppelt: ${user.id}`);
+    if (ids.has(user.id)) throw new Error(`${location}.id is a duplicate: ${user.id}`);
     ids.add(user.id);
     if (typeof entry.password !== "string" && (!isEnvironmentReference(entry.password)
       || typeof entry.password.name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(entry.password.name))) {
-      throw new Error(`${location}.password braucht einen Text oder env("ENV_NAME")`);
+      throw new Error(`${location}.password needs a text or env("ENV_NAME")`);
     }
     const password = typeof entry.password === "string" ? entry.password : environment[entry.password.name];
-    if (!password || password.length > 2048) throw new Error(`${location}.password fehlt, ist leer oder länger als 2048 Zeichen`);
+    if (!password || password.length > 2048) throw new Error(`${location}.password is missing, empty or longer than 2048 characters`);
     const token = resolveUserToken(location, entry.token, environment);
     if (token !== undefined) {
       const other = tokens.get(token);
-      if (other) throw new Error(`${location}.token ist derselbe wie bei Benutzer ${other}; jeder Token gehört genau einem Benutzer`);
+      if (other) throw new Error(`${location}.token is the same as for user ${other}; every token belongs to exactly one user`);
       tokens.set(token, user.id);
     }
     return Object.freeze({ ...user, password, ...(token !== undefined ? { token } : {}) });
@@ -152,7 +152,7 @@ export const listFromEnvironmentValue = (value: string): readonly string[] | und
   if (!value.startsWith("[")) return undefined;
   const parsed = JSON.parse(value) as unknown;
   if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) {
-    throw new Error(`Der Wert ${value} sieht aus wie eine Liste, ist aber keine Liste von Strings`);
+    throw new Error(`The value ${value} looks like a list, but is not a list of strings`);
   }
   return parsed as string[];
 };
@@ -164,16 +164,16 @@ const materialize = (value: Exclude<ConfigValue, EnvironmentReference | Provisio
   return JSON.stringify(value);
 };
 
-/** Der Datenordner des Hosts, in dessen tools/ die Provisionierung ihre Werkzeuge legt. */
+/** The host's data folder, in whose tools/ the provisioning puts its tools. */
 const dataDirectoryOf = (source: string, raw: RAgentsConfig): string => {
   const configured = raw.host?.DATA_DIR;
   if (isEnvironmentReference(configured) && process.env[configured.name] === undefined) {
     throw new MissingEnvironmentError({ variable: configured.name, section: "host", key: "DATA_DIR" },
-      `${source}: host.DATA_DIR verweist auf die nicht gesetzte Umgebungsvariable ${configured.name}`);
+      `${source}: host.DATA_DIR refers to the unset environment variable ${configured.name}`);
   }
   const fromFile = isEnvironmentReference(configured) ? process.env[configured.name] : typeof configured === "string" ? configured : undefined;
   const profile = process.env.PRODUCT_PROFILE;
-  if (!profile) throw new Error(`${source}: ohne PRODUCT_PROFILE gibt es keinen Datenordner und damit keinen Werkzeugordner`);
+  if (!profile) throw new Error(`${source}: without PRODUCT_PROFILE there is no data folder and therefore no tool folder`);
   return path.resolve(process.env.DATA_DIR ?? fromFile ?? defaultDataDirectory(profile));
 };
 
@@ -187,21 +187,21 @@ const entryFor = (source: string, section: string, key: string, value: ConfigVal
     const resolved = process.env[value.name];
     if (resolved === undefined) {
       throw new MissingEnvironmentError({ variable: value.name, section, key },
-        `${source}: ${section}.${key} verweist mit env("${value.name}") auf eine Umgebungsvariable, `
-        + `die in dieser Shell nicht gesetzt ist. Setze sie vor dem Start (export ${value.name}=...) oder `
-        + "hinterlege sie in der Startdatei Deiner Shell; Secrets stehen nie in der Konfigurationsdatei.");
+        `${source}: ${section}.${key} refers with env("${value.name}") to an environment variable `
+        + `that is not set in this shell. Set it before starting (export ${value.name}=...) or `
+        + "put it in your shell's startup file; secrets never appear in the configuration file.");
     }
     return { section, key, value: resolved, viaReference: true, overriddenByEnvironment };
   }
   if (typeof value === "string" && ENVIRONMENT_PLACEHOLDER.test(value)) {
     throw new Error(
-      `${source}: ${section}.${key} steht als Text "${value}" in der Konfiguration; `
-      + `eine Referenz auf die Umgebung wird als env("...") geschrieben`);
+      `${source}: ${section}.${key} appears as the text "${value}" in the configuration; `
+      + `a reference to the environment is written as env("...")`);
   }
   if (SECRET_KEY_PATTERN.test(key)) {
     throw new Error(
-      `${source}: ${section}.${key} ist ein Secret und darf nicht im Klartext in der Konfiguration stehen; `
-      + `per Umgebungsvariable setzen oder als env("ENV_NAME") referenzieren`);
+      `${source}: ${section}.${key} is a secret and must not appear in plain text in the configuration; `
+      + `set it through an environment variable or reference it as env("ENV_NAME")`);
   }
   return { section, key, value: materialize(value), viaReference: false, overriddenByEnvironment };
 };
@@ -221,7 +221,7 @@ const parseEntries = (source: string, raw: RAgentsConfig): readonly ConfigFileEn
     const existing = byKey.get(entry.key);
     if (existing && existing.value !== entry.value) {
       throw new Error(
-        `${source}: ${entry.key} steht in ${existing.section} und ${entry.section} mit unterschiedlichen Werten`);
+        `${source}: ${entry.key} appears in ${existing.section} and ${entry.section} with different values`);
     }
     byKey.set(entry.key, entry);
   }
@@ -236,14 +236,14 @@ export const profileFileName = (profile: string): string => `ragents.config.${pr
 export const profileFilePath = (root: string, environment: Readonly<Record<string, string | undefined>> = process.env): string | undefined => {
   const profile = environment.PRODUCT_PROFILE;
   if (!profile) return undefined;
-  if (!PROFILE_NAME.test(profile)) throw new Error(`PRODUCT_PROFILE ist kein gültiger Profilname: ${profile}`);
+  if (!PROFILE_NAME.test(profile)) throw new Error(`PRODUCT_PROFILE is not a valid profile name: ${profile}`);
   const file = environment.PRODUCT_PROFILE_FILE;
   if (!file) return path.join(root, profileFileName(profile));
   const source = path.resolve(file);
   if (path.basename(source) !== profileFileName(profile)) {
-    throw new Error(`PRODUCT_PROFILE_FILE ${source} passt nicht zum Profil ${profile}; erwartet wird ${profileFileName(profile)}`);
+    throw new Error(`PRODUCT_PROFILE_FILE ${source} does not match the profile ${profile}; expected is ${profileFileName(profile)}`);
   }
-  if (!statSync(source, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei ${source} fehlt`);
+  if (!statSync(source, { throwIfNoEntry: false })?.isFile()) throw new Error(`The profile file ${source} is missing`);
   return source;
 };
 
@@ -260,12 +260,12 @@ const readProfileConfiguration = async (root: string): Promise<LoadedConfigFile
   const module = await import(pathToFileURL(source).href) as Record<string, unknown>;
   const loadedConfig = module.config;
   if (typeof loadedConfig !== "object" || loadedConfig === null) {
-    throw new Error(`${source} exportiert keine Konstante config mit den Konfigurationssektionen`);
+    throw new Error(`${source} does not export a constant config with the configuration sections`);
   }
   const raw = withPluginPaths(source, loadedConfig as RAgentsConfig);
   const users = resolveProfileUsers(source, module.users);
   const anonymousUser = resolveAnonymousUser(source, module.anonymousUser);
-  if (users && anonymousUser) throw new Error(`${source}: users und anonymousUser schließen einander aus`);
+  if (users && anonymousUser) throw new Error(`${source}: users and anonymousUser exclude each other`);
   const defaultStartEntry = resolveDefaultStartEntry(source, module.defaultStartEntry);
   return { path: source, entries: parseEntries(source, raw), users, anonymousUser, defaultStartEntry };
 };
@@ -274,7 +274,7 @@ let loadedConfigFile: LoadedConfigFile | undefined;
 let loadCompleted = false;
 
 export const loadConfigFile = async (root = rootDir): Promise<void> => {
-  if (loadCompleted) throw new Error("Die Konfiguration wurde bereits geladen");
+  if (loadCompleted) throw new Error("The configuration has already been loaded");
   loadedConfigFile = await readProfileConfiguration(root);
   loadCompleted = true;
   if (!loadedConfigFile) return;
@@ -285,8 +285,8 @@ export const loadConfigFile = async (root = rootDir): Promise<void> => {
     applied++;
   }
   const overridden = loadedConfigFile.entries.length - applied;
-  console.log(`Konfiguration ${loadedConfigFile.path} geladen `
-    + `(${applied} Werte übernommen, ${overridden} durch Umgebung überstimmt)`);
+  console.log(`Configuration ${loadedConfigFile.path} loaded `
+    + `(${applied} values applied, ${overridden} overridden by the environment)`);
 };
 
 export const configFilePath = (): string | null => loadedConfigFile?.path ?? null;
@@ -306,7 +306,7 @@ export interface ConfigFileValidationContext {
 }
 
 export const validateConfigFileSections = (context: ConfigFileValidationContext): void => {
-  if (!loadCompleted) throw new Error("Die Konfiguration muss vor ihrer Prüfung geladen werden");
+  if (!loadCompleted) throw new Error("The configuration must be loaded before it is checked");
   if (!loadedConfigFile) return;
   const source = loadedConfigFile.path;
   const known = new Set(context.knownPluginIds);
@@ -315,21 +315,21 @@ export const validateConfigFileSections = (context: ConfigFileValidationContext)
   for (const section of new Set(loadedConfigFile.entries.map((entry) => entry.section))) {
     if (section === "host") continue;
     if (!known.has(section)) {
-      throw new Error(`${source}: unbekannte Sektion ${section}; bekannt sind host, ${[...known].join(", ")}`);
+      throw new Error(`${source}: unknown section ${section}; known are host, ${[...known].join(", ")}`);
     }
     if (!active.has(section)) {
-      console.log(`Konfiguration: Sektion ${section} gehört zu einem inaktiven Plugin und wird ignoriert`);
+      console.log(`Configuration: section ${section} belongs to an inactive plugin and is ignored`);
     }
   }
   for (const entry of loadedConfigFile.entries) {
     if (secret.has(entry.key) && !entry.viaReference) {
       throw new Error(
-        `${source}: ${entry.section}.${entry.key} ist als Secret deklariert und darf nicht im Klartext `
-        + `in der Konfiguration stehen; per Umgebungsvariable setzen oder als env("ENV_NAME") referenzieren`);
+        `${source}: ${entry.section}.${entry.key} is declared as a secret and must not appear in plain text `
+        + `in the configuration; set it through an environment variable or reference it as env("ENV_NAME")`);
     }
     if (entry.section === "host") {
       if (!context.hostKeys.includes(entry.key)) {
-        throw new Error(`${source}: host.${entry.key} ist kein Host-Schlüssel; erlaubt sind ${context.hostKeys.join(", ")}`);
+        throw new Error(`${source}: host.${entry.key} is not a host key; allowed are ${context.hostKeys.join(", ")}`);
       }
       continue;
     }
@@ -337,8 +337,8 @@ export const validateConfigFileSections = (context: ConfigFileValidationContext)
     const declared = context.declaredKeysFor(entry.section);
     if (!declared.includes(entry.key)) {
       throw new Error(
-        `${source}: ${entry.section}.${entry.key} ist für dieses Plugin nicht deklariert; `
-        + (declared.length > 0 ? `deklariert sind ${declared.join(", ")}` : "das Plugin deklariert keine Schlüssel"));
+        `${source}: ${entry.section}.${entry.key} is not declared for this plugin; `
+        + (declared.length > 0 ? `declared are ${declared.join(", ")}` : "the plugin declares no keys"));
     }
   }
 };

package/apps/server/src/config.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { modelAliasEnvDescriptors } from "./plugin-support/model-aliases.js";
+import { modelProviderEnvDescriptors } from "./plugin-support/model-providers.js";
 import { declaredEnvironment } from "./plugin-support/plugin-config.js";
 import { defaultDataDirectory } from "./data-directory.js";
 import { hostWebDirectory } from "./host-web.js";
@@ -13,6 +14,7 @@ export const hostConfigDescriptors = [
   { key: "AGENT_THINKING", source: "environment" },
   { key: "COMPACTION_PROVIDER", source: "environment" },
   { key: "COMPACTION_MODEL", source: "environment" },
+  ...modelProviderEnvDescriptors,
   ...modelAliasEnvDescriptors,
   { key: "PRODUCT_PROFILE", source: "environment" },
   { key: "PLUGINS", source: "environment" },

package/apps/server/src/data-directory.ts

@@ -6,7 +6,7 @@ import { ragentsDataRoot } from "@ragents/workspace-executor/src/tools.ts";
 export { ragentsDataRoot };
 
 export function defaultDataDirectory(profile: string, home = homedir()): string {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(profile)) throw new Error("PRODUCT_PROFILE muss ein einfacher Profilname sein.");
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(profile)) throw new Error("PRODUCT_PROFILE must be a simple profile name.");
   return path.join(ragentsDataRoot(home), profile);
 }
 
@@ -35,7 +35,7 @@ export async function assertDataDirectoryIsolated(directory: string): Promise<vo
         if (error.code === "ENOENT") return undefined;
         throw error;
       });
-      if (entry) throw new Error(`DATA_DIR liegt innerhalb eines Projekts (${filename}). Wähle einen externen Datenordner, zum Beispiel ~/.local/share/ragents/<profil>.`);
+      if (entry) throw new Error(`DATA_DIR is inside a project (${filename}). Choose an external data folder, for example ~/.local/share/ragents/<profile>.`);
     }
     if (path.dirname(current) === current) return;
   }

package/apps/server/src/external-access.ts

@@ -35,6 +35,6 @@ export const setExternalAccess = async (value: boolean): Promise<void> => {
 export const externalGate = (req: IncomingMessage, res: ServerResponse): boolean => {
   if (open || isLocalRequest(req)) return false;
   res.writeHead(503, { "Content-Type": "text/plain; charset=utf-8" });
-  res.end("Der Zugang von außen ist ausgeschaltet.\n");
+  res.end("External access is turned off.\n");
   return true;
 };

package/apps/server/src/folder-install.ts

@@ -46,7 +46,7 @@ export const acquireLock = async (file: string): Promise<() => Promise<void>> =>
         continue;
       }
       if (Date.now() - started > LOCK_TIMEOUT_MS) {
-        throw new Error(`${file} ist seit ${Math.round(LOCK_TIMEOUT_MS / 60_000)} Minuten von Prozess ${owner || "?"} belegt; läuft dort noch ein Bau?`);
+        throw new Error(`${file} has been held by process ${owner || "?"} for ${Math.round(LOCK_TIMEOUT_MS / 60_000)} minutes; is a build still running there?`);
       }
       await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));
     }

package/apps/server/src/help-files.ts

@@ -37,7 +37,7 @@ export async function readHelpResponse(url: URL, webDistDir: string, method = "G
   const notFound = (): HelpResponse => ({
     status: 404,
     headers: { "Content-Type": "text/plain; charset=utf-8" },
-    body: method === "HEAD" ? undefined : "Nicht gefunden",
+    body: method === "HEAD" ? undefined : "Not found",
   });
   let requested: string;
   try {

package/apps/server/src/host-api.json

@@ -141,7 +141,8 @@
     ],
     "@ragents/host/plugin-support/model-aliases": [
       "configuredModelAliases",
-      "modelLabel"
+      "modelLabel",
+      "validatedAliasModel"
     ],
     "@ragents/host/plugin-support/model-choice": [
       "builtinCatalog",
@@ -150,8 +151,12 @@
       "modelThinkingOptions"
     ],
     "@ragents/host/plugin-support/model-completion": [
+      "aliasCompletionModelToken",
       "openRouterCompletionModel"
     ],
+    "@ragents/host/plugin-support/model-providers": [
+      "configuredModelProviders"
+    ],
     "@ragents/host/plugin-support/model-upstreams": [
       "modelUpstreamsToken"
     ],

package/apps/server/src/host-api.ts

@@ -58,11 +58,12 @@ export const hostApi: { readonly server: HostApiModules; readonly web: HostApiMo
       "PayloadTooLargeError", "guardedJsonRoute", "readBody", "readJsonBody", "withAbort", "writeJson",
     ],
     "@ragents/host/plugin-support/language-server/plugin": ["createLanguageServerPlugin"],
-    "@ragents/host/plugin-support/model-aliases": ["configuredModelAliases", "modelLabel"],
+    "@ragents/host/plugin-support/model-aliases": ["configuredModelAliases", "modelLabel", "validatedAliasModel"],
     "@ragents/host/plugin-support/model-choice": [
       "builtinCatalog", "modelChoiceEnvDescriptors", "modelChoiceFromEnvironment", "modelThinkingOptions",
     ],
-    "@ragents/host/plugin-support/model-completion": ["openRouterCompletionModel"],
+    "@ragents/host/plugin-support/model-completion": ["aliasCompletionModelToken", "openRouterCompletionModel"],
+    "@ragents/host/plugin-support/model-providers": ["configuredModelProviders"],
     "@ragents/host/plugin-support/model-upstreams": ["modelUpstreamsToken"],
     "@ragents/host/plugin-support/plugin-config": ["declaredEnvironment"],
     "@ragents/host/plugin-support/plugin-folder": ["folderSystemPrompts", "pluginAsset", "pluginFolder"],

package/apps/server/src/host-record.ts

@@ -9,15 +9,15 @@ export interface HostRecord {
   readonly startedAt: string;
 }
 
-/** Der gemerkte Host eines Profils; ragents run und ragents start schreiben dieselbe Datei, stop --host liest sie. */
+/** The remembered host of a profile; ragents run and ragents start write the same file, stop --host reads it. */
 export const hostRecordFile = (dataDirectory: string): string => path.join(dataDirectory, "host.json");
 
 export const readHostRecord = (dataDirectory: string): HostRecord | undefined => {
   const file = hostRecordFile(dataDirectory);
   if (!statSync(file, { throwIfNoEntry: false })?.isFile()) return undefined;
   const parsed = JSON.parse(readFileSync(file, "utf8")) as Partial<HostRecord>;
-  // Eine PID unter 1 wäre für process.kill die ganze Prozessgruppe; sie darf nie aus dieser Datei kommen.
-  if (typeof parsed.url !== "string" || !Number.isInteger(parsed.pid) || (parsed.pid ?? 0) < 1) throw new Error(`${file} nennt keine Adresse oder keine PID des Hosts`);
+  // A PID below 1 would mean the whole process group to process.kill; it must never come from this file.
+  if (typeof parsed.url !== "string" || !Number.isInteger(parsed.pid) || (parsed.pid ?? 0) < 1) throw new Error(`${file} names no address or no PID of the host`);
   return parsed as HostRecord;
 };
 

package/apps/server/src/host-resolution-hooks.mjs

@@ -43,14 +43,14 @@ const resolveFromBundle = async (bundle, specifier, context, next) => {
   if (cross) {
     const [, owner, name] = cross;
     const folder = bundles.get(owner);
-    if (!folder) throw new Error(`Das Bundle ${bundle} importiert ${specifier}, aber ${owner} steht nicht in der Pluginliste`);
+    if (!folder) throw new Error(`The bundle ${bundle} imports ${specifier}, but ${owner} is not in the plugin list`);
     const url = new URL(`server/exports/${name.replace(/\.js$/, "")}.js`, folder).href;
-    if (!existsSync(fileURLToPath(url))) throw new Error(`Das Bundle ${bundle} importiert ${specifier}, das Bundle ${owner} exportiert ${name} aber nicht für den Server; beide Bundles aus ihren Quellen neu bauen`);
+    if (!existsSync(fileURLToPath(url))) throw new Error(`The bundle ${bundle} imports ${specifier}, but the bundle ${owner} does not export ${name} for the server; rebuild both bundles from their sources`);
     return { url, shortCircuit: true };
   }
   const listed = specifier.replace(/\.(js|ts|tsx)$/, "");
   if (listed === "@ragents/workflow") return { url: workflowEntry, shortCircuit: true };
-  if (!serverModules.has(listed)) throw new Error(`Das Bundle ${bundle} importiert ${specifier}, das der Host nicht bereitstellt; das Bundle gegen diesen Host neu bauen`);
+  if (!serverModules.has(listed)) throw new Error(`The bundle ${bundle} imports ${specifier}, which the host does not provide; rebuild the bundle against this host`);
   return next(specifier, { ...context, parentURL: serverEntry });
 };
 
@@ -58,7 +58,7 @@ const resolveFromBundle = async (bundle, specifier, context, next) => {
 export const load = async (url, context, next) =>
   bundleOf(url) !== undefined && url.endsWith(".js") ? next(url, { ...context, format: "module" }) : next(url, context);
 
-// Reines JavaScript, weil Node diese Datei im Loader-Thread lädt und dort unter node_modules keine Typen entfernt.
+// Plain JavaScript, because Node loads this file in the loader thread and strips no types under node_modules there.
 /** Bundles resolve strictly; other code outside the repository resolves bare imports through the host, so it needs no own node_modules. */
 export const resolve = async (specifier, context, next) => {
   const bundle = bundleOf(context.parentURL);

package/apps/server/src/host-version.ts

@@ -8,12 +8,12 @@ export const hostRoot = (): string => path.resolve(path.dirname(fileURLToPath(im
 /** The value names of the host API and its number, relative to the host root; generated by pnpm update:host-api. */
 export const HOST_API_RECORD_FILE = "apps/server/src/host-api.json";
 
-/** Die Nummer der Host-API eines Hosts an beliebiger Stelle; so prüft auch die Erweiterung einen Host, der nicht sie selbst ist. */
+/** The host API number of a host anywhere; this way the extension also checks a host that is not itself. */
 export const readHostApiVersion = (root: string = hostRoot()): number => {
   const file = path.join(root, HOST_API_RECORD_FILE);
-  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Host-API ist unbekannt: ${file} fehlt`);
+  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`The host API is unknown: ${file} is missing`);
   const version = (JSON.parse(readFileSync(file, "utf8")) as { version?: unknown }).version;
-  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) throw new Error(`${file}: version ist keine Nummer der Host-API`);
+  if (typeof version !== "number" || !Number.isInteger(version) || version < 1) throw new Error(`${file}: version is not a host API number`);
   return version;
 };
 
@@ -26,7 +26,7 @@ export interface HostApiRecord {
 
 export const readHostApiRecord = (root = hostRoot()): HostApiRecord => {
   const file = path.join(root, HOST_API_RECORD_FILE);
-  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`${file} fehlt; mit pnpm update:host-api erzeugen`);
+  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`${file} is missing; generate it with pnpm update:host-api`);
   return JSON.parse(readFileSync(file, "utf8")) as HostApiRecord;
 };
 
@@ -34,12 +34,12 @@ export const readHostApiRecord = (root = hostRoot()): HostApiRecord => {
 export const checkedHostApiRecord = (root = hostRoot()): HostApiRecord => {
   const record = readHostApiRecord(root);
   if (record.version !== HOST_API_VERSION) {
-    throw new Error(`host-api.json beschreibt Host-API ${record.version}, der Host bietet ${HOST_API_VERSION}; pnpm update:host-api`);
+    throw new Error(`host-api.json describes host API ${record.version}, the host offers ${HOST_API_VERSION}; pnpm update:host-api`);
   }
   for (const half of ["server", "web"] as const) {
     const listed = [...hostApiModules(half)].sort().join("\n");
     if (Object.keys(record[half]).sort().join("\n") !== listed) {
-      throw new Error(`host-api.json nennt für die ${half}-Hälfte andere Module als apps/server/src/host-api.ts; pnpm update:host-api`);
+      throw new Error(`host-api.json names different modules for the ${half} half than apps/server/src/host-api.ts; pnpm update:host-api`);
     }
   }
   return record;
@@ -51,7 +51,7 @@ export interface HostPackage {
   readonly hostVersion: string;
 }
 
-/** Das npm-Paket @schlenkr/ragents trägt den Commit, aus dem es gebaut wurde; ein Checkout hat diese Datei nicht. */
+/** The npm package @schlenkr/ragents carries the commit it was built from; a checkout does not have this file. */
 export const readHostPackage = (root: string = hostRoot()): HostPackage | undefined => {
   const file = path.join(root, "package.json");
   if (!statSync(file, { throwIfNoEntry: false })?.isFile()) return undefined;
@@ -59,19 +59,19 @@ export const readHostPackage = (root: string = hostRoot()): HostPackage | undefi
   const hostVersion = parsed.ragents?.hostVersion;
   if (hostVersion === undefined) return undefined;
   if (typeof hostVersion !== "string" || !/^[0-9a-f]{40}$/.test(hostVersion)) {
-    throw new Error(`${file}: ragents.hostVersion muss ein vollständiger Git-Commit sein, nicht ${JSON.stringify(hostVersion)}`);
+    throw new Error(`${file}: ragents.hostVersion must be a full Git commit, not ${JSON.stringify(hostVersion)}`);
   }
-  if (typeof parsed.name !== "string" || typeof parsed.version !== "string") throw new Error(`${file}: name und version fehlen`);
+  if (typeof parsed.name !== "string" || typeof parsed.version !== "string") throw new Error(`${file}: name and version are missing`);
   return { name: parsed.name, version: parsed.version, hostVersion };
 };
 
-/** Die Fassung des npm-Pakets: im Paket seine eigene, im Checkout die der Wurzel; eine Quelle für beide. */
+/** The version of the npm package: in the package its own, in the checkout that of the root; one source for both. */
 export const readPackageVersion = (root: string = hostRoot()): string => {
   const file = path.join(root, "package.json");
-  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Paketfassung ist unbekannt: ${file} fehlt`);
+  if (!statSync(file, { throwIfNoEntry: false })?.isFile()) throw new Error(`The package version is unknown: ${file} is missing`);
   const version = (JSON.parse(readFileSync(file, "utf8")) as { version?: unknown }).version;
   if (typeof version !== "string" || !/^\d+\.\d+\.\d+/.test(version)) {
-    throw new Error(`${file}: version ist die Fassung des Pakets und muss x.y.z sein, nicht ${JSON.stringify(version)}`);
+    throw new Error(`${file}: version is the package version and must be x.y.z, not ${JSON.stringify(version)}`);
   }
   return version;
 };
@@ -79,10 +79,10 @@ export const readPackageVersion = (root: string = hostRoot()): string => {
 const gitDirectoryOf = (root: string): string => {
   const entry = path.join(root, ".git");
   const stats = statSync(entry, { throwIfNoEntry: false });
-  if (!stats) throw new Error(`Die Host-Version ist unbekannt: ${entry} fehlt; der Host braucht einen Git-Checkout oder das Paket @schlenkr/ragents`);
+  if (!stats) throw new Error(`The host version is unknown: ${entry} is missing; the host needs a Git checkout or the package @schlenkr/ragents`);
   if (stats.isDirectory()) return entry;
   const pointer = /^gitdir:\s*(.+)\s*$/.exec(readFileSync(entry, "utf8"));
-  if (!pointer) throw new Error(`Die Host-Version ist unbekannt: ${entry} nennt kein gitdir`);
+  if (!pointer) throw new Error(`The host version is unknown: ${entry} names no gitdir`);
   return path.resolve(root, pointer[1]!.trim());
 };
 
@@ -96,7 +96,7 @@ const refFrom = (gitDirectory: string, ref: string): string | undefined => {
   return line?.split(" ")[0];
 };
 
-/** Der Commit des laufenden Hosts: aus dem Paket @schlenkr/ragents, sonst aus dem Git-Checkout mit Worktrees und gepackten Refs. */
+/** The commit of the running host: from the package @schlenkr/ragents, otherwise from the Git checkout with worktrees and packed refs. */
 export const readHostVersion = (root: string = hostRoot()): string => {
   const packaged = readHostPackage(root);
   if (packaged) return packaged.hostVersion;
@@ -105,11 +105,11 @@ export const readHostVersion = (root: string = hostRoot()): string => {
   const ref = /^ref:\s*(.+)$/.exec(head)?.[1]?.trim();
   if (!ref) {
     if (/^[0-9a-f]{40}$/.test(head)) return head;
-    throw new Error(`Die Host-Version ist unbekannt: HEAD in ${gitDirectory} ist weder Ref noch Commit`);
+    throw new Error(`The host version is unknown: HEAD in ${gitDirectory} is neither a ref nor a commit`);
   }
   const commonDirectory = statSync(path.join(gitDirectory, "commondir"), { throwIfNoEntry: false })?.isFile()
     ? path.resolve(gitDirectory, readFileSync(path.join(gitDirectory, "commondir"), "utf8").trim()) : undefined;
   const commit = refFrom(gitDirectory, ref) ?? (commonDirectory ? refFrom(commonDirectory, ref) : undefined);
-  if (!commit || !/^[0-9a-f]{40}$/.test(commit)) throw new Error(`Die Host-Version ist unbekannt: ${ref} in ${gitDirectory} zeigt auf keinen Commit`);
+  if (!commit || !/^[0-9a-f]{40}$/.test(commit)) throw new Error(`The host version is unknown: ${ref} in ${gitDirectory} points to no commit`);
   return commit;
 };

package/apps/server/src/host-web.ts

@@ -40,7 +40,7 @@ const readRecord = (file: string): HostWebRecord | undefined => {
   const inputs = raw.inputs;
   if (typeof inputs !== "object" || inputs === null || Array.isArray(inputs)
     || Object.values(inputs).some((hash) => typeof hash !== "string")) {
-    throw new Error(`${file} hat nicht die erwartete Form`);
+    throw new Error(`${file} does not have the expected shape`);
   }
   return { inputs: inputs as Record<string, string> };
 };
@@ -48,12 +48,12 @@ const readRecord = (file: string): HostWebRecord | undefined => {
 /** Why a built web cannot be served as it is; with sources, a checkout also compares it with the files it was built from. */
 export const hostWebProblem = (directory: string, root: string, sources: boolean): string | undefined => {
   const missing = HOST_WEB_PAGES.filter((page) => !isFile(path.join(directory, page)));
-  if (missing.length > 0) return `Das Web des Hosts fehlt unter ${directory} (${missing.join(", ")})`;
+  if (missing.length > 0) return `The host's web is missing under ${directory} (${missing.join(", ")})`;
   if (!sources) return undefined;
   const record = readRecord(path.join(directory, HOST_WEB_RECORD));
-  if (!record) return `Das Web des Hosts unter ${directory} hat keinen Quellstand (${HOST_WEB_RECORD})`;
+  if (!record) return `The host's web under ${directory} has no source record (${HOST_WEB_RECORD})`;
   const changed = changedInputs(record, root);
   if (changed.length === 0) return undefined;
-  const shown = changed.slice(0, 5).join(", ") + (changed.length > 5 ? ` und ${changed.length - 5} weitere` : "");
-  return `Das Web des Hosts unter ${directory} passt nicht mehr zu seinen Quellen (geändert: ${shown})`;
+  const shown = changed.slice(0, 5).join(", ") + (changed.length > 5 ? ` and ${changed.length - 5} more` : "");
+  return `The host's web under ${directory} no longer matches its sources (changed: ${shown})`;
 };