@schlenkr/ragents 0.1.8 → 0.1.10

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.ask/web/index.tsx

@@ -6,7 +6,6 @@ import {
 import { runViewFrom, type RunView } from "@ragents/web/run-view";
 import { askPayloadOf, ASK_PLUGIN_ID } from "../ask-payload";
 import { AskActionView } from "./AskActionView";
-import { QuestionSection } from "./QuestionSection";
 
 const pendingQuestions = (view: RunView) =>
   view.actions.filter((action) => action.owner === ASK_PLUGIN_ID && action.status === "pending");
@@ -34,11 +33,6 @@ const configuredPlugin = (descriptor: WebPluginDescriptor): WebPlugin => ({
     owner: ASK_PLUGIN_ID,
     View: AskActionView,
   }],
-  cardSections: [{
-    id: "ragents.ask.questions",
-    order: 100,
-    Section: QuestionSection,
-  }],
   attention: [{
     id: "ragents.ask.pending-questions",
     assess: attentionFor,

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),
   });

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

@@ -1,30 +1,16 @@
 import { constants } from "node:fs";
 import { access } 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 type { Browser } from "playwright-core";
-import { RUN_MARKER_ENV } from "../run-marker.js";
-import { safeProcessEnvironment } from "../safe-environment.js";
+import type { WorkspaceExecutorMachine } from "@ragents/workspace-executor";
 import { BROWSER_EXECUTABLE_VARIABLE } from "./contract.js";
 
 type Playwright = typeof import("playwright-core");
 
-const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
-
-/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Executor. */
-export const hostPlaywright = (hostRoot: string | undefined): Playwright => {
-  if (!hostRoot) {
-    throw new Error("Für die Browserprüfung ist auf diesem Rechner kein Host bekannt, aus dem sich playwright-core auflösen "
-      + "ließe. Ein Arbeitsplatz bekommt ihn mit der ersten Verbindung zu einem verteilenden Server oder über die "
-      + "Einstellung ragents.hostPath");
-  }
-  const load = createRequire(path.join(hostRoot, "package.json"));
-  try {
-    return load("playwright-core") as Playwright;
-  } catch (cause) {
-    throw new Error(`playwright-core liegt nicht im Host ${hostRoot}: ${messageOf(cause)}`);
-  }
+/** playwright-core liegt in den node_modules des Hosts dieser Maschine und wird erst im Aufruf geladen, nie mit dem Beitrag. */
+export const hostPlaywright = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined): Promise<Playwright> => {
+  const loaded = await import(pathToFileURL(machine.hostPackageFile(hostRoot, "playwright-core")).href) as { default: Playwright };
+  return loaded.default;
 };
 
 /** Der Chrome dieser Maschine: der aus ihrer Umgebung, sonst das Chromium, das die Provisionierung für playwright-core holt. */
@@ -41,12 +27,12 @@ export const browserExecutable = async (playwright: Playwright, environment: Nod
 };
 
 /** Startet Chrome headless mit der Umgebung dieser Maschine und dem Marker des Runs, damit die Prozessanzeige ihn zuordnet. */
