@schlenkr/ragents 0.1.0

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

@@ -0,0 +1,157 @@
+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 { processesContracts, type RunProcess, type RunProcessSnapshot } from "../contract";
+import { kindLabel, messageFrom, serviceUrl, titleOf, visibleProcesses } from "./processes";
+
+interface ProcessWatchState {
+  snapshot: RunProcessSnapshot | undefined;
+  error: string | undefined;
+}
+
+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 useRunProcesses = (runId: string): ProcessWatchState => {
+  const [state, setState] = useState<ProcessWatchState>(idle);
+  useEffect(() => {
+    setState(idle);
+    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");
+        setState((current) => message.kind === "snapshot"
+          ? { snapshot: message.snapshot, error: undefined }
+          : { snapshot: current.snapshot, error: message.error });
+      } catch (caught) {
+        setState((current) => ({ ...current, error: caught instanceof Error ? caught.message : String(caught) }));
+      }
+    }, (message) => setState((current) => ({ ...current, error: message })));
+  }, [runId]);
+  return state;
+};
+
+function IconProcess() {
+  return <svg aria-hidden fill="none" height="12" stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="1.8" viewBox="0 0 24 24" width="12">
+    <rect height="16" rx="2" width="18" x="3" y="4" />
+    <path d="m7 9 3 3-3 3M13 15h4" />
+  </svg>;
+}
+
+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 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}
+  </a>);
+  return <div className={cn("flex min-w-0 flex-col", toolbar ? "flex-none self-stretch max-md:not-first:hidden" : "w-full")} data-process-id={process.id}>
+    {toolbar
+      ? <ToolbarItem className="max-w-none flex-1 data-[origin=background]:[border-right-style:dashed]" data-origin={process.origin} title={titleOf(process)}>
+        <IconProcess />
+        <ToolbarCopy className="w-35 flex-none">
+          <ToolbarLabel>{kindLabel(process)}</ToolbarLabel>
+          <ToolbarText>{process.label}</ToolbarText>
+        </ToolbarCopy>
+        {ports}
+        {stop}
+      </ToolbarItem>
+      : <span className={cn(pillClass, "w-full")} data-origin={process.origin} title={titleOf(process)}>
+        <IconProcess />
+        <em className="flex-none text-[0.56rem] font-bold uppercase not-italic tracking-[0.035em]">{kindLabel(process)}</em>
+        <span className="min-w-0 flex-1 overflow-hidden text-ellipsis text-foreground">{process.label}</span>
+        {ports}
+        {stop}
+      </span>}
+    {state?.error && <span className={cn("text-[0.65rem] text-destructive", toolbar ? "max-w-62 overflow-hidden text-ellipsis whitespace-nowrap" : "[overflow-wrap:anywhere]")}
+      role="alert" title={state.error}>{state.error}</span>}
+  </div>;
+}
+
+function ProcessHeaderContent({ runId }: { runId: string }) {
+  const access = useAccess();
+  const writable = access.can("runs.write") && access.can("runs.inspect");
+  const state = useRunProcesses(runId);
+  const [stops, setStops] = useState<Record<string, StopState>>({});
+  const [allOpen, setAllOpen] = useState(false);
+  const requests = useRef(new Map<string, AbortController>());
+  const rootRef = useRef<HTMLDivElement>(null);
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const focused = useRef<HTMLElement>(null);
+  const fallback = useRef<HTMLElement>(null);
+  const processes = state.snapshot?.processes ?? [];
+  const { shown, hidden } = visibleProcesses(processes);
+  useEffect(() => {
+    const active = requests.current;
+    return () => { for (const controller of active.values()) controller.abort(); active.clear(); };
+  }, []);
+  useLayoutEffect(() => {
+    if (!focused.current || focused.current.isConnected || document.activeElement !== document.body) return;
+    const target = (allOpen ? dialogRef.current : rootRef.current)?.querySelector<HTMLElement>("button:not(:disabled), a[href]")
+      ?? (allOpen ? dialogRef.current : null) ?? fallback.current;
+    focused.current = null;
+    target?.focus({ preventScroll: true });
+  }, [state.snapshot, allOpen]);
+  const rememberFocus = (event: FocusEvent<HTMLElement>) => {
+    if (!(event.target instanceof HTMLElement)) return;
+    focused.current = event.target;
+    const header = rootRef.current?.closest("header");
+    fallback.current = [...(header?.querySelectorAll<HTMLElement>("button:not(:disabled), a[href]") ?? [])]
+      .find((element) => !rootRef.current?.contains(element)) ?? null;
+  };
+  const stop = async (process: RunProcess) => {
+    if (!writable || requests.current.has(process.id) || stops[process.id]?.busy) return;
+    const controller = new AbortController();
+    requests.current.set(process.id, controller);
+    setStops((current) => ({ ...current, [process.id]: { busy: true } }));
+    try {
+      await rpc.call(processesContracts.stop, { runId, processId: process.id }, { signal: controller.signal });
+    } catch (cause) {
+      if (!controller.signal.aborted) setStops((current) => ({ ...current, [process.id]: { error: cause instanceof Error ? cause.message : String(cause) } }));
+    } finally { requests.current.delete(process.id); }
+  };
+  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}>
+      {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">
+        <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>}
+    </div>
+    {allOpen && <Dialog open onOpenChange={(open) => {
+      if (open) return;
+      setAllOpen(false);
+      if (processes.length === 0) requestAnimationFrame(() => fallback.current?.focus({ preventScroll: true }));
+    }}>
+      <DialogContent scope="run">
+        <DialogHeader><DialogTitle>Prozesse und Ports</DialogTitle></DialogHeader>
+        <DialogBody className="flex flex-col gap-3 outline-none" ref={dialogRef} tabIndex={-1} onFocusCapture={rememberFocus}>
+          {processes.length > 0 ? processes.map((process) => renderProcess(process)) : <p role="status">Keine aktiven Prozesse.</p>}
+          {state.error !== undefined && <p className="text-destructive" role="alert">{state.error}</p>}
+        </DialogBody>
+      </DialogContent>
+    </Dialog>}
+  </>;
+}
+
+export const processHeader = (): ComponentType<SessionHeaderContext> =>
+  function ProcessHeader({ session }: SessionHeaderContext) {
+    const access = useAccess();
+    return access.can("runs.read") && access.can("ragents.processes.read")
+      ? <ProcessHeaderContent key={session.session.id} runId={session.session.id} /> : null;
+  };

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

