@schlenkr/ragents 0.1.4 → 0.1.6

package/{plugins/ragents.actor-programs → apps/server/src/plugin-support/actor-programs}/workflow/index.ts

@@ -53,9 +53,9 @@ function optionalText(value: unknown, name: string) {
   if (value !== undefined && typeof value !== "string") throw new Error(`${name} muss Text sein.`);
 }
 export function validatePromptReference(value: unknown) {
-  text(value, "Promptreferenz");
+  text(value, "Prompt reference");
   if (!/^[^\\/:]+(?:\/[^\\/:]+)*\.(?:md|hbs)$/.test(value) || value.split("/").some(part => part === "." || part === "..") || /[\x00-\x1f?#]/.test(value)) {
-    throw new Error(`Promptreferenz muss eine relative .md- oder .hbs-Datei innerhalb des Pakets sein: ${value}`);
+    throw new Error(`Prompt reference must be a relative .md or .hbs file within the package: ${value}`);
   }
 }
 function has(object: object, key: string) { return Object.prototype.hasOwnProperty.call(object, key); }
@@ -63,50 +63,50 @@ 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.title, "Workflowtitel");
-  object(definition.roles, "Rollen");
-  if (Object.keys(definition.roles).length === 0) throw new Error("Ein Workflow benötigt Rollen.");
+  text(definition.title, "Workflow title");
+  object(definition.roles, "Roles");
+  if (Object.keys(definition.roles).length === 0) throw new Error("A workflow requires roles.");
   for (const [id, role] of Object.entries(definition.roles)) {
-    text(id, "Rollen-ID"); object(role, "Rolle"); text(role.title, "Rollentitel"); if (role.prompt !== undefined) validatePromptReference(role.prompt);
+    text(id, "Role ID"); object(role, "Role"); text(role.title, "Role title"); if (role.prompt !== undefined) validatePromptReference(role.prompt);
   }
-  if (!Array.isArray(definition.steps) || definition.steps.length === 0) throw new Error("Ein Workflow benötigt Schritte.");
+  if (!Array.isArray(definition.steps) || definition.steps.length === 0) throw new Error("A workflow requires steps.");
   const ids = new Set<string>();
   for (const step of definition.steps) {
-    object(step, "Schritt"); text(step.id, "Schritt-ID"); text(step.title, "Schritttitel"); text(step.goal, "Schrittziel"); text(step.role, "Schrittrolle");
-    if (ids.has(step.id)) throw new Error(`Doppelte Schritt-ID: ${step.id}`);
+    object(step, "Step"); text(step.id, "Step ID"); text(step.title, "Step title"); text(step.goal, "Step goal"); text(step.role, "Step role");
+    if (ids.has(step.id)) throw new Error(`Duplicate step ID: ${step.id}`);
     ids.add(step.id);
-    if (!has(definition.roles, step.role)) throw new Error(`Unbekannte Rolle: ${step.role}`);
+    if (!has(definition.roles, step.role)) throw new Error(`Unknown role: ${step.role}`);
     if (step.prompt !== undefined) validatePromptReference(step.prompt);
-    object(step.completion, "Abschluss"); text(step.completion.source, "Abschlussquelle"); text(step.completion.description, "Abschlussbeschreibung");
-    if (!["agent", "service", "operator"].includes(step.completion.source)) throw new Error(`Unbekannte Abschlussquelle: ${step.id}`);
-    object(step.freedom, "Freiheitsgrad"); text(step.freedom.mode, "Freiheitsgradmodus"); text(step.freedom.description, "Freiheitsgradbeschreibung");
-    if (!["fixed", "extend"].includes(step.freedom.mode)) throw new Error(`Unbekannter Freiheitsgrad: ${step.id}`);
-    if (step.freedom.allowSkip !== undefined && typeof step.freedom.allowSkip !== "boolean") throw new Error("allowSkip muss ein Wahrheitswert sein.");
+    object(step.completion, "Completion"); text(step.completion.source, "Completion source"); text(step.completion.description, "Completion description");
+    if (!["agent", "service", "operator"].includes(step.completion.source)) throw new Error(`Unknown completion source: ${step.id}`);
+    object(step.freedom, "Freedom"); text(step.freedom.mode, "Freedom mode"); text(step.freedom.description, "Freedom description");
+    if (!["fixed", "extend"].includes(step.freedom.mode)) throw new Error(`Unknown freedom mode: ${step.id}`);
+    if (step.freedom.allowSkip !== undefined && typeof step.freedom.allowSkip !== "boolean") throw new Error("allowSkip must be a boolean.");
     if (step.freedom.maxItems !== undefined) positiveInteger(step.freedom.maxItems, "maxItems");
     if (step.expansion !== undefined) {
-      object(step.expansion, "Erweiterung"); text(step.expansion.source, "Erweiterungsquelle"); text(step.expansion.role, "Erweiterungsrolle");
-      if (!has(definition.roles, step.expansion.role)) throw new Error(`Unbekannte Erweiterungsrolle: ${step.expansion.role}`);
-      if (step.expansion.mode !== "parallel") throw new Error("Erweiterungen müssen den Modus parallel verwenden.");
+      object(step.expansion, "Expansion"); text(step.expansion.source, "Expansion source"); text(step.expansion.role, "Expansion role");
+      if (!has(definition.roles, step.expansion.role)) throw new Error(`Unknown expansion role: ${step.expansion.role}`);
+      if (step.expansion.mode !== "parallel") throw new Error("Expansions must use parallel mode.");
       positiveInteger(step.expansion.maxConcurrent, "maxConcurrent");
     }
   }
