@schlenkr/ragents 0.1.4 → 0.1.6

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

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import type { ChatAttachment, ChatAttachmentInput, ChatEvent, ChatStartupStatus } from "../chat-events.js";
-import { parseChatAttachments } from "../chat-attachments.js";
+import { isDeepStrictEqual } from "node:util";
+import { parseChatAttachments, type ChatAttachment, type ChatAttachmentInput, type ChatEvent, type ChatStartupStatus } from "quassel/events";
 import { attachmentContentPath } from "../api/contracts.js";
 import type { ChatSessionLike, ChatUser } from "../chat-handler.js";
 import {
@@ -20,21 +20,24 @@ import {
   type RegisteredStartOption,
   type RunScriptPackage,
   type RunView,
+  type SessionStartedContext,
   type StartOptionContext,
   type AgentExecution,
   type ModelSelection,
-} from "@aicontainer/ragents";
+} from "@ragents/engine";
 import type { ActorProgramsService } from "../plugin-support/actor-programs/service.js";
+import { modelLabel } from "../plugin-support/model-aliases.js";
 import type { StartOptionState } from "../plugin-support/start-options-contract.js";
 import type { Engine } from "./engine.js";
 import type { CoordinatorDescriptor } from "./product-runtime.js";
-import { startOptionScope, storedModel, storedStartOption, storedThinking } from "./start-option-state.js";
+import { modelStartOptionId, startOptionScope, storedModel, storedStartOption, storedThinking } from "./start-option-state.js";
+import { coordinatorSelection, isRunCoordinator, storedModelChoice } from "./coordinator.js";
 import { chatEventsOf, chatHistoryOf, type ChatProjectionScope } from "./chat-projection.js";
 import { ChatTextPositions } from "./chat-text-positions.js";
 import type { GlobalChatPolicy } from "./global-chat.js";
 import { actorChatHistoryOf, type ActorConversations } from "./actor-chat-history.js";
 