@@ -0,0 +1,23 @@
+import {
+  type WebPlugin,
+  type WebPluginDescriptor,
+} from "@aicontainer/web/PluginRegistry";
+import { PROCESSES_PLUGIN_ID } from "../contract";
+import { processHeader } from "./ProcessHeader";
+
+const configuredPlugin = (descriptor: WebPluginDescriptor): WebPlugin => ({
+  ...descriptor,
+  sessionHeaders: [{
+    readRight: "ragents.processes.read",
+    id: "ragents.processes.live",
+    order: 110,
+    Header: processHeader(),
+  }],
+});
+
+const descriptor: WebPluginDescriptor = { id: PROCESSES_PLUGIN_ID };
+
+export const webPlugin: WebPlugin = {
+  ...descriptor,
+  activate: () => configuredPlugin(descriptor),
+};

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

@@ -0,0 +1,75 @@
+import { isRecord } from "@aicontainer/web/lib/guards";
+import type { RunProcess, RunProcessMessage, RunProcessPort, RunProcessSnapshot } from "../contract";
+
+export const VISIBLE_PROCESSES = 4;
+
+const ORIGINS = ["tool-call", "background"] as const;
+
+const portFrom = (value: unknown): RunProcessPort => {
+  if (!isRecord(value) || typeof value.port !== "number" || typeof value.address !== "string") {
+    throw new Error("Ein Port-Eintrag der Prozessüberwachung ist unlesbar");
+  }
+  return { port: value.port, address: value.address };
+};
+
+const processFrom = (value: unknown): RunProcess => {
+  if (!isRecord(value) || typeof value.id !== "string" || !value.id || typeof value.pid !== "number" || typeof value.label !== "string"
+    || typeof value.command !== "string" || typeof value.seenSince !== "string"
+    || !ORIGINS.includes(value.origin as RunProcess["origin"]) || !Array.isArray(value.ports)) {
+    throw new Error("Ein Prozess-Eintrag der Prozessüberwachung ist unlesbar");
+  }
+  return {
+    id: value.id,
+    pid: value.pid,
+    label: value.label,
+    command: value.command,
+    origin: value.origin as RunProcess["origin"],
+    ports: value.ports.map(portFrom),
+    seenSince: value.seenSince,
+  };
+};
+
+const snapshotFrom = (value: unknown): RunProcessSnapshot => {
+  if (!isRecord(value) || typeof value.runId !== "string" || typeof value.observedAt !== "string"
+    || !Array.isArray(value.processes)) {
+    throw new Error("Der Stand der Prozessüberwachung ist unlesbar");
+  }
+  return { runId: value.runId, observedAt: value.observedAt, processes: value.processes.map(processFrom) };
+};
+
+export const messageFrom = (value: unknown): RunProcessMessage => {
+  if (!isRecord(value)) throw new Error("Die Nachricht der Prozessüberwachung ist unlesbar");
+  if (value.kind === "error" && typeof value.error === "string") return { kind: "error", error: value.error };
+  if (value.kind === "snapshot") return { kind: "snapshot", snapshot: snapshotFrom(value.snapshot) };
+  throw new Error("Die Nachricht der Prozessüberwachung hat eine unbekannte Art");
+};
+
+export const serviceUrl = (hostname: string, port: number): string =>
+  `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}/`;
+
+export const kindLabel = (process: RunProcess): string => process.ports.length > 0 ? "Dienst" : "Prozess";
+
+const originText = (origin: RunProcess["origin"]): string =>
+  origin === "background" ? "läuft im Hintergrund weiter" : "läuft in einem Werkzeugaufruf";
+
+const timeText = (iso: string): string => {
+  const parsed = new Date(iso);
+  return Number.isNaN(parsed.getTime()) ? iso : parsed.toLocaleTimeString("de-DE");
+};
+
+export const titleOf = (process: RunProcess): string => {
+  const ports = process.ports.length > 0
+    ? `\nLauscht auf ${process.ports.map((port) => `${port.address}:${port.port}`).join(", ")}`
+    : "";
+  return `${process.command}\nPID ${process.pid}, ${originText(process.origin)}, beobachtet seit ${timeText(process.seenSince)}${ports}`;
+};
+
+export interface VisibleProcesses {
+  shown: readonly RunProcess[];
+  hidden: number;
+}
+
+export const visibleProcesses = (processes: readonly RunProcess[]): VisibleProcesses => ({
+  shown: processes.slice(0, VISIBLE_PROCESSES),
+  hidden: Math.max(0, processes.length - VISIBLE_PROCESSES),
+});