-export const launchChromium = async (hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
-  const playwright = hostPlaywright(hostRoot);
+export const launchChromium = async (machine: WorkspaceExecutorMachine, hostRoot: string | undefined, runId: string, timeoutMs: number): Promise<Browser> => {
+  const playwright = await hostPlaywright(machine, hostRoot);
   return playwright.chromium.launch({
     executablePath: await browserExecutable(playwright),
     headless: true,
     timeout: timeoutMs,
-    env: { ...safeProcessEnvironment(process.env), HOME: homedir(), [RUN_MARKER_ENV]: runId },
+    env: machine.processEnvironment(runId),
   });
 };

package/plugins/ragents.browser/provision.ts

@@ -2,13 +2,13 @@ import { spawn } from "node:child_process";
 import { access, constants } from "node:fs/promises";
 import path from "node:path";
 import { chromium } from "playwright-core";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import {
   hostPackageFolder,
   provisionGap,
   provisionReady,
   type PluginProvision,
 } from "@ragents/host/plugin-support/provision.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "./executor/contract.js";
 
 const executable = async (file: string): Promise<boolean> => access(file, constants.X_OK).then(() => true, () => false);
 

package/plugins/ragents.browser/server/browser.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
 import {
   BROWSER_OPERATIONS,
   type BrowserCheck,
@@ -10,9 +12,7 @@ import {
   type BrowserStep,
   type BrowserTarget,
   type BrowserViewport,
-} from "@ragents/workspace-executor";
-import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
-import { documentsApiPrefix } from "@ragents/plugins/ragents.documents/contract.js";
+} from "../executor/contract.js";
 import type { BrowserCallOptions, BrowserEvidence, BrowserRuntime } from "./contract.js";
 
 export const DEFAULT_VIEWPORT: BrowserViewport = { width: 1920, height: 1080 };

package/plugins/ragents.browser/server/contract.ts

@@ -1,7 +1,7 @@
 import { serviceToken } from "@ragents/engine";
-import type { BrowserSnapshot } from "@ragents/workspace-executor";
+import type { BrowserSnapshot } from "../executor/contract.js";
 
-export type { BrowserSnapshot, BrowserTarget } from "@ragents/workspace-executor";
+export type { BrowserSnapshot, BrowserTarget } from "../executor/contract.js";
 
 export interface BrowserEvidence {
   checkedAt?: string;

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

@@ -1,8 +1,8 @@
 import type { RAgentsPlugin } from "@ragents/engine";
-import { BROWSER_EXECUTABLE_VARIABLE } from "@ragents/workspace-executor";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { documentStoreToken } from "@ragents/host/ragents/document-store.js";
+import { BROWSER_EXECUTABLE_VARIABLE } from "../executor/contract.js";
 import { RunBrowser } from "./browser.js";
 import { browserRuntimeToken } from "./contract.js";
 import { createBrowserFunctions, createBrowserImageContribution } from "./tools.js";

package/plugins/ragents.lsp-fsharp/executor.ts

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const FSHARP_SERVER_VARIABLE = "FSHARP_LANGUAGE_SERVER";
+export const FSHARP_SERVER_FILE = "fsautocomplete/fsautocomplete.dll";
+
+const languages = { ".fs": "fsharp", ".fsi": "fsharp", ".fsx": "fsharp" } as const;
+
+export const fsharpLanguageServer: LanguageServerDescription = {
+  id: "fsharp",
+  label: "FSAC",
+  languages,
+  rootDescription: "the .sln file (or a single .fsproj)",
+};
+
+const PROJECT_LINE = /^Project\("\{[^}]+\}"\)\s*=\s*"[^"]*",\s*"([^"]+)"/gm;
+
+/** Die Projekte einer .sln, aufgelöst neben ihr; Ordnereinträge der Solution zählen nicht. */
+export const solutionProjects = async (solutionFile: string): Promise<string[]> => {
+  const text = await readFile(solutionFile, "utf8");
+  const directory = path.dirname(solutionFile);
+  return [...text.matchAll(PROJECT_LINE)]
+    .map((match) => match[1].replaceAll("\\", "/"))
+    .filter((relative) => /\.[a-z]+proj$/i.test(relative))
+    .map((relative) => path.resolve(directory, relative));
+};
+
+const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
+  server.toLowerCase().endsWith(".dll")
+    ? { command: "dotnet", args: [server, ...args] }
+    : { command: server, args: [...args] };
+
+const serverPath = (toolsDirectory: string): string => {
+  const configured = process.env[FSHARP_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...FSHARP_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("fsautocomplete gibt es auf diesem Rechner nicht: weder "
+    + `${FSHARP_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt es mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${FSHARP_SERVER_VARIABLE} übersteuert beides`);
+};
+
+const contentOf = (params: unknown): string => (params as { content?: string } | undefined)?.content ?? "";
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...fsharpLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".fsproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "FSAC",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), ["--state-directory", path.join(context.logDirectory, "fsautocomplete")]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      initializationOptions: { AutomaticWorkspaceInit: false },
+      languages,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const projects = root.toLowerCase().endsWith(".sln")
+        ? (await solutionProjects(root)).filter((project) => project.toLowerCase().endsWith(".fsproj"))
+        : [root];
+      if (projects.length === 0) throw new Error(`${path.basename(root)} enthält keine F#-Projekte`);
+      const finished = session.waitForNotification(timeoutMs, "Projekte geladen", (method, params) =>
+        method === "fsharp/notifyWorkspace"
+        && contentOf(params).includes("\"workspaceLoad\"")
+        && contentOf(params).includes("\"finished\""));
+      await session.request("fsharp/workspaceLoad", {
+        textDocuments: projects.map((project) => ({ uri: pathToFileURL(project).href })),
+      });
+      await finished;
+      return `${projects.length} F#-Projekt${projects.length === 1 ? "" : "e"} aus ${path.basename(root)} geladen`;
+    },
+  }],
+});