-  if (!Array.isArray(definition.transitions)) throw new Error("Übergänge müssen eine Liste sein.");
+  if (!Array.isArray(definition.transitions)) throw new Error("Transitions must be an array.");
   const outgoing = new Map([...ids].map(id => [id, [] as string[]]));
   const transitions = new Set<string>();
   for (const transition of definition.transitions) {
-    object(transition, "Übergang"); text(transition.from, "Übergangsquelle"); text(transition.to, "Übergangsziel");
-    if (!ids.has(transition.from) || !ids.has(transition.to)) throw new Error("Ein Übergang verweist auf einen unbekannten Schritt.");
-    optionalText(transition.condition, "Übergangsbedingung");
-    if (transition.kind !== undefined && transition.kind !== "return") throw new Error("Unbekannte Übergangsart.");
+    object(transition, "Transition"); text(transition.from, "Transition source"); text(transition.to, "Transition target");
+    if (!ids.has(transition.from) || !ids.has(transition.to)) throw new Error("A transition references an unknown step.");
+    optionalText(transition.condition, "Transition condition");
+    if (transition.kind !== undefined && transition.kind !== "return") throw new Error("Unknown transition type.");
     const key = JSON.stringify([transition.from, transition.to, transition.kind, transition.condition]);
-    if (transitions.has(key)) throw new Error("Doppelter Übergang.");
+    if (transitions.has(key)) throw new Error("Duplicate transition.");
     transitions.add(key);
     if (transition.kind !== "return") outgoing.get(transition.from)!.push(transition.to);
   }
   const visiting = new Set<string>();
   const visited = new Set<string>();
   const visit = (id: string) => {
-    if (visiting.has(id)) throw new Error("Normale Übergänge müssen azyklisch sein; Rückwege benötigen kind: return.");
+    if (visiting.has(id)) throw new Error("Regular transitions must be acyclic; return paths require kind: return.");
     if (visited.has(id)) return;
     visiting.add(id);
     for (const next of outgoing.get(id)!) visit(next);
@@ -118,7 +118,7 @@ export function defineWorkflow<const Definition extends WorkflowDefinition>(defi
 
 export async function workflowInstructions(definition: WorkflowDefinition, role: string, readPrompt: (reference: string) => Promise<string>): Promise<string> {
   defineWorkflow(definition);
-  if (!has(definition.roles, role)) throw new Error(`Unbekannte Rolle: ${role}`);
+  if (!has(definition.roles, role)) throw new Error(`Unknown role: ${role}`);
   const owned = definition.steps.filter(step => step.role === role);
   const selectedRole = definition.roles[role]!;
   const load = async (reference: string) => {
@@ -126,54 +126,54 @@ export async function workflowInstructions(definition: WorkflowDefinition, role:
     text(content, `Prompt ${reference}`);
     return content;
   };
-  const lines = [`# ${definition.title}`, `Rolle: ${selectedRole.title} (${role})`];
+  const lines = [`# ${definition.title}`, `Role: ${selectedRole.title} (${role})`];
   if (selectedRole.prompt !== undefined) lines.push(await load(selectedRole.prompt));
-  lines.push("## Ablauf", ...definition.steps.map(step => `- ${step.id}: ${step.title}; zuständig: ${definition.roles[step.role]!.title}`));
+  lines.push("## Workflow", ...definition.steps.map(step => `- ${step.id}: ${step.title}; owner: ${definition.roles[step.role]!.title}`));
   for (const step of owned) {
-    lines.push(`## ${step.title} (${step.id})`, `Ziel: ${step.goal}`, `Abschluss durch ${step.completion.source}: ${step.completion.description}`,
-      `Freiheitsgrad ${step.freedom.mode}: ${step.freedom.description}`, `Überspringen: ${step.freedom.allowSkip === true ? "nur für eigene optionale Punkte erlaubt, begründen; Pflichtschritte bleiben verbindlich" : "nicht erlaubt"}`);
-    if (step.freedom.maxItems !== undefined) lines.push(`Höchstens ${step.freedom.maxItems} eigene Punkte.`);
-    if (step.expansion) lines.push(`Parallele Erweiterung aus ${step.expansion.source}: Rolle ${step.expansion.role}, höchstens ${step.expansion.maxConcurrent} gleichzeitig.`);
+    lines.push(`## ${step.title} (${step.id})`, `Goal: ${step.goal}`, `Completed by ${step.completion.source}: ${step.completion.description}`,
+      `Freedom ${step.freedom.mode}: ${step.freedom.description}`, `Skipping: ${step.freedom.allowSkip === true ? "allowed only for optional items you own, with a reason; required steps remain mandatory" : "not allowed"}`);
+    if (step.freedom.maxItems !== undefined) lines.push(`At most ${step.freedom.maxItems} custom items.`);
+    if (step.expansion) lines.push(`Parallel expansion from ${step.expansion.source}: role ${step.expansion.role}, at most ${step.expansion.maxConcurrent} at once.`);
     if (step.prompt !== undefined) lines.push(await load(step.prompt));
   }
-  lines.push("## Übergänge", ...definition.transitions.map(transition => `${transition.from} -> ${transition.to}${transition.kind === "return" ? " (Rückweg)" : ""}${transition.condition ? `: ${transition.condition}` : ""}`));
+  lines.push("## Transitions", ...definition.transitions.map(transition => `${transition.from} -> ${transition.to}${transition.kind === "return" ? " (return path)" : ""}${transition.condition ? `: ${transition.condition}` : ""}`));
   return lines.join("\n\n");
 }
 
 function status(value: unknown) {
-  if (!["pending", "active", "done", "blocked"].includes(value as string)) throw new Error(`Unbekannter Schrittstatus: ${String(value)}`);
+  if (!["pending", "active", "done", "blocked"].includes(value as string)) throw new Error(`Unknown step status: ${String(value)}`);
 }
 function items(value: unknown) {
-  if (!Array.isArray(value)) throw new Error("Punkte müssen eine Liste sein.");
+  if (!Array.isArray(value)) throw new Error("Items must be an array.");
   for (const item of value) {
-    object(item, "Punkt"); text(item.label, "Punktlabel"); optionalText(item.detail, "Punktdetail");
-    if (item.status !== undefined && !["pending", "active", "done", "blocked", "skipped"].includes(item.status as string)) throw new Error("Unbekannter Punktstatus.");
+    object(item, "Item"); text(item.label, "Item label"); optionalText(item.detail, "Item detail");
+    if (item.status !== undefined && !["pending", "active", "done", "blocked", "skipped"].includes(item.status as string)) throw new Error("Unknown item status.");
   }
 }
 
 export function workflowGraph(definition: WorkflowDefinition, state: WorkflowState): WorkflowGraph {
   defineWorkflow(definition);
-  object(state, "Workflowzustand"); object(state.steps, "Schrittzustände");
+  object(state, "Workflow state"); object(state.steps, "Step states");
   const steps = new Map(definition.steps.map(step => [step.id, step]));
   for (const [id, step] of Object.entries(state.steps)) {
-    if (!steps.has(id)) throw new Error(`Unbekannter Schrittzustand: ${id}`);
-    object(step, "Schrittzustand"); status(step.status); optionalText(step.detail, "Schrittdetail");
+    if (!steps.has(id)) throw new Error(`Unknown step state: ${id}`);
+    object(step, "Step state"); status(step.status); optionalText(step.detail, "Step detail");
     if (step.items !== undefined) items(step.items);
   }
   const sources = new Set(definition.steps.flatMap(step => step.expansion ? [step.expansion.source] : []));
-  if (state.expansions !== undefined) object(state.expansions, "Erweiterungszustände");
-  for (const source of Object.keys(state.expansions ?? {})) if (!sources.has(source)) throw new Error(`Unbekannte Erweiterungsquelle: ${source}`);
+  if (state.expansions !== undefined) object(state.expansions, "Expansion states");
+  for (const source of Object.keys(state.expansions ?? {})) if (!sources.has(source)) throw new Error(`Unknown expansion source: ${source}`);
   for (const source of sources) {
-    if (!state.expansions || !has(state.expansions, source)) throw new Error(`Erweiterungsquelle fehlt im Zustand: ${source}`);
+    if (!state.expansions || !has(state.expansions, source)) throw new Error(`Expansion source is missing from state: ${source}`);
     const groups = state.expansions[source]!;
-    if (!Array.isArray(groups)) throw new Error(`Erweiterungsquelle ${source} muss eine Liste sein.`);
+    if (!Array.isArray(groups)) throw new Error(`Expansion source ${source} must be an array.`);
     const ids = new Set<string>();
     for (const group of groups) {
-      object(group, "Erweiterungsgruppe"); text(group.id, "Gruppen-ID"); text(group.title, "Gruppentitel");
-      if (ids.has(group.id)) throw new Error(`Doppelte Gruppen-ID: ${group.id}`);
+      object(group, "Expansion group"); text(group.id, "Group ID"); text(group.title, "Group title");
+      if (ids.has(group.id)) throw new Error(`Duplicate group ID: ${group.id}`);
       ids.add(group.id);
       if (group.status !== undefined) status(group.status);
-      optionalText(group.detail, "Gruppendetail"); items(group.items);
+      optionalText(group.detail, "Group detail"); items(group.items);
     }
   }
   const graph: WorkflowGraph = { nodes: [], edges: [] };
@@ -186,7 +186,7 @@ export function workflowGraph(definition: WorkflowDefinition, state: WorkflowSta
       const ids: string[] = [];
       for (const group of state.expansions![step.expansion.source]!) {
         const id = `expansion:${JSON.stringify([step.id, group.id])}`;
-        if (nodeIds.has(id)) throw new Error(`Erweiterungs-ID kollidiert mit einem Knoten: ${id}`);
+        if (nodeIds.has(id)) throw new Error(`Expansion ID collides with a node: ${id}`);
         nodeIds.add(id); ids.push(id);
         graph.nodes.push({ id, label: group.title, status: group.status ?? "pending", kind: "agent", items: group.items, ...(group.detail === undefined ? {} : { detail: group.detail }) });
         graph.edges.push({ id: `expansion:${JSON.stringify([step.id, group.id])}`, source: step.id, target: id });

package/apps/server/src/plugin-support/agent-tool.ts

@@ -1,4 +1,4 @@
-import type { ToolDefinition } from "@aicontainer/agent";
+import type { ToolDefinition } from "@ragents/agent";
 import { Type } from "typebox";
 import {
   describeToolAvailability,
@@ -7,12 +7,17 @@ import {
   type ToolAvailability,
   type ToolDescriptor,
   type ToolExecutionMode,
-} from "@aicontainer/ragents";
+} from "@ragents/engine";
 
 export type AgentToolDefinition = ToolDefinition<any, any, any> & { longDescription?: string; nativeTool?: boolean };
-export type AgentToolMetadata = Pick<AgentToolDefinition, "name" | "description"> & { nativeTool?: boolean };
 
-type ToolOutput = { content?: ReadonlyArray<{ type: string; text?: string }> };
+export interface AgentToolMetadata {
+  readonly name: string;
+  readonly description: string;
+  readonly nativeTool?: boolean;
+}
+
+export type ToolOutput = { content?: ReadonlyArray<{ type: string; text?: string }> };
 
 type BoundExecute = (
   toolCallId: string,
@@ -22,7 +27,7 @@ type BoundExecute = (
   ctx: unknown,
 ) => Promise<ToolOutput>;
 
-const textOf = (result: ToolOutput): string =>
+export const textOf = (result: ToolOutput): string =>
   (result.content ?? [])
     .filter((part) => part.type === "text" && typeof part.text === "string")
     .map((part) => part.text)

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

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { DomainError } from "@aicontainer/ragents";
+import { DomainError } from "@ragents/engine";
 
 export const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
 

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

@@ -1,23 +1,54 @@
 import { Type } from "typebox";
-import { defineOperation } from "@aicontainer/ragents/src/rpc/contract";
-import { openJson } from "@aicontainer/ragents/src/http/contracts";
-import type { LanguageServerSnapshot } from "@aicontainer/workspace-executor";
+import { defineOperation } from "@ragents/engine/src/rpc/contract";
+import { openJson } from "@ragents/engine/src/http/contracts";
+import type { LanguageServerSnapshot, LanguageServerSolutions } from "@ragents/workspace-executor";
 
 export type {
   LanguageServerInstanceSnapshot,
   LanguageServerSeverity,
   LanguageServerSnapshot,
+  LanguageServerSolution,
+  LanguageServerSolutions,
   LanguageServerState,
-} from "@aicontainer/workspace-executor";
+} from "@ragents/workspace-executor";
+
+const runIdSchema = Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" });
 
 /** Je Sprachserver-Plugin eine Methode; die Rechte tragen seine Kennung. */
 export const languageServerSnapshotContract = (pluginId: string) =>
   defineOperation({
     id: `${pluginId}.snapshot`,
-    description: `Zustand und Diagnosen des Sprachservers ${pluginId} in einem Lauf. Rechte: runs.read und ${pluginId}.read.`,
+    description: `Zustand und Diagnosen des Sprachservers ${pluginId} in einem Run. Rechte: runs.read und ${pluginId}.read.`,
     rights: ["runs.read", `${pluginId}.read`],
     input: Type.Object({
-      runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
+      runId: runIdSchema,
     }, { additionalProperties: false }),
     result: openJson<LanguageServerSnapshot>("LanguageServerSnapshot"),
   });
+
+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.`,
+    rights: ["runs.read", `${pluginId}.read`],
+    input: Type.Object({
+      runId: runIdSchema,
+    }, { additionalProperties: false }),
+    result: openJson<LanguageServerSolutions>("LanguageServerSolutions"),
+  });
+
+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.`,
+    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.Null(),
+      ], { description: "null beendet alle Instanzen" }),
+    }, { additionalProperties: false }),
+    result: openJson<LanguageServerSolutions>("LanguageServerSolutions"),
+  });

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