package/plugins/ragents.product/model-settings-contract.ts

@@ -0,0 +1,10 @@
+import type { ThinkingLevel } from "../../packages/ragents/src/domain/driver.js";
+
+export interface ProductModelDraft {
+  profiles: { name: string; model: string; thinking: ThinkingLevel }[];
+}
+
+export interface ProductModelSettings {
+  profiles: (ProductModelDraft["profiles"][number] & { description: string; provider: string })[];
+  models: { id: string; provider: string; label: string; thinking: readonly ThinkingLevel[] }[];
+}

package/plugins/ragents.product/preamble.hbs

@@ -0,0 +1,9 @@
+# RAgents
+
+You are running in RAgents: a workshop in which you talk to the user as a coordinator and, when
+needed, spawn further actors, observe their events and give them ordinary inputs.
+
+Always write user-facing replies in the USER'S language, no matter which language these
+instructions are written in.
+
+What exactly you are supposed to do is described in the following sections.

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

@@ -0,0 +1,73 @@
+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 {
+  lazySystemPromptCatalog,
+  systemPromptEnvDescriptors,
+} from "@aicontainer/server/plugin-support/system-prompts.js";
+
+export const ragentsProductConfigDescriptors = [
+  { key: "AGENT_PROVIDER", source: "environment" },
+  { key: "AGENT_MODEL", source: "environment" },
+  { key: "AGENT_THINKING", source: "environment" },
+  { key: "AGENT_COORDINATOR_MODEL", source: "environment" },
+  { key: "AGENT_COORDINATOR_THINKING", source: "environment" },
+  { key: "SYSTEM_PROMPT_PATH", source: "environment" },
+  { key: "OPENROUTER_API_KEY", source: "environment", secret: true },
+  { key: "RELAY_URL", source: "environment" },
+  { key: "RELAY_TOKEN", source: "environment", secret: true },
+  ...chatDisplayEnvDescriptors,
+  ...skillEnvDescriptors,
+  ...modelChoiceEnvDescriptors,
+  ...systemPromptEnvDescriptors,
+] as const;
+
+const env = declaredEnvironment(ragentsProductConfigDescriptors);
+
+const systemPromptPath = env.optional("SYSTEM_PROMPT_PATH");
+const configuredModel = () => env.required("AGENT_MODEL");
+const configuredCoordinatorModel = () => env.value("AGENT_COORDINATOR_MODEL", "") || configuredModel();
+const provider = env.value("AGENT_PROVIDER", "openrouter");
+
+// Mit AGENT_PROVIDER "relay" kommen Katalog und Modellzugang von einem anderen RAgents-Server.
+const relay: RelayCatalog | undefined = provider === RELAY_PROVIDER
+  ? createRelayCatalog({ url: env.required("RELAY_URL"), token: env.required("RELAY_TOKEN") })
+  : undefined;
+
+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;
+};
+
+export const ragentsProductConfig = Object.freeze({
+  provider,
+  relay,
+  upstreams: (): readonly ModelUpstream[] => [openrouterUpstream()].filter((upstream): upstream is ModelUpstream => upstream !== undefined),
+  model: configuredModel,
+  thinking: checkedThinkingLevel(env.value("AGENT_THINKING", "high"), "AGENT_THINKING"),
+  coordinatorModel: configuredCoordinatorModel,
+  coordinatorThinking: checkedThinkingLevel(env.value("AGENT_COORDINATOR_THINKING", "high"), "AGENT_COORDINATOR_THINKING"),
+  systemPromptPath: systemPromptPath ? path.resolve(systemPromptPath) : undefined,
+  chatDisplayPolicy: chatDisplayPolicyFromEnvironment(env, { selectable: true }),
+  skills: skillsFromEnvironment(env, "ragents.file"),
+  modelChoice: modelChoiceFromEnvironment(env, {
+    provider,
+    selectable: true,
+    defaultModel: configuredCoordinatorModel,
+    fallback: () => ragentsProductModelNames(),
+    ...(relay ? { catalog: relay.models } : {}),
+  }),
+  systemPrompts: lazySystemPromptCatalog(env, () => folderSystemPrompts(pluginFolder("ragents.product"))),
+});
+
+export const ragentsProductModelNames = (): string[] => [
+  ragentsProductConfig.model(),
+  ragentsProductConfig.coordinatorModel(),
+];

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

