@schlenkr/ragents 0.1.10 → 0.1.11

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

@@ -6,16 +6,16 @@ import type { DeclaredEnvironment } from "./plugin-config.js";
 
 export type ModelCatalogSource = () => readonly Model<Api>[];
 
-/** Der eingebaute Katalog eines Anbieters; ein Plugin kann einen eigenen Katalog liefern, etwa den eines Relays. */
+/** The built-in catalog of a provider; a plugin can supply its own catalog, such as that of a relay. */
 export const builtinCatalog = (provider: string): ModelCatalogSource => () => getBuiltinModels(provider as BuiltinProvider);
 
-/** Der Katalog, den die Modelllaufzeit für einen Anbieter kennt: die Aliasse des Profils oder den eingebauten. */
+/** The catalog the model runtime knows for a provider: the profile's aliases or the built-in one. */
 const providerCatalog = (provider: string): ModelCatalogSource =>
   provider === ALIAS_PROVIDER ? () => aliasCatalog() : builtinCatalog(provider);
 
 export const modelThinkingOptions = (provider: string, model: string, catalog: ModelCatalogSource = providerCatalog(provider)): readonly ThinkingLevel[] => {
   const metadata = catalog().find((entry) => entry.id === model);
-  if (!metadata) throw new Error(`Das Modell ${provider}/${model} fehlt im Modellkatalog`);
+  if (!metadata) throw new Error(`The model ${provider}/${model} is missing from the model catalog`);
   return getSupportedThinkingLevels(metadata);
 };
 
@@ -25,7 +25,7 @@ export interface ModelChoice {
   readonly provider: string;
   readonly selectable: boolean;
   thinkingOptionsFor(model: string | null): readonly ThinkingLevel[];
-  /** Die Denktiefe, die ein Modell mitbringt, wenn es gewählt wird; ohne Angabe gilt die des Koordinators. */
+  /** The thinking level a model brings along when it is chosen; without one the coordinator's applies. */
   defaultThinkingFor?(model: string): ThinkingLevel | undefined;
 }
 
