@schlenkr/ragents 0.1.7 → 0.1.9

package/packages/workspace-executor/src/contributions.ts

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { WorkspaceOperationError } from "./errors.js";
+import type { LanguageServerAdapter } from "./language-server/host.js";
+import { resolveRootDirectory, resolveRootFile } from "./language-server/roots.js";
+import type { WorkspaceModuleFactory } from "./module.js";
+import { RUN_MARKER_ENV } from "./run-marker.js";
+import { safeProcessEnvironment } from "./safe-environment.js";
+
+/** Wo ein Bundle seinen Beitrag zum Executor trägt: eine in sich geschlossene Datei, die jeder Node-Prozess ohne Host-Auflösung lädt. */
+export const EXECUTOR_CONTRIBUTION_FILE = "executor/index.mjs";
+
+/** Was der Executor einer Maschine einem Beitrag über sie sagt; ein Beitrag importiert vom Host nur Typen, alles andere kommt hierüber. */
+export interface WorkspaceExecutorMachine {
+  /** Der Werkzeugordner des Plugins auf dieser Maschine, wohin seine Provisionierung lädt. */
+  readonly toolsDirectory: string;
+  /** Eine Datei aus einem Paket in den node_modules des Hosts dieser Maschine; ohne Host oder Paket scheitert der Aufruf mit Ursache. */
+  readonly hostPackageFile: (hostRoot: string | undefined, specifier: string) => string;
+  /** Eine Datei mit einer der Endungen im Arbeitsbereich, aufgelöst und geprüft. */
+  readonly resolveRootFile: (workspaceRoot: string, requested: string, extensions: readonly string[]) => Promise<string>;
+  /** Ein Ordner im Arbeitsbereich, aufgelöst und geprüft. */
+  readonly resolveRootDirectory: (workspaceRoot: string, requested: string) => Promise<string>;
+  /** Ein fachlicher Fehler einer Operation mit Kennung und Status; beim Aufrufer kommt er als derselbe Fehler an wie einer des Executors. */
+  readonly operationError: (code: string, message: string, status: number) => Error;
+  /** Die Umgebung eines Prozesses, den ein Beitrag selbst startet: die sichere Auswahl dieser Maschine, ihr HOME und der Marker des Runs für die Prozessanzeige. */
+  readonly processEnvironment: (runId: string) => NodeJS.ProcessEnv;
+}
+
+/** Was ein Beitrag dem Executor einer Maschine hinzufügt. */
+export interface WorkspaceExecutorParts {
+  readonly languageServers?: readonly LanguageServerAdapter[];
+  /** Module mit eigenen Operationen; jede Operation gehört genau einem Modul. */
+  readonly modules?: readonly WorkspaceModuleFactory[];
+}
+
+/** Was ein Plugin-Bundle als `executor` exportiert; es läuft in jedem Executor, im Server wie auf jedem Arbeitsplatz, und berührt beim Bauen weder Platte noch Netz. */
+export type WorkspaceExecutorContribution = (machine: WorkspaceExecutorMachine) => WorkspaceExecutorParts;
+
+/** Wessen Beitrag in welchem Stand; Server und Arbeitsplatz verlangen dieselben. */
+export interface ExecutorContributionStand {
+  readonly plugin: string;
+  /** SHA-256 der Datei des Beitrags. */
+  readonly stand: string;
+}
+
+export interface LoadedExecutorContribution extends ExecutorContributionStand {
+  readonly contribution: WorkspaceExecutorContribution;
+}
+
+/** Ein Beitrag, gebaut für diese Maschine. */
+export interface PreparedExecutorContribution extends ExecutorContributionStand {
+  readonly parts: WorkspaceExecutorParts;
+}
+
+const LANGUAGE_SERVER_ID = /^[a-z][a-z0-9]{0,39}$/;
+const PART_KEYS = new Set(["languageServers", "modules"]);
+
+const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
+
+/** Der Paketname eines Bezeichners wie acme-server/lib/cli.mjs oder @scope/name/datei. */
+const packageOf = (specifier: string): string =>
+  specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+
+const hostPackageFile = (hostRoot: string | undefined, specifier: string): string => {
+  if (!hostRoot) {
+    throw new Error(`Auf diesem Rechner ist kein Host bekannt, aus dem sich ${packageOf(specifier)} auflösen ließe. Ein Arbeitsplatz `
+      + "bekommt ihn mit der ersten Verbindung zu einem verteilenden Server oder über die Einstellung ragents.hostPath");
+  }
+  try {
+    return createRequire(path.join(hostRoot, "package.json")).resolve(specifier);
+  } catch (cause) {
+    throw new Error(`${packageOf(specifier)} liegt nicht im Host ${hostRoot}: ${messageOf(cause)}`);
+  }
+};
+
+export const executorMachine = (toolsDirectory: string): WorkspaceExecutorMachine => ({
+  toolsDirectory,
+  hostPackageFile,
+  resolveRootFile,
+  resolveRootDirectory,
+  operationError: (code, message, status) => new WorkspaceOperationError(code, message, status),
+  processEnvironment: (runId) => ({ ...safeProcessEnvironment(process.env), HOME: homedir(), [RUN_MARKER_ENV]: runId }),
+});
+
+/** Lädt die Datei eines Beitrags, mit `expected` nur in diesem Stand; der Stand steht in ihrer Adresse, damit ein neu gebauter Beitrag nie aus dem Modulcache kommt. */
+export const loadExecutorContribution = async (plugin: string, file: string, expected?: string): Promise<LoadedExecutorContribution> => {
+  const content = await readFile(file).catch((cause: unknown) => {
+    throw new Error(`Der Executor-Beitrag von ${plugin} fehlt unter ${file}: ${messageOf(cause)}`);
+  });
+  const stand = createHash("sha256").update(content).digest("hex");
+  if (expected !== undefined && stand !== expected) {
+    throw new Error(`Der Executor-Beitrag von ${plugin} unter ${file} hat den Stand ${stand.slice(0, 12)}, verlangt ist ${expected.slice(0, 12)}`);
+  }
+  const exported = await import(`${pathToFileURL(file).href}?stand=${stand}`).catch((cause: unknown) => {
+    throw new Error(`Der Executor-Beitrag von ${plugin} (${file}) lädt nicht: ${messageOf(cause)}`, { cause });
+  }) as Readonly<Record<string, unknown>>;
+  const contribution = exported.executor;
+  if (typeof contribution !== "function") {
+    throw new Error(`Das Bundle ${plugin} exportiert in ${file} keinen gültigen Executor-Beitrag; erwartet wird `
+      + "\"export const executor: WorkspaceExecutorContribution\" als Funktion der Maschine");
+  }
+  return { plugin, stand, contribution: contribution as WorkspaceExecutorContribution };
+};
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isStringList = (value: unknown): value is readonly string[] =>
+  Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+/** Was an einem Sprachserver fehlt oder die falsche Form hat; leer, wenn er taugt. */
+const adapterProblems = (value: Readonly<Record<string, unknown>>): readonly string[] => [
+  ...typeof value.id === "string" && LANGUAGE_SERVER_ID.test(value.id) ? [] : ["id aus Kleinbuchstaben und Ziffern"],
+  ...typeof value.label === "string" ? [] : ["label"],
+  ...isRecord(value.languages) && Object.values(value.languages).every((entry) => typeof entry === "string") ? [] : ["languages"],
+  ...typeof value.rootDescription === "string" ? [] : ["rootDescription"],
+  ...value.solutionExtensions === undefined || isStringList(value.solutionExtensions) ? [] : ["solutionExtensions"],
+  ...(["resolveRoot", "rootDirectory", "launch", "open"] as const).filter((name) => typeof value[name] !== "function"),
+];
+
+/** Baut einen geladenen Beitrag für diese Maschine und prüft, was er liefert; eine falsche Form ist ein Fehler mit Ursache. */
+export const prepareExecutorContribution = (loaded: LoadedExecutorContribution, toolsDirectory: string): PreparedExecutorContribution => {
+  const invalid = (detail: string): Error => new Error(`Der Executor-Beitrag von ${loaded.plugin} ist ungültig: ${detail}`);
+  const parts = ((): unknown => {
+    try {
+      return loaded.contribution(executorMachine(toolsDirectory));
+    } catch (cause) {
+      throw invalid(`die Funktion wirft: ${messageOf(cause)}`);
+    }
+  })();
+  if (!isRecord(parts)) throw invalid("die Funktion liefert kein Objekt");
+  const unknown = Object.keys(parts).filter((key) => !PART_KEYS.has(key));
+  if (unknown.length > 0) throw invalid(`unbekannte Teile ${unknown.join(", ")}; erlaubt sind ${[...PART_KEYS].join(", ")}`);
+  const modules = parts.modules;
+  if (modules !== undefined && (!Array.isArray(modules) || !modules.every((module) => typeof module === "function"))) {
+    throw invalid("modules ist keine Liste von Modulfabriken");
+  }
+  const servers = parts.languageServers;
+  if (servers !== undefined && !Array.isArray(servers)) throw invalid("languageServers ist keine Liste");
+  for (const [index, server] of (servers ?? []).entries()) {
+    if (!isRecord(server)) throw invalid(`der Sprachserver ${index + 1} ist kein Objekt`);
+    const problems = adapterProblems(server);
+    if (problems.length > 0) throw invalid(`der Sprachserver ${index + 1} braucht ${problems.join(", ")}`);
+  }
+  return { plugin: loaded.plugin, stand: loaded.stand, parts: parts as WorkspaceExecutorParts };
+};