-const STAMPED_KINDS = new Set<ChatEvent["kind"]>(["user", "text", "thinking", "tool", "system", "question", "extension"]);
+const STAMPED_KINDS = new Set<ChatEvent["kind"]>(["user", "text", "thinking", "tool", "system", "action", "plugin"]);
 
 type LiveTurn = {
   emitProgress: boolean;
@@ -65,7 +68,19 @@ const primaryActorOf = (view: RunView) => view.primaryActorId
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-/** A run script entry together with the package the host installs when it is clicked. */
+const userIdOf = (user: ChatUser | undefined): string | null => user?.id ?? null;
+
+/** Wer einen Run startet, über welche Vorlage und welche Startoptionen sie festlegt. */
+interface StartChoice {
+  readonly userId: string | null;
+  readonly entry: SessionStartedContext["startEntry"];
+  readonly fixed: ReadonlyMap<string, JsonValue>;
+}
+
+/** Ein Start ohne Vorlage legt nichts fest. */
+const freeChoice = (userId: string | null): StartChoice => ({ userId, entry: null, fixed: new Map() });
+
+/** A script template together with the package the host installs when it is clicked. */
 export type RunScriptStart = RunScriptPackage & { entry: PublicStartEntry };
 
 export interface RunChatSessionOptions {
@@ -80,7 +95,10 @@ export interface RunChatSessionOptions {
   assertUsable: (id: string) => void;
   prepare: (id: string, emitSystem: (text: string) => void) => Promise<void>;
   prepareWorkspace: (id: string, emitSystem: (text: string) => void) => Promise<void>;
+  /** Nach dem Aufbau des ersten Actors im vorbereiteten Arbeitsbereich, bevor ein Actor Input bekommt. */
+  started: (id: string, startEntry: SessionStartedContext["startEntry"]) => Promise<void>;
   scriptEntryFor: (entryId: string) => RunScriptStart | undefined;
+  startEntryFor: (entryId: string) => PublicStartEntry | undefined;
   actorPrograms: ActorProgramsService;
 }
 
@@ -96,7 +114,9 @@ export class RunChatSession implements ChatSessionLike {
   readonly #assertUsable: (id: string) => void;
   readonly #prepare: (id: string, emitSystem: (text: string) => void) => Promise<void>;
   readonly #prepareWorkspace: (id: string, emitSystem: (text: string) => void) => Promise<void>;
+  readonly #started: (id: string, startEntry: SessionStartedContext["startEntry"]) => Promise<void>;
   readonly #scriptEntryFor: (entryId: string) => RunScriptStart | undefined;
+  readonly #startEntryFor: (entryId: string) => PublicStartEntry | undefined;
   readonly #actorPrograms: ActorProgramsService;
   readonly #events: ChatEvent[] = [];
   readonly #listeners = new Set<(event: ChatEvent) => void>();
@@ -128,7 +148,9 @@ export class RunChatSession implements ChatSessionLike {
     this.#assertUsable = options.assertUsable;
     this.#prepare = options.prepare;
     this.#prepareWorkspace = options.prepareWorkspace;
+    this.#started = options.started;
     this.#scriptEntryFor = options.scriptEntryFor;
+    this.#startEntryFor = options.startEntryFor;
     this.#actorPrograms = options.actorPrograms;
   }
 
@@ -144,43 +166,96 @@ export class RunChatSession implements ChatSessionLike {
     return this.#engine.journal.stateOf(this.id) !== null;
   }
 
-  startOptions(): readonly StartOptionState[] {
-    return this.#engine.startOptions.entries().map((entry) => this.#startOptionState(entry));
+  startOptions(userId: string | null): readonly StartOptionState[] {
+    return this.#engine.startOptions.entries().map((entry) => this.#startOptionState(entry, userId));
   }
 
-  selectStartOption(optionId: string, value: unknown): StartOptionState {
+  /** Vor dem Start merkt sich der Run die Wahl, danach schreibt er eine änderbare Option ins Journal. */
+  async selectStartOption(optionId: string, value: unknown, userId: string | null): Promise<StartOptionState> {
     const entry = this.#engine.startOptions.entry(optionId);
     if (!entry) throw new DomainError("option-unknown", `Die Startoption ${optionId} ist nicht registriert.`, 404);
     if (!entry.option.selectable()) {
       throw new DomainError("option-not-selectable", `Die Startoption ${optionId} ist fest konfiguriert.`, 409);
     }
-    if (this.startLocked) {
-      throw new DomainError("option-locked", "Die Unterhaltung läuft bereits, die Startoptionen stehen fest.", 409);
+    if (this.startLocked && !entry.option.changeable) {
+      throw new DomainError("option-locked", "Der Run läuft bereits, die Startoptionen stehen fest.", 409);
+    }
+    const accepted = this.#engine.startOptions.accept(optionId, value, this.#startContext(userId));
+    if (!this.startLocked) {
+      this.#startValues.set(optionId, accepted);
+      return this.#startOptionState(entry, userId);
+    }
+    if (!isDeepStrictEqual(storedStartOption(this.#engine.journal.stateOf(this.id), optionId), accepted)) {
+      if (optionId === modelStartOptionId) await this.#assertCoordinatorCanRead(accepted as { model?: string; thinking?: string });
+      const state = this.#engine.runtime.state(this.id);
+      this.#engine.runtime.replacePluginState(
+        { actorId: state.ownerId, commandId: `start-option:${optionId}:${this.id}:${this.#engine.runtime.view(this.id).revision}` },
+        this.id,
+        { pluginId: optionId, scope: startOptionScope, state: accepted },
+      );
+    }
+    return this.#startOptionState(entry, userId);
+  }
+
+  /** Ein anderes Modell muss die Anhänge lesen können, die das Gespräch des Koordinators schon enthält. */
+  async #assertCoordinatorCanRead(choice: { model?: string; thinking?: string }): Promise<void> {
+    const view = this.#engine.runtime.view(this.id);
+    const primary = primaryActorOf(view);
+    if (!primary || primary.kind === "human" || primary.execution.driver.kind !== "agent" || !isRunCoordinator(this.#engine.runtime, this.id, primary.id)) return;
+    const { provider, model } = coordinatorSelection(this.#engine.catalog, this.#coordinator,
+      { model: choice.model, thinking: choice.thinking }, primary.execution.driver.config);
+    const attached = new Set(view.inputs.filter((input) => input.actorId === primary.id).flatMap((input) => input.artifactIds));
+    const kinds = new Set(view.artifacts.filter((artifact) => attached.has(artifact.id)).map((artifact) => attachmentInputKind(artifact.mediaType)));
+    const supported = await this.#engine.inputCapabilities(provider, model);
+    const missing = [...kinds].filter((kind) => (kind === "image" || kind === "video" || kind === "file") && !supported.includes(kind));
+    if (missing.length > 0) {
+      throw new DomainError("model-history-unsupported", `Das Gespräch enthält bereits ${missing.join(", ")}-Anhänge, die ${modelLabel(provider, model)} nicht verarbeiten kann; wähle ein passendes Modell.`, 400);
     }
-    this.#startValues.set(optionId, this.#engine.startOptions.accept(optionId, value, this.#startContext()));
-    return this.#startOptionState(entry);
   }
 
-  #startContext(): StartOptionContext {
-    return { runId: this.id };
+  #startContext(userId: string | null): StartOptionContext {
+    return { runId: this.id, userId };
   }
 
-  #startValueOf(entry: RegisteredStartOption): JsonValue {
+  #startValueOf(entry: RegisteredStartOption, choice: StartChoice): JsonValue {
     const chosen = this.startLocked
       ? storedStartOption(this.#engine.journal.stateOf(this.id), entry.option.id)
-      : this.#startValues.get(entry.option.id);
-    return chosen ?? this.#engine.startOptions.defaultValue(entry.option.id, this.#startContext());
+      : choice.fixed.get(entry.option.id) ?? this.#startValues.get(entry.option.id);
+    return chosen ?? this.#engine.startOptions.defaultValue(entry.option.id, this.#startContext(choice.userId));
   }
 
-  #startOptionState(entry: RegisteredStartOption): StartOptionState {
-    const value = this.#startValueOf(entry);
+  /** Die eine Stelle, an der eine Vorlage Startoptionen festlegt: mit dem Handelnden angenommen, eine andere Belegung davor ist ein Fehler. */
+  #startChoice(entry: PublicStartEntry, userId: string | null): StartChoice {
+    const state = this.#engine.journal.stateOf(this.id);
+    const fixed = new Map(Object.entries(entry.fixedStartOptions ?? {}).map(([optionId, value]) => {
+      const accepted = this.#engine.startOptions.accept(optionId, value, this.#startContext(userId));
+      const chosen = this.startLocked ? storedStartOption(state, optionId) : this.#startValues.get(optionId);
+      if (chosen !== undefined && !isDeepStrictEqual(chosen, accepted)) {
+        throw new DomainError("start-option-fixed", this.startLocked
+          ? `Die Vorlage "${entry.title}" legt die Startoption ${optionId} fest, dieser Run steht dort aber schon auf einem anderen Wert.`
+          : `Die Vorlage "${entry.title}" legt die Startoption ${optionId} fest, gewählt ist ein anderer Wert. Nimm die Wahl zurück oder starte ohne diese Vorlage.`, 409);
+      }
+      return [optionId, accepted] as const;
+    }));
+    return { userId, entry: { id: entry.id, action: entry.action }, fixed };
+  }
+
+  #skillEntry(entryId: string): PublicStartEntry {
+    const entry = this.#startEntryFor(entryId);
+    if (!entry || entry.action !== "skill") throw new DomainError("entry-unknown", `Die Vorlage ${entryId} ist keine Skill-Vorlage dieses Profils.`, 404);
+    return entry;
+  }
+
+  #startOptionState(entry: RegisteredStartOption, userId: string | null): StartOptionState {
+    const value = this.#startValueOf(entry, freeChoice(userId));
     return {
       id: entry.option.id,
       owner: entry.owner,
       value,
-      presentation: entry.option.describe(value, this.#startContext()),
+      presentation: entry.option.describe(value, this.#startContext(userId)),
       selectable: entry.option.selectable(),
-      locked: this.startLocked,
+      locked: this.startLocked && !entry.option.changeable,
+      chosen: !this.startLocked && this.#startValues.has(entry.option.id),
     };
   }
 
@@ -206,16 +281,17 @@ export class RunChatSession implements ChatSessionLike {
     return () => this.#listeners.delete(listener);
   }
 
-  send(text: string, attachments?: ChatAttachmentInput[], userLocation?: unknown, user?: ChatUser): Promise<void> {
-    return this.#track(() => this.#send(text, attachments, undefined, userLocation, user), false);
+  /** Mit einer Skill-Vorlage startet die Nachricht einen neuen Run über sie, mit den Startoptionen, die sie festlegt. */
+  send(text: string, attachments?: ChatAttachmentInput[], userLocation?: unknown, user?: ChatUser, entryId?: string): Promise<void> {
+    return this.#track(() => this.#send(text, attachments, undefined, userLocation, user, entryId), false);
   }
 
-  async sendAndWait(text: string, attachments?: ChatAttachmentInput[]): Promise<void> {
-    await this.send(text, attachments);
+  async sendAndWait(text: string, user?: ChatUser): Promise<void> {
+    await this.send(text, undefined, undefined, user);
   }
 
-  sendToActor(actorId: string, text: string, attachments?: ChatAttachmentInput[]): Promise<void> {
-    return this.#track(() => this.#send(text, attachments, actorId), false);
+  sendToActor(actorId: string, text: string, attachments?: ChatAttachmentInput[], user?: ChatUser): Promise<void> {
+    return this.#track(() => this.#send(text, attachments, actorId, undefined, user), false);
   }
 
   actorConversations(): ActorConversations {
@@ -224,12 +300,16 @@ export class RunChatSession implements ChatSessionLike {
     return actorChatHistoryOf(this.#engine.runtime.view(this.id), this.#engine.runtime.events(this.id));
   }
 
-  async capabilities(actor = "primary"): Promise<{ input: string[]; model: string }> {
-    const execution = this.#executionFor(actor);
+  capabilities(actor: string, userId: string | null): Promise<{ input: string[]; model: string }> {
+    return this.#capabilitiesFor(actor, freeChoice(userId));
+  }
+
+  async #capabilitiesFor(actor: string, choice: StartChoice): Promise<{ input: string[]; model: string }> {
+    const execution = this.#executionFor(actor, choice);
     if (execution.driver.kind === "script") return { input: [], model: "TypeScript" };
     if (execution.driver.kind !== "agent") return { input: ["text"], model: execution.driver.kind };
     const { provider, model } = execution.driver.config;
-    return { input: [...await this.#engine.inputCapabilities(provider, model)], model: `${provider}/${model}` };
+    return { input: [...await this.#engine.inputCapabilities(provider, model)], model: modelLabel(provider, model) };
   }
 
   attachment(artifactId: string): { attachment: ChatAttachment; content: Uint8Array } {
@@ -239,7 +319,7 @@ export class RunChatSession implements ChatSessionLike {
     return { attachment: this.#attachmentInfo(artifact), content };
   }
 
-  /** Starts the run through a run script entry: no message, the script's first turn builds the run. */
+  /** Starts the run through a script template: no message, the script's first turn builds the run. */
   start(entryId: string, input: unknown, user?: ChatUser): void {
     this.#track(() => this.#start(entryId, input, user));
   }
@@ -248,12 +328,12 @@ export class RunChatSession implements ChatSessionLike {
     await this.#track(() => this.#start(entryId, input, user));
   }
 
-  async startPackageAndWait(script: RunScriptStart, input: unknown): Promise<void> {
-    await this.#track(() => this.#startPackage(() => script, input));
+  async startPackageAndWait(script: RunScriptStart, input: unknown, user?: ChatUser): Promise<void> {
+    await this.#track(() => this.#startPackage(() => script, input, user));
   }
 
   #track(work: () => Promise<void>, reportError = true): Promise<void> {
-    if (this.#disposed) throw new Error("Die Unterhaltung wurde gelöscht");
+    if (this.#disposed) throw new Error("Der Run wurde gelöscht");
     this.#assertUsable(this.id);
     const operation = work();
     const tracked = operation.catch((error: unknown) => {
@@ -298,8 +378,8 @@ export class RunChatSession implements ChatSessionLike {
   }
 
   postExtension(event: { pluginId: string; type: string; payload?: unknown }): void {
-    if (this.#disposed) throw new Error("Die Unterhaltung wurde gelöscht");
-    this.#emit({ kind: "extension", ...event });
+    if (this.#disposed) throw new Error("Der Run wurde gelöscht");
+    this.#emit({ kind: "plugin", ...event });
   }
 
   resetHistory(): void {
@@ -327,7 +407,7 @@ export class RunChatSession implements ChatSessionLike {
 
   dispose(): void {
     this.#disposed = true;
-    this.#startCancellation?.abort(new Error("Die Unterhaltung wurde gelöscht"));
+    this.#startCancellation?.abort(new Error("Der Run wurde gelöscht"));
     this.#startCancellation = undefined;
     this.#startup = undefined;
     this.#unsubscribeJournal?.();
@@ -351,22 +431,23 @@ export class RunChatSession implements ChatSessionLike {
     return (system) => this.#emit({ kind: "system", text: system });
   }
 
-  async #send(text: string, supplied?: ChatAttachmentInput[], target?: string, userLocation?: unknown, user?: ChatUser): Promise<void> {
-    if (userLocation !== undefined && !this.#inputContext) throw new DomainError("chat-context-unavailable", "Diese Unterhaltung übernimmt keinen Oberflächenkontext.", 400);
+  async #send(text: string, supplied?: ChatAttachmentInput[], target?: string, userLocation?: unknown, user?: ChatUser, entryId?: string): Promise<void> {
+    if (userLocation !== undefined && !this.#inputContext) throw new DomainError("chat-context-unavailable", "Dieser Run übernimmt keinen Oberflächenkontext.", 400);
+    const choice = entryId === undefined ? freeChoice(userIdOf(user)) : this.#startChoice(this.#skillEntry(entryId), userIdOf(user));
     const attachments = this.#checkedAttachments(supplied);
     if (!text.trim() && attachments.length === 0) throw new DomainError("empty-message", "Text oder Anhänge fehlen", 400);
     const existingTarget = target ?? this.#engine.journal.stateOf(this.id)?.primaryActorId;
     if (existingTarget) this.#assertChatTarget(existingTarget);
-    if (attachments.length > 0) await this.#checkAttachmentCapabilities(target ?? "primary", attachments);
+    if (attachments.length > 0) await this.#checkAttachmentCapabilities(target ?? "primary", attachments, choice);
     await this.#prepare(this.id, this.#emitSystem());
     this.#assertUsable(this.id);
-    const primaryActorId = target ? this.#targetActor(target).id : await this.#ensureRun(user);
+    const primaryActorId = target ? this.#targetActor(target).id : await this.#ensureRun(user, choice);
     this.#assertUsable(this.id);
     this.#assertChatTarget(primaryActorId);
     if (target) await this.#prepareWorkspace(this.id, this.#emitSystem());
     this.#assertUsable(this.id);
-    if (attachments.length > 0) await this.#checkAttachmentCapabilities(primaryActorId, attachments);
-    const sourceEventIds = !target && this.#inputContext ? await this.#inputContext(this.#engine.runtime, userLocation) : [];
+    if (attachments.length > 0) await this.#checkAttachmentCapabilities(primaryActorId, attachments, choice);
+    const sourceEventIds = !target && this.#inputContext ? await this.#inputContext(this.#engine.runtime, this.id, userLocation) : [];
     this.#assertUsable(this.id);
     const state = this.#engine.runtime.state(this.id);
     this.#assertChatTarget(primaryActorId);
@@ -416,48 +497,51 @@ export class RunChatSession implements ChatSessionLike {
     return actor;
   }
 
-  #executionFor(reference: string): AgentExecution {
+  #executionFor(reference: string, choice: StartChoice): AgentExecution {
     const state = this.#engine.journal.stateOf(this.id);
     const id = reference === "primary" ? state?.primaryActorId : reference;
     if (id) {
       const execution = this.#targetActor(id).execution;
-      return id === state?.primaryActorId && execution.driver.kind === "agent" && this.#modelSelection
-        ? { ...execution, driver: { kind: "agent", config: this.#modelSelection() } } : execution;
+      if (execution.driver.kind !== "agent") return execution;
+      if (id === state?.primaryActorId && this.#modelSelection) return { ...execution, driver: { kind: "agent", config: this.#modelSelection() } };
+      return isRunCoordinator(this.#engine.runtime, this.id, id)
+        ? { ...execution, driver: { kind: "agent", config: coordinatorSelection(this.#engine.catalog, this.#coordinator, storedModelChoice(state), execution.driver.config) } }
+        : execution;
     }
     if (reference !== "primary") throw new DomainError("actor-unavailable", "Der Actor ist nicht verfügbar", 404);
-    return this.#coordinatorExecution();
+    return this.#coordinatorExecution(choice);
   }
 
-  #coordinatorExecution(): AgentExecution {
+  #coordinatorExecution(choice: StartChoice): AgentExecution {
     const state = this.#engine.journal.stateOf(this.id);
-    const selected = this.#engine.startOptions.entry("ragents.model");
-    const choice = selected ? this.#startValueOf(selected) as { model?: string; thinking?: string } : undefined;
-    const model = choice?.model ?? storedModel(state);
-    const thinking = choice?.thinking ?? storedThinking(state);
+    const selected = this.#engine.startOptions.entry(modelStartOptionId);
+    const modelChoice = selected ? this.#startValueOf(selected, choice) as { model?: string; thinking?: string } : undefined;
+    const model = modelChoice?.model ?? storedModel(state);
+    const thinking = modelChoice?.thinking ?? storedThinking(state);
     const execution = resolveExecution(this.#engine.catalog, {
       profile: this.#coordinator.profile,
       ...(model ? { model } : {}),
       ...(isThinkingLevel(thinking) ? { thinking } : {}),
-    }, this.#coordinator.handle, this.#engine.catalogModels);
+    }, this.#coordinator.handle, this.#engine.catalog.modelList);
     return execution.driver.kind === "agent" && this.#modelSelection
       ? { ...execution, driver: { kind: "agent", config: this.#modelSelection() } } : execution;
   }
 
-  preparationSelection(): ModelSelection {
+  preparationSelection(userId: string | null): ModelSelection {
     this.#assertUsable(this.id);
     if (this.#disposed || this.started || this.startLocked) {
-      throw new DomainError("preparation-unavailable", "Die Vorbereitung ist nur vor dem Start der Unterhaltung möglich.", 409);
+      throw new DomainError("preparation-unavailable", "Die Vorbereitung ist nur vor dem Start des Runs möglich.", 409);
     }
-    const execution = this.#coordinatorExecution();
+    const execution = this.#coordinatorExecution(freeChoice(userId));
     if (execution.driver.kind !== "agent") throw new DomainError("preparation-model-required", "Die Vorbereitung benötigt einen Koordinator mit Modelllaufzeit.", 400);
     return { ...execution.driver.config };
   }
 
-  async #checkAttachmentCapabilities(reference: string, attachments: readonly ChatAttachmentInput[]): Promise<void> {
-    const execution = this.#executionFor(reference);
+  async #checkAttachmentCapabilities(reference: string, attachments: readonly ChatAttachmentInput[], choice: StartChoice): Promise<void> {
+    const execution = this.#executionFor(reference, choice);
     if (execution.driver.kind === "script") return;
     if (execution.driver.kind !== "agent") throw new DomainError("attachments-unsupported", "Anhänge benötigen einen Actor mit Modelllaufzeit", 400);
-    const { input, model } = await this.capabilities(reference);
+    const { input, model } = await this.#capabilitiesFor(reference, choice);
     const state = this.#engine.journal.stateOf(this.id);
     const id = reference === "primary" ? state?.primaryActorId : reference;
     const toolNames = id ? this.#targetActor(id).toolNames : this.#toolNames;
@@ -477,14 +561,14 @@ export class RunChatSession implements ChatSessionLike {
       url: attachmentContentPath(this.id, artifact.id) };
   }
 
-  async #ensureRun(user?: ChatUser): Promise<string> {
+  async #ensureRun(user: ChatUser | undefined, choice: StartChoice): Promise<string> {
     this.#assertUsable(this.id);
     const bound = this.#syncPrimaryActor();
     if (bound) return bound;
     if (this.#starting) await this.#starting;
     const afterStart = this.#syncPrimaryActor();
     if (afterStart) return afterStart;
-    await this.#exclusiveStart(() => this.#startRun(user));
+    await this.#exclusiveStart(() => this.#startRun(user, choice));
     const primaryActorId = this.#syncPrimaryActor();
     if (!primaryActorId) throw new Error("Der Run hat nach dem Start keinen Primary-Actor");
     return primaryActorId;
@@ -500,7 +584,7 @@ export class RunChatSession implements ChatSessionLike {
   async #start(entryId: string, input: unknown, user?: ChatUser): Promise<void> {
     await this.#startPackage(() => {
       const found = this.#scriptEntryFor(entryId);
-      if (!found) throw new DomainError("entry-unknown", `Der Einstieg ${entryId} ist kein Run-Script dieses Profils.`, 404);
+      if (!found) throw new DomainError("entry-unknown", `Die Vorlage ${entryId} ist keine Script-Vorlage dieses Profils.`, 404);
       return found;
     }, input, user);
   }
@@ -517,11 +601,12 @@ export class RunChatSession implements ChatSessionLike {
       try {
         signal.throwIfAborted();
         const found = resolve();
+        const choice = this.#startChoice(found.entry, userIdOf(user));
         const startValue: JsonValue | null = input === undefined || input === null ? null : (assertJsonValue(input, "Startwert des Run-Scripts"), input);
         await this.#prepare(this.id, this.#emitSystem());
         signal.throwIfAborted();
         this.#assertUsable(this.id);
-        await this.#startWithScript(found, startValue, signal, user);
+        await this.#startWithScript(found, startValue, signal, user, choice);
         signal.throwIfAborted();
         this.#setStartup(undefined);
       } catch (error) {
@@ -537,17 +622,19 @@ export class RunChatSession implements ChatSessionLike {
     await operation;
   }
 
-  async #startRun(user?: ChatUser): Promise<void> {
-    this.#createRunIfNeeded(this.#initialTitle ?? this.#coordinator.runTitle, user);
+  async #startRun(user: ChatUser | undefined, choice: StartChoice): Promise<void> {
+    this.#createRunIfNeeded(this.#initialTitle ?? this.#coordinator.runTitle, user, choice);
     this.#assertUsable(this.id);
     await this.#prepareWorkspace(this.id, this.#emitSystem());
     this.#assertUsable(this.id);
-    this.#ensureCoordinatorAsPrimary();
+    this.#ensureCoordinatorAsPrimary(choice);
+    await this.#started(this.id, choice.entry);
+    this.#assertUsable(this.id);
   }
 
-  async #startWithScript(found: RunScriptStart, input: JsonValue | null, signal: AbortSignal, user?: ChatUser): Promise<void> {
+  async #startWithScript(found: RunScriptStart, input: JsonValue | null, signal: AbortSignal, user: ChatUser | undefined, choice: StartChoice): Promise<void> {
     const { entry, ...script } = found;
-    this.#createRunIfNeeded(this.#initialTitle ?? entry.title, user);
+    this.#createRunIfNeeded(this.#initialTitle ?? entry.title, user, choice);
     this.#assertUsable(this.id);
     this.#setStartup({ status: "preparing", message: "Arbeitsverzeichnis wird vorbereitet." });
     signal.throwIfAborted();
@@ -565,13 +652,15 @@ export class RunChatSession implements ChatSessionLike {
     );
     signal.throwIfAborted();
     this.#assertUsable(this.id);
-    if (script.coordinator) this.#ensureCoordinatorAsPrimary();
+    if (script.coordinator) this.#ensureCoordinatorAsPrimary(choice);
     else {
       this.#engine.runtime.selectPrimaryActor({actorId: state.ownerId, commandId: `run-script-primary:${this.id}`}, this.id, installed.actorId);
       this.#bind(installed.actorId);
     }
+    await this.#started(this.id, choice.entry);
+    this.#assertUsable(this.id);
     const options = Object.fromEntries(this.#engine.startOptions.entries()
-      .map((option) => [option.option.id, this.#startValueOf(option)]));
+      .map((option) => [option.option.id, this.#startValueOf(option, choice)]));
     signal.throwIfAborted();
     this.#engine.runtime.enqueueInput(
       { actorId: state.ownerId, commandId: `run-script-input:${this.id}:${script.handle}` },
@@ -600,7 +689,7 @@ export class RunChatSession implements ChatSessionLike {
     }
   }
 
-  #createRunIfNeeded(title: string, user?: ChatUser): void {
+  #createRunIfNeeded(title: string, user: ChatUser | undefined, choice: StartChoice): void {
     this.#assertUsable(this.id);
     const isNewRun = !this.#engine.journal.stateOf(this.id);
     if (isNewRun) {
@@ -611,16 +700,17 @@ export class RunChatSession implements ChatSessionLike {
           title,
           ownerHandle: user?.id ?? this.#coordinator.ownerHandle,
           ownerDisplayName: user?.label ?? this.#coordinator.ownerDisplayName,
-          initialPluginStates: this.#startupPluginStates(),
+          ...user ? { ownerUserId: user.id } : {},
+          initialPluginStates: this.#startupPluginStates(choice),
         },
       );
     }
 
     if (!isNewRun && !this.#engine.runtime.view(this.id).actors.some((actor) => actor.kind !== "human"))
-      this.#persistStartupSelections();
+      this.#persistStartupSelections(choice);
   }
 
-  #ensureCoordinatorAsPrimary(): void {
+  #ensureCoordinatorAsPrimary(choice: StartChoice): void {
     const state = this.#engine.runtime.state(this.id);
     let primaryActor = primaryActorOf(this.#engine.runtime.view(this.id));
     if (!primaryActor) {
@@ -639,7 +729,7 @@ export class RunChatSession implements ChatSessionLike {
             handle: this.#coordinator.handle,
             displayName: this.#coordinator.displayName,
             prompt: this.#prompt(),
-            execution: this.#coordinatorExecution(),
+            execution: this.#coordinatorExecution(choice),
             grants: coordinatorGrants(),
             toolNames: this.#toolNames === null ? null : [...this.#toolNames],
           },
@@ -669,21 +759,21 @@ export class RunChatSession implements ChatSessionLike {
     this.#bind(primaryActor.id);
   }
 
-  #startupPluginStates(): readonly { pluginId: string; state: JsonValue }[] {
+  #startupPluginStates(choice: StartChoice): readonly { pluginId: string; state: JsonValue }[] {
     return this.#engine.startOptions.entries().map((entry) => ({
       pluginId: entry.option.id,
-      state: this.#startValueOf(entry),
+      state: this.#startValueOf(entry, choice),
     }));
   }
 
-  #persistStartupSelections(): void {
+  #persistStartupSelections(choice: StartChoice): void {
     const state = this.#engine.runtime.state(this.id);
     for (const entry of this.#engine.startOptions.entries()) {
       if (storedStartOption(this.#engine.journal.stateOf(this.id), entry.option.id) !== undefined) continue;
       this.#engine.runtime.replacePluginState(
         { actorId: state.ownerId, commandId: `start-option:${entry.option.id}:${this.id}` },
         this.id,
-        { pluginId: entry.option.id, scope: startOptionScope, state: this.#startValueOf(entry) },
+        { pluginId: entry.option.id, scope: startOptionScope, state: this.#startValueOf(entry, choice) },
       );
     }
   }
@@ -814,7 +904,16 @@ export class RunChatSession implements ChatSessionLike {
       primaryActorId,
       ownerId: this.#engine.runtime.state(this.id).ownerId,
       labelOf: (actorId) => this.#engine.runtime.state(this.id).actors.get(actorId)?.displayName,
-      actionKindOf: (actionId) => this.#engine.runtime.state(this.id).actions.get(actionId)?.kind,
+      turnOf: (turnId) => {
+        const turn = this.#engine.runtime.state(this.id).turns.get(turnId);
+        if (!turn) throw new Error(`Der Turn ${turnId} fehlt im Run ${this.id}`);
+        return turn;
+      },
+      interruptedByCommand: (commandId, actorId) => {
+        const turns = this.#engine.runtime.state(this.id).turns;
+        return this.#engine.runtime.events(this.id).some((event) => event.commandId === commandId
+          && event.type === "turn.interrupted" && turns.get(event.payload.turnId)?.actorId === actorId);
+      },
       attachmentOf: (artifactId) => {
         const artifact = this.#engine.runtime.state(this.id).artifacts.get(artifactId);
         if (!artifact) throw new Error(`Der Anhang ${artifactId} fehlt`);
@@ -825,7 +924,7 @@ export class RunChatSession implements ChatSessionLike {
 
   #isLive(event: JournalEvent): boolean {
     if (event.actorId !== this.#primaryActorId) return false;
-    if (event.type === "model.output.completed") return this.#liveTurns.get(event.payload.turnId)?.text === true
+    if (event.type === "model.output.completed" || event.type === "model.output.interrupted") return this.#liveTurns.get(event.payload.turnId)?.text === true
       && this.#textPositions.covers(event.payload.turnId, event.payload.text);
     if (event.type === "model.reasoning.completed") return this.#liveTurns.get(event.payload.turnId)?.thinking === true;
     if (event.type === "tool.call.started")

package/apps/server/src/ragents/start-option-state.ts

@@ -1,4 +1,4 @@
-import { pluginStateKey, type JsonValue, type PluginStateScope, type RunState } from "@aicontainer/ragents";
+import { pluginStateKey, type JsonValue, type PluginStateScope, type RunState } from "@ragents/engine";
 import { modelStartOptionId, systemPromptStartOptionId } from "../plugin-support/start-options-contract.js";
 
 export { modelStartOptionId, systemPromptStartOptionId };