@schlenkr/ragents 0.1.8 → 0.1.9

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

@@ -1,3 +1,5 @@
+import type { ModelCompaction } from "@ragents/ai";
+import type { ThinkingLevel } from "@ragents/engine";
 import type { hostConfigDescriptors } from "./config.js";
 
 export interface EnvironmentReference {
@@ -52,7 +54,23 @@ export interface ProfileUser extends ProfileAnonymousUser {
   readonly token?: EnvironmentReference;
 }
 
-export type ConfigValue = string | number | boolean | readonly string[] | EnvironmentReference | ProvisionedReference;
+/** Ein Eintrag von MODEL_ALIASES: ein Modell unter eigenem Namen mit den Kompaktierungswerten, die für dieses Modell gelten. */
+export interface ProfileModelAlias {
+  readonly alias: string;
+  /** Das Ziel als anbieter/modell aus dem eingebauten Katalog des Anbieters. */
+  readonly model: string;
+  readonly thinking?: ThinkingLevel;
+  readonly compaction: Readonly<ModelCompaction>;
+}
+
+export type ConfigValue =
+  | string
+  | number
+  | boolean
+  | readonly string[]
+  | readonly ProfileModelAlias[]
+  | EnvironmentReference
+  | ProvisionedReference;
 
 type Descriptors = readonly { readonly key: string }[];
 
@@ -64,6 +82,10 @@ type Section<T extends Descriptors> = {
   readonly [Key in T[number]["key"]]?: Key extends SecretKeyOf<T> ? EnvironmentReference : ConfigValue;
 };
 
+type HostSection = Omit<Section<typeof hostConfigDescriptors>, "MODEL_ALIASES"> & {
+  readonly MODEL_ALIASES?: readonly ProfileModelAlias[];
+};
+
 // Der Kern kennt keine Plugin-IDs: welche Sektion und welcher Schlüssel gültig ist, entscheidet die
 // Laufzeitprüfung gegen die Deklarationen der geladenen Plugins.
 export type PluginSection = {
@@ -76,5 +98,5 @@ export type PluginSection = {
 };
 
 export type RAgentsConfig =
-  & { readonly host?: Section<typeof hostConfigDescriptors> }
+  & { readonly host?: HostSection }
   & { readonly [pluginId: string]: PluginSection | undefined };

package/apps/server/src/config.ts

@@ -11,8 +11,6 @@ export const hostConfigDescriptors = [
   { key: "PORT", source: "environment" },
   { key: "DATA_DIR", source: "environment" },
   { key: "AGENT_THINKING", source: "environment" },
-  { key: "AGENT_COMPACTION_RESERVE_TOKENS", source: "environment" },
-  { key: "AGENT_COMPACTION_KEEP_RECENT_TOKENS", source: "environment" },
   { key: "COMPACTION_PROVIDER", source: "environment" },
   { key: "COMPACTION_MODEL", source: "environment" },
   ...modelAliasEnvDescriptors,
@@ -37,10 +35,6 @@ export const config = Object.freeze({
   dataDir: path.resolve(env.value("DATA_DIR", defaultDataDirectory(env.required("PRODUCT_PROFILE")))),
   webDistDir: hostWebDirectory(rootDir),
   agentThinking: env.value("AGENT_THINKING", "high"),
-  agentCompaction: {
-    ...(env.optional("AGENT_COMPACTION_RESERVE_TOKENS") ? { reserveTokens: env.positiveNumber("AGENT_COMPACTION_RESERVE_TOKENS", "") } : {}),
-    ...(env.optional("AGENT_COMPACTION_KEEP_RECENT_TOKENS") ? { keepRecentTokens: env.positiveNumber("AGENT_COMPACTION_KEEP_RECENT_TOKENS", "") } : {}),
-  },
   compactionProvider: env.value("COMPACTION_PROVIDER", "openrouter"),
   compactionModel: env.value("COMPACTION_MODEL", ""),
   productProfile: env.required("PRODUCT_PROFILE"),

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

@@ -1,5 +1,5 @@
 {
-  "version": 6,
+  "version": 7,
   "server": {
     "@ragents/engine": [
       "DomainError",
@@ -239,6 +239,7 @@
       "runManagementToken"
     ],
     "@ragents/host/ragents/host-services": [
+      "executorContributionsToken",
       "hostAddressToken",
       "runGuardToken",
       "runWorkspaceProviderToken",
@@ -266,31 +267,23 @@
       "workflowInstructions"
     ],
     "@ragents/workspace-executor": [
-      "BROWSER_EXECUTABLE_VARIABLE",
-      "BROWSER_OPERATIONS",
       "COMMAND_OPERATIONS",
       "FILE_OPERATIONS",
-      "FSHARP_SERVER_FILE",
-      "FSHARP_SERVER_VARIABLE",
       "PROCESS_OPERATIONS",
-      "ROSLYN_SERVER_FILE",
-      "ROSLYN_SERVER_VARIABLE",
       "RUN_FOLDER_OPERATIONS",
       "RUN_MARKER_ENV",
       "WORKSPACE_EXECUTOR_VERSION",
-      "fsharpAdapter",
       "languageServerOpenOperation",
       "languageServerSolutionsOperation",
       "listDirectory",
       "readTextFile",
-      "roslynAdapter",
+      "ripgrepAvailable",
       "runManagedProcess",
       "safeProcessEnvironment",
       "sandboxRunEnvironment",
       "sandboxedLaunch",
       "shellPlatformText",
       "startManagedService",
-      "typescriptAdapter",
       "watchDirectory"
     ],
     "@ragents/workspace-executor/src/git-config-environment": [

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

@@ -1,5 +1,5 @@
 /** The number of the host API a plugin is built against; it changes with every incompatible change of a list, a listed name or a library. */
-export const HOST_API_VERSION = 6;
+export const HOST_API_VERSION = 7;
 
 /** A library the host shares whole, as its installed version exports it; host code instead names each value it offers. */
 export const LIBRARY = "library";
@@ -90,7 +90,8 @@ export const hostApi: { readonly server: HostApiModules; readonly web: HostApiMo
     "@ragents/host/ragents/document-store": ["documentStoreToken"],
     "@ragents/host/ragents/global-chat": ["globalChatToken", "runManagementToken"],
     "@ragents/host/ragents/host-services": [
-      "hostAddressToken", "runtimeProviderToken", "secretEnvNamesToken", "runGuardToken", "runWorkspaceProviderToken", "workspaceGuardToken",
+      "executorContributionsToken", "hostAddressToken", "runtimeProviderToken", "secretEnvNamesToken", "runGuardToken", "runWorkspaceProviderToken",
+      "workspaceGuardToken",
     ],
     "@ragents/host/ragents/product-runtime": ["productRuntimeToken"],
     "@ragents/host/ragents/runtime-bridge": ["runtimeBridgeToken"],
@@ -100,11 +101,9 @@ export const hostApi: { readonly server: HostApiModules; readonly web: HostApiMo
     ],
     "@ragents/workflow": ["defineWorkflow", "workflowInstructions"],
     "@ragents/workspace-executor": [
-      "BROWSER_EXECUTABLE_VARIABLE", "BROWSER_OPERATIONS", "COMMAND_OPERATIONS", "FILE_OPERATIONS",
-      "FSHARP_SERVER_FILE", "FSHARP_SERVER_VARIABLE", "PROCESS_OPERATIONS", "ROSLYN_SERVER_FILE",
-      "ROSLYN_SERVER_VARIABLE", "RUN_FOLDER_OPERATIONS", "RUN_MARKER_ENV", "WORKSPACE_EXECUTOR_VERSION", "fsharpAdapter",
-      "languageServerOpenOperation", "languageServerSolutionsOperation", "listDirectory", "readTextFile", "roslynAdapter", "runManagedProcess", "safeProcessEnvironment", "sandboxRunEnvironment", "sandboxedLaunch",
-      "shellPlatformText", "startManagedService", "typescriptAdapter", "watchDirectory",
+      "COMMAND_OPERATIONS", "FILE_OPERATIONS", "PROCESS_OPERATIONS", "RUN_FOLDER_OPERATIONS", "RUN_MARKER_ENV", "WORKSPACE_EXECUTOR_VERSION",
+      "languageServerOpenOperation", "languageServerSolutionsOperation", "listDirectory", "readTextFile", "ripgrepAvailable", "runManagedProcess", "safeProcessEnvironment", "sandboxRunEnvironment", "sandboxedLaunch",
+      "shellPlatformText", "startManagedService", "watchDirectory",
     ],
     "@ragents/workspace-executor/src/git-config-environment": ["withGitConfigPairs"],
     "@ragents/workspace-executor/src/managed-process": ["ProcessGroupJoinError"],

package/apps/server/src/plugin-build/build.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { Scanner } from "@tailwindcss/oxide";
 import { build as esbuild, type Message, type Metafile, type OutputFile, type PartialMessage, type Plugin } from "esbuild";
 import ts from "typescript";
+import { EXECUTOR_CONTRIBUTION_FILE } from "@ragents/workspace-executor";
 import { installFolder, withLock } from "../folder-install.js";
 import { HOST_API_VERSION, HOST_MODULES_GLOBAL, LIBRARY, hostApi, hostOnly, providedByHost, type HostApiHalf } from "../host-api.js";
 import { checkedHostApiRecord, hostRoot, type HostApiRecord } from "../host-version.js";
@@ -172,13 +173,27 @@ interface HalfState {
 }
 
 /** Keeps a half to the host API, its own folder and declared exports of other plugins; everything else is a build error with its cause. */
-const boundaryPlugin = (source: PluginSource, half: HostApiHalf, environment: BuildEnvironment, state: HalfState, assets: readonly string[]): Plugin => ({
+const boundaryPlugin = (
+  source: PluginSource,
+  half: HostApiHalf,
+  environment: BuildEnvironment,
+  state: HalfState,
+  assets: readonly string[],
+  selfContained: boolean,
+): Plugin => ({
   name: "ragents-plugin-boundary",
   setup(build) {
     const id = source.description.id;
     const packageProblems = new Map<string, string | undefined>();
 
+    /** The executor contribution loads in every process without the host's loader, the VS Code extension included. */
+    const outsideContribution = (specifier: string) => ({ errors: [{
+      text: `${specifier}: der Executor-Beitrag lädt in jedem Node-Prozess ohne die Auflösung des Hosts; er importiert nur node:*, eigene Dateien, `
+        + "gebündelte Bibliotheken und vom Host Typen (import type), alles andere bekommt er über die Maschine",
+    }] });
+
     const crossImport = (owner: string, name: string) => {
+      if (selfContained) return outsideContribution(`@ragents/plugins/${owner}/${name}`);
       state.uses.add(owner);
       return half === "server"
         ? { path: `@ragents/plugins/${owner}/${name}`, external: true }
@@ -221,6 +236,7 @@ const boundaryPlugin = (source: PluginSource, half: HostApiHalf, environment: Bu
           }
           return crossImport(owner, name);
         }
+        if (selfContained && (providedByHost(half, specifier) || hostOnly(specifier))) return outsideContribution(specifier);
         if (providedByHost(half, specifier)) {
           if (args.kind === "dynamic-import" && (half === "web" || !isLibrary(half, specifier))) {
             return { errors: [{ text: `import() von ${specifier}: ein Modul des Hosts wird statisch importiert, damit der Bau jeden Namen gegen die Host-API prüft` }] };
@@ -381,23 +397,27 @@ const nodePathsOf = (root: string, half: HostApiHalf): string[] =>
   [path.join(root, "node_modules"), path.join(root, half === "server" ? "apps/server/node_modules" : "apps/web/node_modules")]
     .filter((folder) => existsSync(folder));
 
+/** Builds a half; `selfContained` builds the executor contribution as one file under executor/ that imports nothing but node:*. */
 const buildHalf = async (
   source: PluginSource,
   half: HostApiHalf,
   entries: readonly { readonly in: string; readonly out: string }[],
   environment: BuildEnvironment,
   assets: readonly string[],
+  selfContained = false,
 ): Promise<HalfResult | { readonly problems: readonly string[] }> => {
   const state: HalfState = { uses: new Set() };
   const id = source.description.id;
-  const problemsOf = (messages: readonly Message[]): readonly string[] => messages.map((message) => `${half}: ${messageText(message, source.folder)}`);
+  const part = selfContained ? path.posix.dirname(EXECUTOR_CONTRIBUTION_FILE) : half;
+  const problemsOf = (messages: readonly Message[]): readonly string[] => messages.map((message) => `${part}: ${messageText(message, source.folder)}`);
   try {
     const result = await esbuild({
       absWorkingDir: source.folder,
       entryPoints: [...entries],
-      outdir: path.join(environment.out, id, half),
+      outdir: path.join(environment.out, id, part),
       bundle: true,
-      splitting: true,
+      splitting: !selfContained,
+      ...(selfContained ? { outExtension: { ".js": path.posix.extname(EXECUTOR_CONTRIBUTION_FILE) } } : {}),
       format: "esm",
       write: false,
       metafile: true,
@@ -416,7 +436,7 @@ const buildHalf = async (
         define: { "process.env.NODE_ENV": JSON.stringify("production") },
       } : { banner: { js: SERVER_BANNER } }),
       logLevel: "silent",
-      plugins: [boundaryPlugin(source, half, environment, state, assets)],
+      plugins: [boundaryPlugin(source, half, environment, state, assets, selfContained)],
     });
     const fatal = result.warnings.filter((warning) => FATAL_WARNINGS.has(warning.id));
     if (fatal.length > 0) return { problems: problemsOf(fatal) };
@@ -472,6 +492,7 @@ const buildPlugin = async (folder: string, environment: BuildEnvironment, typeEr
   const serverEntry = sourceFileOf(path.join(source.folder, "server/index"));
   const webEntry = sourceFileOf(path.join(source.folder, "web/index"));
   const provision = sourceFileOf(path.join(source.folder, "provision"));
+  const executorEntry = sourceFileOf(path.join(source.folder, "executor"));
   const exportEntries = (half: HostApiHalf) => source.description.exports[half].map((name) => ({
     in: sourceFileOf(path.join(source.folder, name))!,
     out: `exports/${name}`,
@@ -481,6 +502,7 @@ const buildPlugin = async (folder: string, environment: BuildEnvironment, typeEr
   const results = await Promise.all([
     buildHalf(source, "server", [{ in: provision ? "ragents-entry:server" : serverEntry, out: "index" }, ...exportEntries("server")], environment, assets),
     ...(hasWeb ? [buildHalf(source, "web", [...(webEntry ? [{ in: webEntry, out: "index" }] : []), ...exportEntries("web")], environment, assets)] : []),
+    ...(executorEntry ? [buildHalf(source, "server", [{ in: executorEntry, out: path.posix.parse(EXECUTOR_CONTRIBUTION_FILE).name }], environment, assets, true)] : []),
   ]);
   const problems = results.flatMap((result) => "problems" in result ? result.problems : []);
   if (problems.length > 0) return failed(problems);
@@ -525,6 +547,7 @@ const buildPlugin = async (folder: string, environment: BuildEnvironment, typeEr
           classes: "web/classes.json",
         },
       } : {}),
+      ...(executorEntry ? { executor: EXECUTOR_CONTRIBUTION_FILE } : {}),
       exports: {
         server: Object.fromEntries(source.description.exports.server.map((name) => [name, exportOutput("server", name)])),
         web: Object.fromEntries(source.description.exports.web.map((name) => [name, exportOutput("web", name)])),

package/apps/server/src/plugin-build/plugin-description.ts

@@ -19,7 +19,7 @@ export interface PluginSource {
 
 const ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
 /** Places of the bundle the build tool writes itself; an asset there would overwrite its output or publish sources under /plugins/<id>/web/. */
-const RESERVED_ASSET_ROOTS = new Set(["server", "web", "ragents-bundle.json"]);
+const RESERVED_ASSET_ROOTS = new Set(["server", "web", "executor", "ragents-bundle.json"]);
 const DESCRIPTION_KEYS = new Set(["id", "exports", "assets"]);
 const HALVES = new Set(["server", "web"]);
 

package/apps/server/src/plugin-build/typecheck.ts

@@ -11,9 +11,9 @@ export const PLUGIN_TSCONFIG: Readonly<Record<HostApiHalf, string>> = {
   web: "apps/web/tsconfig.plugin.json",
 };
 
-/** The files a half starts from: its entry, the provisioning for the server, and the declared exports. */
+/** The files a half starts from: its entry, the provisioning and the executor contribution for the server, and the declared exports. */
 export const halfEntries = (source: PluginSource, half: HostApiHalf): readonly string[] => {
-  const own = half === "server" ? ["server/index", "provision"] : ["web/index"];
+  const own = half === "server" ? ["server/index", "provision", "executor"] : ["web/index"];
   return [...own, ...source.description.exports[half]]
     .map((name) => sourceFileOf(path.join(source.folder, name)))
     .filter((file): file is string => file !== undefined);

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

@@ -1,5 +1,5 @@
 import type { PluginConfigDescriptor, RAgentsPlugin } from "@ragents/engine";
-import type { LanguageServerAdapter } from "@ragents/workspace-executor";
+import type { LanguageServerDescription } from "@ragents/workspace-executor";
 import { workspaceGuardToken } from "../../ragents/host-services.js";
 import { sandboxServicesToken } from "../workspace-sandbox-host.js";
 import { createLanguageServerSnapshotMethod, createLanguageServerSolutionMethods } from "./snapshot-method.js";
@@ -7,7 +7,8 @@ import { createLanguageServerToolContributor } from "./tools.js";
 
 export interface LanguageServerPluginOptions {
   id: string;
-  adapter: LanguageServerAdapter;
+  /** Beschreibt den Sprachserver für Werkzeuge und Reiter; gestartet wird er im Executor aus dem Beitrag des Plugins. */
+  languageServer: LanguageServerDescription;
   tabLabel?: string;
   configDescriptors?: readonly PluginConfigDescriptor[];
   /** Nach jedem erfolgreichen Öffnen über Werkzeug oder Umschalten, mit dem Run. */
@@ -20,16 +21,16 @@ export const createLanguageServerPlugin = (options: LanguageServerPluginOptions)
     const sandbox = host.service(sandboxServicesToken);
     if (options.configDescriptors) host.config(...options.configDescriptors);
     const opened = options.onOpened ?? (() => undefined);
-    host.functions(createLanguageServerToolContributor(options.adapter, sandbox, opened));
-    const solutions = options.adapter.solutionExtensions !== undefined;
+    host.functions(createLanguageServerToolContributor(options.id, options.languageServer, sandbox, opened));
+    const solutions = options.languageServer.solutionExtensions !== undefined;
     host.clientConfig({
-      label: options.tabLabel ?? options.adapter.label,
-      openTool: `${options.adapter.id}_open`,
+      label: options.tabLabel ?? options.languageServer.label,
+      openTool: `${options.languageServer.id}_open`,
       solutions,
     });
     const methodOptions = {
       pluginId: options.id,
-      adapterId: options.adapter.id,
+      adapterId: options.languageServer.id,
       sandbox,
       ensureWorkspaceAccess: host.service(workspaceGuardToken),
       opened,

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

@@ -5,7 +5,7 @@ import {
   languageServerDiagnosticsOperation,
   languageServerOpenOperation,
   languageServerSolutionsOperation,
-  type LanguageServerAdapter,
+  type LanguageServerDescription,
   type LanguageServerSolutions,
   type LanguageServerState,
 } from "@ragents/workspace-executor";
@@ -30,11 +30,12 @@ export const formatSolutions = (label: string, listing: LanguageServerSolutions)
 
 /** Beschreibung und Weiterreichung: der Sprachserver läuft im Executor des Runs, nicht in diesem Plugin. */
 export const createLanguageServerToolContributor = (
-  adapter: LanguageServerAdapter,
+  pluginId: string,
+  languageServer: LanguageServerDescription,
   sandbox: SandboxServices,
   opened: (runId: string) => void,
 ): ToolContributor => {
-  const { id, label, rootDescription, languages } = adapter;
+  const { id, label, rootDescription, languages } = languageServer;
   const extensions = Object.keys(languages).join(", ");
   const openMetadata = {
     name: languageServerOpenOperation(id),
@@ -96,7 +97,7 @@ export const createLanguageServerToolContributor = (
   const solutionsMetadata = {
     name: languageServerSolutionsOperation(id),
     nativeTool: true,
-    description: `List the solution files (${(adapter.solutionExtensions ?? []).join(", ")}) of this run's workspace and mark `
+    description: `List the solution files (${(languageServer.solutionExtensions ?? []).join(", ")}) of this run's workspace and mark `
       + `which ones the ${label} language server has open. ${openMetadata.name} loads another one in addition; `
       + "the open ones stay open.",
   } as const;
@@ -128,9 +129,9 @@ export const createLanguageServerToolContributor = (
         ...(scope.signal ? { signal: scope.signal } : {}),
       }) as string,
   });
-  const withSolutions = adapter.solutionExtensions !== undefined;
+  const withSolutions = languageServer.solutionExtensions !== undefined;
   return {
-    name: `ragents.lsp-${id}`,
+    name: pluginId,
     descriptors: [
       toolDescriptorFrom(openMetadata, alwaysAvailable),
       toolDescriptorFrom(diagnosticsMetadata, alwaysAvailable),

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

@@ -1,10 +1,10 @@
-import { aliasedModel, type ModelAlias as RuntimeModelAlias } from "@ragents/agent";
+import { aliasedModel, compactionProblem, 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 { declaredEnvironment } from "./plugin-config.js";
 
-/** Ein Alias des Profils mit seinem Ziel und optional der Denktiefe, die gilt, solange niemand eine andere wählt. */
+/** Ein Alias des Profils mit Ziel und Kompaktierungswerten und optional der Denktiefe, die gilt, solange niemand eine andere wählt. */
 export interface ModelAlias extends RuntimeModelAlias {
   readonly thinking?: ThinkingLevel;
 }
@@ -17,47 +17,77 @@ export const modelAliasEnvDescriptors = [
 ] as const;
 
 const ALIAS = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const ENTRY_KEYS: readonly string[] = ["alias", "model", "thinking", "compaction"];
 
-/** MODEL_ALIASES: eine Liste "alias=anbieter/modell" oder "alias=anbieter/modell@denktiefe"; der Alias ist der einzige Name, den Oberfläche, Journal und Relay-Clients sehen. */
-export const parseModelAliases = (entries: readonly string[]): readonly ModelAlias[] => {
-  const aliases = entries.map((entry): ModelAlias => {
-    const separator = entry.indexOf("=");
-    const alias = separator > 0 ? entry.slice(0, separator).trim() : "";
-    const rest = separator > 0 ? entry.slice(separator + 1).trim() : "";
-    const at = rest.lastIndexOf("@");
-    const target = at < 0 ? rest : rest.slice(0, at);
-    const thinking = at < 0 ? undefined : rest.slice(at + 1);
-    const slash = target.indexOf("/");
-    if (!ALIAS.test(alias) || slash <= 0 || slash === target.length - 1) {
-      throw new Error(`MODEL_ALIASES: "${entry}" hat nicht das Format "alias=anbieter/modell" oder "alias=anbieter/modell@denktiefe"`);
-    }
-    if (thinking !== undefined && !isThinkingLevel(thinking)) throw new Error(`MODEL_ALIASES: "${entry}" nennt die unbekannte Denktiefe "${thinking}"`);
-    return { alias, upstream: target.slice(0, slash), model: target.slice(slash + 1), ...(thinking === undefined ? {} : { thinking }) };
-  });
+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`);
+  }
+  const entry = value as Record<string, unknown>;
+  const unknown = Object.keys(entry).find((key) => !ENTRY_KEYS.includes(key));
+  if (unknown) throw new Error(`${location}.${unknown} is not supported; allowed are ${ENTRY_KEYS.join(", ")}`);
+  if (typeof entry.alias !== "string" || !ALIAS.test(entry.alias)) {
+    throw new Error(`${location}.alias needs 1 to 64 lowercase letters, digits, dots, underscores or hyphens`);
+  }
+  const target = typeof entry.model === "string" ? entry.model : "";
+  const slash = target.indexOf("/");
+  if (slash <= 0 || slash === target.length - 1) throw new Error(`${location}.model of ${entry.alias} needs the form "provider/model"`);
+  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);
+  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 }),
+    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. */
+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);
   const duplicate = aliases.find((entry, index) => aliases.findIndex((other) => other.alias === entry.alias) !== index);
-  if (duplicate) throw new Error(`MODEL_ALIASES nennt den Alias ${duplicate.alias} mehrfach`);
+  if (duplicate) throw new Error(`MODEL_ALIASES names the alias ${duplicate.alias} more than once`);
   return aliases;
 };
 
 const env = declaredEnvironment(modelAliasEnvDescriptors);
 
-export const configuredModelAliases = (): readonly ModelAlias[] => parseModelAliases(env.list("MODEL_ALIASES"));
+/** Die Aliasse des Profils; in der Umgebung steht MODEL_ALIASES als JSON der Liste aus der Profildatei. */
+export const configuredModelAliases = (): readonly ModelAlias[] => {
+  const value = env.optional("MODEL_ALIASES");
+  if (value === undefined || value === "") return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("MODEL_ALIASES is no JSON list of aliases");
+  }
+  return parseModelAliases(parsed);
+};
 
 /** Der Katalog der Aliasse aus den eingebauten Katalogen ihrer Anbieter, so wie die Modelllaufzeit sie anbietet. */
 export const aliasCatalog = (aliases: readonly ModelAlias[] = configuredModelAliases()): readonly Model<Api>[] => {
-  if (aliases.length === 0) throw new Error(`Der Anbieter ${ALIAS_PROVIDER} braucht MODEL_ALIASES im Abschnitt host`);
+  if (aliases.length === 0) throw new Error(`The provider ${ALIAS_PROVIDER} needs MODEL_ALIASES in the host section`);
   return aliases.map((entry) => {
     const target = getBuiltinModels(entry.upstream as BuiltinProvider).find((model) => model.id === entry.model);
-    if (!target) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);
+    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: die Denktiefe ${entry.thinking} gibt es für ${entry.alias} nicht (gültig: ${supported.join(", ")})`);
+      throw new Error(`MODEL_ALIASES: the thinking level ${entry.thinking} does not exist for ${entry.alias} (valid: ${supported.join(", ")})`);
     }
-    return aliasedModel(ALIAS_PROVIDER, entry.alias, target);
+    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);
   });
 };
 
-/** Die Aliasse des Profils, geprüft gegen die Kataloge ihrer Ziele samt Denktiefe. */
+/** Die Aliasse des Profils, geprüft gegen die Kataloge ihrer Ziele samt Denktiefe und Kompaktierungswerten. */
 export const validatedModelAliases = (): readonly ModelAlias[] => {
   const aliases = configuredModelAliases();
   if (aliases.length > 0) aliasCatalog(aliases);

package/apps/server/src/plugin-support/product-relay.ts

@@ -1,4 +1,5 @@
-import type { Api, Model } from "@ragents/ai";
+import { compactionProblem } from "@ragents/agent";
+import type { Api, Model, ModelCompaction } from "@ragents/ai";
 import type { ModelProviderRegistration } from "@ragents/engine";
 
 export const RELAY_PROVIDER = "relay";
@@ -9,7 +10,7 @@ export interface RelayConnection {
   readonly token: string;
 }
 
-/** Was das Relay je Alias über das dahinterliegende Modell verrät; der echte Name bleibt beim Server. */
+/** Was das Relay je Alias über das dahinterliegende Modell verrät, samt den Kompaktierungswerten des Alias; der echte Name bleibt beim Server. */
 export interface RelayCatalogEntry {
   readonly id: string;
   readonly object: "model";
@@ -19,6 +20,7 @@ export interface RelayCatalogEntry {
     readonly input: Model<Api>["input"];
     readonly contextWindow: number;
     readonly maxTokens: number;
+    readonly compaction: ModelCompaction;
     readonly compat?: Model<Api>["compat"];
   };
 }
@@ -61,6 +63,7 @@ const modelOf = (entry: RelayCatalogEntry, baseUrl: string): Model<"openai-compl
   cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
   contextWindow: entry.catalog.contextWindow,
   maxTokens: entry.catalog.maxTokens,
+  compaction: entry.catalog.compaction,
   ...(entry.catalog.compat ? { compat: entry.catalog.compat as Model<"openai-completions">["compat"] } : {}),
 });
 
@@ -83,6 +86,10 @@ export const createRelayCatalog = (connection: RelayConnection, fetchImpl: typeo
     const body = await response.json() as { data?: unknown };
     if (!Array.isArray(body.data) || !body.data.every(isEntry)) throw new Error(`Das Modell-Relay ${address} liefert keinen gültigen Aliaskatalog`);
     if (body.data.length === 0) throw new Error(`Das Modell-Relay ${address} bietet keine Modelle an`);
+    for (const entry of body.data) {
+      const problem = compactionProblem(entry.catalog.compaction, entry.catalog);
+      if (problem) throw new Error(`The model relay ${address} offers ${entry.id} without valid compaction values: ${problem}`);
+    }
     loaded = body.data.map((entry) => modelOf(entry, baseUrl));
     return loaded;
   };
@@ -110,6 +117,7 @@ export const createRelayCatalog = (connection: RelayConnection, fetchImpl: typeo
           cost: model.cost,
           contextWindow: model.contextWindow,
           maxTokens: model.maxTokens,
+          ...(model.compaction ? { compaction: model.compaction } : {}),
           ...(model.compat ? { compat: model.compat } : {}),
         })),
       },

package/apps/server/src/plugin-support/workspace-sandbox-host.ts

@@ -1,5 +1,6 @@
 import { mkdir, realpath } from "node:fs/promises";
 import path from "node:path";
+import { Value } from "typebox/value";
 import {
   DomainError,
   serviceToken,
@@ -28,6 +29,7 @@ import {
   type SessionIdent,
   type WorkspaceExecuteOptions,
   type WorkspaceExecutor,
+  type WorkspaceExecutorParts,
   type WorkspaceProcessContext,
 } from "@ragents/workspace-executor";
 import { hostRoot } from "../host-version.js";
@@ -70,6 +72,8 @@ export const sandboxServicesToken = serviceToken<SandboxServices>("ragents.works
 
 export interface WorkspaceSandboxHostOptions {
   contributorName: string;
+  /** Was die Plugins des Profils zum Executor dieses Servers beitragen; jeder Arbeitsplatz der Runs trägt dieselben Beiträge. */
+  contributions: readonly WorkspaceExecutorParts[];
   workspaceFor: (runId: string) => Promise<SessionWorkspace>;
   identFor: (runId: string) => Promise<SessionIdent | undefined>;
   skillPaths: () => Promise<readonly string[]>;
@@ -83,6 +87,10 @@ export interface WorkspaceSandboxHostOptions {
   processSandbox?: RunProcessSandboxes;
   /** Die Bash des Executors dieses Servers; unter Windows Pflicht, sonst ohne Angabe die des Systems. */
   bash?: string;
+  /** Das rg des Executors dieses Servers; ohne Angabe gilt eines im PATH. */
+  rg?: string;
+  /** Die Zeitgrenze von bash in Sekunden für Aufrufe ohne eigene, auf jeder Maschine der Runs; ohne Angabe die des Werkzeugs. */
+  bashTimeoutSeconds?: number;
 }
 
 const sandboxDescriptions: Readonly<Record<string, string>> = {
@@ -98,16 +106,13 @@ const describeSandboxTool = (definition: AgentToolDefinition): AgentToolDefiniti
   return { ...definition, description, longDescription: definition.description, nativeTool: true };
 };
 
-const sandboxDescriptorDefinitions = [
+const sandboxDefinitions = (bashTimeoutSeconds: number | undefined): readonly AgentToolDefinition[] => [
   createReadToolDefinition("."),
   createEditToolDefinition("."),
   createWriteToolDefinition("."),
-  createBashToolDefinition("."),
+  createBashToolDefinition(".", bashTimeoutSeconds === undefined ? {} : { defaultTimeoutSeconds: bashTimeoutSeconds }),
 ] as readonly AgentToolDefinition[];
 
-const sandboxDescriptors = sandboxDescriptorDefinitions.map((definition) =>
-  toolDescriptorFrom(describeSandboxTool(definition), alwaysAvailable));
-
 const fileToolNames = new Set(["read", "edit", "write"]);
 
 interface StableRunParts {
@@ -142,6 +147,7 @@ const existingRoots = async (roots: readonly ResolvedWorkspaceRoot[]): Promise<R
 /** Der Executor des Servers mit den Wurzeln des Servers; eine Operation mit Alias läuft dort, jede andere beim Executor der Bindung des Runs. */
 export class WorkspaceSandboxHost implements SandboxServices {
   readonly #options: WorkspaceSandboxHostOptions;
+  readonly #definitions: readonly AgentToolDefinition[];
   readonly #workspaceRoots: RegisteredWorkspaceRoot[] = [];
   readonly #local: WorkspaceOperationExecutor;
   readonly #stable = new Map<string, Promise<StableRunParts>>();
@@ -150,9 +156,10 @@ export class WorkspaceSandboxHost implements SandboxServices {
 
   constructor(options: WorkspaceSandboxHostOptions) {
     this.#options = options;
+    this.#definitions = sandboxDefinitions(options.bashTimeoutSeconds);
     this.#local = new WorkspaceOperationExecutor({
       contextFor: (runId) => this.serverProcessContextFor(runId),
-      modules: workspaceExecutorModules(),
+      modules: workspaceExecutorModules({ contributions: options.contributions }),
     });
   }
 
@@ -234,6 +241,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
       runOperation: workspace.runOperation,
       ...(sandbox ? { sandbox } : {}),
       ...(this.#options.bash === undefined ? {} : { bash: this.#options.bash }),
+      ...(this.#options.rg === undefined ? {} : { rg: this.#options.rg }),
     });
   }
 
@@ -288,7 +296,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
   workspaceTools(): ToolContributor {
     return {
       name: this.#options.contributorName,
-      descriptors: sandboxDescriptors,
+      descriptors: this.#definitions.map((definition) => toolDescriptorFrom(describeSandboxTool(definition), alwaysAvailable)),
       tools: (context) => this.#workspaceToolsFor(context),
     };
   }
@@ -330,12 +338,13 @@ export class WorkspaceSandboxHost implements SandboxServices {
   }
 
   #workspaceToolsFor(context: PluginContext): Promise<RunFunction[]> {
-    return Promise.resolve(sandboxDescriptorDefinitions.map((definition) => {
+    return Promise.resolve(this.#definitions.map((definition) => {
       const described = describeSandboxTool(definition);
       const proxy = {
         ...described,
+        // Die Vorgaben des Schemas, etwa die Zeitgrenze von bash, setzt der Server ein; so gilt auf jeder Maschine, was das Modell im Schema sieht.
         execute: (toolCallId: string, params: unknown, signal: AbortSignal | undefined) =>
-          this.execute(context.runId, described.name, params, {
+          this.execute(context.runId, described.name, Value.Default(described.parameters, structuredClone(params)), {
             toolCallId,
             ...(signal ? { signal } : {}),
           }),