@@ -1,8 +1,8 @@
-import type { PluginConfigDescriptor, RAgentsPlugin } from "@aicontainer/ragents";
-import type { LanguageServerAdapter } from "@aicontainer/workspace-executor";
-import { sessionGuardToken } from "../../ragents/host-services.js";
+import type { PluginConfigDescriptor, RAgentsPlugin } from "@ragents/engine";
+import type { LanguageServerAdapter } from "@ragents/workspace-executor";
+import { workspaceGuardToken } from "../../ragents/host-services.js";
 import { sandboxServicesToken } from "../workspace-sandbox-host.js";
-import { createLanguageServerSnapshotMethod } from "./snapshot-method.js";
+import { createLanguageServerSnapshotMethod, createLanguageServerSolutionMethods } from "./snapshot-method.js";
 import { createLanguageServerToolContributor } from "./tools.js";
 
 export interface LanguageServerPluginOptions {
@@ -10,6 +10,8 @@ export interface LanguageServerPluginOptions {
   adapter: LanguageServerAdapter;
   tabLabel?: string;
   configDescriptors?: readonly PluginConfigDescriptor[];
+  /** Nach jedem erfolgreichen Öffnen über Werkzeug oder Umschalten, mit dem Run. */
+  onOpened?: (runId: string) => void;
 }
 
 export const createLanguageServerPlugin = (options: LanguageServerPluginOptions): RAgentsPlugin => ({
@@ -17,16 +19,24 @@ export const createLanguageServerPlugin = (options: LanguageServerPluginOptions)
   register: (host) => {
     const sandbox = host.service(sandboxServicesToken);
     if (options.configDescriptors) host.config(...options.configDescriptors);
-    host.functions(createLanguageServerToolContributor(options.adapter, sandbox));
+    const opened = options.onOpened ?? (() => undefined);
+    host.functions(createLanguageServerToolContributor(options.adapter, sandbox, opened));
+    const solutions = options.adapter.solutionExtensions !== undefined;
     host.clientConfig({
       label: options.tabLabel ?? options.adapter.label,
       openTool: `${options.adapter.id}_open`,
+      solutions,
     });
-    host.methods(createLanguageServerSnapshotMethod({
+    const methodOptions = {
       pluginId: options.id,
       adapterId: options.adapter.id,
       sandbox,
-      ensureSession: host.service(sessionGuardToken),
-    }));
+      ensureWorkspaceAccess: host.service(workspaceGuardToken),
+      opened,
+    };
+    host.methods(
+      createLanguageServerSnapshotMethod(methodOptions),
+      ...solutions ? createLanguageServerSolutionMethods(methodOptions) : [],
+    );
   },
 });

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

@@ -1,17 +1,42 @@
-import { implement, type MethodContribution } from "@aicontainer/ragents";
-import { languageServerSnapshotTool, type LanguageServerSnapshot } from "@aicontainer/workspace-executor";
+import { implement, type AccessContext, type MethodContribution } from "@ragents/engine";
+import {
+  languageServerSnapshotOperation,
+  languageServerSolutionsOperation,
+  languageServerSwitchOperation,
+  type LanguageServerSnapshot,
+  type LanguageServerSolutions,
+} from "@ragents/workspace-executor";
 import type { SandboxServices } from "../workspace-sandbox-host.js";
-import { languageServerSnapshotContract } from "./contract.js";
+import { languageServerSnapshotContract, languageServerSolutionsContract, languageServerSwitchContract } from "./contract.js";
 
 export interface LanguageServerMethodOptions {
   pluginId: string;
   adapterId: string;
   sandbox: SandboxServices;
-  ensureSession: (runId: string) => void;
+  /** Die Sprachserver arbeiten im Arbeitsbereich des Runs; wer ihn nicht sehen darf, sieht auch ihren Stand nicht. */
+  ensureWorkspaceAccess: (access: AccessContext, runId: string) => void;
+  opened: (runId: string) => void;
 }
 
 export const createLanguageServerSnapshotMethod = (options: LanguageServerMethodOptions): MethodContribution =>
-  implement(languageServerSnapshotContract(options.pluginId), async ({ runId }) => {
-    options.ensureSession(runId);
-    return await options.sandbox.execute(runId, languageServerSnapshotTool(options.adapterId), null) as LanguageServerSnapshot;
+  implement(languageServerSnapshotContract(options.pluginId), async ({ runId }, { access }) => {
+    options.ensureWorkspaceAccess(access, runId);
+    return await options.sandbox.execute(runId, languageServerSnapshotOperation(options.adapterId), null) as LanguageServerSnapshot;
   });
+
+export const createLanguageServerSolutionMethods = (options: LanguageServerMethodOptions): MethodContribution[] => {
+  const solutions = async (runId: string): Promise<LanguageServerSolutions> =>
+    await options.sandbox.execute(runId, languageServerSolutionsOperation(options.adapterId), null) as LanguageServerSolutions;
+  return [
+    implement(languageServerSolutionsContract(options.pluginId), async ({ runId }, { access }) => {
+      options.ensureWorkspaceAccess(access, runId);
+      return await solutions(runId);
+    }),
+    implement(languageServerSwitchContract(options.pluginId), async ({ runId, root }, { access }) => {
+      options.ensureWorkspaceAccess(access, runId);
+      await options.sandbox.execute(runId, languageServerSwitchOperation(options.adapterId), { root });
+      if (root !== null) options.opened(runId);
+      return await solutions(runId);
+    }),
+  ];
+};

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

@@ -1,38 +1,57 @@
 import { Type } from "typebox";
-import { defineRunFunction, type ToolContributor } from "@aicontainer/ragents";
+import { defineRunFunction, type ToolContributor } from "@ragents/engine";
 import {
-  languageServerCloseTool,
-  languageServerDiagnosticsTool,
-  languageServerOpenTool,
+  languageServerCloseOperation,
+  languageServerDiagnosticsOperation,
+  languageServerOpenOperation,
+  languageServerSolutionsOperation,
   type LanguageServerAdapter,
-} from "@aicontainer/workspace-executor";
+  type LanguageServerSolutions,
+  type LanguageServerState,
+} from "@ragents/workspace-executor";
 import { toolDescriptorFrom } from "../agent-tool.js";
 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",
+};
+
+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 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");
+};
+
 /** Beschreibung und Weiterreichung: der Sprachserver läuft im Executor des Runs, nicht in diesem Plugin. */
 export const createLanguageServerToolContributor = (
   adapter: LanguageServerAdapter,
   sandbox: SandboxServices,
+  opened: (runId: string) => void,
 ): ToolContributor => {
   const { id, label, rootDescription, languages } = adapter;
   const extensions = Object.keys(languages).join(", ");
   const openMetadata = {
-    name: languageServerOpenTool(id),
+    name: languageServerOpenOperation(id),
     nativeTool: true,
-    description: `Start a ${label} language server instance for this conversation's workspace and load ${rootDescription}. `
+    description: `Start a ${label} language server instance for this run's workspace and load ${rootDescription}. `
       + `Afterwards every edit or write of a ${extensions} file gets its diagnostics appended automatically, `
-      + `and ${languageServerDiagnosticsTool(id)} is available. Idempotent for the same root; other roots stay open.`,
+      + `and ${languageServerDiagnosticsOperation(id)} is available. Idempotent for the same root; other roots stay open.`,
   } as const;
   const diagnosticsMetadata = {
-    name: languageServerDiagnosticsTool(id),
+    name: languageServerDiagnosticsOperation(id),
     nativeTool: true,
     description: `Current ${label} diagnostics (errors, warnings on request) for ${extensions} files from the running `
       + `language server, without building. Without paths: all changed files of every open root according to git. `
       + `With paths every file is answered by the instance whose root contains it; root asks one instance.`,
   } as const;
   const closeMetadata = {
-    name: languageServerCloseTool(id),
+    name: languageServerCloseOperation(id),
     nativeTool: true,
     description: `Stop the ${label} language server instance of one root; without root every ${label} instance of `
       + "this conversation. Other languages and other conversations stay untouched.",
@@ -46,11 +65,14 @@ export const createLanguageServerToolContributor = (
     resultSchema: Type.String(),
     available: alwaysAvailable,
     executionMode: "sequential",
-    run: async (scope, toolCallId, input) =>
-      await sandbox.execute(scope.caller.runId, openMetadata.name, input, {
+    run: async (scope, toolCallId, input) => {
+      const result = await sandbox.execute(scope.caller.runId, openMetadata.name, input, {
         toolCallId,
         ...(scope.signal ? { signal: scope.signal } : {}),
-      }) as string,
+      }) as string;
+      opened(scope.caller.runId);
+      return result;
+    },
   });
   const diagnosticsTool = defineRunFunction({
     ...diagnosticsMetadata,
@@ -71,11 +93,31 @@ export const createLanguageServerToolContributor = (
         ...(scope.signal ? { signal: scope.signal } : {}),
       }) as string,
   });