@@ -50,7 +50,7 @@ export const modelChoiceFromEnvironment = (
   const catalog = defaults.catalog ?? providerCatalog(defaults.provider);
   const raw = env.optional("MODEL_SELECTABLE");
   if (raw !== undefined && raw !== "" && raw !== "0" && raw !== "1") {
-    throw new Error(`MODEL_SELECTABLE muss "0" oder "1" sein, nicht "${raw}"`);
+    throw new Error(`MODEL_SELECTABLE must be "0" or "1", not "${raw}"`);
   }
   const released = raw === undefined || raw === "" ? defaults.selectable : raw === "1";
   let resolvedOptions: readonly string[] | undefined;
@@ -58,8 +58,8 @@ export const modelChoiceFromEnvironment = (
     if (resolvedOptions) return resolvedOptions;
     const configured = env.list("AGENT_MODELS");
     const duplicate = configured.find((model, index) => configured.indexOf(model) !== index);
-    if (duplicate) throw new Error(`AGENT_MODELS nennt ${duplicate} mehrfach`);
-    // Ohne AGENT_MODELS gelten alle Aliasse oder die Modelle des Profils, und Agent und Koordinator dürfen dasselbe haben.
+    if (duplicate) throw new Error(`AGENT_MODELS names ${duplicate} more than once`);
+    // Without AGENT_MODELS all aliases or the profile's models apply, and agent and coordinator may share the same one.
     const fallback = defaults.provider === ALIAS_PROVIDER ? catalog().map((model) => model.id) : defaults.fallback();
     const list = configured.length > 0 ? configured : [...new Set(fallback)];
     resolvedOptions = Object.freeze([...list]);
@@ -70,7 +70,7 @@ export const modelChoiceFromEnvironment = (
     if (resolvedDefault) return resolvedDefault;
     const configured = defaults.defaultModel();
     if (!options().includes(configured))
-      throw new Error(`Das Koordinator-Modell ${configured} steht nicht in AGENT_MODELS`);
+      throw new Error(`The coordinator model ${configured} is not in AGENT_MODELS`);
     resolvedDefault = configured;
     return resolvedDefault;
   };
@@ -80,18 +80,18 @@ export const modelChoiceFromEnvironment = (
     const map = new Map<string, readonly ThinkingLevel[]>();
     for (const entry of env.list("AGENT_MODEL_REASONING")) {
       const separator = entry.indexOf(":");
-      if (separator < 0) throw new Error(`AGENT_MODEL_REASONING: "${entry}" hat kein "<modell>: <stufen>"-Format`);
+      if (separator < 0) throw new Error(`AGENT_MODEL_REASONING: "${entry}" does not have the "<model>: <levels>" format`);
       const model = entry.slice(0, separator).trim();
       const levels = entry.slice(separator + 1).trim().split(/[\s,]+/).filter(Boolean);
-      if (!options().includes(model)) throw new Error(`AGENT_MODEL_REASONING nennt ${model}, das nicht in AGENT_MODELS steht`);
-      if (map.has(model)) throw new Error(`AGENT_MODEL_REASONING nennt ${model} mehrfach`);
-      if (levels.length === 0) throw new Error(`AGENT_MODEL_REASONING: ${model} nennt keine Stufe`);
+      if (!options().includes(model)) throw new Error(`AGENT_MODEL_REASONING names ${model}, which is not in AGENT_MODELS`);
+      if (map.has(model)) throw new Error(`AGENT_MODEL_REASONING names ${model} more than once`);
+      if (levels.length === 0) throw new Error(`AGENT_MODEL_REASONING: ${model} names no level`);
       const invalid = levels.find((level) => !isThinkingLevel(level));
-      if (invalid) throw new Error(`AGENT_MODEL_REASONING: ${invalid} ist keine Stufe (gültig: ${thinkingLevels.join(", ")})`);
+      if (invalid) throw new Error(`AGENT_MODEL_REASONING: ${invalid} is not a level (valid: ${thinkingLevels.join(", ")})`);
       const supported = modelThinkingOptions(defaults.provider, model, catalog);
       const unsupported = levels.find((level) => !supported.includes(level as ThinkingLevel));
-      if (unsupported) throw new Error(`AGENT_MODEL_REASONING: ${unsupported} ist für ${defaults.provider}/${model} nicht verfügbar (gültig: ${supported.join(", ")})`);
-      if (new Set(levels).size !== levels.length) throw new Error(`AGENT_MODEL_REASONING: ${model} nennt eine Stufe mehrfach`);
+      if (unsupported) throw new Error(`AGENT_MODEL_REASONING: ${unsupported} is not available for ${defaults.provider}/${model} (valid: ${supported.join(", ")})`);
+      if (new Set(levels).size !== levels.length) throw new Error(`AGENT_MODEL_REASONING: ${model} names a level more than once`);
       map.set(model, Object.freeze(levels as ThinkingLevel[]));
     }
     reasoning = map;

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

@@ -1,6 +1,8 @@
-import { createModels, getSupportedThinkingLevels, type Api, type Model } from "@ragents/ai";
+import type { ModelRuntime } from "@ragents/agent";
+import { createModels, getSupportedThinkingLevels, type Api, type AssistantMessage, type Context, type Model, type SimpleStreamOptions } from "@ragents/ai";
 import { openrouterProvider } from "@ragents/ai/providers/openrouter";
-import type { ThinkingLevel } from "@ragents/engine";
+import { serviceToken, type ServiceToken, type ThinkingLevel } from "@ragents/engine";
+import { ALIAS_PROVIDER, aliasCatalog, configuredModelAliases } from "./model-aliases.js";
 
 /** One question to a model, without history and without tools. */
 export interface TextCompletionRequest {
@@ -25,6 +27,30 @@ export interface CompletionModel {
   readonly complete: (request: TextCompletionRequest) => Promise<TextCompletion>;
 }
 
+type Completer = (model: Model<Api>, context: Context, options: SimpleStreamOptions) => Promise<AssistantMessage>;
+
+const completionModel = (id: string, model: Model<Api>, levels: Model<Api>, completeSimple: Completer): CompletionModel => ({
+  id,
+  thinkingLevels: getSupportedThinkingLevels(levels),
+  complete: async (request) => {
+    const response = await completeSimple(model, {
+      systemPrompt: request.systemPrompt,
+      messages: [{ role: "user", content: request.text, timestamp: Date.now() }],
+    }, {
+      // An omitted effort is the off setting of the model; OpenRouter gets it explicitly.
+      reasoning: request.thinking === "off" ? undefined : request.thinking,
+      temperature: request.temperature,
+      maxTokens: request.maxTokens,
+      maxRetries: 0,
+      timeoutMs: request.timeoutMs,
+      signal: request.signal,
+    });
+    if (response.stopReason !== "stop") return { kind: "unfinished" };
+    if (response.content.some((part) => part.type !== "text" && part.type !== "thinking")) return { kind: "not-text" };
+    return { kind: "text", text: response.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("") };
+  },
+});
+
 /** An OpenRouter model of the built-in catalog that answers over the fastest provider and never retries; the key comes from OPENROUTER_API_KEY. */
 export const openRouterCompletionModel = (id: string): CompletionModel | undefined => {
   const models = createModels();
@@ -34,25 +60,20 @@ export const openRouterCompletionModel = (id: string): CompletionModel | undefin
   const model: Model<Api> = { ...selected, compat: { ...selected.compat,
     openRouterRouting: { ...selected.compat?.openRouterRouting, sort: "latency" },
   } };
-  return {
-    id,
-    thinkingLevels: getSupportedThinkingLevels(selected),
-    complete: async (request) => {
-      const response = await models.completeSimple(model, {
-        systemPrompt: request.systemPrompt,
-        messages: [{ role: "user", content: request.text, timestamp: Date.now() }],
-      }, {
-        // An omitted effort is the off setting of the model; OpenRouter gets it explicitly.
-        reasoning: request.thinking === "off" ? undefined : request.thinking,
-        temperature: request.temperature,
-        maxTokens: request.maxTokens,
-        maxRetries: 0,
-        timeoutMs: request.timeoutMs,
-        signal: request.signal,
-      });
-      if (response.stopReason !== "stop") return { kind: "unfinished" };
-      if (response.content.some((part) => part.type !== "text" && part.type !== "thinking")) return { kind: "not-text" };
-      return { kind: "text", text: response.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("") };
-    },
-  };
+  return completionModel(id, model, selected, (target, context, options) => models.completeSimple(target, context, options));
 };
+
+/** A profile alias (MODEL_ALIASES) over the server's model runtime, with the levels the alias offers; none for an unknown alias. */
+export const aliasCompletionModel = (runtime: () => Promise<ModelRuntime>, alias: string): CompletionModel | undefined => {
+  if (!configuredModelAliases().some((entry) => entry.alias === alias)) return undefined;
+  const offered = aliasCatalog().find((model) => model.id === alias)!;
+  return completionModel(alias, offered, offered, async (_model, context, options) => {
+    const models = await runtime();
+    const model = models.getModel(ALIAS_PROVIDER, alias);
+    if (!model) throw new Error(`The model runtime offers no alias ${alias}`);
+    return models.completeSimple(model, context, options);
+  });
+};
+
+/** Resolves a profile alias to a completion model over the server's model runtime; plugins take it with host.service(...) and call it at any time. */
+export const aliasCompletionModelToken: ServiceToken<(alias: string) => CompletionModel | undefined> = serviceToken("host.alias-completion-model");

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

@@ -0,0 +1,170 @@
+import { EXTENDED_THINKING_LEVELS, type Api, type InputModality, type Model } from "@ragents/ai";
+import { builtinProviders } from "@ragents/ai/providers/all";
+import type { ModelProviderRegistration } from "@ragents/engine";
+import { isEnvironmentReference } from "../config-definition.js";
+import { MissingEnvironmentError } from "../missing-environment.js";
+import type { ModelUpstream } from "./model-upstreams.js";
+import { declaredEnvironment } from "./plugin-config.js";
+import { RELAY_PROVIDER } from "./product-relay.js";
+
+export const modelProviderEnvDescriptors = [
+  { key: "MODEL_PROVIDERS", source: "environment" },
+] as const;
+
+const PROVIDER_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PROVIDER_KEYS: readonly string[] = ["id", "baseUrl", "apiKey", "compat", "models"];
+const COMPAT_KEYS: readonly string[] = ["thinkingFormat", "requiresReasoningContentOnAssistantMessages"];
+const THINKING_FORMATS: readonly string[] = ["qwen-chat-template"];
+const MODEL_KEYS: readonly string[] = ["id", "contextWindow", "maxTokens", "reasoning", "input", "thinkingLevelMap"];
+const INPUTS: readonly InputModality[] = ["text", "image", "video", "file", "audio"];
+
+type Entry = Record<string, unknown>;
+
+const objectAt = (value: unknown, location: string, expected: string): Entry => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${location} must be an object with ${expected}`);
+  return value as Entry;
+};
+
+const onlyKeys = (entry: Entry, allowed: readonly string[], location: string): void => {
+  const unknown = Object.keys(entry).find((key) => !allowed.includes(key));
+  if (unknown) throw new Error(`${location}.${unknown} is not supported; allowed are ${allowed.join(", ")}`);
+};
+
+const positiveInteger = (value: unknown, location: string): number => {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new Error(`${location} must be a positive integer`);
+  return value;
+};
+
+const baseUrlOf = (value: unknown, location: string): string => {
+  const text = typeof value === "string" ? value : "";
+  const url = URL.canParse(text) ? new URL(text) : undefined;
+  if (!url || (url.protocol !== "http:" && url.protocol !== "https:") || text.endsWith("/")) {
+    throw new Error(`${location}.baseUrl needs an http or https address without a trailing slash, such as http://localhost:8000/v1`);
+  }
+  return text;
+};
+
+const apiKeyOf = (value: unknown, location: string, environment: Readonly<Record<string, string | undefined>>): string => {
+  if (!isEnvironmentReference(value) || typeof value.name !== "string" || !ENVIRONMENT_NAME.test(value.name)) {
+    throw new Error(`${location}.apiKey must be env("NAME"); a key never appears in plain text in the configuration`);
+  }
+  const key = environment[value.name];
+  if (!key) {
+    throw new MissingEnvironmentError({ variable: value.name, section: "host", key: "MODEL_PROVIDERS" },
+      `${location}.apiKey refers with env("${value.name}") to an environment variable that is not set in this shell`);
+  }
+  return key;
+};
+
+const compatOf = (value: unknown, location: string): Model<Api>["compat"] => {
+  if (value === undefined) return undefined;
+  const entry = objectAt(value, `${location}.compat`, COMPAT_KEYS.join(" and/or "));
+  onlyKeys(entry, COMPAT_KEYS, `${location}.compat`);
+  if (entry.thinkingFormat !== undefined && !THINKING_FORMATS.includes(entry.thinkingFormat as string)) {
+    throw new Error(`${location}.compat.thinkingFormat "${String(entry.thinkingFormat)}" is not supported; supported are ${THINKING_FORMATS.join(", ")}`);
+  }
+  const reasoningContent = entry.requiresReasoningContentOnAssistantMessages;
+  if (reasoningContent !== undefined && typeof reasoningContent !== "boolean") {
+    throw new Error(`${location}.compat.requiresReasoningContentOnAssistantMessages must be true or false`);
+  }
+  return entry as Model<Api>["compat"];
+};
+
+const thinkingLevelMapOf = (value: unknown, reasoning: boolean, location: string): Model<Api>["thinkingLevelMap"] => {
+  if (value === undefined) return undefined;
+  if (!reasoning) throw new Error(`${location}.thinkingLevelMap needs reasoning: true`);
+  const entry = objectAt(value, `${location}.thinkingLevelMap`, "thinking levels as keys");
+  for (const [level, sent] of Object.entries(entry)) {
+    if (!EXTENDED_THINKING_LEVELS.includes(level as never)) throw new Error(`${location}.thinkingLevelMap.${level} is not a thinking level`);
+    if (sent !== null && (typeof sent !== "string" || !sent)) {
+      throw new Error(`${location}.thinkingLevelMap.${level} must be the value to send or null for a level the model does not offer`);
+    }
+  }
+  return entry as Model<Api>["thinkingLevelMap"];
+};
+
+const modelOf = (value: unknown, index: number, provider: { id: string; baseUrl: string; compat: Model<Api>["compat"] }, location: string): Model<Api> => {
+  const at = `${location}.models[${index}]`;
+  const entry = objectAt(value, at, "id, contextWindow, maxTokens, reasoning, input and optionally thinkingLevelMap");
+  onlyKeys(entry, MODEL_KEYS, at);
+  if (typeof entry.id !== "string" || !entry.id.trim()) throw new Error(`${at}.id must name the model as the server knows it`);
+  const contextWindow = positiveInteger(entry.contextWindow, `${at}.contextWindow`);
+  const maxTokens = positiveInteger(entry.maxTokens, `${at}.maxTokens`);
+  if (maxTokens > contextWindow) throw new Error(`${at}.maxTokens (${maxTokens}) exceeds the contextWindow (${contextWindow})`);
+  if (typeof entry.reasoning !== "boolean") throw new Error(`${at}.reasoning must be true or false`);
+  const input = entry.input;
+  if (!Array.isArray(input) || !input.includes("text") || input.some((kind) => !INPUTS.includes(kind as InputModality))) {
+    throw new Error(`${at}.input needs "text" and optionally ${INPUTS.filter((kind) => kind !== "text").join(", ")}`);
+  }
+  const thinkingLevelMap = thinkingLevelMapOf(entry.thinkingLevelMap, entry.reasoning, at);
+  return {
+    id: entry.id,
+    name: entry.id,
+    api: "openai-completions",
+    provider: provider.id,
+    baseUrl: provider.baseUrl,
+    reasoning: entry.reasoning,
+    input: [...new Set(input as InputModality[])],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow,
+    maxTokens,
+    ...(thinkingLevelMap ? { thinkingLevelMap } : {}),
+    ...(provider.compat ? { compat: provider.compat } : {}),
+  };
+};
+
+const providerOf = (value: unknown, index: number, reserved: ReadonlySet<string>, environment: Readonly<Record<string, string | undefined>>): ModelUpstream => {
+  const location = `MODEL_PROVIDERS[${index}]`;
+  const entry = objectAt(value, location, "id, baseUrl, apiKey, models and optionally compat");
+  onlyKeys(entry, PROVIDER_KEYS, location);
+  if (typeof entry.id !== "string" || !PROVIDER_ID.test(entry.id)) {
+    throw new Error(`${location}.id needs 1 to 64 lowercase letters, digits, dots, underscores or hyphens`);
+  }
+  if (reserved.has(entry.id)) throw new Error(`${location}.id ${entry.id} is already a provider of the host`);
+  const at = `${location} (${entry.id})`;
+  const baseUrl = baseUrlOf(entry.baseUrl, at);
+  const apiKey = apiKeyOf(entry.apiKey, at, environment);
+  const compat = compatOf(entry.compat, at);
+  if (!Array.isArray(entry.models) || entry.models.length === 0) throw new Error(`${at}.models needs at least one model`);
+  const models = entry.models.map((model, modelIndex) => modelOf(model, modelIndex, { id: entry.id as string, baseUrl, compat }, at));
+  const duplicate = models.find((model, modelIndex) => models.findIndex((other) => other.id === model.id) !== modelIndex);
+  if (duplicate) throw new Error(`${at}.models names the model ${duplicate.id} more than once`);
+  return { id: entry.id, baseUrl, apiKey, models };
+};
+
+/** MODEL_PROVIDERS: a list of OpenAI-compatible servers { id, baseUrl, apiKey: env("NAME"), compat?, models }, for instance self-hosted ones. */
+export const parseModelProviders = (entries: unknown, environment: Readonly<Record<string, string | undefined>> = process.env): readonly ModelUpstream[] => {
+  if (!Array.isArray(entries)) throw new Error("MODEL_PROVIDERS must be a list of providers");
+  const reserved = new Set([...builtinProviders().map((provider) => provider.id), RELAY_PROVIDER]);
+  const providers = entries.map((entry, index) => providerOf(entry, index, reserved, environment));
+  const duplicate = providers.find((entry, index) => providers.findIndex((other) => other.id === entry.id) !== index);
+  if (duplicate) throw new Error(`MODEL_PROVIDERS names the provider ${duplicate.id} more than once`);
+  return providers;
+};
+
+const env = declaredEnvironment(modelProviderEnvDescriptors);
+
+/** The profile's providers; the environment holds MODEL_PROVIDERS as JSON of the list from the profile file, each key as its env reference. */
+export const configuredModelProviders = (): readonly ModelUpstream[] => {
+  const value = env.optional("MODEL_PROVIDERS");
+  if (value === undefined || value === "") return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("MODEL_PROVIDERS is no JSON list of providers");
+  }
+  return parseModelProviders(parsed);
+};
+
+/** The registration in the model runtime: every model over the OpenAI-compatible transport with the provider's address and key. */
+export const modelProviderRegistration = (provider: ModelUpstream): ModelProviderRegistration => ({
+  id: provider.id,
+  config: {
+    baseUrl: provider.baseUrl,
+    apiKey: provider.apiKey,
+    api: "openai-completions",
+    models: provider.models.map((model) => ({ ...model })),
+  },
+});

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

@@ -1,7 +1,7 @@
 import type { Api, Model } from "@ragents/ai";
 import { serviceToken, type ServiceToken } from "@ragents/engine";
 
-/** Ein Modellanbieter, den dieser Server mit eigenem Schlüssel erreicht; das Relay reicht Aufrufe dorthin durch. */
+/** A model provider this server reaches with its own key; the relay passes calls through to it. */
 export interface ModelUpstream {
   readonly id: string;
   readonly baseUrl: string;

package/apps/server/src/plugin-support/native-typescript-child.ts

@@ -5,7 +5,7 @@ import type { NativeTypeScriptRequest } from "../../../../packages/ragents/src/t
 import { assertJsonValue, type JsonValue } from "../../../../packages/ragents/src/domain/json.ts";
 
 const send = (message: unknown): void => {
-  if (!process.send || !process.connected) throw new Error("Die Run-Verbindung ist geschlossen.");
+  if (!process.send || !process.connected) throw new Error("The run connection is closed.");
   process.send(message as Parameters<NonNullable<typeof process.send>>[0]);
 };
 const errors = (error: unknown): string => error instanceof Error ? error.message : String(error);
@@ -32,12 +32,12 @@ process.on("message", (raw: unknown) => {
     return;
   }
   if (message.kind === "cancel") {
-    active?.abort(new Error("Der Run-Aufruf wurde abgebrochen."));
+    active?.abort(new Error("The run call was cancelled."));
     return;
   }
   if (message.kind !== "execute") return;
   if (!loaded || active) {
-    send({ kind: "failed", error: "Der Backendprozess ist nicht bereit." });
+    send({ kind: "failed", error: "The backend process is not ready." });
     return;
   }
   const request = message.request!;
@@ -68,7 +68,7 @@ process.on("message", (raw: unknown) => {
       capabilities,
     }) : undefined;
     const handle = loaded![request.program.exportName ?? "handle"];
-    if (typeof handle !== "function") throw new Error(`Backend-Export ${request.program.exportName ?? "handle"} ist keine Funktion.`);
+    if (typeof handle !== "function") throw new Error(`Backend export ${request.program.exportName ?? "handle"} is not a function.`);
     const result: unknown = await handle(request.input, { ...context, actor: request.context.actor, ...(std ? { std } : {}) });
     controller.signal.throwIfAborted();
     if (result !== undefined) assertJsonValue(result, "TypeScript result");

package/apps/server/src/plugin-support/native-typescript-executor.ts

@@ -10,7 +10,7 @@ import { syncWorkspaceOwnership } from "./workspace-ownership.js";
 
 interface ExecutorOptions {
   directoryFor(runId: string): string;
-  /** Die Node-Ausführung läuft immer auf dem Server, auch bei einem Arbeitsbereich auf einem Arbeitsplatz. */
+  /** Node execution always runs on the server, even for a workspace on a workstation. */
   serverProcessContextFor(runId: string): Promise<WorkspaceProcessContext>;
 }
 interface Backend {
@@ -51,7 +51,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
 
   async execute(request: NativeTypeScriptRequest, binding: NativeTypeScriptBinding): Promise<NativeTypeScriptResult> {
     binding.signal?.throwIfAborted();
-    if (this.#closed || this.#stopping.has(request.context.runId)) throw new Error("Die Node-Ausführung wird beendet.");
+    if (this.#closed || this.#stopping.has(request.context.runId)) throw new Error("Node execution is shutting down.");
     const instanceId = request.instanceId ?? `invocation-${randomUUID()}`;
     const key = `${request.context.runId}\0${instanceId}`;
     const fingerprint = createHash("sha256").update(JSON.stringify({ entry: request.program.entry, files: request.program.files })).digest("hex");
@@ -65,7 +65,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
     }
     slot.controller.signal.throwIfAborted();
     const backend = await slot.pending;
-    if (backend.fingerprint !== fingerprint) throw new Error("Die Backend-Revision muss vor dem Codewechsel beendet werden.");
+    if (backend.fingerprint !== fingerprint) throw new Error("The backend revision must be stopped before the code changes.");
     const operation = backend.queue.then(() => this.#invoke(backend, request, binding));
     backend.queue = operation.then(() => undefined, () => undefined);
     try { return await operation; }
@@ -82,13 +82,13 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
     await mkdir(directory, { recursive: true });
     for (const file of request.program.files) {
       const target = path.resolve(directory, file.fileName);
-      if (!target.startsWith(`${directory}${path.sep}`)) throw new Error("Backend-Datei liegt außerhalb des Builds.");
+      if (!target.startsWith(`${directory}${path.sep}`)) throw new Error("Backend file lies outside the build.");
       await mkdir(path.dirname(target), { recursive: true });
       await writeFile(target, file.text);
     }
     const entry = path.resolve(directory, request.program.entry);
     if (!entry.startsWith(`${directory}${path.sep}`) || !request.program.files.some((file) => path.resolve(directory, file.fileName) === entry))
-      throw new Error("Der gebaute Backend-Einstieg fehlt.");
+      throw new Error("The built backend entry is missing.");
     await writeFile(path.join(directory, "package.json"), JSON.stringify({ type: "module" }));
     await writeFile(path.join(directory, "__runner.mjs"), await runner());
     const toolkit = fileURLToPath(new URL("../../../../node_modules", import.meta.url));
@@ -143,7 +143,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
       },
       onError: fail,
       onExit: (code) => {
-        const error = new Error(`Backendprozess beendet (Code ${code}).${stderr.trim() ? `\n${stderr.trim()}` : ""}`);
+        const error = new Error(`Backend process exited (code ${code}).${stderr.trim() ? `\n${stderr.trim()}` : ""}`);
         controller.abort(error);
         backend.reject(error);
         void backend.service.finished.then(() => backend.queue).finally(() => {
@@ -153,15 +153,15 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
         }).catch(() => undefined);
       },
     });
-    const timeout = setTimeout(() => rejectReady(new Error("Das Backend wurde nicht innerhalb von 15 Sekunden bereit.")), 15_000);
-    const abort = () => rejectReady(errorOf(signal?.reason ?? "Der Backendstart wurde abgebrochen."));
+    const timeout = setTimeout(() => rejectReady(new Error("The backend did not become ready within 15 seconds.")), 15_000);
+    const abort = () => rejectReady(errorOf(signal?.reason ?? "The backend start was cancelled."));
     signal?.addEventListener("abort", abort, { once: true });
     try {
       signal?.throwIfAborted();
       await backend.service.send({ kind: "load", entry });
       await ready;
       signal.throwIfAborted();
-      if (this.#closed || this.#stopping.has(backend.runId)) throw new Error("Der Run wurde beim Backendstart gestoppt.");
+      if (this.#closed || this.#stopping.has(backend.runId)) throw new Error("The run was stopped during the backend start.");
       return backend;
     } catch (error) {
       backend.service.kill("SIGKILL");
@@ -180,7 +180,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
     const abort = (): void => {
       void backend.service.send({ kind: "cancel" }).catch(() => undefined);
       force = setTimeout(() => backend.service.kill("SIGKILL"), 200);
-      rejectInvocation(errorOf(signal.reason ?? "Der Aufruf wurde abgebrochen."));
+      rejectInvocation(errorOf(signal.reason ?? "The call was cancelled."));
     };
     const operation = new Promise<NativeTypeScriptResult>((resolve, reject) => {
       rejectInvocation = reject;
@@ -195,7 +195,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
           const operation = (async () => {
             try {
               signal.throwIfAborted();
-              if (!capabilities.has(message.name!)) throw new Error(`Capability ${message.name} ist nicht freigegeben.`);
+              if (!capabilities.has(message.name!)) throw new Error(`Capability ${message.name} is not granted.`);
               const value = await binding.call(message.name!, message.input!);
               await backend.service.send({ kind: "reply", callId: message.callId, value });
             } catch (error) {
@@ -234,7 +234,7 @@ export class NodeTypeScriptExecutor implements NativeTypeScriptExecutor {
     const slot = this.#backends.get(key);
     if (!slot) return Promise.resolve();
     if (slot.stopping) return slot.stopping;
-    slot.controller.abort(new Error("Die Node-Instanz wird beendet."));
+    slot.controller.abort(new Error("The Node instance is shutting down."));
     slot.stopping = (async () => {
       const backend = await slot.pending.catch(() => undefined);
       if (!backend) return;

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

@@ -21,7 +21,7 @@ export const declaredEnvironment = <const T extends readonly PluginConfigDescrip
     descriptors.filter((descriptor) => descriptor.source === "environment").map((descriptor) => descriptor.key),
   );
   const read = (key: string): string | undefined => {
-    if (!declared.has(key)) throw new Error(`Umgebungsvariable ${key} ist für dieses Plugin nicht deklariert`);
+    if (!declared.has(key)) throw new Error(`Environment variable ${key} is not declared for this plugin`);
     return process.env[key];
   };
   return {
@@ -30,7 +30,7 @@ export const declaredEnvironment = <const T extends readonly PluginConfigDescrip
     optional: (key) => read(key),
     required: (key) => {
       const value = read(key);
-      if (!value) throw new Error(`Umgebungsvariable ${key} fehlt`);
+      if (!value) throw new Error(`Environment variable ${key} is missing`);
       return value;
     },
     list: (key) => {
@@ -41,7 +41,7 @@ export const declaredEnvironment = <const T extends readonly PluginConfigDescrip
     flag: (key) => read(key) === "1",
     positiveNumber: (key, fallback) => {
       const value = Number(read(key) ?? fallback);
-      if (!Number.isFinite(value) || value <= 0) throw new Error(`${key} muss eine positive Zahl sein`);
+      if (!Number.isFinite(value) || value <= 0) throw new Error(`${key} must be a positive number`);
       return value;
     },
   };

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

@@ -20,7 +20,7 @@ const assetFolder = (folder: string, name: string): string | undefined => {
   const directory = path.join(folder, name);
   const stats = statSync(directory, { throwIfNoEntry: false });
   if (!stats) return undefined;
-  if (!stats.isDirectory()) throw new Error(`${directory} muss ein Verzeichnis sein`);
+  if (!stats.isDirectory()) throw new Error(`${directory} must be a directory`);
   return directory;
 };
 
@@ -74,7 +74,7 @@ export const withFolderAssets = (plugin: RAgentsPlugin): RAgentsPlugin => ({
     if (skillPaths.length === 0) return;
     host.skills({
       id: `${plugin.manifest.id}.folder-skills`,
-      // Ein ausdrücklich angemeldeter Pfad gehört in jedem Run dem ausdrücklichen Beitrag, auch wo der ihn für diesen Run weglässt.
+      // An explicitly registered path belongs to the explicit contribution in every run, even where it omits the path for this run.
       paths: async (context) => {
         const explicit = await Promise.all(explicitSkills.flatMap((skill) => [skill.paths(undefined), skill.paths(context)]));
         const taken = new Set(explicit.flat());

package/apps/server/src/plugin-support/plugins-root.ts

@@ -25,13 +25,13 @@ const folders = new Map<string, string>();
 
 export const registerPluginFolder = (id: string, folder: string): void => {
   const known = folders.get(id);
-  if (known && known !== folder) throw new Error(`Das Plugin ${id} liegt bereits unter ${known}, nicht unter ${folder}`);
+  if (known && known !== folder) throw new Error(`The plugin ${id} already lives under ${known}, not under ${folder}`);
   folders.set(id, folder);
 };
 
 export const pluginFolder = (pluginId: string): string => {
   const folder = folders.get(pluginId) ?? path.join(pluginsRoot, pluginId);
   const stats = statSync(folder, { throwIfNoEntry: false });
-  if (!stats?.isDirectory()) throw new Error(`Das Plugin ${pluginId} hat keinen Ordner ${folder}`);
+  if (!stats?.isDirectory()) throw new Error(`The plugin ${pluginId} has no folder ${folder}`);
   return folder;
 };