@schlenkr/ragents 0.1.10 → 0.1.12

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

@@ -26,7 +26,7 @@ const libraryDirectory = (name: string): string => {
       if (existsSync(file) && (JSON.parse(readFileSync(file, "utf8")) as { name?: string }).name === name) return directory;
       directory = path.dirname(directory);
     }
-    throw new Error(`Das installierte Paket ${name} besitzt keine Paketmetadaten.`);
+    throw new Error(`The installed package ${name} has no package metadata.`);
   }
 };
 const json = (value: unknown): string => `${JSON.stringify(value, null, 2)}\n`;
@@ -34,7 +34,7 @@ const link = async (source: string, target: string): Promise<void> => {
   await mkdir(path.dirname(target), { recursive: true });
   await symlink(source, target).catch(async (error: NodeJS.ErrnoException) => {
     if (error.code !== "EEXIST") throw error;
-    if (await realpath(target) !== await realpath(source)) throw new Error(`Die vorbereitete Bibliothek ${target} hat einen anderen Ursprung.`);
+    if (await realpath(target) !== await realpath(source)) throw new Error(`The prepared library ${target} has a different origin.`);
   });
 };
 export const prepareAppDependencies = async (directory: string): Promise<void> => {
@@ -96,15 +96,15 @@ export function createTestContextWithContracts(options, contracts) {
   const controller = new AbortController();
   const statePort = {read:()=>structuredClone(state),replace:value=>{state=structuredClone(value);}};
   const declared = new Map(contracts.map(contract=>[contract.id,contract]));
-  for (const name of Object.keys(options.functions ?? {})) if (!declared.has(name)) throw new Error("Unbekannte Testfunktion "+name);
+  for (const name of Object.keys(options.functions ?? {})) if (!declared.has(name)) throw new Error("Unknown test function "+name);
   const capabilities = {descriptors:()=>contracts,call:async(name,input)=>{
     const contract=declared.get(name);
     const call=options.functions?.[name];
-    if(!call)throw new Error("Im Test fehlt die Funktion "+name);
-    if(!Value.Check(contract.schema,input))throw new Error("Testeingabe verletzt den Vertrag von "+name+": "+schemaComplaints(contract.schema,input));
+    if(!call)throw new Error("The test is missing the function "+name);
+    if(!Value.Check(contract.schema,input))throw new Error("Test input violates the contract of "+name+": "+schemaComplaints(contract.schema,input));
     const result=await call(input);
-    assertJsonValue(result,"Testantwort von "+name);
-    if(!Value.Check(contract.resultSchema,result))throw new Error("Testantwort verletzt den Vertrag von "+name+": "+schemaComplaints(contract.resultSchema,result,"result"));
+    assertJsonValue(result,"Test response of "+name);
+    if(!Value.Check(contract.resultSchema,result))throw new Error("Test response violates the contract of "+name+": "+schemaComplaints(contract.resultSchema,result,"result"));
     return result;
   }};
   return {...createRunContext({runId:"test",invocationId:"test",invocationKind:"tool",principal:{id:"test",kind:"service"},state:statePort,capabilities,log:()=>{},signal:controller.signal}),
@@ -163,7 +163,7 @@ const workflowSdkFiles = () => workflowSdk ??= (async () => {
   const diagnostics = ts.getPreEmitDiagnostics(program);
   if (diagnostics.length) throw new Error(diagnostics.map(diagnostic => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")).join("\n"));
   const emitted = program.emit(undefined, (name, content) => { if (name.endsWith("index.d.ts")) declarations = content; if (name.endsWith("prompt-reader.d.ts")) promptDeclarations = content; });
-  if (emitted.emitSkipped || !declarations) throw new Error("Workflow-SDK-Deklarationen konnten nicht erzeugt werden.");
+  if (emitted.emitSkipped || !declarations) throw new Error("Workflow SDK declarations could not be generated.");
   const runtime = await build({ entryPoints: [workflowSource], bundle: true, write: false, platform: "neutral", format: "esm", target: "es2022", logLevel: "silent" });
   const promptRuntime = await build({ entryPoints: [promptSource], bundle: true, write: false, platform: "node", format: "esm", target: "es2022", logLevel: "silent" });
   return { javaScript: runtime.outputFiles[0]!.text, declarations, promptReader: promptRuntime.outputFiles[0]!.text, promptDeclarations };
@@ -215,10 +215,10 @@ export const prepareAppProject = async (directory: string): Promise<void> => {
 
 export const readAppPackage = async (directory: string): Promise<AppPackage> => {
   const pkg = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8")) as Record<string, unknown>;
-  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error(`package.json.ragents ist ungültig: ${schemaComplaints(appPackageSchema, pkg.ragents, "ragents")}`);
-  if (!pkg.ragents.backend && !pkg.ragents.views?.length) throw new Error("Ein Actor-Paket braucht ein Backend oder mindestens eine Ansicht.");
+  if (!Value.Check(appPackageSchema, pkg.ragents)) throw new Error(`package.json.ragents is invalid: ${schemaComplaints(appPackageSchema, pkg.ragents, "ragents")}`);
+  if (!pkg.ragents.backend && !pkg.ragents.views?.length) throw new Error("An actor package needs a backend or at least one view.");
   const views = pkg.ragents.views ?? [];
-  if (new Set(views.map((view) => view.id)).size !== views.length) throw new Error("Ansichtsnamen müssen eindeutig sein.");
+  if (new Set(views.map((view) => view.id)).size !== views.length) throw new Error("View names must be unique.");
   return pkg.ragents;
 };
 
@@ -228,7 +228,7 @@ export const projectSourceFiles = async (directory: string): Promise<{ path: str
     for (const entry of await readdir(path.join(directory, relative), { withFileTypes: true })) {
       if (["node_modules", ".build", "dist", ".git"].includes(entry.name)) continue;
       const name = path.join(relative, entry.name);
-      if (entry.isSymbolicLink()) throw new Error(`App-Quelldateien dürfen keine Symlinks enthalten: ${name}`);
+      if (entry.isSymbolicLink()) throw new Error(`App source files must not contain symlinks: ${name}`);
       if (entry.isDirectory()) await walk(name);
       else if (entry.isFile()) files.push({ path: name, content: await readFile(path.join(directory, name), "utf8") });
     }
@@ -255,18 +255,18 @@ export const compileAppBackend = async (options: {
 }): Promise<{ contract: AppContract; javaScript: string; hash: string }> => {
   const signal = AbortSignal.any([...(options.signal ? [options.signal] : []), AbortSignal.timeout(15_000)]);
   const entry = path.resolve(options.directory, options.backend);
-  if (!entry.startsWith(`${options.directory}${path.sep}`)) throw new Error("Der Backend-Einstieg liegt außerhalb der App.");
+  if (!entry.startsWith(`${options.directory}${path.sep}`)) throw new Error("The backend entry lies outside the app.");
   const result = await build({
     stdin: { contents: `import actor from ${JSON.stringify(`./${options.backend}`)};
 export const describe = () => {
-  for (const name of Object.keys(actor.contract.functions ?? {})) if (typeof actor.functions?.[name] !== 'function') throw new Error('Fehlende Funktion ' + name);
-  if (Boolean(actor.contract.input) !== (typeof actor.onInput === 'function')) throw new Error('input und onInput müssen gemeinsam vorhanden sein.');
+  for (const name of Object.keys(actor.contract.functions ?? {})) if (typeof actor.functions?.[name] !== 'function') throw new Error('Missing function ' + name);
+  if (Boolean(actor.contract.input) !== (typeof actor.onInput === 'function')) throw new Error('input and onInput must be present together.');
   return JSON.parse(JSON.stringify(actor.contract));
 };
 export const handle = (request, context) => {
-  if (request.kind === 'input') { if (!actor.onInput) throw new Error('Dieser Actor verarbeitet keine Eingaben.'); return actor.onInput(request.input, context); }
+  if (request.kind === 'input') { if (!actor.onInput) throw new Error('This actor does not process input.'); return actor.onInput(request.input, context); }
   const handler = actor.functions[request.functionId];
-  if (typeof handler !== 'function') throw new Error('Unbekannte Actor-Funktion ' + request.functionId);
+  if (typeof handler !== 'function') throw new Error('Unknown actor function ' + request.functionId);
   return handler(request.input, context);
 };`, resolveDir: options.directory, sourcefile: "actor-entry.ts", loader: "ts" },
     absWorkingDir: options.directory, platform: "node", format: "esm", target: "node22", bundle: true, packages: "external", write: false,
@@ -277,7 +277,7 @@ export const handle = (request, context) => {
     program: { entry: "server.mjs", files: [{ fileName: "server.mjs", text: javaScript }], exportName: "describe" },
     input: {}, state: {}, cwd: options.directory,
     context: { runId: options.runId, invocationId: "app-contract", invocationKind: "tool", principal: { id: "app-build", kind: "service" }, capabilities: [] },
-  }, { signal, call: async () => { throw new Error("Beim Laden des App-Vertrags sind Run-Aufrufe nicht verfügbar."); }, log: () => undefined });
-  if (!Value.Check(appContractSchema, described.result)) throw new Error(`Der Backend-Export braucht defineActor({state, functions, input?}, {functions, onInput?}) mit gültigen Aktionsverträgen: ${schemaComplaints(appContractSchema, described.result, "contract")}`);
+  }, { signal, call: async () => { throw new Error("Run calls are not available while loading the app contract."); }, log: () => undefined });
+  if (!Value.Check(appContractSchema, described.result)) throw new Error(`The backend export needs defineActor({state, functions, input?}, {functions, onInput?}) with valid action contracts: ${schemaComplaints(appContractSchema, described.result, "contract")}`);
   return { contract: described.result, javaScript, hash: canonicalHash({ javaScript }) };
 };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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