+  const solutionsMetadata = {
+    name: languageServerSolutionsOperation(id),
+    nativeTool: true,
+    description: `List the solution files (${(adapter.solutionExtensions ?? []).join(", ")}) of this run's workspace and mark `
+      + `which ones the ${label} language server has open. ${openMetadata.name} loads another one in addition; `
+      + "the open ones stay open.",
+  } as const;
+  const solutionsTool = defineRunFunction({
+    ...solutionsMetadata,
+    label: `${label} Solutions`,
+    schema: Type.Object({}),
+    resultSchema: Type.String(),
+    available: alwaysAvailable,
+    executionMode: "parallel",
+    run: async (scope, toolCallId) =>
+      formatSolutions(label, await sandbox.execute(scope.caller.runId, solutionsMetadata.name, null, {
+        toolCallId,
+        ...(scope.signal ? { signal: scope.signal } : {}),
+      }) as LanguageServerSolutions),
+  });
   const closeTool = defineRunFunction({
     ...closeMetadata,
     label: `${label} schließen`,
     schema: Type.Object({
-      root: Type.Optional(Type.String({ description: "The open root to stop; omit for every instance of this conversation" })),
+      root: Type.Optional(Type.String({ description: "The open root to stop; omit for every instance of this run" })),
     }),
     resultSchema: Type.String(),
     available: alwaysAvailable,
@@ -86,13 +128,15 @@ export const createLanguageServerToolContributor = (
         ...(scope.signal ? { signal: scope.signal } : {}),
       }) as string,
   });
