@schlenkr/ragents 0.1.10 → 0.1.12

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

@@ -48,23 +48,23 @@ export interface RegisteredWorkspaceRoot {
   ownershipDirectoryFor?: (runId: string) => string | Promise<string>;
 }
 
-/** Eine Wurzel des Servers, wie ein Prompt sie nennt: ihr Alias, ob Werkzeuge darin schreiben dürfen, und die Variable, die sie in einer Bash auf dem Server nennt. */
+/** A root of the server as a prompt names it: its alias, whether tools may write in it, and the variable that names it in a bash on the server. */
 export interface ServerRootDescription {
   readonly alias: string;
   readonly writable: boolean;
   readonly environmentVariable?: string;
 }
 
-/** Der einzige Zugang der Plugins zum Arbeitsbereich eines Runs: eine Operation läuft beim Executor der Maschine, der die angesprochene Wurzel gehört. */
+/** The plugins' only access to a run's workspace: an operation runs at the executor of the machine that owns the addressed root. */
 export interface SandboxServices {
   execute: (runId: string, operation: string, input: unknown, options?: WorkspaceExecuteOptions) => Promise<unknown>;
-  /** Der Kontext für Arbeit, die auf dem Server läuft (TypeScript-Plattform, Actor-Programme); nie der Ordner eines Arbeitsplatzes. */
+  /** The context for work that runs on the server (TypeScript platform, actor programs); never the folder of a workstation. */
   serverProcessContextFor: (runId: string) => Promise<WorkspaceProcessContext>;
   registerWorkspaceRoot: (root: RegisteredWorkspaceRoot) => void;
   shutdown: (runId: string) => Promise<void>;
 }
 
-/** Ein fachlicher Fehler des Executors sieht beim Aufrufer aus wie jeder andere Fehler des Servers. */
+/** A domain error of the executor looks to the caller like any other error of the server. */
 export const withDomainCause = (error: unknown): unknown =>
   error instanceof WorkspaceOperationError ? new DomainError(error.code, error.message, error.status) : error;
 
@@ -72,24 +72,24 @@ 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. */
+  /** What the profile's plugins contribute to this server's executor; every workstation of the runs carries the same contributions. */
   contributions: readonly WorkspaceExecutorParts[];
   workspaceFor: (runId: string) => Promise<SessionWorkspace>;
   identFor: (runId: string) => Promise<SessionIdent | undefined>;
   skillPaths: () => Promise<readonly string[]>;
   homeFor: (runId: string) => Promise<SandboxHomeEnvironment>;
   storageRootFor?: (runId: string) => string;
-  /** Der Executor eines Runs, der nicht auf dem Server arbeitet; ohne Antwort führt der Executor des Servers aus. */
+  /** The executor of a run that does not work on the server; without an answer the server's executor executes. */
   executorFor?: (runId: string) => Promise<WorkspaceExecutor | undefined>;
-  /** Der eigene Ordner eines solchen Runs auf dem Server, für Arbeit, die dort läuft. */
+  /** The own folder of such a run on the server, for work that runs there. */
   serverDirectoryFor?: (runId: string) => Promise<string>;
-  /** Die Prozess-Sandbox, in der jeder Prozess des Executors dieses Servers startet; ohne sie laufen Prozesse ohne. */
+  /** The process sandbox in which every process of this server's executor starts; without it processes run without one. */
   processSandbox?: RunProcessSandboxes;
-  /** Die Bash des Executors dieses Servers; unter Windows Pflicht, sonst ohne Angabe die des Systems. */
+  /** The bash of this server's executor; required on Windows, otherwise the system's when not set. */
   bash?: string;
-  /** Das rg des Executors dieses Servers; ohne Angabe gilt eines im PATH. */
+  /** The rg of this server's executor; when not set, one on the PATH applies. */
   rg?: string;
-  /** Die Zeitgrenze von bash in Sekunden für Aufrufe ohne eigene, auf jeder Maschine der Runs; ohne Angabe die des Werkzeugs. */
+  /** The bash time limit in seconds for calls without their own, on every machine of the runs; when not set, the tool's. */
   bashTimeoutSeconds?: number;
 }
 