package/packages/workspace-executor/src/executor.ts

@@ -4,7 +4,7 @@ import type { WorkspaceExecutorModule, WorkspaceModuleFactory, WorkspaceOperatio
 import { NO_ROOTS, type OperationFootprint } from "./paths.js";
 
 /** Der Stand des Executors; Server und Arbeitsplatz müssen denselben tragen. */
-export const WORKSPACE_EXECUTOR_VERSION = "5";
+export const WORKSPACE_EXECUTOR_VERSION = "7";
 
 export interface WorkspaceExecuteOptions {
   toolCallId?: string;

package/packages/workspace-executor/src/index.ts

@@ -18,6 +18,18 @@ export {
   type WorkspaceModuleFactory,
 } from "./module.js";
 export { workspaceExecutorModules, type WorkspaceExecutorModuleOptions } from "./modules.js";
+export {
+  EXECUTOR_CONTRIBUTION_FILE,
+  executorMachine,
+  loadExecutorContribution,
+  prepareExecutorContribution,
+  type ExecutorContributionStand,
+  type LoadedExecutorContribution,
+  type PreparedExecutorContribution,
+  type WorkspaceExecutorContribution,
+  type WorkspaceExecutorMachine,
+  type WorkspaceExecutorParts,
+} from "./contributions.js";
 export { RUN_FOLDER_OPERATIONS, runFolderModule, type RunFolderCreated } from "./run-folders.js";
 export {
   FILE_OPERATIONS,
@@ -37,18 +49,6 @@ export {
   type CommandResult,
   type CommandRunInput,
 } from "./commands.js";
-export {
-  BROWSER_EXECUTABLE_VARIABLE,
-  BROWSER_OPERATIONS,
-  type BrowserCheck,
-  type BrowserCheckResult,
-  type BrowserPageState,
-  type BrowserSnapshot,
-  type BrowserStep,
-  type BrowserTarget,
-  type BrowserViewport,
-} from "./browser/contract.js";
-export { browserModule, type BrowserModuleOptions } from "./browser/module.js";
 export { processGroupExists, runManagedProcess, startManagedService, type ManagedService } from "./managed-process.js";
 export {
   containsWorkspacePath,
@@ -81,15 +81,16 @@ export { labelOf, runProcessesFrom } from "./processes/snapshot.js";
 export { RunProcessTerminator } from "./processes/terminator.js";
 export { RUN_MARKER_ENV } from "./run-marker.js";
 export { editorFreeEnvironment, inheritedProcessEnvironment, safeProcessEnvironment } from "./safe-environment.js";
-export { bashLaunch, type BashLaunch } from "./bash-launch.js";
+export { bashLaunch, ripgrepAvailable, type BashLaunch, type BashPrograms } from "./bash-launch.js";
 export { createSandboxTools, sandboxToolsModule, withAnnotation, type SeenFile } from "./sandbox-tools.js";
 export { type SessionIdent } from "./session-ident.js";
-export { shellPlatformText } from "./shell-platform.js";
-export { ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
+export { shellPlatformText, type ShellTools } from "./shell-platform.js";
+export { hostDataDirectory, pluginToolsDirectory, ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
 export {
   LanguageServerHost,
   changedWorkspaceFiles,
   type LanguageServerAdapter,
+  type LanguageServerDescription,
   type LanguageServerHostOptions,
 } from "./language-server/host.js";
 export {
@@ -112,7 +113,3 @@ export {
 } from "./language-server/module.js";
 export { resolveRootDirectory } from "./language-server/roots.js";
 export { LanguageServerSession, withTimeout } from "./language-server/session.js";
-export { solutionProjects } from "./language-server/solution.js";
-export { fsharpAdapter, FSHARP_SERVER_FILE, FSHARP_SERVER_VARIABLE } from "./language-server/adapters/fsharp.js";
-export { roslynAdapter, ROSLYN_SERVER_FILE, ROSLYN_SERVER_VARIABLE } from "./language-server/adapters/roslyn.js";
-export { typescriptAdapter } from "./language-server/adapters/typescript.js";

package/packages/workspace-executor/src/language-server/host.ts

@@ -27,6 +27,9 @@ export interface LanguageServerAdapter {
   open: (session: LanguageServerSession, root: string, timeoutMs: number) => Promise<string>;
 }
 
+/** Was der Server über einen Sprachserver wissen muss, um Werkzeuge und Reiter zu beschreiben; gestartet wird er nur im Executor. */
+export type LanguageServerDescription = Pick<LanguageServerAdapter, "id" | "label" | "languages" | "rootDescription" | "solutionExtensions">;
+
 export interface LanguageServerHostOptions {
   idleMs?: number;
   openTimeoutMs?: number;

package/packages/workspace-executor/src/language-server/module.ts

@@ -1,5 +1,5 @@
 import { WorkspaceOperationError } from "../errors.js";
-import type { WorkspaceModuleFactory, WorkspaceOperation } from "../module.js";
+import type { WorkspaceExecutorModule, WorkspaceModuleFactory, WorkspaceModuleHost, WorkspaceOperation } from "../module.js";
 import { rootsOfFields, type OperationFootprint } from "../paths.js";
 import { LanguageServerHost, type LanguageServerAdapter, type LanguageServerHostOptions } from "./host.js";
 
@@ -89,7 +89,17 @@ const footprintsOf = (server: LanguageServerHost): Array<readonly [string, (inpu
 export const languageServerModule = (
   adapters: readonly LanguageServerAdapter[],
   options: LanguageServerHostOptions = {},
-): WorkspaceModuleFactory => (host) => {
+): WorkspaceModuleFactory => {
+  const duplicate = adapters.find((adapter, index) => adapters.findIndex((other) => other.id === adapter.id) !== index);
+  if (duplicate) throw new Error(`Der Sprachserver ${duplicate.id} kommt im Executor zweimal vor; seine Operationen gehören genau einem Beitrag`);
+  return (host) => languageServersOn(host, adapters, options);
+};
+
+const languageServersOn = (
+  host: WorkspaceModuleHost,
+  adapters: readonly LanguageServerAdapter[],
+  options: LanguageServerHostOptions,
+): WorkspaceExecutorModule => {
   const servers = adapters.map((adapter) => new LanguageServerHost(adapter, host.contextFor, options));
   return {
     operations: Object.fromEntries(servers.flatMap(operationsOf)),

package/packages/workspace-executor/src/language-server/roots.ts

@@ -22,8 +22,3 @@ export const resolveRootDirectory = async (workspaceRoot: string, requested: str
   if (!info?.isDirectory()) throw new Error(`${requested} ist kein Verzeichnis im Arbeitsverzeichnis`);
   return absolute;
 };
-
-export const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
-  server.toLowerCase().endsWith(".dll")
-    ? { command: "dotnet", args: [server, ...args] }
-    : { command: server, args: [...args] };

package/packages/workspace-executor/src/modules.ts

@@ -1,7 +1,6 @@
-import { browserModule } from "./browser/module.js";
 import { commandModule } from "./commands.js";
+import type { WorkspaceExecutorParts } from "./contributions.js";
 import { fileModule } from "./files.js";
-import { workspaceLanguageServers } from "./language-server/adapters/index.js";
 import { languageServerModule } from "./language-server/module.js";
 import type { WorkspaceModuleFactory } from "./module.js";
 import { processModule } from "./processes/module.js";
@@ -11,15 +10,17 @@ import { sandboxToolsModule } from "./sandbox-tools.js";
 export interface WorkspaceExecutorModuleOptions {
   /** Der neue Ordner eines Runs auf dieser Maschine; nur ein Arbeitsplatz kennt ihn, auf dem Server legt ihn der Host an. */
   runFolder?: (runId: string) => string;
+  /** Die Beiträge der Plugins, gebaut für diese Maschine; Server und Arbeitsplatz bekommen dieselben. */
+  contributions: readonly WorkspaceExecutorParts[];
 }
 
-/** Die Module jedes Executors, im Server wie auf dem Arbeitsplatz dieselben. */
-export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions = {}): readonly WorkspaceModuleFactory[] => [
+/** Die Module eines Executors: die eigenen und was die Beiträge der Plugins hinzufügen. */
+export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions): readonly WorkspaceModuleFactory[] => [
   sandboxToolsModule,
-  languageServerModule(workspaceLanguageServers),
+  languageServerModule(options.contributions.flatMap((parts) => parts.languageServers ?? [])),
   fileModule,
   processModule(),
   commandModule(),
-  browserModule(),
+  ...options.contributions.flatMap((parts) => parts.modules ?? []),
   runFolderModule(options.runFolder),
 ];

package/packages/workspace-executor/src/sandbox-tools.ts

@@ -40,11 +40,6 @@ export interface SandboxTools {
   shutdown: () => Promise<void>;
 }
 
-export const DEFAULT_BASH_TIMEOUT_SECONDS = (() => {
-  const value = Number(process.env.RAGENTS_BASH_TIMEOUT_SECONDS);
-  return Number.isFinite(value) && value > 0 ? value : 600;
-})();
-
 type ToolResult = { content?: Array<{ type: string; text?: string }>; details?: unknown };
 
 /** Der Stand einer Datei, den das Modell zuletzt gesehen hat; der Host führt ihn je Actor und gibt ihn mit, das Modell nennt ihn nie. */
@@ -269,7 +264,7 @@ export const createSandboxTools = async (
       const context = await contextFor();
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
-      const bash = bashLaunch(context.bash, command, context.env);
+      const bash = bashLaunch({ bash: context.bash, rg: context.rg }, command, context.env);
       const launch = await sandboxedLaunch(context, bash);
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
@@ -303,11 +298,10 @@ export const createSandboxTools = async (
             }
           });
         };
-        const timeoutSeconds = options.timeout ?? DEFAULT_BASH_TIMEOUT_SECONDS;
         const timer = setTimeout(() => {
           timedOut = true;
           kill();
-        }, timeoutSeconds * 1000);
+        }, options.timeout * 1000);
         options.signal?.addEventListener("abort", kill);
         const cleanup = () => {
           if (timer) clearTimeout(timer);
@@ -322,7 +316,7 @@ export const createSandboxTools = async (
           const finish = () => processError
             ? reject(processError)
             : timedOut
-              ? reject(new Error(`timeout:${timeoutSeconds}`))
+              ? reject(new Error(`timeout:${options.timeout}`))
               : resolve({ exitCode: killed ? null : code });
           if (!child.pid) {
             finish();

package/packages/workspace-executor/src/shell-platform.ts

@@ -1,11 +1,22 @@
 const platformTexts: Partial<Record<NodeJS.Platform, string>> = {
-  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E` or `rg`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
+  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
   linux: "`bash` runs on Linux with the GNU userland: `grep -P`, `sed -i` without suffix and the usual GNU flags work.",
   win32: "`bash` runs on Windows with the bash RAgents brings along, an MSYS userland with the GNU tools (coreutils, `grep`, `sed`, `awk`, `find`, `xargs`, `diff`, `patch`, `tar`, `gzip`, `unzip`, `file`, `cygpath`, `dos2unix`): `grep -P`, `sed -i` without suffix and the usual GNU flags work. `git`, `dotnet` and `node` are the Windows programs of this machine on the `PATH`, with the user's own configuration and login; they take Windows paths, not `/c/...` (`cygpath -w` converts). The file system is the Windows one: absolute paths are `C:/project/...` or `/c/project/...`, both spellings reach the same file, and a path from another tool may use backslashes. Files often carry CRLF line endings, so anchor patterns with `\\r\\?$` and keep the line ending a file already has.",
 };
 
-export const shellPlatformText = (platform: NodeJS.Platform = process.platform): string => {
+const searchTexts = {
+  ripgrep: "Search code with `rg` (ripgrep) and list files with `rg --files`: it skips hidden files and everything `.gitignore` excludes, such as `node_modules`, `bin` and `obj`, and is far faster than `grep -r` (`rg -uu` searches those too). Use `grep` only on single files or in pipes.",
+  grep: "`rg` (ripgrep) is not available here. `grep -r` also walks dependency and build folders, so exclude them: `grep -r --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj ...`.",
+};
+
+/** Was der Executor dem Werkzeug bash über die Plattform hinaus bietet. */
+export interface ShellTools {
+  readonly ripgrep: boolean;
+}
+
+export const shellPlatformText = (platform: NodeJS.Platform, tools: ShellTools): string => {
   const text = platformTexts[platform];
   if (!text) throw new Error(`Für die Plattform ${platform} gibt es keine Shell-Beschreibung.`);
-  return `${text} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
+  const search = tools.ripgrep ? searchTexts.ripgrep : searchTexts.grep;
+  return `${text} ${search} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
 };

package/packages/workspace-executor/src/tools.ts

@@ -23,6 +23,3 @@ export const workspaceDataDirectory = (home = homedir()): string => path.join(ra
 /** Der Datenordner dieses Prozesses: DATA_DIR wie beim Server, sonst der des Arbeitsplatzes ohne Profil. */
 export const hostDataDirectory = (environment: NodeJS.ProcessEnv = process.env): string =>
   path.resolve(environment.DATA_DIR ?? workspaceDataDirectory());
-
-export const hostToolFile = (pluginId: string, relative: string): string =>
-  path.join(pluginToolsDirectory(hostDataDirectory(), pluginId), ...relative.split("/"));

package/plugins/ragents.ask/ask-payload.ts

@@ -1,5 +1,8 @@
 export const ASK_PLUGIN_ID = "ragents.ask";
 
+/** What the asking tool call gets when a person's message to the asker closes its question. */
+export const SUPERSEDED_ANSWER = "Not answered: the user sent a new message instead.";
+
 export interface AskPayload {
   question: string;
   options: string[];
@@ -23,3 +26,9 @@ export const askPayloadOf = (payload: unknown): AskPayload | undefined => {
     ...(typeof candidate.recipient === "string" ? { recipient: candidate.recipient } : {}),
   };
 };
+
+export const supersedingInputOf = (result: unknown): string | undefined => {
+  if (typeof result !== "object" || result === null) return undefined;
+  const { supersededBy } = result as { supersededBy?: unknown };
+  return typeof supersededBy === "string" ? supersededBy : undefined;
+};

package/plugins/ragents.ask/server/ask-service.ts

@@ -4,20 +4,34 @@ import {
   type Action,
   type CommandContext,
   type JournalEvent,
+  type JsonValue,
   type Orchestration,
 } from "@ragents/engine";
-import { askPayloadOf, ASK_PLUGIN_ID } from "../ask-payload.js";
+import { askPayloadOf, ASK_PLUGIN_ID, SUPERSEDED_ANSWER, supersedingInputOf } from "../ask-payload.js";
 import { DISMISSED_ANSWER, type AskCall, type AskRequest, type AskService } from "./contract.js";
 
 const answerOf = (decision: "approved" | "dismissed", result: unknown): string =>
-  decision !== "approved" ? DISMISSED_ANSWER : typeof result === "string" ? result : result === null || result === undefined ? "" : JSON.stringify(result);
+  decision !== "approved"
+    ? supersedingInputOf(result) === undefined ? DISMISSED_ANSWER : SUPERSEDED_ANSWER
+    : typeof result === "string" ? result : result === null || result === undefined ? "" : JSON.stringify(result);
 
 const resolvedAnswerOf = (action: Action): string | null =>
   action.status === "pending" ? null : answerOf(action.status, action.result);
 
+const humanInputPendingFor = (runtime: Orchestration, runId: string, actorId: string): boolean =>
+  [...runtime.state(runId).inputs.values()].some((input) =>
+    input.actorId === actorId && input.origin === "human" && input.lifecycle.kind === "pending");
+
+interface Waiter {
+  runId: string;
+  /** The actor whose running turn waits for the answer; null for a question asked outside a turn. */
+  blockedActorId: string | null;
+  settle: (answer: string) => void;
+}
+
 export class RuntimeAskService implements AskService {
   #runtime: Orchestration | undefined;
-  readonly #waiters = new Map<string, (answer: string) => void>();
+  readonly #waiters = new Map<string, Waiter>();
   readonly #aborting = new Set<string>();
 
   bind(runtime: Orchestration): void {
@@ -28,6 +42,7 @@ export class RuntimeAskService implements AskService {
 
   ask(call: AskCall, request: AskRequest, signal: AbortSignal | undefined): Promise<string> {
     const runtime = this.#requireRuntime();
+    if (call.turnId && humanInputPendingFor(runtime, call.runId, call.agentId)) return Promise.resolve(SUPERSEDED_ANSWER);
     const context: CommandContext = {
       actorId: call.agentId,
       commandId: call.commandId,
@@ -51,7 +66,7 @@ export class RuntimeAskService implements AskService {
     if (proposed?.type !== "action.proposed") {
       throw new Error(`Die Frage von ${call.agentId} wurde nicht im Journal von ${call.runId} angelegt`);
     }
-    return this.#awaitAnswer(call.runId, proposed.payload.actionId, signal);
+    return this.#awaitAnswer(call.runId, proposed.payload.actionId, call.turnId ? call.agentId : null, signal);
   }
 
   answer(runId: string, actionId: string, input: { answer?: string; dismiss?: boolean }): void {
@@ -72,6 +87,18 @@ export class RuntimeAskService implements AskService {
   }
 
   withdraw(runId: string, actionId: string): void {
+    this.#dismiss(runId, actionId, "ask-withdraw", null, DISMISSED_ANSWER);
+  }
+
+  #supersede(runId: string, actionId: string, inputId: string): void {
+    try {
+      this.#dismiss(runId, actionId, "ask-supersede", { supersededBy: inputId }, SUPERSEDED_ANSWER);
+    } catch (error) {
+      console.error(`Question ${actionId} could not be closed for message ${inputId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  #dismiss(runId: string, actionId: string, commandPrefix: string, result: JsonValue, answer: string): void {
     const runtime = this.#requireRuntime();
     const state = runtime.state(runId);
     const action = state.actions.get(actionId);
@@ -79,18 +106,18 @@ export class RuntimeAskService implements AskService {
     this.#aborting.add(actionId);
     try {
       runtime.resolveAction(
-        { actorId: state.ownerId, commandId: `ask-withdraw:${actionId}:${randomUUID()}` },
+        { actorId: state.ownerId, commandId: `${commandPrefix}:${actionId}:${randomUUID()}` },
         runId,
         actionId,
-        { decision: "dismissed", result: null },
+        { decision: "dismissed", result },
       );
     } finally {
       this.#aborting.delete(actionId);
     }
-    this.#waiters.get(actionId)?.(DISMISSED_ANSWER);
+    this.#waiters.get(actionId)?.settle(answer);
   }
 
-  #awaitAnswer(runId: string, actionId: string, signal: AbortSignal | undefined): Promise<string> {
+  #awaitAnswer(runId: string, actionId: string, blockedActorId: string | null, signal: AbortSignal | undefined): Promise<string> {
     const runtime = this.#requireRuntime();
     const action = runtime.state(runId).actions.get(actionId);
     if (!action) throw new Error(`Frage ${actionId} existiert nicht in Run ${runId}`);
@@ -123,16 +150,29 @@ export class RuntimeAskService implements AskService {
         return;
       }
       signal?.addEventListener("abort", abort, { once: true });
-      this.#waiters.set(actionId, (answer) => {
-        signal?.removeEventListener("abort", abort);
-        this.#waiters.delete(actionId);
-        resolve(answer);
+      this.#waiters.set(actionId, {
+        runId,
+        blockedActorId,
+        settle: (answer) => {
+          signal?.removeEventListener("abort", abort);
+          this.#waiters.delete(actionId);
+          resolve(answer);
+        },
       });
     });
   }
 
   #onJournal(events: JournalEvent[]): void {
     for (const event of events) {
+      if (event.type === "actor.input.enqueued") {
+        if (event.payload.origin !== "human") continue;
+        const { actorId, inputId } = event.payload;
+        for (const [actionId, waiter] of this.#waiters) {
+          if (waiter.runId !== event.runId || waiter.blockedActorId !== actorId) continue;
+          queueMicrotask(() => this.#supersede(event.runId, actionId, inputId));
+        }
+        continue;
+      }
       if (event.type !== "action.resolved") continue;
       if (this.#aborting.has(event.payload.actionId)) continue;
       const resolved = this.#requireRuntime().state(event.runId).actions.get(event.payload.actionId);
@@ -140,7 +180,7 @@ export class RuntimeAskService implements AskService {
       const answer = answerOf(event.payload.decision, event.payload.result);
       const waiter = this.#waiters.get(event.payload.actionId);
       if (waiter) {
-        waiter(answer);
+        waiter.settle(answer);
         continue;
       }
       queueMicrotask(() => this.#enqueueAnswer(event.runId, event.payload.actionId, answer));

package/plugins/ragents.ask/web/AskActionView.tsx

@@ -1,7 +1,7 @@
 import { useAccess } from "@ragents/web/AccessContext";
 import { useState } from "react";
 import type { ActionViewContext } from "@ragents/web/PluginRegistry";
-import { askPayloadOf } from "../ask-payload";
+import { askPayloadOf, SUPERSEDED_ANSWER, supersedingInputOf } from "../ask-payload";
 import { answerQuestion } from "./api";
 import { QuestionCard } from "./QuestionCard";
 
@@ -25,7 +25,8 @@ export function AskActionView({ action, session, text }: ActionViewContext) {
       <QuestionCard
         answer={action.status === undefined
           ? undefined
-          : action.status === "approved" ? answerTextOf(action.result) : "Der Benutzer hat die Frage verworfen."}
+          : action.status === "approved" ? answerTextOf(action.result)
+          : supersedingInputOf(action.result) !== undefined ? SUPERSEDED_ANSWER : "Der Benutzer hat die Frage verworfen."}
         onAnswer={access.can("runs.write") ? answer : undefined}
         question={question}
         text={text}

package/plugins/ragents.browser/executor/index.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+import { browserModule } from "./module.js";
+
+/** Der Browser läuft dort, wo der Arbeitsbereich des Runs liegt: im Executor des Servers oder in dem des Arbeitsplatzes. */
+export const executor: WorkspaceExecutorContribution = (machine) => ({ modules: [browserModule(machine)] });

package/{packages/workspace-executor/src/browser → plugins/ragents.browser/executor}/module.ts

@@ -1,6 +1,5 @@
 import type { Browser } from "playwright-core";
-import { WorkspaceOperationError } from "../errors.js";
-import type { WorkspaceModuleFactory } from "../module.js";
+import type { WorkspaceExecutorMachine, WorkspaceModuleFactory } from "@ragents/workspace-executor";
 import { BROWSER_OPERATIONS, type BrowserCheck, type BrowserTarget, type BrowserViewport } from "./contract.js";
 import { BrowserPages } from "./pages.js";
 import { launchChromium } from "./playwright.js";
@@ -14,38 +13,33 @@ export interface BrowserModuleOptions {
   checkTimeoutMs?: number;
 }
 
-const invalid = (message: string): WorkspaceOperationError => new WorkspaceOperationError("browser-input-invalid", message, 400);
-
-const fieldsOf = (input: unknown): Readonly<Record<string, unknown>> => {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("Die Eingabe einer Browseroperation ist ein Objekt");
-  return input as Readonly<Record<string, unknown>>;
-};
-
-const textOf = (input: unknown, key: string): string => {
-  const value = fieldsOf(input)[key];
-  if (typeof value !== "string") throw invalid(`Die Browseroperation braucht ${key} als Text`);
-  return value;
-};
-
-const targetOf = (input: unknown): BrowserTarget => {
-  const value = fieldsOf(input).target;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("Die Browseroperation braucht ein Ziel");
-  return value as BrowserTarget;
-};
-
-const viewportOf = (input: unknown): BrowserViewport => {
-  const { width, height } = fieldsOf(input);
-  if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-    throw invalid("Ein Viewport braucht Breite und Höhe als positive ganze Zahlen");
-  }
-  return { width, height };
-};
-
 /** Der Browser eines Runs auf dieser Maschine: Seite, Aktionen, Prüfungen und Aufnahmen; Evidenz und Ablage hält der Aufrufer. */
-export const browserModule = (options: BrowserModuleOptions = {}): WorkspaceModuleFactory => (host) => {
+export const browserModule = (machine: WorkspaceExecutorMachine, options: BrowserModuleOptions = {}): WorkspaceModuleFactory => (host) => {
+  const invalid = (message: string): Error => machine.operationError("browser-input-invalid", message, 400);
+  const fieldsOf = (input: unknown): Readonly<Record<string, unknown>> => {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) throw invalid("Die Eingabe einer Browseroperation ist ein Objekt");
+    return input as Readonly<Record<string, unknown>>;
+  };
+  const textOf = (input: unknown, key: string): string => {
+    const value = fieldsOf(input)[key];
+    if (typeof value !== "string") throw invalid(`Die Browseroperation braucht ${key} als Text`);
+    return value;
+  };
+  const targetOf = (input: unknown): BrowserTarget => {
+    const value = fieldsOf(input).target;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalid("Die Browseroperation braucht ein Ziel");
+    return value as BrowserTarget;
+  };
+  const viewportOf = (input: unknown): BrowserViewport => {
+    const { width, height } = fieldsOf(input);
+    if (typeof width !== "number" || typeof height !== "number" || !Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+      throw invalid("Ein Viewport braucht Breite und Höhe als positive ganze Zahlen");
+    }
+    return { width, height };
+  };
   const timeoutMs = options.timeoutMs ?? BROWSER_TIMEOUT_MS;
   const pages = new BrowserPages({
-    launch: options.launch ?? (async (runId) => launchChromium((await host.contextFor(runId)).hostRoot, runId, timeoutMs)),
+    launch: options.launch ?? (async (runId) => launchChromium(machine, (await host.contextFor(runId)).hostRoot, runId, timeoutMs)),
     timeoutMs,
     checkTimeoutMs: options.checkTimeoutMs ?? Math.min(5_000, timeoutMs),
   });