@schlenkr/ragents 0.1.5 → 0.1.6

package/plugins/ragents.processes/server/observer.ts

@@ -1,13 +1,9 @@
 import type { RunProcessMessage, RunProcessSnapshot } from "../contract.js";
-import type { ProcessRecord, ProcessTable } from "./process-table.js";
-import { runProcessesFrom } from "./snapshot.js";
 
 export interface RunProcessObserverOptions {
-  table: ProcessTable;
-  serverPid: number;
-  serverUid: number | undefined;
+  /** Der Stand eines Runs beim Executor, der ihn ausführt; `signal` bricht die Abfrage dort ab. */
+  snapshot: (runId: string, signal: AbortSignal) => Promise<RunProcessSnapshot>;
   pollIntervalMs: number;
-  now?: () => Date;
 }
 
 export type RunProcessListener = (message: RunProcessMessage) => void;
@@ -16,51 +12,51 @@ interface RunWatch {
   listeners: Set<RunProcessListener>;
   fresh: Set<RunProcessListener>;
   last: string | undefined;
+  /** Die laufende Abfrage dieses Runs; ein hängender Executor hält nur sie auf. */
+  polling: Promise<void> | undefined;
+  controller: AbortController | undefined;
 }
 
-const keyOf = (record: ProcessRecord): string => `${record.pid}:${record.startKey}`;
+/** So viele Takte darf eine Abfrage dauern, bevor sie als gescheitert gilt. */
+const SNAPSHOT_TIMEOUT_TICKS = 5;
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-/** Beobachtet die markierten Prozesse aller beobachteten Läufe mit EINEM Tabellenscan je Intervall. */
+/** Fragt je Takt den Stand jedes beobachteten Runs bei seinem Executor ab, jeden für sich und mit Zeitgrenze, und meldet nur Änderungen. */
 export class RunProcessObserver {
   readonly #options: RunProcessObserverOptions;
-  readonly #now: () => Date;
-  readonly #markers = new Map<string, string | null>();
-  readonly #firstSeen = new Map<string, string>();
   readonly #watches = new Map<string, RunWatch>();
   #timer: NodeJS.Timeout | undefined;
-  #scanning: Promise<void> | undefined;
   #stopped = false;
 
   constructor(options: RunProcessObserverOptions) {
     this.#options = options;
-    this.#now = options.now ?? (() => new Date());
   }
 
-  async observe(runId: string): Promise<RunProcessSnapshot> {
-    const snapshot = (await this.#scan([runId])).get(runId);
-    if (!snapshot) throw new Error(`Der Scan hat keinen Stand für ${runId} geliefert`);
-    return snapshot;
+  observe(runId: string, signal?: AbortSignal): Promise<RunProcessSnapshot> {
+    return this.#bounded(runId, signal);
   }
 
   watch(runId: string, listener: RunProcessListener): () => void {
     if (this.#stopped) throw new Error("Die Prozessüberwachung ist beendet");
     let watch = this.#watches.get(runId);
     if (!watch) {
-      watch = { listeners: new Set(), fresh: new Set(), last: undefined };
+      watch = { listeners: new Set(), fresh: new Set(), last: undefined, polling: undefined, controller: undefined };
       this.#watches.set(runId, watch);
     }
     watch.listeners.add(listener);
     watch.fresh.add(listener);
     this.#ensureTimer();
-    void this.#tick();
+    void this.#poll(runId, watch);
     return () => {
       const current = this.#watches.get(runId);
       if (!current) return;
       current.listeners.delete(listener);
       current.fresh.delete(listener);
-      if (current.listeners.size === 0) this.#watches.delete(runId);
+      if (current.listeners.size === 0) {
+        this.#watches.delete(runId);
+        current.controller?.abort();
+      }
       if (this.#watches.size === 0) this.#clearTimer();
     };
   }
@@ -72,13 +68,17 @@ export class RunProcessObserver {
   async shutdown(): Promise<void> {
     this.#stopped = true;
     this.#clearTimer();
+    const watches = [...this.#watches.values()];
     this.#watches.clear();
-    await this.#scanning?.catch(() => undefined);
+    for (const watch of watches) watch.controller?.abort();
+    await Promise.allSettled(watches.map((watch) => watch.polling));
   }
 
   #ensureTimer(): void {
     if (this.#timer || this.#watches.size === 0) return;
-    this.#timer = setInterval(() => void this.#tick(), this.#options.pollIntervalMs);
+    this.#timer = setInterval(() => {
+      for (const [runId, watch] of this.#watches) void this.#poll(runId, watch);
+    }, this.#options.pollIntervalMs);
     this.#timer.unref();
   }
 
@@ -88,92 +88,52 @@ export class RunProcessObserver {
     this.#timer = undefined;
   }
 
-  #tick(): Promise<void> {
-    if (this.#scanning) return this.#scanning;
-    this.#scanning = this.#deliver().finally(() => {
-      this.#scanning = undefined;
-    });
-    return this.#scanning;
-  }
-
-  async #deliver(): Promise<void> {
-    const runIds = [...this.#watches.keys()];
-    if (runIds.length === 0) return;
-    let messages: Map<string, RunProcessMessage>;
-    try {
-      const snapshots = await this.#scan(runIds);
-      messages = new Map(runIds.map((runId) => {
-        const snapshot = snapshots.get(runId);
-        if (!snapshot) throw new Error(`Der Scan hat keinen Stand für ${runId} geliefert`);
-        return [runId, { kind: "snapshot", snapshot }];
-      }));
-    } catch (error) {
-      const message: RunProcessMessage = { kind: "error", error: messageOf(error) };
-      messages = new Map(runIds.map((runId) => [runId, message]));
-    }
-    for (const [runId, message] of messages) {
-      const watch = this.#watches.get(runId);
-      if (!watch) continue;
-      const serialized = JSON.stringify(message.kind === "snapshot"
-        ? { kind: message.kind, processes: message.snapshot.processes }
-        : message);
-      const changed = serialized !== watch.last;
-      watch.last = serialized;
-      if (changed && message.kind === "error") console.error(`Prozessüberwachung für ${runId}: ${message.error}`);
-      for (const listener of watch.listeners) {
-        if (changed || watch.fresh.has(listener)) listener(message);
-      }
-      watch.fresh.clear();
-    }
+  #poll(runId: string, watch: RunWatch): Promise<void> {
+    if (watch.polling) return watch.polling;
+    const controller = new AbortController();
+    watch.controller = controller;
+    watch.polling = this.#bounded(runId, controller.signal)
+      .then((snapshot): RunProcessMessage => ({ kind: "snapshot", snapshot }), (error: unknown): RunProcessMessage => ({ kind: "error", error: messageOf(error) }))
+      .then((message) => {
+        if (!controller.signal.aborted && this.#watches.get(runId) === watch) this.#publish(watch, runId, message);
+      })
+      .finally(() => {
+        watch.polling = undefined;
+        watch.controller = undefined;
+      });
+    return watch.polling;
   }
 
-  #readable(record: ProcessRecord): boolean {
-    const uid = this.#options.serverUid;
-    return uid === undefined || uid === 0 || record.uid === uid;
+  /** Eine Abfrage endet spätestens nach ihrer Zeitgrenze; der Abbruch erreicht dabei auch den Executor. */
+  #bounded(runId: string, signal: AbortSignal | undefined): Promise<RunProcessSnapshot> {
+    const timeoutMs = this.#options.pollIntervalMs * SNAPSHOT_TIMEOUT_TICKS;
+    const controller = new AbortController();
+    const forward = (): void => controller.abort(signal?.reason);
+    signal?.addEventListener("abort", forward, { once: true });
+    let timer: NodeJS.Timeout | undefined;
+    const deadline = new Promise<never>((_settle, fail) => {
+      timer = setTimeout(() => {
+        const error = new Error(`Der Executor des Runs ${runId} hat die Prozessabfrage nicht innerhalb von ${timeoutMs / 1000} s beantwortet`);
+        fail(error);
+        controller.abort(error);
+      }, timeoutMs);
+    });
+    return Promise.race([this.#options.snapshot(runId, controller.signal), deadline]).finally(() => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", forward);
+    });
   }
 
-  async #scan(runIds: readonly string[]): Promise<Map<string, RunProcessSnapshot>> {
-    const { table, serverPid } = this.#options;
-    const records = await table.list();
-    const observedAt = this.#now().toISOString();
-    const present = new Set<string>();
-    const unknown: ProcessRecord[] = [];
-    for (const record of records) {
-      const key = keyOf(record);
-      present.add(key);
-      if (!this.#firstSeen.has(key)) this.#firstSeen.set(key, observedAt);
-      if (!this.#markers.has(key) && this.#readable(record)) unknown.push(record);
+  #publish(watch: RunWatch, runId: string, message: RunProcessMessage): void {
+    const serialized = JSON.stringify(message.kind === "snapshot"
+      ? { kind: message.kind, processes: message.snapshot.processes }
+      : message);
+    const changed = serialized !== watch.last;
+    watch.last = serialized;
+    if (changed && message.kind === "error") console.error(`Prozessüberwachung für ${runId}: ${message.error}`);
+    for (const listener of watch.listeners) {
+      if (changed || watch.fresh.has(listener)) listener(message);
     }
-    if (unknown.length > 0) {
-      const found = await table.runMarkers(unknown.map((record) => record.pid));
-      for (const record of unknown) this.#markers.set(keyOf(record), found.get(record.pid) ?? null);
-    }
-    for (const key of [...this.#markers.keys(), ...this.#firstSeen.keys()]) {
-      if (present.has(key)) continue;
-      this.#markers.delete(key);
-      this.#firstSeen.delete(key);
-    }
-    const markerOf = (record: ProcessRecord): string | undefined => this.#markers.get(keyOf(record)) ?? undefined;
-    const marked = records.filter((record) => {
-      const marker = markerOf(record);
-      return marker !== undefined && runIds.includes(marker);
-    });
-    const ports = marked.length > 0 ? await table.listeningPorts(marked.map((record) => record.pid)) : new Map();
-    return new Map(runIds.map((runId) => [runId, {
-      runId,
-      observedAt,
-      processes: runProcessesFrom({
-        runId,
-        serverPid,
-        records,
-        markerOf,
-        ports,
-        firstSeen: (record) => {
-          const seen = this.#firstSeen.get(keyOf(record));
-          if (!seen) throw new Error(`Prozess ${record.pid} ohne Erstsichtung`);
-          return seen;
-        },
-      }),
-    }]));
+    watch.fresh.clear();
   }
 }

package/plugins/ragents.processes/server/run-processes.ts

@@ -0,0 +1,24 @@
+import { PROCESS_OPERATIONS } from "@ragents/workspace-executor";
+import type { SandboxServices } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import type { RunProcessSnapshot } from "../contract.js";
+
+export interface RunProcesses {
+  snapshot: (runId: string, signal?: AbortSignal) => Promise<RunProcessSnapshot>;
+  terminate: (runId: string, processId: string, signal: AbortSignal) => Promise<void>;
+  /** Ist der Arbeitsplatz nicht erreichbar, holt der Stopp des Runs (`stopRun` seines Executors) das Beenden nach, sobald er wieder da ist. */
+  stopAll: (runId: string, signal?: AbortSignal) => Promise<void>;
+}
+
+/** Die Prozesse eines Runs liegen beim Executor, der ihn ausführt; wo das ist, entscheidet allein seine Bindung. */
+export const runProcessesOf = (sandbox: Pick<SandboxServices, "execute">): RunProcesses => ({
+  snapshot: async (runId, signal) => {
+    const observed = await sandbox.execute(runId, PROCESS_OPERATIONS.snapshot, {}, signal ? { signal } : {}) as Omit<RunProcessSnapshot, "runId">;
+    return { runId, ...observed };
+  },
+  terminate: async (runId, processId, signal) => {
+    await sandbox.execute(runId, PROCESS_OPERATIONS.stop, { processId }, { signal });
+  },
+  stopAll: async (runId, signal) => {
+    await sandbox.execute(runId, PROCESS_OPERATIONS.stopAll, {}, { whenReachable: true, ...(signal ? { signal } : {}) });
+  },
+});

package/plugins/ragents.processes/web/ProcessHeader.tsx

@@ -1,10 +1,9 @@
 import { useEffect, useLayoutEffect, useRef, useState, type ComponentType, type FocusEvent } from "react";
-import { useAccess } from "@aicontainer/web/AccessContext";
-import type { SessionHeaderContext } from "@aicontainer/web/PluginRegistry";
-import { SquareIcon } from "lucide-react";
-import { Button, Dialog, DialogBody, DialogContent, DialogHeader, DialogTitle, Spinner, cn } from "@aicontainer/web/ui";
-import { ToolbarCopy, ToolbarItem, ToolbarLabel, ToolbarText } from "@aicontainer/web/Toolbar";
-import { rpc } from "@aicontainer/web/rpc";
+import { useAccess } from "@ragents/web/AccessContext";
+import type { SessionHeaderContext } from "@ragents/web/PluginRegistry";
+import { Dialog, DialogBody, DialogContent, DialogHeader, DialogTitle, StopButton, cn } from "@ragents/web/ui";
+import { ToolbarCopy, ToolbarItem, ToolbarLabel, ToolbarText } from "@ragents/web/Toolbar";
+import { rpc } from "@ragents/web/rpc";
 import { processesContracts, type RunProcess, type RunProcessSnapshot } from "../contract";
 import { kindLabel, messageFrom, serviceUrl, titleOf, visibleProcesses } from "./processes";
 
@@ -17,7 +16,7 @@ const idle: ProcessWatchState = { snapshot: undefined, error: undefined };
 
 const pillClass = "inline-flex h-6 min-w-0 items-center gap-1.5 whitespace-nowrap rounded-full border border-border-soft bg-card/78 pl-2.5 pr-0.5 text-xs font-medium text-muted-foreground data-[origin=background]:border-dashed [&>svg]:flex-none";
 const portClass = "flex-none rounded-full bg-primary/14 px-1.5 py-px text-foreground tabular-nums underline underline-offset-2 hover:bg-primary/28 focus-visible:bg-primary/28";
-const stopClass = "size-5 min-w-5 rounded-full p-0.75 text-destructive";
+const stopClass = "size-5 min-w-5 rounded-full p-0.75 [&_svg]:size-2.5";
 
 const useRunProcesses = (runId: string): ProcessWatchState => {
   const [state, setState] = useState<ProcessWatchState>(idle);
@@ -26,7 +25,7 @@ const useRunProcesses = (runId: string): ProcessWatchState => {
     return rpc.subscribe(processesContracts.live, { runId }, (data) => {
       try {
         const message = messageFrom(data);
-        if (message.kind === "snapshot" && message.snapshot.runId !== runId) throw new Error("Der Prozessstand gehört zu einem anderen Lauf");
+        if (message.kind === "snapshot" && message.snapshot.runId !== runId) throw new Error("Der Prozessstand gehört zu einem anderen Run");
         setState((current) => message.kind === "snapshot"
           ? { snapshot: message.snapshot, error: undefined }
           : { snapshot: current.snapshot, error: message.error });
@@ -48,12 +47,10 @@ function IconProcess() {
 interface StopState { busy?: boolean; error?: string }
 
 function ProcessPill({ process, state, writable, onStop, toolbar = false }: { process: RunProcess; state?: StopState; writable: boolean; onStop: () => void; toolbar?: boolean }) {
-  const stop = <Button className={stopClass} size="icon-xs" variant="ghost"
-    aria-label={state?.busy ? `${process.label} wird beendet` : `${process.label} beenden`}
-    title={!writable ? "Zum Beenden fehlen Schreib- oder Inspektionsrechte" : state?.busy ? "Wird beendet ..." : `${process.label} beenden`}
-    disabled={!writable || state?.busy} aria-busy={state?.busy || undefined} onClick={onStop}>
-    {state?.busy ? <Spinner className="size-2.5" /> : <SquareIcon fill="currentColor" size={10} />}
-  </Button>;
+  const stop = <StopButton busy={state?.busy === true} className={stopClass} disabled={!writable || state?.busy}
+    label={state?.busy ? `${process.label} wird beendet` : `${process.label} beenden`}
+    onClick={onStop} size="icon-xs"
+    title={!writable ? "Zum Beenden fehlen Schreib- oder Inspektionsrechte" : state?.busy ? "Wird beendet ..." : `${process.label} beenden`} />;
   const ports = process.ports.map((port) => <a className={portClass} href={serviceUrl(window.location.hostname, port.port)}
     key={`${port.address}:${port.port}`} rel="noreferrer" target="_blank" title={`${port.address}:${port.port} im neuen Tab öffnen`}>
     :{port.port}
@@ -126,9 +123,9 @@ function ProcessHeaderContent({ runId }: { runId: string }) {
   const renderProcess = (process: RunProcess, toolbar = false) => <ProcessPill key={process.id} process={process} state={stops[process.id]} writable={writable} toolbar={toolbar} onStop={() => { void stop(process); }} />;
   if (shown.length === 0 && state.error === undefined && !allOpen) return null;
   return <>
-    <div aria-label="Prozesse und Ports des Laufs" className="flex min-w-0 flex-none items-stretch self-stretch" ref={rootRef} onFocusCapture={rememberFocus}>
+    <div aria-label="Prozesse und Ports des Runs" className="flex min-w-0 flex-none items-stretch self-stretch" ref={rootRef} onFocusCapture={rememberFocus}>
       {shown.map((process) => renderProcess(process, true))}
-      {(processes.length > 1 || allOpen) && <ToolbarItem as="button" className="md:data-[hidden=false]:hidden" data-hidden={hidden > 0 || allOpen} type="button" onClick={() => setAllOpen(true)} title="Alle Prozesse des Laufs anzeigen">
+      {(processes.length > 1 || allOpen) && <ToolbarItem as="button" className="md:data-[hidden=false]:hidden" data-hidden={hidden > 0 || allOpen} type="button" onClick={() => setAllOpen(true)} title="Alle Prozesse des Runs anzeigen">
         <span className="max-md:hidden">{hidden > 0 ? `+${hidden} weitere` : "Prozesse"}</span><span className="hidden max-md:inline">Alle {processes.length}</span>
       </ToolbarItem>}
       {state.error !== undefined && <ToolbarItem className="w-42 text-destructive" role="status" title={state.error}><ToolbarCopy><ToolbarLabel>Prozesse</ToolbarLabel><ToolbarText>Überwachung gestört</ToolbarText></ToolbarCopy></ToolbarItem>}

package/plugins/ragents.processes/web/index.tsx

@@ -1,7 +1,7 @@
 import {
   type WebPlugin,
   type WebPluginDescriptor,
-} from "@aicontainer/web/PluginRegistry";
+} from "@ragents/web/PluginRegistry";
 import { PROCESSES_PLUGIN_ID } from "../contract";
 import { processHeader } from "./ProcessHeader";
 
@@ -9,6 +9,7 @@ const configuredPlugin = (descriptor: WebPluginDescriptor): WebPlugin => ({
   ...descriptor,
   sessionHeaders: [{
     readRight: "ragents.processes.read",
+    requiresWorkspace: true,
     id: "ragents.processes.live",
     order: 110,
     Header: processHeader(),

package/plugins/ragents.processes/web/processes.ts

@@ -1,4 +1,4 @@
-import { isRecord } from "@aicontainer/web/lib/guards";
+import { isRecord } from "@ragents/web/lib/guards";
 import type { RunProcess, RunProcessMessage, RunProcessPort, RunProcessSnapshot } from "../contract";
 
 export const VISIBLE_PROCESSES = 4;

package/plugins/ragents.product/ragents-plugin.json

@@ -0,0 +1,3 @@
+{
+  "id": "ragents.product"
+}

package/plugins/ragents.product/server/config.ts

@@ -1,17 +1,16 @@
 import path from "node:path";
-import { getBuiltinModels } from "@aicontainer/ai/providers/all";
-import type { ModelUpstream } from "@aicontainer/server/plugin-support/model-upstreams.js";
-import { chatDisplayEnvDescriptors, chatDisplayPolicyFromEnvironment } from "@aicontainer/server/plugin-support/chat-display-policy.js";
-import { modelChoiceEnvDescriptors, modelChoiceFromEnvironment } from "@aicontainer/server/plugin-support/model-choice.js";
-import { declaredEnvironment } from "@aicontainer/server/plugin-support/plugin-config.js";
-import { folderSystemPrompts, pluginFolder } from "@aicontainer/server/plugin-support/plugin-folder.js";
-import { checkedThinkingLevel } from "@aicontainer/server/plugin-support/thinking-level.js";
-import { skillEnvDescriptors, skillsFromEnvironment } from "@aicontainer/server/plugin-support/skills.js";
-import { createRelayCatalog, RELAY_PROVIDER, type RelayCatalog } from "./relay.js";
+import type { ModelUpstream } from "@ragents/host/plugin-support/model-upstreams.js";
+import { chatDisplayEnvDescriptors, chatDisplayPolicyFromEnvironment } from "@ragents/host/plugin-support/chat-display-policy.js";
+import { builtinCatalog, modelChoiceEnvDescriptors, modelChoiceFromEnvironment } from "@ragents/host/plugin-support/model-choice.js";
+import { declaredEnvironment } from "@ragents/host/plugin-support/plugin-config.js";
+import { folderSystemPrompts, pluginFolder } from "@ragents/host/plugin-support/plugin-folder.js";
+import { createRelayCatalog, RELAY_PROVIDER, type RelayCatalog } from "@ragents/host/plugin-support/product-relay.js";
+import { roleThinkingLevel } from "@ragents/host/plugin-support/thinking-level.js";
+import { skillEnvDescriptors, skillsFromEnvironment } from "@ragents/host/plugin-support/skills.js";
 import {
   lazySystemPromptCatalog,
   systemPromptEnvDescriptors,
-} from "@aicontainer/server/plugin-support/system-prompts.js";
+} from "@ragents/host/plugin-support/system-prompts.js";
 
 export const ragentsProductConfigDescriptors = [
   { key: "AGENT_PROVIDER", source: "environment" },
@@ -43,7 +42,7 @@ const relay: RelayCatalog | undefined = provider === RELAY_PROVIDER
 
 const openrouterUpstream = (): ModelUpstream | undefined => {
   const apiKey = env.optional("OPENROUTER_API_KEY");
-  return apiKey ? { id: "openrouter", baseUrl: "https://openrouter.ai/api/v1", apiKey, models: getBuiltinModels("openrouter") } : undefined;
+  return apiKey ? { id: "openrouter", baseUrl: "https://openrouter.ai/api/v1", apiKey, models: builtinCatalog("openrouter")() } : undefined;
 };
 
 export const ragentsProductConfig = Object.freeze({
@@ -51,9 +50,9 @@ export const ragentsProductConfig = Object.freeze({
   relay,
   upstreams: (): readonly ModelUpstream[] => [openrouterUpstream()].filter((upstream): upstream is ModelUpstream => upstream !== undefined),
   model: configuredModel,
-  thinking: checkedThinkingLevel(env.value("AGENT_THINKING", "high"), "AGENT_THINKING"),
+  thinking: () => roleThinkingLevel(env.optional("AGENT_THINKING"), "AGENT_THINKING", provider, configuredModel()),
   coordinatorModel: configuredCoordinatorModel,
-  coordinatorThinking: checkedThinkingLevel(env.value("AGENT_COORDINATOR_THINKING", "high"), "AGENT_COORDINATOR_THINKING"),
+  coordinatorThinking: () => roleThinkingLevel(env.optional("AGENT_COORDINATOR_THINKING"), "AGENT_COORDINATOR_THINKING", provider, configuredCoordinatorModel()),
   systemPromptPath: systemPromptPath ? path.resolve(systemPromptPath) : undefined,
   chatDisplayPolicy: chatDisplayPolicyFromEnvironment(env, { selectable: true }),
   skills: skillsFromEnvironment(env, "ragents.file"),

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

@@ -3,20 +3,19 @@ import {
   type AgentProfile,
   type CatalogModel,
   type RAgentsPlugin,
-} from "@aicontainer/ragents";
-import { pluginAssetPath } from "@aicontainer/server/plugin-support/asset-path.js";
-import type { ModelChoice } from "@aicontainer/server/plugin-support/model-choice.js";
-import { modelUpstreamsToken } from "@aicontainer/server/plugin-support/model-upstreams.js";
-import type { PluginModule } from "@aicontainer/server/plugin-support/plugin-module.js";
-import { productStartOptions } from "@aicontainer/server/plugin-support/product-start-options.js";
-import { ProductModelSettingsStore, productModelSettingsMethods } from "@aicontainer/server/plugin-support/product-model-settings.js";
-import { handlebarsPrompt, systemPromptSelectionPrompt } from "@aicontainer/server/plugin-support/prompt.js";
-import { productRuntimeToken } from "@aicontainer/server/ragents/product-runtime.js";
+} from "@ragents/engine";
+import { modelLabel } from "@ragents/host/plugin-support/model-aliases.js";
+import type { ModelChoice } from "@ragents/host/plugin-support/model-choice.js";
+import { modelUpstreamsToken } from "@ragents/host/plugin-support/model-upstreams.js";
+import { pluginAsset } from "@ragents/host/plugin-support/plugin-folder.js";
+import type { PluginModule } from "@ragents/host/plugin-support/plugin-module.js";
+import { productStartOptions } from "@ragents/host/plugin-support/product-start-options.js";
+import { ProductModelSettingsStore, productModelSettingsMethods } from "@ragents/host/plugin-support/product-model-settings.js";
+import { handlebarsPrompt, systemPromptSelectionPrompt } from "@ragents/host/plugin-support/prompt.js";
+import { productRuntimeToken } from "@ragents/host/ragents/product-runtime.js";
 import { ragentsProductConfig, ragentsProductConfigDescriptors, ragentsProductModelNames } from "./config.js";
 import { ragentsProductRuntime } from "./runtime.js";
 
-const defaultSystemPromptPath = pluginAssetPath(import.meta.url, "../preamble.hbs");
-
 const productProfiles = (): AgentProfile[] => {
   const base = {
     driver: "agent" as const,
@@ -32,21 +31,21 @@ const productProfiles = (): AgentProfile[] => {
       name: "coordinator",
       description: "Nur für den Koordinator selbst, nicht für Agenten.",
       model: coordinatorModel,
-      thinking: ragentsProductConfig.coordinatorThinking,
+      thinking: ragentsProductConfig.coordinatorThinking(),
     },
     {
       ...base,
       name: "relay",
       description: "Für Vermittlung mit wenigen Werkzeugen.",
       model: coordinatorModel,
-      thinking: ragentsProductConfig.coordinatorThinking,
+      thinking: ragentsProductConfig.coordinatorThinking(),
     },
     {
       ...base,
       name: "standard",
       description: "Für alle Agenten.",
       model,
-      thinking: ragentsProductConfig.thinking,
+      thinking: ragentsProductConfig.thinking(),
     },
     ...builtinProfiles.filter((profile) => profile.name === "manual"),
   ];
@@ -57,7 +56,7 @@ const productModels = (): CatalogModel[] =>
     driver: "agent" as const,
     provider: ragentsProductConfig.provider,
     model,
-    label: `${ragentsProductConfig.provider}/${model}`,
+    label: modelLabel(ragentsProductConfig.provider, model),
     thinking: ragentsProductConfig.modelChoice.thinkingOptionsFor(model),
   }));
 
@@ -105,7 +104,7 @@ const ragentsProductPlugin: RAgentsPlugin = {
     });
     host.startEntries(...ragentsProductConfig.skills.startEntries);
     host.prompts(
-      handlebarsPrompt("ragents.product.preamble", 0, ragentsProductConfig.systemPromptPath ?? defaultSystemPromptPath),
+      handlebarsPrompt("ragents.product.preamble", 0, ragentsProductConfig.systemPromptPath ?? pluginAsset("ragents.product", "preamble.hbs")),
       systemPromptSelectionPrompt("ragents.product.selected-prompt", 50, ragentsProductConfig.systemPrompts()),
     );
   },

package/plugins/ragents.product/server/runtime.ts

@@ -1,4 +1,4 @@
-import type { ProductRuntimePolicy } from "@aicontainer/server/ragents/product-runtime.js";
+import type { ProductRuntimePolicy } from "@ragents/host/ragents/product-runtime.js";
 import { ragentsProductConfig } from "./config.js";
 
 const contract = [
@@ -11,7 +11,7 @@ const promptComposition = [
   "Run-Koordinator: Produktprompt und Aufbauanweisung, unabhängig vom gewählten Primary-Actor.",
   "Weitere Actors behalten ihren eigenen Actor-Prompt; die Primary-Auswahl bestimmt nur Ausgabe und Rollenvertrag.",
   "ActorInputs und aktueller Run-Zustand kommen getrennt als Turn-Kontext hinzu.",
-  "Die Agentenlaufzeit ergänzt den Prompt zur Laufzeit um Working Directory, Skills und Extension-Beiträge.",
+  "Actors mit Arbeitsbereichswerkzeugen bekommen die Beschreibung des Arbeitsbereichs als letztes Kapitel; die Agentenlaufzeit ergänzt Skills und Hooks.",
 ].join(" ");
 
 export const ragentsProductRuntime = {

package/plugins/ragents.product/web/index.tsx

@@ -2,9 +2,9 @@ import {
   chatDisplayPolicyFrom,
   type WebPlugin,
   type WebPluginDescriptor,
-} from "@aicontainer/web/PluginRegistry";
-import { productStartOptions } from "./start-options";
-import { ProductModelSettings } from "./ProductModelSettings";
+} from "@ragents/web/PluginRegistry";
+import { ProductModelSettings } from "@ragents/web/product/ProductModelSettings";
+import { productStartOptions } from "@ragents/web/product/start-options";
 
 const ModelSettings = () => <ProductModelSettings pluginId="ragents.product" />;
 

package/plugins/ragents.profile-distribution/contract.ts

@@ -1,23 +1,20 @@
 import { Type, type Static } from "typebox";
-import { defineOperation } from "@aicontainer/ragents/src/rpc/contract";
+import { defineOperation } from "@ragents/engine/src/rpc/contract";
 
 const pluginEntry = Type.Object({
   id: Type.String({ minLength: 1 }),
   source: Type.Union([Type.Literal("host"), Type.Literal("archive")], {
-    description: "host: der Client nimmt das Plugin aus seinem Host-Checkout; archive: das Plugin liegt im Archiv",
+    description: "host: der Client nimmt das eingebaute Bundle seines Hosts; archive: das Bundle liegt im Archiv",
   }),
 }, { additionalProperties: false });
 
-/** Im Archiv liegt das für dieses Profil gebaute Web unter diesem Ordner; der Client baut es nicht selbst. */
-export const CLIENT_WEB_FOLDER = "web";
-
 const description = Type.Object({
   profile: Type.String({ minLength: 1, description: "Profilname; die Datei heißt ragents.config.<profil>.ts" }),
   version: Type.String({ minLength: 64, maxLength: 64, description: "Stand des Archivs als SHA-256" }),
-  hostVersion: Type.String({ minLength: 40, maxLength: 40, description: "Git-Commit des Hosts, den der Client exakt braucht" }),
-  packageVersion: Type.String({ minLength: 1, description: "Fassung des npm-Pakets, die diesen Commit trägt; damit findet der Client die passende Installation" }),
+  hostApi: Type.Integer({ minimum: 1, description: "Nummer der Host-API, gegen die die Bundles im Archiv gebaut sind; der Host des Clients muss genau diese bieten" }),
+  hostVersion: Type.String({ minLength: 40, maxLength: 40, description: "Git-Commit des Hosts dieses Servers; ein Checkout mit anderer Host-API kommt damit zu einer passenden" }),
+  packageVersion: Type.String({ minLength: 1, description: "Fassung des npm-Pakets, die diesen Commit trägt; eine Installation mit anderer Host-API kommt damit zu einer passenden" }),
   file: Type.String({ minLength: 1, description: "Pfad der Profildatei innerhalb des Archivs" }),
-  web: Type.String({ minLength: 1, description: "Ordner des gebauten Webs innerhalb des Archivs; der Client setzt WEB_DIST_DIR darauf" }),
   size: Type.Integer({ minimum: 0, description: "Archivgröße in Byte" }),
   archivePath: Type.String({ minLength: 1, description: "HTTP-Pfad des Archivs auf diesem Server" }),
   plugins: Type.Array(pluginEntry),
@@ -30,7 +27,7 @@ export const profileArchivePath = (version: string): string => `/profile/${versi
 export const profileDistributionContracts = {
   describe: defineOperation({
     id: "ragents.profile.describe",
-    description: "Das Client-Profil dieses Servers: Name, Stand, verlangte Host- und Paketfassung, Plugins und Archiv. Recht: profile.fetch.",
+    description: "Das Client-Profil dieses Servers: Name, Stand, verlangte Host-API, Host- und Paketfassung, Plugins und Archiv. Recht: profile.fetch.",
     rights: ["profile.fetch"],
     input: Type.Object({}, { additionalProperties: false }),
     result: description,

package/plugins/ragents.profile-distribution/ragents-plugin.json

@@ -0,0 +1,3 @@
+{
+  "id": "ragents.profile-distribution"
+}