@@ -102,7 +102,7 @@ const sandboxDescriptions: Readonly<Record<string, string>> = {
 
 const describeSandboxTool = (definition: AgentToolDefinition): AgentToolDefinition => {
   const description = sandboxDescriptions[definition.name];
-  if (!description) throw new Error(`Das Sandbox-Werkzeug ${definition.name} hat keine Kurzbeschreibung`);
+  if (!description) throw new Error(`The sandbox tool ${definition.name} has no short description`);
   return { ...definition, description, longDescription: definition.description, nativeTool: true };
 };
 
@@ -119,39 +119,39 @@ interface StableRunParts {
   ident?: SessionIdent;
   home: SandboxHomeEnvironment;
   readOnlyRoots: readonly ResolvedWorkspaceRoot[];
-  /** Der eigene Temp-Ordner des Runs in der Sandbox. */
+  /** The run's own temp folder in the sandbox. */
   temporary?: string;
 }
 
 const mixedRoots = (aliases: readonly string[]): DomainError => new DomainError(
   "workspace-roots-mixed",
-  `Der Aufruf nennt ${aliases.join(", ")} auf dem Server und zugleich einen Pfad im Arbeitsbereich auf dem Arbeitsplatz; `
-    + "ein Aufruf erreicht nur einen Rechner. Teile ihn in einen Aufruf je Rechner.",
+  `The call names ${aliases.join(", ")} on the server and at the same time a path in the workspace on the workstation; `
+    + "a call reaches only one machine. Split it into one call per machine.",
   400,
 );
 
-/** Die Ordner, die ein Arbeitsbereich der Prozess-Sandbox zusätzlich öffnet, getrennt nach Zugriff; ein relativer Pfad hätte auf dem Server keinen Ort. */
+/** The folders a workspace additionally opens to the process sandbox, separated by access; a relative path would have no location on the server. */
 const sandboxFoldersWith = (folders: readonly SandboxFolder[], access: SandboxFolder["access"]): string[] =>
   folders.filter((folder) => folder.access === access).map((folder) => {
-    if (!path.isAbsolute(folder.directory)) throw new Error(`Der Ordner ${folder.directory} für die Prozess-Sandbox muss absolut sein`);
+    if (!path.isAbsolute(folder.directory)) throw new Error(`The folder ${folder.directory} for the process sandbox must be absolute`);
     return folder.directory;
   });
 
-/** Ein nur lesbarer Pfad, den es nicht gibt, ist keine Wurzel; ein fehlender Skill-Ordner darf keinen Run verhindern. */
+/** A read-only path that does not exist is not a root; a missing skill folder must not prevent a run. */
 const existingRoots = async (roots: readonly ResolvedWorkspaceRoot[]): Promise<ResolvedWorkspaceRoot[]> => {
   const resolved = await Promise.all(roots.map((root) =>
     realpath(root.directory).then((directory) => ({ ...root, directory }), () => undefined)));
   return resolved.filter((root) => root !== undefined);
 };
 
-/** Der Executor des Servers mit den Wurzeln des Servers; eine Operation mit Alias läuft dort, jede andere beim Executor der Bindung des Runs. */
+/** The server's executor with the server's roots; an operation with an alias runs there, every other one at the executor of the run's binding. */
 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>>();
-  /** Je Run der Dateistand, den ein Modell zuletzt gesehen hat, nach Actor, Modellkontext und Pfad; nur im Speicher, ein Verlust verlangt höchstens ein neues read. */
+  /** Per run the file state a model saw last, by actor, model context and path; only in memory, a loss requires at most a new read. */
   readonly #seen = new Map<string, Map<string, SeenFile>>();
 
   constructor(options: WorkspaceSandboxHostOptions) {
@@ -165,14 +165,14 @@ export class WorkspaceSandboxHost implements SandboxServices {
 
   registerWorkspaceRoot(root: RegisteredWorkspaceRoot): void {
     if (!root.id.trim() || this.#workspaceRoots.some((entry) => entry.id === root.id)) {
-      throw new Error(`Arbeitsverzeichnis ${root.id} ist leer oder bereits registriert`);
+      throw new Error(`Working directory ${root.id} is empty or already registered`);
     }
     if (root.alias && (!/^@[a-z][a-z0-9-]*$/.test(root.alias) || root.alias === SKILLS_ALIAS
       || this.#workspaceRoots.some((entry) => entry.alias === root.alias))) {
-      throw new Error(`Arbeitsverzeichnis-Alias ${root.alias} ist ungültig, dem Host vorbehalten oder bereits registriert`);
+      throw new Error(`Working directory alias ${root.alias} is invalid, reserved for the host or already registered`);
     }
     if (root.environmentVariable && (!/^RAGENTS_[A-Z_]+_DIR$/.test(root.environmentVariable) || this.#workspaceRoots.some((entry) => entry.environmentVariable === root.environmentVariable))) {
-      throw new Error(`Arbeitsverzeichnis-Variable ${root.environmentVariable} ist ungültig oder bereits registriert`);
+      throw new Error(`Working directory variable ${root.environmentVariable} is invalid or already registered`);
     }
     this.#workspaceRoots.push(root);
   }
@@ -181,7 +181,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     const roots = await Promise.all(this.#workspaceRoots.map(async (entry) => {
       const directory = await entry.directoryFor(runId);
       if (directory === undefined) return undefined;
-      if (!path.isAbsolute(directory)) throw new Error(`Arbeitsverzeichnis ${entry.id} muss absolut sein`);
+      if (!path.isAbsolute(directory)) throw new Error(`Working directory ${entry.id} must be absolute`);
       if (ident) await syncWorkspaceOwnership(await entry.ownershipDirectoryFor?.(runId) ?? directory, {
         ...ident, storageRoot: this.#options.storageRootFor?.(runId),
       });
@@ -190,7 +190,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     return roots.filter((root) => root !== undefined);
   }
 
-  /** Die Wurzeln des Servers mit Alias, die ein Run neben seinem Arbeitsbereich erreicht: die registrierten und die Skill-Ordner. */
+  /** The server's roots with an alias that a run reaches besides its workspace: the registered ones and the skill folders. */
   async serverRoots(): Promise<readonly ServerRootDescription[]> {
     const registered = this.#workspaceRoots.flatMap(({ alias, environmentVariable }) => alias === undefined ? [] : [{
       alias, writable: true, ...(environmentVariable === undefined ? {} : { environmentVariable }),
@@ -199,15 +199,15 @@ export class WorkspaceSandboxHost implements SandboxServices {
     return [...registered, ...skills];
   }
 
-  /** Bei einem Run mit eigenem Executor ein Ordner des Runs auf dem Server, sonst derselbe Kontext wie für seine Werkzeuge. */
+  /** For a run with its own executor a folder of the run on the server, otherwise the same context as for its tools. */
   async serverProcessContextFor(runId: string): Promise<WorkspaceProcessContext> {
     if (!await this.#options.executorFor?.(runId)) return this.#contextFor(runId);
     const serverDirectoryFor = this.#options.serverDirectoryFor;
-    if (!serverDirectoryFor) throw new Error(`Der Run ${runId} arbeitet nicht auf dem Server, und der Sandbox-Host kennt keinen Serverordner für ihn`);
+    if (!serverDirectoryFor) throw new Error(`The run ${runId} does not work on the server, and the sandbox host knows no server folder for it`);
     return this.#contextFor(runId, await serverDirectoryFor(runId));
   }
 
-  /** Der Kontext des Executors dieses Servers; ohne eigenen Ordner der Arbeitsbereich selbst, der dafür auf dem Server liegen muss. */
+  /** The context of this server's executor; without its own folder the workspace itself, which must then lie on the server. */
   async #contextFor(runId: string, serverDirectory?: string): Promise<WorkspaceProcessContext> {
     const workspace = await this.#options.workspaceFor(runId);
     const { ident, home, readOnlyRoots, temporary } = await this.#stableParts(runId, workspace);
@@ -245,18 +245,18 @@ export class WorkspaceSandboxHost implements SandboxServices {
     });
   }
 
-  /** Der Temp-Ordner eines Runs liegt in seiner Ablage, damit er mit dem Run verschwindet und kein anderer Run ihn sieht. */
+  /** A run's temp folder lies in its storage so that it vanishes with the run and no other run sees it. */
   async #temporaryFor(runId: string, ident: SessionIdent | undefined): Promise<string | undefined> {
     if (!this.#options.processSandbox) return undefined;
     const storageRoot = this.#options.storageRootFor?.(runId);
-    if (!storageRoot) throw new Error(`Die Prozess-Sandbox braucht die Ablage des Runs ${runId} für seinen Temp-Ordner`);
+    if (!storageRoot) throw new Error(`The process sandbox needs the storage of the run ${runId} for its temp folder`);
     const directory = path.join(storageRoot, "tmp");
     await mkdir(directory, { recursive: true });
     if (ident) await syncWorkspaceOwnership(directory, { ...ident, storageRoot });
     return realpath(directory);
   }
 
-  /** Kennung, Heimatordner und nur lesbare Wurzeln stehen je Run fest; nur sie werden gemerkt. */
+  /** Identity, home folder and read-only roots are fixed per run; only they are remembered. */
   #stableParts(runId: string, workspace: SessionWorkspace): Promise<StableRunParts> {
     const known = this.#stable.get(runId);
     if (known) return known;
@@ -301,7 +301,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     };
   }
 
-  /** Die Laufzeit, die eine Eingabe selbst verlangt, gilt, wenn der Aufrufer keine nennt; sie verlängert nur das Warten auf einen entfernten Executor. */
+  /** The duration an input asks for itself applies when the caller names none; it only extends the wait for a remote executor. */
   async execute(runId: string, operation: string, input: unknown, options: WorkspaceExecuteOptions = {}): Promise<unknown> {
     try {
       const { roots, durationMs } = this.#local.footprintOf(operation, input);
@@ -313,7 +313,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     }
   }
 
-  /** Auch ein Run mit eigenem Executor hat auf dem Server markierte Prozesse der TypeScript-Plattform; beide Executoren räumen ab. */
+  /** A run with its own executor also has marked TypeScript platform processes on the server; both executors clean up. */
   async shutdown(runId: string): Promise<void> {
     this.#stable.delete(runId);
     this.#seen.delete(runId);
@@ -329,7 +329,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     return this.#local.shutdown();
   }
 
-  /** Aliasse nennen Wurzeln des Servers, jeder andere Pfad die Wurzel des Runs auf der Maschine seiner Bindung; ohne Alias entscheidet die Bindung. */
+  /** Aliases name roots of the server, every other path the run's root on the machine of its binding; without an alias the binding decides. */
   async #executorFor(runId: string, { aliases, runRoot }: AddressedRoots): Promise<WorkspaceExecutor> {
     const bound = await this.#options.executorFor?.(runId);
     if (!bound || aliases.length === 0) return bound ?? this.#local;
@@ -342,7 +342,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
       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.
+        // The server fills in the schema defaults, such as the bash time limit; so what the model sees in the schema applies on every machine.
         execute: (toolCallId: string, params: unknown, signal: AbortSignal | undefined) =>
           this.execute(context.runId, described.name, Value.Default(described.parameters, structuredClone(params)), {
             toolCallId,
@@ -356,7 +356,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     }));
   }
 
-  /** Ein direkter Aufruf des Modells gibt den Stand mit, den es von der Datei gesehen hat, und merkt sich den neuen; ein Aufruf aus TypeScript arbeitet ohne. */
+  /** A direct call of the model passes the state it has seen of the file and remembers the new one; a call from TypeScript works without it. */
   async #fileToolCall(runId: string, name: string, scope: ToolScope, toolCallId: string, input: { path: string }): Promise<string> {
     const options = { toolCallId, ...(scope.signal ? { signal: scope.signal } : {}) };
     if (scope.modelContext === undefined) return textOf(await this.execute(runId, name, input, options) as ToolOutput);
@@ -364,7 +364,7 @@ export class WorkspaceSandboxHost implements SandboxServices {
     const key = [scope.caller.actorId, scope.modelContext, path.posix.normalize(input.path)].join("\0");
     const result = await this.execute(runId, name, { ...input, seen: known.get(key) ?? null }, options) as ToolOutput & { details?: { seen?: SeenFile } };
     const seen = result.details?.seen;
-    if (!seen) throw new Error(`Der Executor meldet nach ${name} keinen Dateistand; Server und Arbeitsplatz brauchen denselben Executor-Stand`);
+    if (!seen) throw new Error(`The executor reports no file state after ${name}; server and workstation need the same executor version`);
     this.#seen.set(runId, known.set(key, seen));
     return textOf(result);
   }

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

@@ -15,16 +15,16 @@ const endOffset = (archive: Buffer): number => {
   for (let offset = archive.byteLength - 22; offset >= first; offset -= 1) {
     if (archive.readUInt32LE(offset) === END_OF_CENTRAL_DIRECTORY) return offset;
   }
-  throw new Error("Das Archiv hat kein Ende des Zentralverzeichnisses; es ist keine ZIP-Datei");
+  throw new Error("The archive has no end of central directory; it is not a ZIP file");
 };
 
 const contentOf = (archive: Buffer, localOffset: number, compression: number, compressedSize: number): Buffer => {
-  if (archive.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) throw new Error(`Der lokale Eintrag bei ${localOffset} fehlt im Archiv`);
+  if (archive.readUInt32LE(localOffset) !== LOCAL_FILE_HEADER) throw new Error(`The local entry at ${localOffset} is missing from the archive`);
   const start = localOffset + 30 + archive.readUInt16LE(localOffset + 26) + archive.readUInt16LE(localOffset + 28);
   const raw = archive.subarray(start, start + compressedSize);
   if (compression === 0) return Buffer.from(raw);
   if (compression === 8) return inflateRawSync(raw);
-  throw new Error(`Das Archiv verwendet die unbekannte Kompression ${compression}`);
+  throw new Error(`The archive uses the unknown compression ${compression}`);
 };
 
 interface DirectoryEntry {
@@ -34,20 +34,20 @@ interface DirectoryEntry {
   readonly localOffset: number;
 }
 
-/** Liest das Zentralverzeichnis; Zip64 und Verschlüsselung sind harte Fehler. */
+/** Reads the central directory; Zip64 and encryption are hard errors. */
 const readDirectory = (archive: Buffer): readonly DirectoryEntry[] => {
   const end = endOffset(archive);
   const count = archive.readUInt16LE(end + 10);
   const directory = archive.readUInt32LE(end + 16);
-  if (count === 0xffff || directory === 0xffffffff) throw new Error("Das Archiv ist Zip64; diese Form wird nicht gelesen");
+  if (count === 0xffff || directory === 0xffffffff) throw new Error("The archive is Zip64; this form is not read");
   const entries: DirectoryEntry[] = [];
   let offset = directory;
   for (let index = 0; index < count; index += 1) {
-    if (archive.readUInt32LE(offset) !== CENTRAL_FILE_HEADER) throw new Error(`Der Verzeichniseintrag ${index} fehlt im Archiv`);
+    if (archive.readUInt32LE(offset) !== CENTRAL_FILE_HEADER) throw new Error(`The directory entry ${index} is missing from the archive`);
     const flags = archive.readUInt16LE(offset + 8);
     const nameLength = archive.readUInt16LE(offset + 28);
     const name = archive.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
-    if ((flags & 0x1) !== 0) throw new Error(`Der Archiveintrag ${name} ist verschlüsselt`);
+    if ((flags & 0x1) !== 0) throw new Error(`The archive entry ${name} is encrypted`);
     if (!name.endsWith("/")) {
       entries.push({
         name,

package/apps/server/src/profile/bundle-manifest.ts

@@ -10,7 +10,7 @@ import { isCheckout } from "../host-web.js";
 import { bundlesRoot, pluginIdOf } from "../plugin-support/plugins-root.js";
 
 export const BUNDLE_MANIFEST_FILE = "ragents-bundle.json";
-export const BUNDLE_FORMAT = 4;
+export const BUNDLE_FORMAT = 5;
 
 /** The value names a half imports from each module of the host API. */
 export type HostNames = Readonly<Record<string, readonly string[]>>;
@@ -23,9 +23,9 @@ export interface BundleManifest {
   /** The names of the host API the bundle uses, per half; a host that lacks one refuses the bundle. */
   readonly hostNames: Readonly<Record<HostApiHalf, HostNames>>;
   /** A hash over every file of the bundle; copies and the build tool check it. */
-  readonly stand: string;
+  readonly revision: string;
   /** A hash over the source folder and the host inputs of the build; a checkout compares it with its built-in plugins. */
-  readonly sourceStand: string;
+  readonly sourceRevision: string;
   readonly server: string;
   readonly web?: { readonly entry: string; readonly css?: string; readonly classes: string };
   /** The contribution to every executor, a self-contained file that any Node process loads. */
@@ -35,7 +35,7 @@ export interface BundleManifest {
   readonly assets: readonly string[];
 }
 
-const MANIFEST_KEYS = new Set(["format", "id", "api", "hostNames", "stand", "sourceStand", "server", "web", "executor", "exports", "uses", "assets"]);
+const MANIFEST_KEYS = new Set(["format", "id", "api", "hostNames", "revision", "sourceRevision", "server", "web", "executor", "exports", "uses", "assets"]);
 const SOURCE_MARKERS = ["ragents-plugin.json", "server/index.ts", "server/index.tsx"];
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -69,9 +69,9 @@ export const isFetchedBundle = (folder: string, dataRoot = ragentsDataRoot()): b
 
 /** How the author, or for a fetched bundle its user, gets a bundle that fits this host again. */
 export const rebuildHint = (folder: string): string => {
-  if (isBuiltInBundle(folder)) return "im Checkout mit pnpm build:plugins neu bauen";
-  if (isFetchedBundle(folder)) return "der Stand kommt von einem Server: mit ragents connect <server-url> neu holen, connect nennt die passende Host-Fassung";
-  return "mit ragents plugin build <quellordner> neu bauen";
+  if (isBuiltInBundle(folder)) return "rebuild in the checkout with pnpm build:plugins";
+  if (isFetchedBundle(folder)) return "this state comes from a server: fetch it again with ragents connect <server-url>, connect names the matching host version";
+  return "rebuild with ragents plugin build <source-folder>";
 };
 
 const SKIPPED_SOURCE_ENTRIES = new Set(["node_modules", ".DS_Store"]);
@@ -98,7 +98,7 @@ const buildInputsOf = (root: string): readonly string[] => [
 ];
 
 /** A hash over every file of a plugin source folder except dependencies and the given output folders, together with the build inputs of the host. */
-export const sourceStandOf = (folder: string, skipped: readonly string[] = [], root = hostRoot()): string => {
+export const sourceRevisionOf = (folder: string, skipped: readonly string[] = [], root = hostRoot()): string => {
   const hash = createHash("sha256");
   for (const relative of sourceFiles(folder, new Set(skipped))) hash.update(`${relative}\0${fileDigest(path.join(folder, relative))}\n`);
   for (const input of buildInputsOf(root)) hash.update(`host:${input}\0${fileDigest(path.join(root, input))}\n`);
@@ -106,7 +106,7 @@ export const sourceStandOf = (folder: string, skipped: readonly string[] = [], r
 };
 
 /** A hash over every file of the bundle except its manifest and what Finder leaves behind, stable across machines. */
-export const bundleStand = (folder: string): string => {
+export const bundleRevision = (folder: string): string => {
   const hash = createHash("sha256");
   const files = filesBelow(folder).filter((name) => name !== BUNDLE_MANIFEST_FILE && path.posix.basename(name) !== ".DS_Store");
   for (const relative of files) hash.update(`${relative}\0${fileDigest(path.join(folder, relative))}\n`);
@@ -114,9 +114,9 @@ export const bundleStand = (folder: string): string => {
 };
 
 /** A copy of a bundle, from a package or an archive, must carry exactly the files it was built with. */
-export const assertBundleStand = (folder: string, manifest: Pick<BundleManifest, "id" | "stand">): void => {
-  if (bundleStand(folder) !== manifest.stand) {
-    throw new Error(`Das Bundle ${manifest.id} in ${folder} hat nicht mehr die Dateien, mit denen es gebaut wurde (stand); ${rebuildHint(folder)}`);
+export const assertBundleRevision = (folder: string, manifest: Pick<BundleManifest, "id" | "revision">): void => {
+  if (bundleRevision(folder) !== manifest.revision) {
+    throw new Error(`The bundle ${manifest.id} in ${folder} no longer has the files it was built with (revision); ${rebuildHint(folder)}`);
   }
 };
 
@@ -133,8 +133,8 @@ const missingHostNames = (manifest: Pick<BundleManifest, "hostNames">, record: H
 export const assertHostNames = (folder: string, manifest: Pick<BundleManifest, "id" | "hostNames">, record: HostApiRecord): void => {
   const missing = missingHostNames(manifest, record);
   if (missing.length === 0) return;
-  throw new Error(`Das Bundle ${manifest.id} braucht aus der Host-API ${record.version} Namen, die dieser Host nicht anbietet (${missing.join("; ")}); `
-    + `es ist gegen einen neueren Host gebaut: den Host aktualisieren, sonst ${rebuildHint(folder)}`);
+  throw new Error(`The bundle ${manifest.id} needs names from host API ${record.version} that this host does not offer (${missing.join("; ")}); `
+    + `it was built against a newer host: update the host, otherwise ${rebuildHint(folder)}`);
 };
 
 /** Reads and checks the manifest; format and host API must match this host exactly. */
@@ -142,32 +142,32 @@ export const readBundleManifest = (folder: string): BundleManifest => {
   const file = path.join(folder, BUNDLE_MANIFEST_FILE);
   if (!statSync(file, { throwIfNoEntry: false })?.isFile()) {
     if (SOURCE_MARKERS.some((marker) => existsSync(path.join(folder, marker)))) {
-      throw new Error(`${folder} ist ein Quellordner, kein Bundle: mit ragents plugin build ${folder} bauen und im Profil den Bundle-Ordner nennen`);
+      throw new Error(`${folder} is a source folder, not a bundle: build it with ragents plugin build ${folder} and name the bundle folder in the profile`);
     }
-    throw new Error(`${folder} ist kein Bundle: ${BUNDLE_MANIFEST_FILE} fehlt`);
+    throw new Error(`${folder} is not a bundle: ${BUNDLE_MANIFEST_FILE} is missing`);
   }
   const id = pluginIdOf(folder);
   const raw = ((): unknown => {
     try {
       return JSON.parse(readFileSync(file, "utf8"));
     } catch (cause) {
-      throw new Error(`${file} ist kein gültiges JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+      throw new Error(`${file} is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
   })();
-  if (!isRecord(raw)) throw new Error(`${file} muss ein Objekt enthalten`);
+  if (!isRecord(raw)) throw new Error(`${file} must contain an object`);
   if (raw.format !== BUNDLE_FORMAT) {
-    throw new Error(`Das Bundle ${id} hat das Format ${String(raw.format)}, dieser Host liest Format ${BUNDLE_FORMAT}; ${rebuildHint(folder)}`);
+    throw new Error(`The bundle ${id} has format ${String(raw.format)}, this host reads format ${BUNDLE_FORMAT}; ${rebuildHint(folder)}`);
   }
-  if (raw.id !== id) throw new Error(`Das Bundle in ${folder} meldet die Kennung ${String(raw.id)}; die Kennung ist der Ordnername ${id}`);
+  if (raw.id !== id) throw new Error(`The bundle in ${folder} reports the id ${String(raw.id)}; the id is the folder name ${id}`);
   if (raw.api !== HOST_API_VERSION) {
-    throw new Error(`Das Bundle ${id} ist für Host-API ${String(raw.api)} gebaut, dieser Host bietet ${HOST_API_VERSION}; ${rebuildHint(folder)}`);
+    throw new Error(`The bundle ${id} is built for host API ${String(raw.api)}, this host offers ${HOST_API_VERSION}; ${rebuildHint(folder)}`);
   }
   const unknown = Object.keys(raw).filter((key) => !MANIFEST_KEYS.has(key));
-  if (unknown.length > 0) throw new Error(`${file}: unbekannte Felder ${unknown.join(", ")}; ${rebuildHint(folder)}`);
+  if (unknown.length > 0) throw new Error(`${file}: unknown fields ${unknown.join(", ")}; ${rebuildHint(folder)}`);
   const malformed = [
     ...(isHostNames(raw.hostNames) ? [] : ["hostNames"]),
-    ...(typeof raw.stand === "string" ? [] : ["stand"]),
-    ...(typeof raw.sourceStand === "string" ? [] : ["sourceStand"]),
+    ...(typeof raw.revision === "string" ? [] : ["revision"]),
+    ...(typeof raw.sourceRevision === "string" ? [] : ["sourceRevision"]),
     ...(typeof raw.server === "string" ? [] : ["server"]),
     ...(isWeb(raw.web) ? [] : ["web"]),
     ...(raw.executor === undefined || raw.executor === EXECUTOR_CONTRIBUTION_FILE ? [] : ["executor"]),
@@ -175,13 +175,13 @@ export const readBundleManifest = (folder: string): BundleManifest => {
     ...(isStringList(raw.uses) ? [] : ["uses"]),
     ...(isStringList(raw.assets) ? [] : ["assets"]),
   ];
-  if (malformed.length > 0) throw new Error(`${file}: ${malformed.join(", ")} fehlt oder hat die falsche Form; ${rebuildHint(folder)}`);
+  if (malformed.length > 0) throw new Error(`${file}: ${malformed.join(", ")} is missing or has the wrong shape; ${rebuildHint(folder)}`);
   const web = raw.web as BundleManifest["web"];
   const webFiles = web === undefined ? [] : [web.entry, web.classes, ...(web.css === undefined ? [] : [web.css])];
   const misplaced = webFiles.filter((entry) => !entry.startsWith("web/") || entry.split("/").includes(".."));
-  if (misplaced.length > 0) throw new Error(`${file}: ${misplaced.join(", ")} liegt nicht unter web/; ${rebuildHint(folder)}`);
+  if (misplaced.length > 0) throw new Error(`${file}: ${misplaced.join(", ")} is not under web/; ${rebuildHint(folder)}`);
   for (const required of [raw.server as string, ...webFiles, ...(raw.executor === undefined ? [] : [EXECUTOR_CONTRIBUTION_FILE])]) {
-    if (!statSync(path.join(folder, required), { throwIfNoEntry: false })?.isFile()) throw new Error(`Dem Bundle ${id} fehlt ${required}; ${rebuildHint(folder)}`);
+    if (!statSync(path.join(folder, required), { throwIfNoEntry: false })?.isFile()) throw new Error(`The bundle ${id} is missing ${required}; ${rebuildHint(folder)}`);
   }
   return raw as unknown as BundleManifest;
 };

package/apps/server/src/profile/compose.ts

@@ -2,6 +2,7 @@ import { PluginHost, type PluginWebAddresses } from "@ragents/engine";
 import { pluginToolsDirectory, prepareExecutorContribution, type LoadedExecutorContribution } from "@ragents/workspace-executor";
 import { config, HOST_SECRET_ENV_NAMES } from "../config.js";
 import { SESSION_MODE, SESSIONS_MODE } from "../layout.js";
+import { aliasCompletionModel, aliasCompletionModelToken } from "../plugin-support/model-completion.js";
 import { withFolderAssets } from "../plugin-support/plugin-folder.js";
 import type { PluginModule } from "../plugin-support/plugin-module.js";
 import { runManagementToken } from "../ragents/global-chat.js";
@@ -29,9 +30,9 @@ export interface ProfileComposition {
   readonly modules: ReadonlyMap<string, PluginModule>;
   /** The plugins with a web half and where the browser loads it; the web loads exactly these. */
   readonly web: ReadonlyMap<string, PluginWebAddresses>;
-  /** Die Beiträge der Bundles zum Executor; der Server baut sie mit den Werkzeugordnern seines Datenordners. */
+  /** The bundles' contributions to the executor; the server builds them with the tool folders of its data folder. */
   readonly executor: readonly LoadedExecutorContribution[];
-  /** Die Vorlage aus defaultStartEntry der Profildatei; der Host lehnt eine nicht registrierte beim Versiegeln ab. */
+  /** The template from defaultStartEntry of the profile file; the host rejects an unregistered one when sealing. */
   readonly defaultStartEntry?: string;
 }
 
@@ -50,23 +51,27 @@ export const composeProfile = (options: ProfileComposition, bridges: HostBridges
   host.provideHost(executorContributionsToken, options.executor.map((loaded) =>
     prepareExecutorContribution(loaded, pluginToolsDirectory(config.dataDir, loaded.plugin))));
   host.provideHost(runManagementToken, () => {
-    if (!bridges.sessions) throw new Error("Der Host stellt keine Sitzungsverwaltung bereit");
+    if (!bridges.sessions) throw new Error("The host provides no session management");
     return bridges.sessions();
   });
+  host.provideHost(aliasCompletionModelToken, (alias) => aliasCompletionModel(() => {
+    if (!bridges.modelRuntime) throw new Error("The host provides no model runtime");
+    return bridges.modelRuntime();
+  }, alias));
   host.provideHost(secretEnvNamesToken, () =>
     [...new Set([...HOST_SECRET_ENV_NAMES, ...host.config.secretKeys()])]);
   for (const id of options.pluginIds) {
     const module = options.modules.get(id);
-    if (!module) throw new Error(`Das Plugin ${id} wurde nicht geladen`);
+    if (!module) throw new Error(`The plugin ${id} was not loaded`);
     const plugin = module.create(host);
     if (plugin.manifest.id !== id) {
-      throw new Error(`Der Plugin-Ordner ${id} meldet die abweichende Kennung ${plugin.manifest.id}`);
+      throw new Error(`The plugin folder ${id} reports the different id ${plugin.manifest.id}`);
     }
     if (plugin.manifest.requires !== undefined) {
-      throw new Error(`Plugin ${id} deklariert requires im Manifest; es gehört in den Modulvertrag`);
+      throw new Error(`Plugin ${id} declares requires in the manifest; it belongs in the module contract`);
     }
     if (plugin.manifest.web !== undefined) {
-      throw new Error(`Plugin ${id} deklariert web im Manifest; das ergibt sich aus dem Bundle`);
+      throw new Error(`Plugin ${id} declares web in the manifest; that follows from the bundle`);
     }
     const web = options.web.get(id);
     host.register(withFolderAssets({