@@ -0,0 +1,117 @@
+import {
+  builtinProfiles,
+  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";
+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,
+    provider: ragentsProductConfig.provider,
+    turnTimeoutMs: 3_600_000,
+    isolateWorkspace: false,
+  };
+  const coordinatorModel = ragentsProductConfig.coordinatorModel();
+  const model = ragentsProductConfig.model();
+  return [
+    {
+      ...base,
+      name: "coordinator",
+      description: "Nur für den Koordinator selbst, nicht für Agenten.",
+      model: coordinatorModel,
+      thinking: ragentsProductConfig.coordinatorThinking,
+    },
+    {
+      ...base,
+      name: "relay",
+      description: "Für Vermittlung mit wenigen Werkzeugen.",
+      model: coordinatorModel,
+      thinking: ragentsProductConfig.coordinatorThinking,
+    },
+    {
+      ...base,
+      name: "standard",
+      description: "Für alle Agenten.",
+      model,
+      thinking: ragentsProductConfig.thinking,
+    },
+    ...builtinProfiles.filter((profile) => profile.name === "manual"),
+  ];
+};
+
+const productModels = (): CatalogModel[] =>
+  [...new Set([...ragentsProductModelNames(), ...ragentsProductConfig.modelChoice.options])].map((model) => ({
+    driver: "agent" as const,
+    provider: ragentsProductConfig.provider,
+    model,
+    label: `${ragentsProductConfig.provider}/${model}`,
+    thinking: ragentsProductConfig.modelChoice.thinkingOptionsFor(model),
+  }));
+
+const ragentsProductPlugin: RAgentsPlugin = {
+  manifest: { id: "ragents.product" },
+  register: (host) => {
+    host.provide(productRuntimeToken, ragentsProductRuntime);
+    host.provide(modelUpstreamsToken, ragentsProductConfig.upstreams);
+    host.config(...ragentsProductConfigDescriptors);
+    void ragentsProductConfig.modelChoice.options;
+    // Die Modellvorgaben prüfen gegen den Katalog; mit Relay liegt der erst nach dem Abruf beim Start vor.
+    let store: ProductModelSettingsStore | undefined;
+    const settings = (): ProductModelSettingsStore =>
+      store ??= new ProductModelSettingsStore(host.storage.root("model-settings.json"), ragentsProductConfig.modelChoice, productProfiles());
+    const modelChoice: ModelChoice = {
+      provider: ragentsProductConfig.modelChoice.provider,
+      get options() { return settings().modelChoice.options; },
+      get selectable() { return settings().modelChoice.selectable; },
+      get defaultModel() { return settings().modelChoice.defaultModel; },
+      thinkingOptionsFor: (model) => settings().modelChoice.thinkingOptionsFor(model),
+    };
+    host.lifecycle({
+      id: "ragents.product.models",
+      initialize: async () => {
+        await ragentsProductConfig.relay?.load();
+        settings();
+      },
+    });
+    host.methods(...productModelSettingsMethods(host.manifest.id, { get: () => settings().get(), save: (value) => settings().save(value) }));
+    host.clientConfig({ chatSteps: ragentsProductConfig.chatDisplayPolicy });
+    host.startOptions(...productStartOptions({
+      modelChoice,
+      coordinatorThinking: () => settings().coordinatorThinking(),
+      systemPrompts: ragentsProductConfig.systemPrompts,
+    }));
+    host.skills({
+      id: "ragents.product.external-skills",
+      paths: () => ragentsProductConfig.skills.paths,
+    });
+    host.profiles({
+      id: "ragents.product.profiles",
+      models: productModels,
+      profiles: () => settings().profiles(),
+      providers: async () => ragentsProductConfig.relay ? [await ragentsProductConfig.relay.registration()] : [],
+    });
+    host.startEntries(...ragentsProductConfig.skills.startEntries);
+    host.prompts(
+      handlebarsPrompt("ragents.product.preamble", 0, ragentsProductConfig.systemPromptPath ?? defaultSystemPromptPath),
+      systemPromptSelectionPrompt("ragents.product.selected-prompt", 50, ragentsProductConfig.systemPrompts()),
+    );
+  },
+};
+
+export const plugin: PluginModule = {
+  requires: ["ragents.orchestration", "ragents.workspace"],
+  create: () => ragentsProductPlugin,
+};

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