package/plugins/ragents.lsp-fsharp/provision.ts

@@ -1,6 +1,5 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { FSHARP_SERVER_FILE } from "@ragents/workspace-executor";
 import {
   DOTNET_INSTRUCTION,
   downloadArchive,
@@ -15,6 +14,7 @@ import {
   type PluginProvision,
   type ProvisionState,
 } from "@ragents/host/plugin-support/provision.js";
+import { FSHARP_SERVER_FILE } from "./executor.js";
 
 export const FSAUTOCOMPLETE_VERSION = "0.83.0";
 

package/plugins/ragents.lsp-fsharp/server/index.ts

@@ -1,6 +1,6 @@
-import { fsharpAdapter, FSHARP_SERVER_VARIABLE } from "@ragents/workspace-executor";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
+import { fsharpLanguageServer, FSHARP_SERVER_VARIABLE } from "../executor.js";
 
 export const fsharpConfigDescriptors = [
   { key: FSHARP_SERVER_VARIABLE, source: "environment" },
@@ -9,7 +9,7 @@ export const fsharpConfigDescriptors = [
 export const plugin: PluginModule = {
   create: () => createLanguageServerPlugin({
     id: "ragents.lsp-fsharp",
-    adapter: fsharpAdapter,
+    languageServer: fsharpLanguageServer,
     tabLabel: "F#",
     configDescriptors: fsharpConfigDescriptors,
   }),

package/plugins/ragents.lsp-roslyn/executor.ts

@@ -0,0 +1,64 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { LanguageServerDescription, WorkspaceExecutorContribution } from "@ragents/workspace-executor";
+
+export const ROSLYN_SERVER_VARIABLE = "ROSLYN_LANGUAGE_SERVER";
+export const ROSLYN_SERVER_FILE = "roslyn/Microsoft.CodeAnalysis.LanguageServer.dll";
+
+const languages = { ".cs": "csharp" } as const;
+
+export const roslynLanguageServer: LanguageServerDescription = {
+  id: "roslyn",
+  label: "Roslyn",
+  languages,
+  rootDescription: "the .sln file (or a single .csproj)",
+  solutionExtensions: [".sln", ".slnx"],
+};
+
+const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
+  server.toLowerCase().endsWith(".dll")
+    ? { command: "dotnet", args: [server, ...args] }
+    : { command: server, args: [...args] };
+
+const serverPath = (toolsDirectory: string): string => {
+  const configured = process.env[ROSLYN_SERVER_VARIABLE];
+  if (configured) return configured;
+  const provisioned = path.join(toolsDirectory, ...ROSLYN_SERVER_FILE.split("/"));
+  if (existsSync(provisioned)) return provisioned;
+  throw new Error("Microsoft.CodeAnalysis.LanguageServer gibt es auf diesem Rechner nicht: weder "
+    + `${ROSLYN_SERVER_VARIABLE} gesetzt noch ${provisioned} vorhanden. Ein Arbeitsplatz holt ihn mit `
+    + `pnpm provision --workspace, ein Server über pnpm provision <profil>; ${ROSLYN_SERVER_VARIABLE} übersteuert beides`);
+};
+
+export const executor: WorkspaceExecutorContribution = (machine) => ({
+  languageServers: [{
+    ...roslynLanguageServer,
+    resolveRoot: (workspaceRoot, root) => machine.resolveRootFile(workspaceRoot, root, [".sln", ".slnx", ".csproj"]),
+    rootDirectory: (root) => path.dirname(root),
+    launch: async (context, root) => ({
+      label: "Roslyn",
+      ...dotnetCommand(serverPath(machine.toolsDirectory), [
+        "--stdio",
+        "--logLevel", "Warning",
+        "--extensionLogDirectory", path.join(context.logDirectory, "roslyn-logs"),
+      ]),
+      cwd: path.dirname(root),
+      env: context.env,
+      uid: context.uid,
+      gid: context.gid,
+      rootUri: pathToFileURL(path.dirname(root)).href,
+      languages,
+      newFileSettleMs: 2_000,
+    }),
+    open: async (session, root, timeoutMs) => {
+      const uri = pathToFileURL(root).href;
+      const loaded = session.waitForNotification(timeoutMs, "Projekte geladen",
+        (method) => method === "workspace/projectInitializationComplete");
+      if (root.toLowerCase().endsWith(".csproj")) session.notify("project/open", { projects: [uri] });
+      else session.notify("solution/open", { solution: uri });
+      await loaded;
+      return `${path.basename(root)} geladen`;
+    },
+  }],
+});

package/plugins/ragents.lsp-roslyn/provision.ts

@@ -1,6 +1,5 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { ROSLYN_SERVER_FILE } from "@ragents/workspace-executor";
 import {
   DOTNET_INSTRUCTION,
   downloadArchive,
@@ -14,6 +13,7 @@ import {
   type PluginProvision,
   type ProvisionState,
 } from "@ragents/host/plugin-support/provision.js";
+import { ROSLYN_SERVER_FILE } from "./executor.js";
 
 export const ROSLYN_VERSION = "5.4.0-2.26179.14";
 

package/plugins/ragents.lsp-roslyn/server/index.ts

@@ -1,15 +1,22 @@
-import { roslynAdapter, ROSLYN_SERVER_VARIABLE } from "@ragents/workspace-executor";
+import path from "node:path";
 import { declaredEnvironment } from "@ragents/host/plugin-support/plugin-config.js";
 import { createLanguageServerPlugin } from "@ragents/host/plugin-support/language-server/plugin.js";
 import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { runtimeProviderToken } from "@ragents/host/ragents/host-services.js";
 import { askServiceToken } from "@ragents/plugins/ragents.ask/server/contract.js";
-import { createSolutionOnStart, SOLUTION_ON_START_VARIABLE, type SolutionOnStart } from "./solution-on-start.js";
+import { roslynLanguageServer, ROSLYN_SERVER_VARIABLE } from "../executor.js";
+import {
+  createSolutionOnStart,
+  SOLUTION_ON_START_VARIABLE,
+  SOLUTION_PREFERRED_VARIABLE,
+  type SolutionOnStart,
+} from "./solution-on-start.js";
 
 export const roslynConfigDescriptors = [
   { key: ROSLYN_SERVER_VARIABLE, source: "environment" },
   { key: SOLUTION_ON_START_VARIABLE, source: "environment" },
+  { key: SOLUTION_PREFERRED_VARIABLE, source: "environment" },
 ] as const;
 
 const PLUGIN_ID = "ragents.lsp-roslyn";
@@ -25,13 +32,26 @@ export const solutionOnStart = (): boolean => {
   return mode === "on";
 };
 
+/** Ein Pfad relativ zur Wurzel des Arbeitsbereichs, wie ihn `roslyn_solutions` nennt; ohne Laden beim Start hätte er keine Wirkung. */
+export const preferredSolution = (loadOnStart: boolean): string | undefined => {
+  const preferred = env.optional(SOLUTION_PREFERRED_VARIABLE);
+  if (preferred === undefined) return undefined;
+  if (!loadOnStart) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn verlangt ${SOLUTION_ON_START_VARIABLE}: "on"`);
+  }
+  if (preferred === "" || preferred.includes("\\") || path.win32.isAbsolute(preferred)) {
+    throw new Error(`${SOLUTION_PREFERRED_VARIABLE} in der Sektion ragents.lsp-roslyn ist ein Pfad relativ zum Arbeitsbereich mit Schrägstrichen, nicht "${preferred}"`);
+  }
+  return preferred;
+};
+
 export const plugin: PluginModule = {
   requires: ["ragents.ask"],
   create: () => {
     let startup: SolutionOnStart | undefined;
     const languageServer = createLanguageServerPlugin({
       id: PLUGIN_ID,
-      adapter: roslynAdapter,
+      languageServer: roslynLanguageServer,
       configDescriptors: roslynConfigDescriptors,
       onOpened: (runId) => startup?.opened(runId),
     });
@@ -39,10 +59,13 @@ export const plugin: PluginModule = {
       manifest: languageServer.manifest,
       register: (host) => {
         languageServer.register(host);
-        if (!solutionOnStart()) return;
+        const loadOnStart = solutionOnStart();
+        const preferred = preferredSolution(loadOnStart);
+        if (!loadOnStart) return;
         startup = createSolutionOnStart({
           pluginId: PLUGIN_ID,
-          adapterId: roslynAdapter.id,
+          adapterId: roslynLanguageServer.id,
+          preferred,
           sandbox: () => host.service(sandboxServicesToken),
           runtime: () => host.service(runtimeProviderToken)(),
           ask: () => host.service(askServiceToken),