@schlenkr/ragents 0.1.4 → 0.1.6

package/apps/server/src/ragents/actor-chat-history.ts

@@ -1,8 +1,8 @@
-import { DomainError, type JournalEvent, type RunView } from "@aicontainer/ragents";
-import { applyEvent, type ChatEvent, type Message } from "../chat-events.js";
+import { DomainError, type JournalEvent, type RunView } from "@ragents/engine";
+import { applyEvent, type ChatEvent, type Message } from "quassel/events";
 import { ChatTextPositions } from "./chat-text-positions.js";
 import { attachmentContentPath } from "../api/contracts.js";
-import { journalChatEventsOf, questionAnswerEventOf, questionEventOf } from "./journal-chat-events.js";
+import { actionEventOf, actionResolvedEventOf, journalChatEventsOf } from "./journal-chat-events.js";
 
 export interface ActorConversations {
   revision: number;
@@ -17,7 +17,7 @@ export function actorChatHistoryOf(view: RunView, events: readonly JournalEvent[
   const positions = new ChatTextPositions();
   const actorOf = (id: string) => {
     const actor = view.actors.find((entry) => entry.id === id);
-    if (!actor) throw new DomainError("actor-not-found", `Der Actor ${id} fehlt in der Laufansicht.`, 404);
+    if (!actor) throw new DomainError("actor-not-found", `Der Actor ${id} fehlt in der Run-Ansicht.`, 404);
     return actor;
   };
   const colorOf = (id: string) => {
@@ -25,11 +25,15 @@ export function actorChatHistoryOf(view: RunView, events: readonly JournalEvent[
     const index = Math.max(view.actors.filter((actor) => actor.kind === "agent").findIndex((actor) => actor.id === id), 0);
     return `hsl(${ACTOR_HUES[index % ACTOR_HUES.length]} 45% 42%)`;
   };
+  const interrupted = (turnId: string) =>
+    view.turns.find((entry) => entry.id === turnId)?.toolCalls.filter((call) => call.status === "interrupted").map((call) => call.id) ?? [];
   const turnActorOf = (id: string) => {
     const turn = view.turns.find((entry) => entry.id === id);
-    if (!turn) throw new Error(`Der Turn ${id} fehlt in der Laufansicht.`);
+    if (!turn) throw new Error(`Der Turn ${id} fehlt in der Run-Ansicht.`);
     return turn.actorId;
   };
+  const interruptingCommands = new Set(events.flatMap((event) =>
+    event.type === "turn.interrupted" ? [JSON.stringify([event.commandId, turnActorOf(event.payload.turnId)])] : []));
   const append = (id: string, event: ChatEvent, source: JournalEvent) => {
     const actor = actorOf(id);
     if (actor.kind === "human") throw new DomainError("actor-not-executable", "Ein menschlicher Actor besitzt keinen Actor-Chat.", 400);
@@ -51,7 +55,7 @@ export function actorChatHistoryOf(view: RunView, events: readonly JournalEvent[
     switch (event.type) {
       case "actor.input.enqueued": {
         const input = view.inputs.find((entry) => entry.id === event.payload.inputId);
-        if (!input) throw new Error(`Die Eingabe ${event.payload.inputId} fehlt in der Laufansicht.`);
+        if (!input) throw new Error(`Die Eingabe ${event.payload.inputId} fehlt in der Run-Ansicht.`);
         if (input.lifecycle.kind === "discarded") break;
         actorOf(input.actorId);
         if (input.presentation === "background") break;
@@ -59,50 +63,47 @@ export function actorChatHistoryOf(view: RunView, events: readonly JournalEvent[
         const sender = actorOf(input.enqueuedBy);
         const attachments = input.artifactIds.map((id) => {
           const artifact = view.artifacts.find((entry) => entry.id === id);
-          if (!artifact) throw new Error(`Der Anhang ${id} fehlt in der Laufansicht.`);
+          if (!artifact) throw new Error(`Der Anhang ${id} fehlt in der Run-Ansicht.`);
           return { name: artifact.title, mediaType: artifact.mediaType, size: artifact.size,
             url: attachmentContentPath(view.id, id) };
         });
         actors[input.actorId].push({ key: event.eventId, role: fromOwner ? "user" : "assistant", sender: input.enqueuedBy,
-          text: input.content, closed: true, at, ...(attachments.length ? { attachments } : {}),
+          text: input.content, closed: true, at, inputId: input.id, ...(attachments.length ? { attachments } : {}),
           ...(fromOwner ? {} : { bubble: { color: colorOf(input.enqueuedBy),
             label: input.subscriptionId ? "Über Subscription zugestellt" : `Zugestellt von @${sender.handle}`, side: "start" } }),
         });
         break;
       }
       case "model.output.completed":
+      case "model.output.interrupted":
       case "model.reasoning.completed":
       case "tool.call.started":
       case "tool.call.completed":
       case "tool.call.failed":
       case "runtime.output.recorded":
-      case "turn.finished": {
+      case "turn.finished":
+      case "turn.interrupted": {
         const actorId = turnActorOf(event.payload.turnId);
-        for (const mapped of journalChatEventsOf(event, cursor, actorToolId)) append(actorId, mapped, event);
+        for (const mapped of journalChatEventsOf(event, cursor, interrupted, actorToolId)) append(actorId, mapped, event);
         if (event.type === "model.reasoning.completed") append(actorId, { kind: "turn-done" }, event);
         break;
       }
-      case "turn.interrupted": {
+      case "turn.input-steered": {
         const actorId = turnActorOf(event.payload.turnId);
-        const turn = view.turns.find((entry) => entry.id === event.payload.turnId)!;
-        for (const call of turn.toolCalls) {
-          const id = actorToolId(turn.id, call.id);
-          if (actors[actorId].some((message) => message.tool?.id === id && message.tool.result === undefined))
-            append(actorId, { kind: "tool-result", id, result: event.payload.reason, isError: true }, event);
-        }
-        for (const mapped of journalChatEventsOf(event, cursor, actorToolId)) append(actorId, mapped, event);
+        actors[actorId] = applyEvent(actors[actorId], { kind: "steered", inputId: event.payload.inputId });
         break;
       }
       case "actor.stopped":
-        for (const mapped of journalChatEventsOf(event, cursor, actorToolId)) append(event.payload.actorId, mapped, event);
+        if (interruptingCommands.has(JSON.stringify([event.commandId, event.payload.actorId]))) break;
+        for (const mapped of journalChatEventsOf(event, cursor, interrupted, actorToolId)) append(event.payload.actorId, mapped, event);
         break;
       case "action.proposed":
-        if (event.payload.kind === "question" && actorOf(event.actorId).kind !== "human") append(event.actorId, questionEventOf(event.payload, at), event);
+        if (actorOf(event.actorId).kind !== "human") append(event.actorId, actionEventOf(event.payload, at), event);
         break;
       case "action.resolved": {
         const action = view.actions.find((entry) => entry.id === event.payload.actionId);
-        if (!action) throw new Error(`Die Aktion ${event.payload.actionId} fehlt in der Laufansicht.`);
-        if (action.kind === "question" && actorOf(action.askedBy).kind !== "human") append(action.askedBy, questionAnswerEventOf(event), event);
+        if (!action) throw new Error(`Die Aktion ${event.payload.actionId} fehlt in der Run-Ansicht.`);
+        if (actorOf(action.askedBy).kind !== "human") append(action.askedBy, actionResolvedEventOf(event), event);
         break;
       }
     }

package/apps/server/src/ragents/chat-projection.ts

@@ -1,14 +1,19 @@
-import type { ChatAttachment, ChatEvent, ChatTextCursor } from "../chat-events.js";
-import { PluginStateProjection, type JournalEvent } from "@aicontainer/ragents";
+import type { ChatAttachment, ChatEvent, ChatTextCursor } from "quassel/events";
+import { PluginStateProjection, type JournalEvent, type Turn } from "@ragents/engine";
 import { ChatTextPositions } from "./chat-text-positions.js";
-import { journalChatEventsOf, questionAnswerEventOf, questionEventOf } from "./journal-chat-events.js";
+import { actionEventOf, actionResolvedEventOf, journalChatEventsOf, type InterruptedToolCalls } from "./journal-chat-events.js";
+
+const interruptedIn = (scope: ChatProjectionScope): InterruptedToolCalls => (turnId) =>
+  scope.turnOf(turnId).toolCalls.filter((call) => call.status === "interrupted").map((call) => call.id);
 
 export interface ChatProjectionScope {
   conversationId: string;
   primaryActorId: string;
   ownerId: string;
   labelOf: (actorId: string) => string | undefined;
-  actionKindOf: (actionId: string) => "action" | "question" | undefined;
+  turnOf: (turnId: string) => Pick<Turn, "actorId" | "toolCalls">;
+  /** Whether this command also interrupted a turn of the actor; its stop then repeats no reason. */
+  interruptedByCommand: (commandId: string, actorId: string) => boolean;
   attachmentOf?: (artifactId: string) => ChatAttachment;
 }
 
@@ -19,36 +24,42 @@ export const chatEventsOf = (event: JournalEvent, scope: ChatProjectionScope, cu
   if (event.type === "actor.input.enqueued") {
     if (event.payload.presentation === "background") return [];
     return event.payload.subscriptionId === null && event.actorId === scope.ownerId && event.payload.actorId === scope.primaryActorId
-      ? [{ kind: "user", text: event.payload.content, at,
+      ? [{ kind: "user", text: event.payload.content, inputId: event.payload.inputId, at,
         ...(scope.attachmentOf && event.payload.artifactIds.length > 0
           ? { attachments: event.payload.artifactIds.map(scope.attachmentOf) } : {}),
       }]
       : [];
   }
 
-  if (event.type === "action.proposed" && event.payload.kind === "question") {
-    const asker = event.actorId === scope.primaryActorId
+  if (event.type === "turn.input-steered")
+    return scope.turnOf(event.payload.turnId).actorId === scope.primaryActorId ? [{ kind: "steered", inputId: event.payload.inputId }] : [];
+
+  if (event.type === "action.proposed") {
+    const asker = event.actorId === scope.primaryActorId || event.actorId === scope.ownerId
       ? undefined
       : scope.labelOf(event.actorId);
-    return [questionEventOf(event.payload, at, asker)];
+    return [actionEventOf(event.payload, at, asker)];
   }
 
-  if (event.type === "action.resolved" && scope.actionKindOf(event.payload.actionId) === "question") {
-    return [questionAnswerEventOf(event)];
-  }
+  if (event.type === "action.resolved") return [actionResolvedEventOf(event)];
 
   if (event.type === "actor.stopped")
-    return event.payload.actorId === scope.primaryActorId ? journalChatEventsOf(event, cursor) : [];
+    return event.payload.actorId === scope.primaryActorId && !scope.interruptedByCommand(event.commandId, event.payload.actorId)
+      ? journalChatEventsOf(event, cursor, interruptedIn(scope))
+      : [];
+
+  if (event.type === "turn.interrupted")
+    return scope.turnOf(event.payload.turnId).actorId === scope.primaryActorId ? journalChatEventsOf(event, cursor, interruptedIn(scope)) : [];
 
   if (event.actorId !== scope.primaryActorId) return [];
 
   if (event.type === "plugin.state-replaced" || event.type === "plugin.state-patched") return [{
-    kind: "extension", pluginId: event.payload.pluginId, type: "state-replaced",
+    kind: "plugin", pluginId: event.payload.pluginId, type: "state-replaced",
     payload: { scope: event.payload.scope, state: pluginState }, at,
     journal: { conversationId: scope.conversationId, eventId: event.eventId, sequence: event.sequence },
   }];
 
-  return journalChatEventsOf(event, cursor);
+  return journalChatEventsOf(event, cursor, interruptedIn(scope));
 };
 
 export const chatHistoryOf = (events: readonly JournalEvent[], scope: ChatProjectionScope, positions = new ChatTextPositions(), pluginStates = new PluginStateProjection()): ChatEvent[] =>

package/apps/server/src/ragents/chat-text-positions.ts

@@ -1,5 +1,5 @@
-import type { JournalEvent } from "@aicontainer/ragents";
-import type { ChatTextCursor } from "../chat-events.js";
+import type { JournalEvent } from "@ragents/engine";
+import type { ChatTextCursor } from "quassel/events";
 
 const textUnits = (text: string): number => text.replace(/\s/g, "").length;
 
@@ -17,7 +17,7 @@ export class ChatTextPositions {
   observe(event: JournalEvent): ChatTextCursor | undefined {
     if (event.type === "run.created") this.#conversationId = event.eventId;
     if (event.type === "turn.started") this.#turns.set(event.payload.turnId, { sequence: event.sequence, committed: 0, live: 0 });
-    if (event.type !== "model.output.completed") return undefined;
+    if (event.type !== "model.output.completed" && event.type !== "model.output.interrupted") return undefined;
     const turn = this.#turn(event.payload.turnId);
     turn.committed += textUnits(event.payload.text);
     turn.live = Math.max(turn.live, turn.committed);
@@ -37,7 +37,7 @@ export class ChatTextPositions {
   }
 
   #cursor(sequence: number, offset: number): ChatTextCursor {
-    if (this.#conversationId === null) throw new Error("Der Journalanfang der Unterhaltung fehlt.");
+    if (this.#conversationId === null) throw new Error("Der Journalanfang des Runs fehlt.");
     return { conversationId: this.#conversationId, sequence, offset };
   }
 }

package/apps/server/src/ragents/coordinator.ts

@@ -1,5 +1,31 @@
-import type { Orchestration } from "@aicontainer/ragents";
+import { isThinkingLevel, resolveExecution, type CatalogModel, type ModelCatalog, type ModelSelection, type Orchestration, type RunState } from "@ragents/engine";
+import type { CoordinatorDescriptor } from "./product-runtime.js";
+import { storedModel, storedThinking } from "./start-option-state.js";
 
 export const isRunCoordinator = (runtime: Orchestration, runId: string, actorId: string): boolean =>
   runtime.events(runId).some((event) => event.type === "agent.spawned"
     && event.payload.agentId === actorId && /(?:^|:)coordinator:[^:]+:\d+$/.test(event.commandId));
+
+export interface CoordinatorModelChoice {
+  readonly model: string | undefined;
+  readonly thinking: string | undefined;
+}
+
+export const storedModelChoice = (state: RunState | null): CoordinatorModelChoice => ({ model: storedModel(state), thinking: storedThinking(state) });
+
+/** Das Modell eines Turns des Run-Koordinators: die Modellwahl des Runs, ohne sie das beim Anlegen. */
+export const coordinatorSelection = (
+  catalog: ModelCatalog & { readonly modelList: readonly CatalogModel[] },
+  coordinator: Pick<CoordinatorDescriptor, "handle" | "profile">,
+  choice: CoordinatorModelChoice,
+  spawned: ModelSelection,
+): ModelSelection => {
+  if (!choice.model) return spawned;
+  const execution = resolveExecution(catalog, {
+    profile: coordinator.profile,
+    model: choice.model,
+    ...(isThinkingLevel(choice.thinking) ? { thinking: choice.thinking } : {}),
+  }, coordinator.handle, catalog.modelList);
+  if (execution.driver.kind !== "agent") throw new Error(`Das Profil ${coordinator.profile} des Koordinators hat keine Modelllaufzeit`);
+  return execution.driver.config;
+};

package/apps/server/src/ragents/document-store.ts

@@ -1,4 +1,4 @@
-import { serviceToken } from "@aicontainer/ragents";
+import { serviceToken } from "@ragents/engine";
 
 export interface DocumentStoreDescription {
   directoryPattern: string;

package/apps/server/src/ragents/engine.ts

@@ -1,6 +1,7 @@
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
-import type { ModelRuntime } from "@aicontainer/agent";
+import type { ModelRuntime } from "@ragents/agent";
+import { FILE_OPERATIONS } from "@ragents/workspace-executor";
 import {
   DirectoryArtifactContents,
   Journal,
@@ -33,32 +34,44 @@ import {
   type RunStopOperation,
   type StartOptionContributionRegistry,
   type Workspaces,
-} from "@aicontainer/ragents";
+} from "@ragents/engine";
 import { config } from "../config.js";
 import { accessibleRunView } from "../access-projection.js";
 import { assertRunRights } from "../api/rights.js";
+import { runOwnerOf, runOwnerOnly } from "./run-owner.js";
 import { layout, ROOT_ONLY_MODE } from "../layout.js";
 import { renderSystemPromptOption, systemPromptSelectionPromptIds } from "../plugin-support/prompt.js";
 import { actorProgramsToken } from "../plugin-support/actor-programs/service.js";
 import { checkedThinkingLevel } from "../plugin-support/thinking-level.js";
+import { skillOfDirectory } from "../plugin-support/skills.js";
 import { selectedSystemPrompts } from "../plugin-support/system-prompts.js";
 import { productRuntimeToken, type ActorRole, type ProductActor } from "./product-runtime.js";
 import { storedSystemPrompt } from "./start-option-state.js";
-import { isRunCoordinator } from "./coordinator.js";
+import { coordinatorSelection, isRunCoordinator, storedModelChoice } from "./coordinator.js";
 import { runtimeBridgeToken } from "./runtime-bridge.js";
 import { workspaceRuntimeToken } from "./workspace-runtime.js";
-import { globalChatToken } from "./global-chat.js";
+import { globalChatToken, globalRunPolicyOf } from "./global-chat.js";
 import { NodeTypeScriptExecutor } from "../plugin-support/native-typescript-executor.js";
-import { sandboxServicesToken } from "../plugin-support/workspace-sandbox-host.js";
-import { registerTypeScriptFunctions } from "./typescript-tools.js";
+import { sandboxServicesToken, type SandboxServices } from "../plugin-support/workspace-sandbox-host.js";
 
 const FINAL_RUN_STOP_TIMEOUT_MS = 15_000;
 
+type RememberedWorkspace = {
+  readonly cwd: string;
+  readonly description?: string;
+};
+
 export class SessionWorkspaces implements Workspaces {
-  readonly #roots = new Map<string, string>();
+  readonly #roots = new Map<string, RememberedWorkspace>();
+  readonly #sandbox: () => Pick<SandboxServices, "execute" | "serverProcessContextFor">;
+
+  /** Der Zugang zum Arbeitsbereich der Runs; über ihn liegen Anhänge dort, wo die Werkzeuge arbeiten, und die Laufzeit bekommt ihren Serverordner. */
+  constructor(sandbox: () => Pick<SandboxServices, "execute" | "serverProcessContextFor">) {
+    this.#sandbox = sandbox;
+  }
 
-  remember(runId: string, cwd: string): void {
-    this.#roots.set(runId, cwd);
+  remember(runId: string, cwd: string, description?: string): void {
+    this.#roots.set(runId, { cwd, ...(description ? { description } : {}) });
   }
 
   forget(runId: string): void {
@@ -67,8 +80,24 @@ export class SessionWorkspaces implements Workspaces {
 
   ensure(runId: string): string {
     const root = this.#roots.get(runId);
-    if (!root) throw new Error(`Für die Unterhaltung ${runId} ist kein Arbeitsverzeichnis bekannt`);
-    return root;
+    if (!root) throw new Error(`Für den Run ${runId} ist kein Arbeitsverzeichnis bekannt`);
+    return root.cwd;
+  }
+
+  description(runId: string): string | undefined {
+    return this.#roots.get(runId)?.description;
+  }
+
+  /** Der Ordner auf diesem Server für Arbeit des Runs, die hier läuft; bei einem Arbeitsplatz nie dessen Pfad. */
+  async runtimeDirectory(runId: string): Promise<string> {
+    return (await this.#sandbox().serverProcessContextFor(runId)).cwd;
+  }
+
+  async storeAttachment(runId: string, name: string, content: Uint8Array): Promise<string> {
+    const stored = await this.#sandbox().execute(runId, FILE_OPERATIONS.attach, { name, content: Buffer.from(content).toString("base64") });
+    const storedName = (stored as { name?: unknown } | null)?.name;
+    if (typeof storedName !== "string") throw new Error(`Der Executor meldet für den Anhang ${name} keinen Namen`);
+    return storedName;
   }
 }
 
@@ -96,7 +125,6 @@ export interface EngineOptions {
   modelRuntime?: Promise<ModelRuntime>;
   assertAvailable: () => void;
   assertRunUsable: (runId: string) => void;
-  onChatSessionPersisted: (runId: string, agentId: string, file: string) => void;
 }
 
 export interface Engine {
@@ -104,9 +132,7 @@ export interface Engine {
   journal: Journal;
   scheduler: TurnScheduler;
   live: LiveBus;
-  catalog: ModelCatalog;
-  catalogModels: readonly CatalogModel[];
-  registry: ToolRegistry;
+  catalog: ModelCatalog & { readonly modelList: readonly CatalogModel[] };
   systemPrompt: string;
   startOptions: StartOptionContributionRegistry;
   systemPromptFor: (runId: string) => string;
@@ -164,7 +190,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
 
   const nativeTypeScriptExecutor = new NodeTypeScriptExecutor({
     directoryFor: (runId) => path.join(layout.sessionDir(runId), "native-programs"),
-    processContextFor: (runId) => options.plugins.service(sandboxServicesToken).processContextFor(runId),
+    serverProcessContextFor: (runId) => options.plugins.service(sandboxServicesToken).serverProcessContextFor(runId),
   });
   const actorPrograms = options.plugins.optionalService(actorProgramsToken);
   const services = { ...runtimeServices, nativeTypeScriptExecutor, ...(actorPrograms ? {actorPrograms} : {}) };
@@ -181,14 +207,13 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     audience: isRunCoordinator(runtime, context.runId, context.agentId) ? "coordinator" : "agent",
   });
   const agentRuntime = new AgentSessionDriver({
-    agentDir: config.agentHomeDir,
     modelRuntime: options.modelRuntime,
-    resolveSkillPaths: (context) => context.runId === globalChat?.runId ? [] : options.plugins.skills.resolve(contributionContextFor(context)),
-    resolveExtensionFactories: (context) => context.runId === globalChat?.runId ? [] : options.plugins.agentRuntime.resolve(contributionContextFor(context)),
+    resolveSkills: async (context) => globalChat?.isCoordinator(context.runId) ? []
+      : (await options.plugins.skills.resolve(contributionContextFor(context))).map(skillOfDirectory),
+    resolveExtensionFactories: (context) => globalChat?.isCoordinator(context.runId) ? [] : options.plugins.agentRuntime.resolve(contributionContextFor(context)),
     sessions: {
       directory: (runId, agentId) => layout.agentChatDir(runId, agentId),
       directoryMode: ROOT_ONLY_MODE,
-      persisted: options.onChatSessionPersisted,
     },
   });
   const configuredModels = await Promise.all(options.plugins.profiles.models().map(async (model) => {
@@ -211,14 +236,14 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
       provider: globalProfile.provider, model: globalProfile.model,
       thinking: globalProfile.thinking ?? checkedThinkingLevel(config.agentThinking, "AGENT_THINKING"),
     }, () => {
-      if (!journal.stateOf(globalChat.runId)) return [];
-      const view = runtime.view(globalChat.runId);
-      const attachments = new Set(view.inputs.flatMap((input) => input.artifactIds));
-      return [...new Set(view.artifacts.filter((artifact) => attachments.has(artifact.id)).map((artifact) => attachmentInputKind(artifact.mediaType)))]
-        .filter((kind) => kind === "image" || kind === "video" || kind === "file");
+      const kinds = journal.runIds().filter((runId) => globalChat.isCoordinator(runId) && journal.stateOf(runId)).flatMap((runId) => {
+        const view = runtime.view(runId);
+        const attachments = new Set(view.inputs.flatMap((input) => input.artifactIds));
+        return view.artifacts.filter((artifact) => attachments.has(artifact.id)).map((artifact) => attachmentInputKind(artifact.mediaType));
+      });
+      return [...new Set(kinds)].filter((kind) => kind === "image" || kind === "video" || kind === "file");
     });
   }
-  registerTypeScriptFunctions(options.plugins);
   const registry = new ToolRegistry();
   for (const contributor of options.plugins.tools.entries()) registry.register(contributor);
   const live = new LiveBus({
@@ -248,7 +273,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     selectedSystemPrompts(promptCatalog, promptIdsFor(runId)).map((option) => {
       const text = optionTexts.get(option.id);
       if (text === undefined) {
-        throw new Error(`Der Systemprompt ${option.id} der Unterhaltung ${runId} ist nicht mehr konfiguriert`);
+        throw new Error(`Der Systemprompt ${option.id} des Runs ${runId} ist nicht mehr konfiguriert`);
       }
       return text;
     });
@@ -274,7 +299,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     }, { delivery: "on-demand", toolNames });
     return chapters.map((entry) => entry.content).filter(Boolean).join("\n\n");
   };
-  const systemPromptFor = (runId: string): string => runId === globalChat?.runId
+  const systemPromptFor = (runId: string): string => globalChat?.isCoordinator(runId)
     ? globalChat.prompt : composeWith(runId, textsFor(runId), null);
   const coordinatorPromptFor = (runId: string, toolNames: readonly string[]): string =>
     composeWith(runId, textsFor(runId), toolNames);
@@ -285,7 +310,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     selectedSystemPrompts(promptCatalog, promptCatalog.defaultIds).map((option) => optionTexts.get(option.id) ?? ""),
     null);
   const basePromptFor = (runId: string, actor: ExecutableActor, toolNames: readonly string[]): string => {
-    if (runId === globalChat?.runId) return [globalChat.prompt, outputContractFor("primary"), globalChat.contextPrompt?.(runtime, actor)].filter(Boolean).join("\n\n");
+    if (globalChat?.isCoordinator(runId)) return [globalChat.prompt, outputContractFor("primary"), globalChat.contextPrompt?.(runtime, runId, actor)].filter(Boolean).join("\n\n");
     const role = roleFor(runId, actor);
     const prompt = isRunCoordinator(runtime, runId, actor.id)
       ? coordinatorPromptFor(runId, toolNames)
@@ -306,8 +331,10 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     live,
     modelSelection: (turn, actor) => {
       if (actor.execution.driver.kind !== "agent") throw new Error("Modellwahl benötigt einen Modell-Actor");
-      return turn.runId === globalChat?.runId && globalChat.model
-        ? globalChat.model.forTurn(runtime, actor.id, turn.turnId) : actor.execution.driver.config;
+      if (globalChat?.isCoordinator(turn.runId) && globalChat.model) return globalChat.model.forTurn(runtime, turn.runId, actor.id, turn.turnId);
+      return isRunCoordinator(runtime, turn.runId, actor.id)
+        ? coordinatorSelection(catalog, productRuntime.coordinator, storedModelChoice(journal.stateOf(turn.runId)), actor.execution.driver.config)
+        : actor.execution.driver.config;
     },
     ...(workspaceToolNaming ? { workspaceToolNaming } : {}),
     basePrompt: basePromptFor,
@@ -362,16 +389,24 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     primaryActorId: (view) => view.primaryActorId,
     stopExternal,
   });
-  const globalPolicy = globalChat?.access ? { runId: globalChat.runId, ...globalChat.access } : undefined;
+  const runAccess = {
+    global: globalRunPolicyOf(globalChat),
+    ownerOf: (runId: string) => runOwnerOf(journal, runId),
+    ownerOnly: (runId: string) => runOwnerOnly(journal, options.plugins.startOptions, runId),
+  };
   const runtimeOptions = {
     runtime,
     assertAvailable: options.assertAvailable,
     assertRunUsable: options.assertRunUsable,
-    assertRunRights: (access: AccessContext, runId: string, kind: RunRightsKind) => assertRunRights(access, runId, kind, globalPolicy),
+    assertRunRights: (access: AccessContext, runId: string, kind: RunRightsKind) => assertRunRights(access, runId, kind, runAccess),
     projectView: accessibleRunView,
     hasRun: (runId: string) => journal.stateOf(runId) !== null,
   };
-  const methods = runtimeMethods({ ...runtimeOptions, stopRun: runStopper.stop });
+  const methods = runtimeMethods({
+    ...runtimeOptions,
+    stopRun: runStopper.stop,
+    interruptTurn: (runId, actorId, interruption) => scheduler.interruptTurn(runId, actorId, interruption),
+  });
   const artifactRoute = artifactContentRoute(runtimeOptions);
   options.plugins.optionalService(runtimeBridgeToken)?.bind(runtime);
 
@@ -381,8 +416,6 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     scheduler,
     live,
     catalog,
-    catalogModels: catalog.modelList,
-    registry,
     systemPrompt,
     startOptions: options.plugins.startOptions,
     systemPromptFor,

package/apps/server/src/ragents/global-chat.ts

@@ -1,40 +1,53 @@
-import { serviceToken, type CatalogModel, type ExecutableActor, type JournalEvent, type JsonValue, type ModelSelection, type Orchestration, type RunView } from "@aicontainer/ragents";
-import type { SessionInfo } from "../chat-handler.js";
+import { serviceToken, type AccessContext, type CatalogModel, type ExecutableActor, type JournalEvent, type JsonValue, type ModelSelection, type Orchestration, type RunView } from "@ragents/engine";
+import type { GlobalRunPolicy } from "../api/rights.js";
+import type { ChatUser, SessionInfo } from "../chat-handler.js";
 
 export interface GlobalChatPolicy {
-  runId: string;
+  /** Der Koordinator eines Benutzers; ohne Anmeldung (null) gibt es genau einen. */
+  runIdFor: (userId: string | null) => string;
+  /** Jede Kennung, die einem Koordinator vorbehalten ist, auch eine, die keinem Zugang mehr gehört. */
+  isCoordinator: (runId: string) => boolean;
   access?: { read: string; write: string };
   title: string;
   prompt: string;
   preparationPrompt?: string;
   toolNames: readonly string[];
-  workspaceDirectory: string;
+  workspaceDirectory: (runId: string) => string;
   prepareWorkspace?: (directory: string) => Promise<void>;
-  resetIntentFile?: string;
-  inputContext?: (runtime: Orchestration, value: unknown) => Promise<readonly string[]>;
-  contextPrompt?: (runtime: Orchestration, actor: ExecutableActor) => string;
+  /** Je Koordinator eine Datei <runId>.json, solange sein Gesprächsreset nicht abgeschlossen ist. */
+  resetIntentDirectory?: string;
+  inputContext?: (runtime: Orchestration, runId: string, value: unknown) => Promise<readonly string[]>;
+  contextPrompt?: (runtime: Orchestration, runId: string, actor: ExecutableActor) => string;
   model?: {
     initialize: (models: readonly (CatalogModel & { input: readonly string[] })[], initial: ModelSelection, requiredInputs: () => readonly string[]) => Promise<void>;
     selection: () => ModelSelection;
-    forTurn: (runtime: Orchestration, actorId: string, turnId: string) => ModelSelection;
+    forTurn: (runtime: Orchestration, runId: string, actorId: string, turnId: string) => ModelSelection;
   };
 }
 
 export type ManagedRunStart = {
   title: string;
   options?: Readonly<Record<string, JsonValue>>;
+  /** Wer die Startoptionen wählt und den Run besitzt: der Benutzer der Anfrage, null ohne Anmeldung. */
+  user: ChatUser | null;
 } & ({ kind: "message"; message: string } | { kind: "script"; entryId: string; input: JsonValue }
   | { kind: "package"; directory: string; input: JsonValue });
 
-export interface SessionManagement {
-  list: () => Promise<SessionInfo[]>;
+export interface RunManagement {
+  /** Mit einem Zugang bleiben nur dessen eigene Runs übrig; ohne ihn ist es die Liste des Servers. */
+  list: (access?: AccessContext) => Promise<SessionInfo[]>;
   view: (runId: string) => RunView;
   events: (runId: string) => readonly JournalEvent[];
   create: (start: ManagedRunStart) => Promise<string>;
-  send: (runId: string, message: string) => Promise<void>;
+  /** Eine Nachricht bedient den Run; der Host prüft dafür denselben Zugang wie beim Chat. */
+  send: (runId: string, message: string, access: AccessContext) => Promise<void>;
   stop: (runId: string) => Promise<void>;
-  resetGlobal: () => Promise<void>;
+  resetGlobal: (runId: string) => Promise<void>;
 }
 
 export const globalChatToken = serviceToken<GlobalChatPolicy>("host.global-chat");
-export const sessionManagementToken = serviceToken<() => SessionManagement>("host.session-management");
+
+/** Die Rechte der Koordinatoren für die Nachrichtenschicht; ohne Rechte des Plugins gilt keiner als eigener Run. */
+export const globalRunPolicyOf = (policy: GlobalChatPolicy | undefined): GlobalRunPolicy | undefined =>
+  policy?.access ? { isCoordinator: policy.isCoordinator, runIdFor: policy.runIdFor, ...policy.access } : undefined;
+export const runManagementToken = serviceToken<() => RunManagement>("host.run-management");

package/apps/server/src/ragents/host-services.ts

@@ -1,26 +1,35 @@
 import {
   serviceToken,
+  type AccessContext,
   type Orchestration,
   type PluginHost,
   type ServiceToken,
-} from "@aicontainer/ragents";
+} from "@ragents/engine";
 import type { SessionWorkspace } from "./workspace-runtime.js";
-import type { SessionManagement } from "./global-chat.js";
+import type { RunManagement } from "./global-chat.js";
 
-export const sessionGuardToken: ServiceToken<(runId: string) => void> = serviceToken("host.session-guard");
+export const runGuardToken: ServiceToken<(runId: string) => void> = serviceToken("host.run-guard");
 
-export const sessionWorkspaceProviderToken: ServiceToken<(runId: string) => Promise<SessionWorkspace>> =
-  serviceToken("host.session-workspaces");
+/** Jeder Weg von außen zum Arbeitsbereich eines Runs (Dateien, Prozesse, Sprachserver) prüft damit Run und Zugang: ein Run, den nur sein Eigentümer bedient, zeigt seinen Arbeitsbereich nur ihm. */
+export const workspaceGuardToken: ServiceToken<(access: AccessContext, runId: string) => void> = serviceToken("host.workspace-guard");
+
+export const runWorkspaceProviderToken: ServiceToken<(runId: string) => Promise<SessionWorkspace>> =
+  serviceToken("host.run-workspaces");
 
 export const secretEnvNamesToken: ServiceToken<() => readonly string[]> = serviceToken("host.secret-env-names");
 
 export const runtimeProviderToken: ServiceToken<() => Orchestration> = serviceToken("host.runtime-provider");
 
+/** Die Adresse, unter der dieser Server seine API anbietet, etwa http://127.0.0.1:4710; ohne HTTP (nur stdio) keine. */
+export const hostAddressToken: ServiceToken<() => string | undefined> = serviceToken("host.address");
+
 export interface HostBridges {
   ensureSession: (runId: string) => void;
+  ensureWorkspaceAccess: (access: AccessContext, runId: string) => void;
   runtime: () => Orchestration;
   sessionWorkspaceFor: (runId: string) => Promise<SessionWorkspace>;
-  sessions?: () => SessionManagement;
+  sessions?: () => RunManagement;
+  apiBaseUrl?: string;
 }
 
 export type ProductProfileFactory = (bridges: HostBridges) => PluginHost;