+  const withSolutions = adapter.solutionExtensions !== undefined;
   return {
     name: `ragents.lsp-${id}`,
     descriptors: [
       toolDescriptorFrom(openMetadata, alwaysAvailable),
       toolDescriptorFrom(diagnosticsMetadata, alwaysAvailable),
       toolDescriptorFrom(closeMetadata, alwaysAvailable),
+      ...withSolutions ? [toolDescriptorFrom(solutionsMetadata, alwaysAvailable)] : [],
     ],
-    tools: () => [openTool, diagnosticsTool, closeTool],
+    tools: () => [openTool, diagnosticsTool, closeTool, ...withSolutions ? [solutionsTool] : []],
   };
 };

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

@@ -0,0 +1,77 @@
+import { aliasedModel, type ModelAlias as RuntimeModelAlias } from "@ragents/agent";
+import { getSupportedThinkingLevels, type Api, type Model } from "@ragents/ai";
+import { getBuiltinModels, type BuiltinProvider } from "@ragents/ai/providers/all";
+import { isThinkingLevel, type ThinkingLevel } from "@ragents/engine";
+import { declaredEnvironment } from "./plugin-config.js";
+
+/** Ein Alias des Profils mit seinem Ziel und optional der Denktiefe, die gilt, solange niemand eine andere wählt. */
+export interface ModelAlias extends RuntimeModelAlias {
+  readonly thinking?: ThinkingLevel;
+}
+
+/** Der Anbieter, unter dem die Aliasse des Profils stehen; er ist kein echter Anbieter und erscheint in keiner Anzeige. */
+export const ALIAS_PROVIDER = "alias";
+
+export const modelAliasEnvDescriptors = [
+  { key: "MODEL_ALIASES", source: "environment" },
+] as const;
+
+const ALIAS = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+
+/** MODEL_ALIASES: eine Liste "alias=anbieter/modell" oder "alias=anbieter/modell@denktiefe"; der Alias ist der einzige Name, den Oberfläche, Journal und Relay-Clients sehen. */
+export const parseModelAliases = (entries: readonly string[]): readonly ModelAlias[] => {
+  const aliases = entries.map((entry): ModelAlias => {
+    const separator = entry.indexOf("=");
+    const alias = separator > 0 ? entry.slice(0, separator).trim() : "";
+    const rest = separator > 0 ? entry.slice(separator + 1).trim() : "";
+    const at = rest.lastIndexOf("@");
+    const target = at < 0 ? rest : rest.slice(0, at);
+    const thinking = at < 0 ? undefined : rest.slice(at + 1);
+    const slash = target.indexOf("/");
+    if (!ALIAS.test(alias) || slash <= 0 || slash === target.length - 1) {
+      throw new Error(`MODEL_ALIASES: "${entry}" hat nicht das Format "alias=anbieter/modell" oder "alias=anbieter/modell@denktiefe"`);
+    }
+    if (thinking !== undefined && !isThinkingLevel(thinking)) throw new Error(`MODEL_ALIASES: "${entry}" nennt die unbekannte Denktiefe "${thinking}"`);
+    return { alias, upstream: target.slice(0, slash), model: target.slice(slash + 1), ...(thinking === undefined ? {} : { thinking }) };
+  });
+  const duplicate = aliases.find((entry, index) => aliases.findIndex((other) => other.alias === entry.alias) !== index);
+  if (duplicate) throw new Error(`MODEL_ALIASES nennt den Alias ${duplicate.alias} mehrfach`);
+  return aliases;
+};
+
+const env = declaredEnvironment(modelAliasEnvDescriptors);
+
+export const configuredModelAliases = (): readonly ModelAlias[] => parseModelAliases(env.list("MODEL_ALIASES"));
+
+/** Der Katalog der Aliasse aus den eingebauten Katalogen ihrer Anbieter, so wie die Modelllaufzeit sie anbietet. */
+export const aliasCatalog = (aliases: readonly ModelAlias[] = configuredModelAliases()): readonly Model<Api>[] => {
+  if (aliases.length === 0) throw new Error(`Der Anbieter ${ALIAS_PROVIDER} braucht MODEL_ALIASES im Abschnitt host`);
+  return aliases.map((entry) => {
+    const target = getBuiltinModels(entry.upstream as BuiltinProvider).find((model) => model.id === entry.model);
+    if (!target) throw new Error(`MODEL_ALIASES: das Modell ${entry.model} hinter ${entry.alias} fehlt im Katalog von ${entry.upstream}`);
+    const supported = getSupportedThinkingLevels(target);
+    if (entry.thinking !== undefined && !supported.includes(entry.thinking)) {
+      throw new Error(`MODEL_ALIASES: die Denktiefe ${entry.thinking} gibt es für ${entry.alias} nicht (gültig: ${supported.join(", ")})`);
+    }
+    return aliasedModel(ALIAS_PROVIDER, entry.alias, target);
+  });
+};
+
+/** Die Aliasse des Profils, geprüft gegen die Kataloge ihrer Ziele samt Denktiefe. */
+export const validatedModelAliases = (): readonly ModelAlias[] => {
+  const aliases = configuredModelAliases();
+  if (aliases.length > 0) aliasCatalog(aliases);
+  return aliases;
+};
+
+/** Die Denktiefe, die der Alias mitbringt; andere Anbieter und Aliasse ohne Angabe haben keine. */
+export const modelDefaultThinking = (provider: string, model: string): ThinkingLevel | undefined =>
+  provider === ALIAS_PROVIDER ? configuredModelAliases().find((entry) => entry.alias === model)?.thinking : undefined;
+
+/** Der Anbieter, wie eine Anzeige ihn nennt: bei Aliassen keiner. */
+export const displayProvider = (provider: string): string => provider === ALIAS_PROVIDER ? "" : provider;
+
+export const modelLabel = (provider: string, model: string): string => {
+  const shown = displayProvider(provider);
+  return shown ? `${shown}/${model}` : model;
+};