@schlenkr/ragents 0.1.5 → 0.1.7

package/{plugins/ragents.actor-programs → apps/web/src/actor-programs}/client-ui/workflow-diagram-contracts.d.ts

@@ -1,5 +1,5 @@
 import type { ReactElement } from "react";
-import type { WorkflowDefinition, WorkflowState } from "../workflow/index";
+import type { WorkflowDefinition, WorkflowState } from "../../../../server/src/plugin-support/actor-programs/workflow/index";
 import type { FlowDiagramProps } from "./flow-diagram-contracts";
 
 export interface WorkflowDiagramProps extends Omit<FlowDiagramProps, "nodes" | "edges"> {

package/apps/web/src/api.ts

@@ -1,19 +1,36 @@
-import { runContracts } from "@aicontainer/ragents/src/http/contracts";
-import { coreContracts } from "@aicontainer/server/api/contracts";
+import { runContracts } from "@ragents/engine/src/http/contracts";
+import { coreContracts } from "@ragents/host/api/contracts";
 import { hasExactKeys, isRecord } from "./lib/guards";
 import { rpc } from "./rpc";
 import type { RpcClient } from "./rpc/client";
-import type { Message } from "./chat/types";
+import type { ChatAttachmentInput, Message } from "quassel/events";
 import { startOptionStateFrom, type StartOptionState } from "../../server/src/plugin-support/start-options-contract";
 
 export type { StartOptionState };
 
-export const stopChatActor = async (runId: string, actorId: string, client: RpcClient = rpc): Promise<void> => {
-  await client.call(runContracts.stopActor, {
+/** Unterbricht nur den laufenden Turn dieses Actors; der Actor bleibt aktiv, ohne laufenden Turn geschieht nichts. */
+export const interruptActorTurn = async (runId: string, actorId: string, client: RpcClient = rpc): Promise<void> => {
+  await client.call(runContracts.interruptTurn, { runId, commandId: crypto.randomUUID(), actorId });
+};
+
+export const restartChatActor = async (runId: string, actorId: string, client: RpcClient = rpc): Promise<void> => {
+  await client.call(runContracts.restartActor, { runId, commandId: crypto.randomUUID(), actorId });
+};
+
+export const sendActorMessage = async (runId: string, actorId: string, text: string, attachments?: ChatAttachmentInput[], client: RpcClient = rpc): Promise<void> => {
+  await client.call(coreContracts.chat.sendToActor, { runId, actorId, text, attachments });
+};
+
+export const stopRun = async (runId: string, reason: string, client: RpcClient = rpc): Promise<void> => {
+  await client.call(runContracts.stopAll, { runId, commandId: crypto.randomUUID(), reason });
+};
+
+export const dismissAction = async (runId: string, actionId: string, client: RpcClient = rpc): Promise<void> => {
+  await client.call(runContracts.resolveAction, {
     runId,
     commandId: crypto.randomUUID(),
-    actorId,
-    reason: "Arbeit durch den Bediener gestoppt",
+    actionId,
+    decision: "dismissed",
   });
 };
 
@@ -24,14 +41,20 @@ export interface SessionInfo {
   updatedAt: number;
   revision?: number;
   running?: boolean;
+  /** Ob der Betrachter den Arbeitsbereich des Runs erreicht; fehlt, solange der Server den Run noch nicht gelistet hat. */
+  workspaceAccessible?: boolean;
   metadata?: Readonly<Record<string, unknown>>;
+  /** Warum ein Metadaten-Beitrag keinen Wert hat: gescheitert oder nicht rechtzeitig geantwortet. */
+  metadataUnavailable?: Readonly<Record<string, string>>;
+  /** Warum der Server den Run gesperrt hat; ein gesperrter Run lässt sich nur noch löschen. */
+  locked?: string;
 }
 
 export const listSessions = (client: RpcClient = rpc): Promise<SessionInfo[]> =>
-  client.call(coreContracts.sessions.list, {});
+  client.call(coreContracts.runs.list, {});
 
 export const deleteSession = async (id: string, client: RpcClient = rpc): Promise<void> => {
-  await client.call(coreContracts.sessions.delete, { runId: id });
+  await client.call(coreContracts.runs.delete, { runId: id });
 };
 
 export const getRunView = async (sessionId: string, client: RpcClient = rpc): Promise<unknown | undefined> =>
@@ -105,16 +128,16 @@ export interface SettingsPlugin {
   configuration: readonly SettingsConfigurationDescriptor[];
 }
 
-export interface SettingsAgentExtensionFactory {
-  name: string | null;
-  scope: "global" | "per-agent";
+export interface SettingsAgentHookFactory {
+  name: string;
+  scope: "per-agent";
 }
 
-export interface SettingsAgentExtension {
+export interface SettingsAgentHook {
   id: string;
   owner: string;
   kind: "plugin" | "internal";
-  factories: readonly SettingsAgentExtensionFactory[];
+  factories: readonly SettingsAgentHookFactory[];
   resolvesPerAgent: boolean;
 }
 
@@ -142,7 +165,7 @@ export interface SettingsSkillDetail {
   files: readonly SettingsSkillFile[];
 }
 
-export type SettingsToolKind = "agent-builtin" | "agent-extension" | "ragents" | "plugin";
+export type SettingsToolKind = "ragents" | "plugin";
 export type SettingsToolScope = "global" | "per-agent" | "per-turn";
 export type SettingsToolAvailability = "always" | "conditional";
 
@@ -182,7 +205,7 @@ export interface SettingsResponse {
   systemPrompt: SettingsSystemPrompt;
   promptContributions: readonly SettingsPromptContribution[];
   plugins: readonly SettingsPlugin[];
-  agentExtensions: readonly SettingsAgentExtension[];
+  agentHooks: readonly SettingsAgentHook[];
   skills: readonly SettingsSkill[];
   tools: readonly SettingsTool[];
 }
@@ -234,7 +257,7 @@ const isSettingsPlugin = (value: unknown): value is SettingsPlugin =>
     && typeof entry.source === "string"
     && typeof entry.secret === "boolean");
 
-const isAgentExtension = (value: unknown): value is SettingsAgentExtension =>
+const isAgentHook = (value: unknown): value is SettingsAgentHook =>
   isRecord(value)
   && typeof value.id === "string"
   && typeof value.owner === "string"
@@ -243,8 +266,8 @@ const isAgentExtension = (value: unknown): value is SettingsAgentExtension =>
   && Array.isArray(value.factories)
   && value.factories.every((factory) =>
     isRecord(factory)
-    && (factory.name === null || typeof factory.name === "string")
-    && (factory.scope === "global" || factory.scope === "per-agent"));
+    && typeof factory.name === "string"
+    && factory.scope === "per-agent");
 
 const isSettingsSkill = (value: unknown): value is SettingsSkill =>
   isRecord(value)
@@ -282,7 +305,7 @@ const isSettingsTool = (value: unknown): value is SettingsTool =>
   && typeof value.description === "string"
   && typeof value.owner === "string"
   && typeof value.source === "string"
-  && (value.kind === "agent-builtin" || value.kind === "agent-extension" || value.kind === "ragents" || value.kind === "plugin")
+  && (value.kind === "ragents" || value.kind === "plugin")
   && (value.scope === "global" || value.scope === "per-agent" || value.scope === "per-turn")
   && (value.availability === "always" || value.availability === "conditional")
   && typeof value.availabilityDetail === "string"
@@ -337,8 +360,8 @@ const settingsResponseFrom = (value: unknown): SettingsResponse => {
     || !value.promptContributions.every(isPromptContribution)
     || !Array.isArray(value.plugins)
     || !value.plugins.every(isSettingsPlugin)
-    || !Array.isArray(value.agentExtensions)
-    || !value.agentExtensions.every(isAgentExtension)
+    || !Array.isArray(value.agentHooks)
+    || !value.agentHooks.every(isAgentHook)
     || !Array.isArray(value.skills)
     || !value.skills.every(isSettingsSkill)
     || !Array.isArray(value.tools)

package/apps/web/src/chat/QuasselHost.tsx

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import { QuasselProvider, type QuasselComponents } from "quassel";
+import { Button, Card, Popover, PopoverContent, StopButton, Toggle } from "../ui";
+
+const components: QuasselComponents = { Button, Toggle, Card, StopButton, Popover, PopoverContent };
+
+const allowRunLinks = (url: string): boolean => /^ablauf:(actor|input|turn|subscription|action|artifact)\/.+/.test(url);
+
+/** Every chat building block below renders with the host's UI primitives and keeps the links into a run. */
+export function QuasselHost({ children }: { children: ReactNode }) {
+  return <QuasselProvider allowUrl={allowRunLinks} components={components}>{children}</QuasselProvider>;
+}

package/apps/web/src/chat/StoppedActorNotice.tsx

@@ -0,0 +1,39 @@
+import { useState, type ReactNode } from "react";
+import { useAccess } from "../AccessContext";
+import { restartChatActor } from "../api";
+import type { RunActor } from "../run-view";
+import { Button, cn } from "../ui";
+
+/** Steht an der Stelle der Eingabe, solange der Actor des Chats gestoppt ist: Grund und, wer bedienen darf, der Neustart; toolbar behält die Knöpfe der Eingabe. */
+export function StoppedActorNotice({ actor, runId, className, toolbar }: { actor: RunActor; runId: string; className?: string; toolbar?: ReactNode }) {
+  const access = useAccess();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string>();
+  const reason = actor.lifecycle?.kind === "stopped" ? actor.lifecycle.reason : "";
+  const restartable = access.can("runs.write") && access.can("runs.inspect");
+  const restart = async () => {
+    setBusy(true);
+    setError(undefined);
+    try {
+      await restartChatActor(runId, actor.id);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return <div className={cn("flex min-w-0 flex-col gap-1.5 rounded-[var(--qsl-input-card-radius,var(--radius-xl))] border border-border-strong bg-background px-3 py-2 text-[0.8rem]", className)}
+    data-slot="stopped-actor">
+    <div className="flex min-w-0 items-center gap-2">
+      <p className="min-w-0 flex-1 [overflow-wrap:anywhere]" role="status">
+        <span className="font-semibold">@{actor.handle} gestoppt:</span> {reason}
+      </p>
+      {restartable && <Button disabled={busy} onClick={() => void restart()} size="sm" title={`@${actor.handle} neu starten; danach nimmt er wieder Nachrichten an`} variant="outline">
+        Neu starten
+      </Button>}
+    </div>
+    {!restartable && <p className="text-[0.7rem] text-muted-foreground">Er nimmt keine Nachrichten an, bis ihn jemand mit Bedienrechten neu startet.</p>}
+    {error && <p className="text-[0.7rem] text-destructive" role="alert">{error}</p>}
+    {toolbar && <div className="flex min-w-0 flex-wrap items-center gap-2">{toolbar}</div>}
+  </div>;
+}

package/apps/web/src/chat/chat-target.ts

@@ -1,10 +1,19 @@
 import { isRecord } from "../lib/guards";
-import { stopChatActor } from "../api";
+import { chatPrimaryId, runViewFrom, type RunActor } from "../run-view";
 
-export function stopChatWork(runId: string, view: unknown, stopStartup: () => Promise<void>): Promise<void> {
-  return isRecord(view) && view.id === runId && typeof view.primaryActorId === "string"
-    ? stopChatActor(runId, view.primaryActorId)
-    : stopStartup();
+/** Der Partner des Run-Chats: gestoppt mit Grund, oder aktiv und ob gerade sein eigener Turn läuft; nur den unterbricht die Eingabe. */
+export type PrimaryChatState =
+  | { kind: "none" }
+  | { kind: "stopped"; actor: RunActor }
+  | { kind: "active"; actorId: string; turnRunning: boolean };
+
+export function primaryChatState(value: unknown, runId: string, liveTurn: boolean): PrimaryChatState {
+  const view = runViewFrom(value);
+  const partnerId = view && view.id === runId ? chatPrimaryId(view) : null;
+  const actor = partnerId === null ? undefined : view?.actors.find((entry) => entry.id === partnerId);
+  if (!actor || actor.kind === "human") return { kind: "none" };
+  if (actor.lifecycle?.kind === "stopped") return { kind: "stopped", actor };
+  return { kind: "active", actorId: actor.id, turnRunning: liveTurn || actor.lifecycle?.kind === "running" };
 }
 
 export const programChatNotice = "Dieser TypeScript-Actor verarbeitet Programmeingaben und führt kein Gespräch. Verwende seine Mini-App oder seine dokumentierten Funktionen.";

package/apps/web/src/chat/requests.ts

@@ -1,6 +1,8 @@
-import { coreContracts } from "@aicontainer/server/api/contracts";
-import type { ChatAttachmentInput } from "../../../server/src/chat-events";
+import { coreContracts } from "@ragents/host/api/contracts";
+import type { ChatAttachmentInput } from "quassel/events";
 import type { ChatUserLocation } from "../../../server/src/chat-context";
+import type { StartEntry } from "../../../server/src/plugin-support/start-entries-contract";
+import { preparedRunInput } from "../../../server/src/run-preparation-input";
 import { rpc } from "../rpc";
 import type { RpcClient } from "../rpc/client";
 
@@ -14,10 +16,16 @@ export async function sendChatMessage(
   await client.call(coreContracts.chat.send, { runId, text, attachments, userLocation });
 }
 
+/** Die erste Nachricht eines Runs über eine Skill-Vorlage; der Server legt damit dessen Startoptionen fest. */
+export async function startSkillEntry(runId: string, entry: string, text: string, attachments?: ChatAttachmentInput[], client: RpcClient = rpc): Promise<void> {
+  await client.call(coreContracts.chat.send, { runId, text, attachments, entry });
+}
+
 export async function startChatEntry(runId: string, entry: string, input: unknown, client: RpcClient = rpc): Promise<void> {
   await client.call(coreContracts.chat.start, { runId, entry, input });
 }
 
-export async function stopChat(runId: string, client: RpcClient = rpc): Promise<void> {
-  await client.call(coreContracts.chat.stop, { runId });
-}
+/** Eine Vorlage ohne Vorbereitungschat: ein Run-Script mit seinem Startwert, ein Skill mit seinem vorbereiteten Auftrag. */
+export const startEntryDirectly = (runId: string, entry: StartEntry, input: unknown, client: RpcClient = rpc): Promise<void> => entry.action === "script"
+  ? startChatEntry(runId, entry.id, input, client)
+  : startSkillEntry(runId, entry.id, preparedRunInput([], entry.prompt, undefined, entry.skill).text, undefined, client);

package/apps/web/src/chat/useAttachmentCapabilities.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
-import { coreContracts } from "@aicontainer/server/api/contracts";
-import type { ChatAttachmentCapabilities } from "../../../server/src/chat-events";
+import { coreContracts } from "@ragents/host/api/contracts";
+import type { ChatAttachmentCapabilities } from "quassel/events";
 import { rpc } from "../rpc";
 import type { RpcClient } from "../rpc/client";
 

package/apps/web/src/chat/useChat.ts

@@ -1,9 +1,9 @@
 import { useCallback, useEffect, useReducer, useRef, useState } from "react";
-import { coreContracts } from "@aicontainer/server/api/contracts";
-import { applyEvent, type ChatEvent, type Message, type ChatAttachmentInput, type ChatStartupStatus } from "../../../server/src/chat-events";
+import { coreContracts } from "@ragents/host/api/contracts";
+import { applyEvent, type ChatEvent, type Message, type ChatAttachmentInput, type ChatStartupStatus } from "quassel/events";
 import type { ChatUserLocation } from "../../../server/src/chat-context";
 import { rpc } from "../rpc";
-import { sendChatMessage, startChatEntry, stopChat } from "./requests";
+import { sendChatMessage, startChatEntry, startSkillEntry } from "./requests";
 
 export function useChat(sessionId: string, onEvent?: (event: ChatEvent) => void, enabled = true): {
   messages: Message[];
@@ -11,8 +11,8 @@ export function useChat(sessionId: string, onEvent?: (event: ChatEvent) => void,
   connected: boolean;
   startup: ChatStartupStatus | undefined;
   send: (text: string, attachments?: ChatAttachmentInput[], userLocation?: ChatUserLocation) => Promise<void>;
+  startSkill: (entryId: string, text: string, attachments?: ChatAttachmentInput[]) => Promise<void>;
   start: (entryId: string, input: unknown) => Promise<void>;
-  stop: () => Promise<void>;
 } {
   const [messages, dispatch] = useReducer(applyEvent, [] as Message[]);
   const [running, setRunning] = useState(false);
@@ -38,9 +38,10 @@ export function useChat(sessionId: string, onEvent?: (event: ChatEvent) => void,
   const send = useCallback((text: string, attachments?: ChatAttachmentInput[], userLocation?: ChatUserLocation) =>
     sendChatMessage(sessionId, text, attachments, userLocation), [sessionId]);
 
-  const start = useCallback((entryId: string, input: unknown) => startChatEntry(sessionId, entryId, input), [sessionId]);
+  const startSkill = useCallback((entryId: string, text: string, attachments?: ChatAttachmentInput[]) =>
+    startSkillEntry(sessionId, entryId, text, attachments), [sessionId]);
 
-  const stop = useCallback(() => stopChat(sessionId), [sessionId]);
+  const start = useCallback((entryId: string, input: unknown) => startChatEntry(sessionId, entryId, input), [sessionId]);
 
-  return { messages, running, connected, startup, send, start, stop };
+  return { messages, running, connected, startup, send, startSkill, start };
 }

package/apps/web/src/chat/user-location.ts

@@ -14,7 +14,7 @@ export function runUserLocation(runId: string, activeTabId: string, tabs: readon
 export function chatUserLocation(activeRunId: string | undefined, overviewOpen: boolean, details: ChatRunLocation | undefined): ChatUserLocation {
   const current = activeRunId !== undefined && details?.runId === activeRunId ? details : undefined;
   return {
-    surface: overviewOpen ? "overview" : activeRunId === undefined ? "home" : "run",
+    page: overviewOpen ? "overview" : activeRunId === undefined ? "home" : "run",
     runId: activeRunId ?? null,
     tab: !overviewOpen && current ? current.tab : null,
     selection: !overviewOpen && current?.selection ? { type: current.selection.type, id: current.selection.id } : null,

package/apps/web/src/chat-view-settings.tsx

@@ -0,0 +1,49 @@
+import { useChatSteps, type ChatStepScope } from "./PluginRegistry";
+import { DetailModeSwitch, TimestampSwitch, type DetailMode } from "quassel";
+import { createLocalStorageSetting } from "./lib/local-storage-setting";
+
+const timestampSetting = createLocalStorageSetting({
+  changeEvent: "ragents-chat-timestamps-change",
+  matchesKey: (key) => key.startsWith("ragents.chat.timestamps:"),
+  parse: (raw: string | null) => {
+    if (raw === null || raw === "true") return true;
+    if (raw === "false") return false;
+    throw new Error("Die gespeicherte Zeitstempel-Einstellung ist ungültig.");
+  },
+  serialize: JSON.stringify,
+});
+
+export interface ChatViewSettings {
+  readonly detailSelectable: boolean;
+  readonly detailMode: DetailMode;
+  readonly setDetailMode: (mode: DetailMode) => void;
+  readonly stepsExpandable: boolean;
+  readonly showTimestamps: boolean;
+  readonly setShowTimestamps: (showTimestamps: boolean) => void;
+}
+
+/** Detailgrad und Zeitstempel eines Chats; display trennt nur den Detailgrad nach Anzeigeort, die Zeitstempel gelten je Run und Actor. */
+export function useChatViewSettings(runId: string, actorId: string, scope: ChatStepScope, display?: string): ChatViewSettings {
+  const steps = useChatSteps(runId, actorId, display);
+  const timestampKey = `ragents.chat.timestamps:${JSON.stringify([runId, actorId])}`;
+  return {
+    detailSelectable: steps.selectable,
+    detailMode: steps.mode(scope),
+    setDetailMode: (mode) => steps.setMode(scope, mode),
+    stepsExpandable: steps.stepsExpandable,
+    showTimestamps: timestampSetting.useValue(timestampKey),
+    setShowTimestamps: (showTimestamps) => timestampSetting.save(timestampKey, showTimestamps),
+  };
+}
+
+/** Die Schalter jeder Chat-Eingabe; collapsible gilt für die Beschriftung des Detailgrads. */
+export function ChatViewSwitches({ settings, collapsible = true, className }: {
+  settings: ChatViewSettings;
+  collapsible?: boolean;
+  className?: string;
+}) {
+  return <>
+    {settings.detailSelectable && <DetailModeSwitch className={className} collapsible={collapsible} mode={settings.detailMode} onChange={settings.setDetailMode} />}
+    <TimestampSwitch className={className} onChange={settings.setShowTimestamps} showTimestamps={settings.showTimestamps} />
+  </>;
+}

package/apps/web/src/host-modules.ts

@@ -0,0 +1,90 @@
+import * as engineSrcDomainEvents from "@ragents/engine/src/domain/events";
+import * as engineSrcHttpContracts from "@ragents/engine/src/http/contracts";
+import * as engineSrcRpcContract from "@ragents/engine/src/rpc/contract";
+import * as hostPluginSupportActorProgramsContract from "@ragents/host/plugin-support/actor-programs/contract";
+import * as webAccessContext from "@ragents/web/AccessContext";
+import * as webDiffCode from "@ragents/web/DiffCode";
+import * as webPluginRegistry from "@ragents/web/PluginRegistry";
+import * as webSourceCode from "@ragents/web/SourceCode";
+import * as webStatusGroup from "@ragents/web/StatusGroup";
+import * as webToolbar from "@ragents/web/Toolbar";
+import * as webAccessToken from "@ragents/web/access-token";
+import * as webActorConversation from "@ragents/web/actor-conversation";
+import * as webApi from "@ragents/web/api";
+import * as webChatViewSettings from "@ragents/web/chat-view-settings";
+import * as webChatStoppedActorNotice from "@ragents/web/chat/StoppedActorNotice";
+import * as webChatChatTarget from "@ragents/web/chat/chat-target";
+import * as webChatUseAttachmentCapabilities from "@ragents/web/chat/useAttachmentCapabilities";
+import * as webChatUseChat from "@ragents/web/chat/useChat";
+import * as webLanguageServerLanguageServerPlugin from "@ragents/web/language-server/language-server-plugin";
+import * as webLibFormat from "@ragents/web/lib/format";
+import * as webLibGuards from "@ragents/web/lib/guards";
+import * as webLibHttp from "@ragents/web/lib/http";
+import * as webLibLabels from "@ragents/web/lib/labels";
+import * as webLibLocalStorageSetting from "@ragents/web/lib/local-storage-setting";
+import * as webPageOpener from "@ragents/web/page-opener";
+import * as webProductProductModelSettings from "@ragents/web/product/ProductModelSettings";
+import * as webProductStartOptions from "@ragents/web/product/start-options";
+import * as webRpc from "@ragents/web/rpc";
+import * as webRunPanelHost from "@ragents/web/run-panel/host";
+import * as webRunPanelInputBridge from "@ragents/web/run-panel/input-bridge";
+import * as webRunView from "@ragents/web/run-view";
+import * as webTheme from "@ragents/web/theme";
+import * as webToolLine from "@ragents/web/toolLine";
+import * as webUi from "@ragents/web/ui";
+import * as webUiDialog from "@ragents/web/ui/dialog";
+import * as quassel from "quassel";
+import * as react from "react";
+import * as reactDom from "react-dom";
+import * as reactJsxRuntime from "react/jsx-runtime";
+import * as typebox from "typebox";
+import { HOST_MODULES_GLOBAL } from "@ragents/host/host-api";
+
+/** Every module of the web host API that has values, under its specifier; plugin bundles read them from here instead of carrying a copy. */
+export const hostModules: Readonly<Record<string, object>> = {
+  "@ragents/engine/src/domain/events": engineSrcDomainEvents,
+  "@ragents/engine/src/http/contracts": engineSrcHttpContracts,
+  "@ragents/engine/src/rpc/contract": engineSrcRpcContract,
+  "@ragents/host/plugin-support/actor-programs/contract": hostPluginSupportActorProgramsContract,
+  "@ragents/web/AccessContext": webAccessContext,
+  "@ragents/web/DiffCode": webDiffCode,
+  "@ragents/web/PluginRegistry": webPluginRegistry,
+  "@ragents/web/SourceCode": webSourceCode,
+  "@ragents/web/StatusGroup": webStatusGroup,
+  "@ragents/web/Toolbar": webToolbar,
+  "@ragents/web/access-token": webAccessToken,
+  "@ragents/web/actor-conversation": webActorConversation,
+  "@ragents/web/api": webApi,
+  "@ragents/web/chat-view-settings": webChatViewSettings,
+  "@ragents/web/chat/StoppedActorNotice": webChatStoppedActorNotice,
+  "@ragents/web/chat/chat-target": webChatChatTarget,
+  "@ragents/web/chat/useAttachmentCapabilities": webChatUseAttachmentCapabilities,
+  "@ragents/web/chat/useChat": webChatUseChat,
+  "@ragents/web/language-server/language-server-plugin": webLanguageServerLanguageServerPlugin,
+  "@ragents/web/lib/format": webLibFormat,
+  "@ragents/web/lib/guards": webLibGuards,
+  "@ragents/web/lib/http": webLibHttp,
+  "@ragents/web/lib/labels": webLibLabels,
+  "@ragents/web/lib/local-storage-setting": webLibLocalStorageSetting,
+  "@ragents/web/page-opener": webPageOpener,
+  "@ragents/web/product/ProductModelSettings": webProductProductModelSettings,
+  "@ragents/web/product/start-options": webProductStartOptions,
+  "@ragents/web/rpc": webRpc,
+  "@ragents/web/run-panel/host": webRunPanelHost,
+  "@ragents/web/run-panel/input-bridge": webRunPanelInputBridge,
+  "@ragents/web/run-view": webRunView,
+  "@ragents/web/theme": webTheme,
+  "@ragents/web/toolLine": webToolLine,
+  "@ragents/web/ui": webUi,
+  "@ragents/web/ui/dialog": webUiDialog,
+  "quassel": quassel,
+  "react": react,
+  "react-dom": reactDom,
+  "react/jsx-runtime": reactJsxRuntime,
+  "typebox": typebox,
+};
+
+/** Puts the register where the shims of the plugin bundles look; the host web calls it before any bundle loads. */
+export const installHostModules = (): void => {
+  Object.assign(globalThis, { [HOST_MODULES_GLOBAL]: hostModules });
+};

package/apps/web/src/language-server/api.ts

@@ -0,0 +1,24 @@
+import {
+  languageServerSnapshotContract,
+  languageServerSolutionsContract,
+  languageServerSwitchContract,
+  type LanguageServerSnapshot,
+  type LanguageServerSolutions,
+} from "@ragents/host/plugin-support/language-server/contract";
+import { rpc } from "../rpc";
+
+export const fetchLanguageServerSnapshot = (
+  pluginId: string,
+  runId: string,
+): Promise<LanguageServerSnapshot> => rpc.call(languageServerSnapshotContract(pluginId), { runId });
+
+export const fetchLanguageServerSolutions = (
+  pluginId: string,
+  runId: string,
+): Promise<LanguageServerSolutions> => rpc.call(languageServerSolutionsContract(pluginId), { runId });
+
+export const switchLanguageServerSolution = (
+  pluginId: string,
+  runId: string,
+  root: string | null,
+): Promise<LanguageServerSolutions> => rpc.call(languageServerSwitchContract(pluginId), { runId, root });