@@ -0,0 +1,118 @@
+import type { Api, Model } from "@aicontainer/ai";
+import type { ModelProviderRegistration } from "@aicontainer/ragents";
+
+export const RELAY_PROVIDER = "relay";
+export const RELAY_API_PATH = "/relay/v1";
+
+export interface RelayConnection {
+  readonly url: string;
+  readonly token: string;
+}
+
+/** Was das Relay je Alias über das dahinterliegende Modell verrät; der echte Name bleibt beim Server. */
+export interface RelayCatalogEntry {
+  readonly id: string;
+  readonly object: "model";
+  readonly catalog: {
+    readonly reasoning: boolean;
+    readonly thinkingLevelMap?: Model<Api>["thinkingLevelMap"];
+    readonly input: Model<Api>["input"];
+    readonly contextWindow: number;
+    readonly maxTokens: number;
+    readonly compat?: Model<Api>["compat"];
+  };
+}
+
+export interface RelayCatalog {
+  readonly baseUrl: string;
+  load: () => Promise<readonly Model<Api>[]>;
+  models: () => readonly Model<Api>[];
+  registration: () => Promise<ModelProviderRegistration>;
+}
+
+const isEntry = (value: unknown): value is RelayCatalogEntry => {
+  if (!value || typeof value !== "object") return false;
+  const entry = value as Record<string, unknown>;
+  const catalog = entry.catalog as Record<string, unknown> | undefined;
+  return typeof entry.id === "string" && entry.id.length > 0 && entry.object === "model"
+    && !!catalog && typeof catalog === "object"
+    && typeof catalog.reasoning === "boolean"
+    && Array.isArray(catalog.input) && catalog.input.every((item) => typeof item === "string")
+    && Number.isInteger(catalog.contextWindow) && Number.isInteger(catalog.maxTokens);
+};
+
+export const relayBaseUrl = (url: string): string => {
+  let parsed: URL;
+  try { parsed = new URL(url); }
+  catch { throw new Error(`RELAY_URL ist keine gültige Adresse: ${url}`); }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`RELAY_URL braucht http oder https: ${url}`);
+  return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}${RELAY_API_PATH}`;
+};
+
+const modelOf = (entry: RelayCatalogEntry, baseUrl: string): Model<"openai-completions"> => ({
+  id: entry.id,
+  name: entry.id,
+  api: "openai-completions",
+  provider: RELAY_PROVIDER,
+  baseUrl,
+  reasoning: entry.catalog.reasoning,
+  ...(entry.catalog.thinkingLevelMap ? { thinkingLevelMap: entry.catalog.thinkingLevelMap } : {}),
+  input: [...entry.catalog.input],
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  contextWindow: entry.catalog.contextWindow,
+  maxTokens: entry.catalog.maxTokens,
+  ...(entry.catalog.compat ? { compat: entry.catalog.compat as Model<"openai-completions">["compat"] } : {}),
+});
+
+/** Holt den Aliaskatalog des Relays genau einmal; ohne erreichbares Relay ist der Start ein Fehler mit Adresse und Ursache. */
+export const createRelayCatalog = (connection: RelayConnection, fetchImpl: typeof fetch = fetch): RelayCatalog => {
+  const baseUrl = relayBaseUrl(connection.url);
+  let loading: Promise<readonly Model<Api>[]> | undefined;
+  let loaded: readonly Model<Api>[] | undefined;
+  const fetchCatalog = async (): Promise<readonly Model<Api>[]> => {
+    const address = `${baseUrl}/models`;
+    let response: Response;
+    try {
+      response = await fetchImpl(address, { headers: { authorization: `Bearer ${connection.token}` }, signal: AbortSignal.timeout(15_000) });
+    } catch (error) {
+      throw new Error(`Das Modell-Relay ${address} ist nicht erreichbar: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok) {
+      throw new Error(`Das Modell-Relay ${address} lehnt den Katalogabruf ab: ${response.status} ${(await response.text()).slice(0, 200)}`);
+    }
+    const body = await response.json() as { data?: unknown };
+    if (!Array.isArray(body.data) || !body.data.every(isEntry)) throw new Error(`Das Modell-Relay ${address} liefert keinen gültigen Aliaskatalog`);
+    if (body.data.length === 0) throw new Error(`Das Modell-Relay ${address} bietet keine Modelle an`);
+    loaded = body.data.map((entry) => modelOf(entry, baseUrl));
+    return loaded;
+  };
+  const load = (): Promise<readonly Model<Api>[]> => loading ??= fetchCatalog();
+  return {
+    baseUrl,
+    load,
+    models: () => {
+      if (!loaded) throw new Error(`Der Modellkatalog des Relays ${baseUrl} ist noch nicht geladen`);
+      return loaded;
+    },
+    registration: async () => ({
+      id: RELAY_PROVIDER,
+      config: {
+        name: "Relay",
+        baseUrl,
+        apiKey: connection.token,
+        api: "openai-completions",
+        models: (await load()).map((model) => ({
+          id: model.id,
+          name: model.name,
+          reasoning: model.reasoning,
+          ...(model.thinkingLevelMap ? { thinkingLevelMap: model.thinkingLevelMap } : {}),
+          input: [...model.input],
+          cost: model.cost,
+          contextWindow: model.contextWindow,
+          maxTokens: model.maxTokens,
+          ...(model.compat ? { compat: model.compat } : {}),
+        })),
+      },
+    }),
+  };
+};

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

@@ -0,0 +1,30 @@
+import type { ProductRuntimePolicy } from "@aicontainer/server/ragents/product-runtime.js";
+import { ragentsProductConfig } from "./config.js";
+
+const contract = [
+  "Allgemeine Regeln:",
+  "- Wo du Deutsch schreibst (Chat, Commit-Messages, Dokumente, Kommentare), gilt immer: echte Umlaute (ä/ö/ü/Ä/Ö/Ü) und echtes ß, niemals ae/oe/ue/ss.",
+  "- Nur Zeichen der deutschen Tastatur: als Strich immer der einfache Bindestrich -, keine Gedankenstriche, keine Ellipsen-Zeichen, keine typografischen Anführungszeichen. ... statt Ellipse, -> statt Pfeil.",
+].join("\n");
+
+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.",
+].join(" ");
+
+export const ragentsProductRuntime = {
+  coordinator: {
+    handle: "coordinator",
+    displayName: "Koordinator",
+    profile: "coordinator",
+    runTitle: "Neuer Run",
+    ownerHandle: "user",
+    ownerDisplayName: "Benutzer",
+  },
+  roleFor: (view, actor) => view.primaryActorId === actor.id ? "primary" : "worker",
+  contract: () => contract,
+  promptComposition,
+  systemPrompts: ragentsProductConfig.systemPrompts,
+} satisfies ProductRuntimePolicy;