@schlenkr/ragents 0.1.5 → 0.1.6

package/bundles/ragents.actor-programs/server/index.js

@@ -0,0 +1,2071 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+
+// server/index.ts
+import path3 from "node:path";
+import { runtimeProviderToken as runtimeProviderToken2, runGuardToken } from "@ragents/host/ragents/host-services.js";
+import { askServiceToken } from "@ragents/plugins/ragents.ask/server/contract";
+
+// server/agent-tools.ts
+import { ToolRegistry } from "@ragents/engine";
+import { runtimeProviderToken, runWorkspaceProviderToken } from "@ragents/host/ragents/host-services.js";
+var agentToolsFrom = (host) => async (runId, actorId, provisional) => {
+  const runtime = host.service(runtimeProviderToken)();
+  const view = runtime.view(runId);
+  const actor = provisional ?? view.actors.find((candidate) => candidate.id === actorId);
+  if (!actor || actor.kind === "human" || actor.lifecycle.kind === "stopped") {
+    throw new Error(`${actorId} bezeichnet keinen aktiven Agenten in diesem Run.`);
+  }
+  const registry = new ToolRegistry();
+  host.tools.entries().forEach((contributor) => registry.register(contributor));
+  const workspace = await host.service(runWorkspaceProviderToken)(runId);
+  const tools = await registry.resolve({
+    runId,
+    actorId,
+    turnId: null,
+    actor,
+    view: provisional ? { ...view, actors: [...view.actors, provisional] } : view,
+    workspace: workspace.cwd
+  });
+  if (actor.toolNames === null) return tools;
+  const availableNames = new Set(tools.map((tool) => tool.name));
+  const unknown = actor.toolNames.filter((name2) => !availableNames.has(name2));
+  if (unknown.length > 0) {
+    throw new Error(`Actor ${actorId} verlangt unbekannte Werkzeuge: ${unknown.join(", ")}.`);
+  }
+  const selected2 = new Set(actor.toolNames);
+  return tools.filter((tool) => selected2.has(tool.name));
+};
+
+// server/methods.ts
+import { DomainError, implement } from "@ragents/engine";
+import { actorProgramContracts } from "@ragents/host/plugin-support/actor-programs/contract.js";
+var MAX_INPUT_BYTES = 64 * 1024;
+var failed = (cause, code, status) => cause instanceof DomainError ? cause : new DomainError(code, cause instanceof Error ? cause.message : String(cause), status);
+var guarded = (code, status, work) => {
+  try {
+    return work();
+  } catch (cause) {
+    throw failed(cause, code, status);
+  }
+};
+var checkedInput = (input) => {
+  if (Buffer.byteLength(JSON.stringify(input ?? null), "utf8") > MAX_INPUT_BYTES)
+    throw new DomainError("input-too-large", `Die Aktionseingabe ist gr\xF6\xDFer als ${MAX_INPUT_BYTES} Byte.`, 413);
+  return input;
+};
+var createActorProgramMethods = (options) => {
+  const session = (runId, code, status) => guarded(code, status, () => options.ensureSession(runId));
+  return [
+    implement(actorProgramContracts.apps, ({ runId }, { access }) => {
+      session(runId, "run-unavailable", 400);
+      return {
+        apps: options.runtime.apps(runId),
+        tools: access.can("runs.inspect") ? options.runtime.runLocalTools(runId) : []
+      };
+    }),
+    implement(actorProgramContracts.source, async ({ runId, moduleId }) => {
+      session(runId, "run-unavailable", 404);
+      try {
+        return await options.runtime.moduleSource(runId, moduleId);
+      } catch (cause) {
+        throw failed(cause, "actor-program-unknown", 404);
+      }
+    }),
+    implement(actorProgramContracts.action, ({ runId, appId, revision, actionId, requestId, input }) => {
+      session(runId, "run-unavailable", 400);
+      return guarded("action-rejected", 400, () => {
+        const permit = options.runtime.invocationPermit(runId);
+        return options.runtime.startInvocation(runId, appId, revision, actionId, requestId, checkedInput(input), permit);
+      });
+    }),
+    implement(actorProgramContracts.invocation, ({ runId, appId, invocationId }) => {
+      session(runId, "run-unavailable", 404);
+      return guarded("invocation-unknown", 404, () => options.runtime.invocation(runId, appId, invocationId));
+    }),
+    implement(actorProgramContracts.function, ({ runId, actorHandle, revision, functionId, requestId, input }) => {
+      session(runId, "run-unavailable", 400);
+      return guarded("function-rejected", 400, () => {
+        const permit = options.runtime.invocationPermit(runId);
+        return options.runtime.startFunctionInvocation(runId, actorHandle, revision, functionId, requestId, checkedInput(input), permit);
+      });
+    }),
+    implement(actorProgramContracts.functionInvocation, ({ runId, actorHandle, invocationId }) => {
+      session(runId, "run-unavailable", 404);
+      return guarded("invocation-unknown", 404, () => options.runtime.invocation(runId, actorHandle, invocationId));
+    })
+  ];
+};
+
+// server/routes.ts
+import { randomBytes } from "node:crypto";
+import { guardedJsonRoute } from "@ragents/host/plugin-support/http.js";
+import { browserInputRuntime, browserRuntimeStyles } from "@ragents/host/plugin-support/actor-programs/client-runtime.js";
+var miniAppsApiPrefix = "/api/plugins/ragents.actor-programs";
+var framePattern = new RegExp(`^${miniAppsApiPrefix.replaceAll(".", "\\.")}/runs/([A-Za-z0-9_-]{1,64})/apps/([a-z][a-z0-9_-]{0,129})/frame$`);
+var escapeForwarder = `
+  window.addEventListener("keydown", (event) => {
+    if (event.key !== "Escape" || event.defaultPrevented) return;
+    queueMicrotask(() => {
+      if (!event.defaultPrevented) parent.postMessage({ type: "ragents.app.escape", version: 1, token: bridgeToken, keyboard: ragentsInputBridge.keyboardMessage(event, "keydown") }, "*");
+    });
+  });`;
+var themeReceiver = `
+  const applyHostTheme = (theme) => {
+    if (theme !== "light" && theme !== "dark") throw new Error("Das Host-Theme muss light oder dark sein.");
+    document.documentElement.dataset.theme = theme;
+  };`;
+var frameContentSecurityPolicy = (nonce) => `sandbox allow-scripts allow-forms allow-downloads; default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; img-src 'self' data: blob:; font-src data:; connect-src 'none'; media-src 'self' data: blob:; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self' https://*.vscode-cdn.net vscode-file: vscode-webview:`;
+var escapedScript = (source) => source.replace(/<\/script/gi, "<\\/script");
+var typedBridgeSdk = (nonce, styles) => `<script nonce="${nonce}">
+${escapedScript(browserInputRuntime)}
+globalThis.__ragentsAppContext = (() => {
+  document.documentElement.dataset.uiSurface = "mini-app";
+  document.documentElement.dataset.miniAppFrame = "true";
+  const style = document.createElement("style");
+  style.setAttribute("nonce", ${JSON.stringify(nonce)});
+  style.textContent = atob(${JSON.stringify(Buffer.from(styles, "utf8").toString("base64"))});
+  document.head.prepend(style);
+  const pending = new Map();
+  const listeners = new Set();
+  const chats = new Map();
+  const freeze = (value) => {
+    if (value && typeof value === "object") {
+      Object.values(value).forEach(freeze);
+      Object.freeze(value);
+    }
+    return value;
+  };
+  const bridgeToken = new URLSearchParams(location.hash.slice(1)).get("ragentsBridge");
+  ${escapeForwarder}
+  ${themeReceiver}
+  const channel = new MessageChannel();
+  const port = channel.port1;
+  let currentState = freeze({});
+  let currentApp = null;
+  let readyResolve;
+  const ready = new Promise((resolve) => { readyResolve = resolve; });
+  const terminal = new Set(["succeeded", "failed", "cancelled"]);
+  const requestId = () => crypto.randomUUID().replaceAll("-", "");
+  const stateValue = (value) => value && typeof value === "object" && value.values && typeof value.values === "object"
+    ? freeze(structuredClone(value.values))
+    : freeze({});
+  const settle = (message) => {
+    const id = message.requestId || message.invocation?.requestId;
+    const waiter = id ? pending.get(id) : undefined;
+    if (!waiter || !terminal.has(message.invocation.status)) return;
+    pending.delete(id);
+    if (message.invocation.status === "succeeded") waiter.resolve(message.invocation.result);
+    else waiter.reject(new Error(message.invocation.error || "Die App-Aktion wurde nicht abgeschlossen."));
+  };
+  port.onmessage = ({ data }) => {
+    if (data?.version !== 1) return;
+    if (data.type === "ragents.app.ready") {
+      applyHostTheme(data.theme);
+      if (data.hostInput === true) {
+        const disposeInput = ragentsInputBridge.installFrameInputBridge(window, port);
+        window.addEventListener("pagehide", disposeInput, { once: true });
+      }
+      currentApp = data.app;
+      currentState = stateValue(data.state);
+      listeners.forEach((listener) => listener(currentState));
+      readyResolve();
+      port.postMessage({ type: "ragents.app.connected", version: 1 });
+    } else if (data.type === "ragents.app.theme") {
+      applyHostTheme(data.theme);
+    } else if (data.type === "ragents.app.state") {
+      currentState = stateValue(data.state);
+      const waiter = data.requestId ? pending.get(data.requestId) : undefined;
+      if (waiter) {
+        pending.delete(data.requestId);
+        waiter.resolve(currentState);
+      }
+      listeners.forEach((listener) => listener(currentState));
+    } else if (data.type === "ragents.app.invocation") {
+      settle(data);
+    } else if (data.type === "ragents.app.chat-state") {
+      const entry = chats.get(data.actor);
+      if (entry) {
+        entry.snapshot = freeze(data.snapshot);
+        entry.listeners.forEach((listener) => listener());
+      }
+      const waiter = pending.get(data.requestId);
+      if (waiter) { pending.delete(data.requestId); waiter.resolve(); }
+    } else if (data.type === "ragents.app.chat-ack") {
+      const waiter = pending.get(data.requestId);
+      if (waiter) { pending.delete(data.requestId); waiter.resolve(); }
+    } else if (data.type === "ragents.app.error") {
+      const waiter = data.requestId ? pending.get(data.requestId) : undefined;
+      if (waiter) {
+        pending.delete(data.requestId);
+        waiter.reject(new Error(data.message));
+      }
+    }
+  };
+  port.start();
+  const send = async (message) => {
+    await ready;
+    return new Promise((resolve, reject) => {
+      pending.set(message.requestId, { resolve, reject });
+      port.postMessage(message);
+    });
+  };
+  if (/^[a-f0-9]{32}$/.test(bridgeToken || "")) {
+    parent.postMessage(
+      { type: "ragents.app.frame-ready", version: 1, token: bridgeToken },
+      "*",
+      [channel.port2],
+    );
+  }
+  return Object.freeze({
+    get actor() { if (!currentApp) throw new Error("Die Actor-Ansicht ist noch nicht bereit."); return Object.freeze({id:currentApp.actorId,handle:currentApp.actorHandle}); },
+    ready: ready.then(() => undefined),
+    run: Object.freeze({ id: "current" }),
+    principal: Object.freeze({ id: "operator", kind: "operator" }),
+    state: Object.freeze({
+      read: () => currentState,
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    }),
+    chat: Object.freeze({
+      read: (actor) => chats.get(actor)?.snapshot,
+      subscribe: (actor, listener) => {
+        let entry = chats.get(actor);
+        if (!entry) {
+          entry = { listeners: new Set(), snapshot: undefined, started: false };
+          chats.set(actor, entry);
+          ready.then(() => {
+            if (chats.get(actor) !== entry) return;
+            entry.started = true;
+            send({ type: "ragents.app.chat-watch", version: 1, requestId: requestId(), actor })
+              .catch((error) => {
+                if (chats.get(actor) !== entry) return;
+                entry.snapshot = freeze({ messages: [], running: false, error: error.message });
+                entry.listeners.forEach((notify) => notify());
+              });
+          });
+        }
+        entry.listeners.add(listener);
+        return () => {
+          entry.listeners.delete(listener);
+          if (entry.listeners.size > 0 || chats.get(actor) !== entry) return;
+          chats.delete(actor);
+          if (entry.started) {
+            port.postMessage({ type: "ragents.app.chat-unwatch", version: 1, requestId: requestId(), actor });
+          }
+        };
+      },
+      send: (actor, text, attachments) => send({ type: "ragents.app.chat-send", version: 1, requestId: requestId(), actor, text, attachments }),
+    }),
+    capabilities: Object.freeze({
+      list: () => (currentApp?.actions ?? []).map((action) => action.id),
+      call: async (actionId, input = {}) => {
+        await ready;
+        if (!(currentApp?.actions ?? []).some((action) => action.id === actionId)) {
+          throw new Error("Die angeforderte App-Aktion ist nicht installiert.");
+        }
+        return send({
+          type: "ragents.app.invoke",
+          version: 1,
+          requestId: requestId(),
+          actionId,
+          input,
+        });
+      },
+    }),
+  });
+})();
+</script>`;
+var frameHtml = (frame, nonce) => {
+  const head = /<head(?:\s[^>]*)?>/i;
+  if (!head.test(frame.html)) throw new Error("Die installierte App besitzt keinen g\xFCltigen head.");
+  const client = `<script nonce="${nonce}" type="module">await globalThis.__ragentsAppContext.ready;${escapedScript(frame.clientJavaScript)}</script>`;
+  return frame.html.replace(head, (value) => `${value}${typedBridgeSdk(nonce, `${browserRuntimeStyles}
+${frame.styles}`)}${client}`);
+};
+var createMiniAppFrameRoutes = (options) => [
+  {
+    id: "ragents.actor-programs.frame",
+    isApiPath: (pathname) => pathname.startsWith(miniAppsApiPrefix),
+    matches: (request, url) => request.method === "GET" && framePattern.test(url.pathname),
+    handle: async ({ request, response, url }) => {
+      const match = url.pathname.match(framePattern);
+      if (!match) throw new Error("Ung\xFCltige App-Route.");
+      const [, runId, appId] = match;
+      await guardedJsonRoute({
+        request,
+        response,
+        ensureSession: () => options.ensureSession(runId),
+        errorStatus: 404,
+        handle: () => {
+          const revision = url.searchParams.get("revision") ?? "";
+          const nonce = randomBytes(18).toString("base64");
+          const frame = options.runtime.frame(runId, appId, revision);
+          const content = Buffer.from(frameHtml(frame, nonce), "utf8");
+          response.writeHead(200, {
+            "Cache-Control": "no-store",
+            "Content-Security-Policy": frameContentSecurityPolicy(nonce),
+            "Content-Type": "text/html; charset=utf-8",
+            "Content-Length": content.byteLength,
+            "Referrer-Policy": "no-referrer",
+            "X-Content-Type-Options": "nosniff"
+          });
+          response.end(content);
+        }
+      });
+    }
+  }
+];
+
+// server/runtime.ts
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir, readFile, realpath as realpath2, rm, writeFile } from "node:fs/promises";
+import { lstatSync, readFileSync, renameSync } from "node:fs";
+import path from "node:path";
+import { Value } from "typebox/value";
+import { actorByHandle, actorDescriptionMaxLength, agentTools, assertJsonValue as assertJsonValue2, canonicalHash, defineRunFunction, defineToolAvailability, emptyUsage, handleKey, runCapabilityContractHash as runCapabilityContractHash2, scriptInputOf, schemaComplaints } from "@ragents/engine";
+import { ACTOR_PROGRAMS_STATE_ID, ACTOR_INVOCATIONS_STATE_ID, ACTOR_SCRIPT_STATE_ID, ACTOR_STATE_ID, resolveActorView } from "@ragents/host/plugin-support/actor-programs/contract.js";
+
+// server/limits.ts
+import { assertJsonValue } from "@ragents/engine";
+var MAX_JSON_BYTES = 25e4;
+var MAX_JSON_DEPTH = 24;
+var MAX_JSON_KEY_LENGTH = 256;
+var MAX_INVOCATIONS_STATE_BYTES = 8 * 1024 * 1024;
+var jsonBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+var jsonValue = (value, label) => {
+  assertJsonValue(value, label);
+  const text = JSON.stringify(value);
+  if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES)
+    throw new Error(`${label} ist gr\xF6\xDFer als ${MAX_JSON_BYTES} Byte.`);
+  const pending = [{ value, depth: 0 }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current.depth > MAX_JSON_DEPTH)
+      throw new Error(`${label} ist tiefer als ${MAX_JSON_DEPTH} Ebenen verschachtelt.`);
+    if (Array.isArray(current.value)) {
+      current.value.forEach((entry) => pending.push({ value: entry, depth: current.depth + 1 }));
+      continue;
+    }
+    if (current.value && typeof current.value === "object") {
+      Object.entries(current.value).forEach(([key, entry]) => {
+        if (key.length > MAX_JSON_KEY_LENGTH)
+          throw new Error(`${label} enth\xE4lt einen Schl\xFCssel mit mehr als ${MAX_JSON_KEY_LENGTH} Zeichen.`);
+        pending.push({ value: entry, depth: current.depth + 1 });
+      });
+    }
+  }
+  return value;
+};
+
+// server/capability-resolver.ts
+import {
+  runCapabilityBindingHash,
+  runCapabilityContractHash
+} from "@ragents/engine";
+var descriptorOf = (capability) => ({
+  id: capability.id,
+  label: capability.label,
+  description: capability.description,
+  schema: capability.schema,
+  resultSchema: capability.resultSchema
+});
+var selected = (available2, capabilityIds, idOf, unavailable) => {
+  const byId = new Map(available2.map((value) => [idOf(value), value]));
+  return capabilityIds.map((id) => {
+    const value = byId.get(id);
+    if (!value) throw unavailable(id, [...byId.keys()].sort().join(", ") || "keine");
+    return value;
+  });
+};
+var operatorCapabilityBinding = (actorId, operations, capabilityIds) => {
+  const resolved = selected(
+    operations.filter((operation) => operation.operator !== "unavailable"),
+    capabilityIds,
+    (operation) => operation.id,
+    (id, names) => new Error(`Capability ${id} ist f\xFCr den Bediener nicht verf\xFCgbar. Verf\xFCgbar sind: ${names}.`)
+  );
+  const descriptors = resolved.map(descriptorOf);
+  return {
+    descriptors,
+    descriptorContractHash: runCapabilityContractHash(descriptors),
+    bindingContractHash: runCapabilityBindingHash({
+      principal: { id: actorId, kind: "operator" },
+      capabilities: descriptors,
+      policies: resolved.map((operation) => ({ id: operation.id, policy: operation.operator }))
+    })
+  };
+};
+var agentCapabilityBinding = (actor, tools, capabilityIds, blockedNames) => {
+  const resolved = selected(
+    tools.filter((tool) => !blockedNames.has(tool.name)),
+    capabilityIds,
+    (tool) => tool.name,
+    (id, names) => new Error(
+      `Capability ${id} ist f\xFCr @${actor.handle} nicht verf\xFCgbar. Verf\xFCgbar sind: ${names}.`
+    )
+  );
+  const descriptors = resolved.map((tool) => descriptorOf({ ...tool, id: tool.name }));
+  return {
+    descriptors,
+    descriptorContractHash: runCapabilityContractHash(descriptors),
+    bindingContractHash: runCapabilityBindingHash({
+      principal: { id: actor.id, kind: actor.kind === "script" ? "script" : "agent", grants: actor.grants },
+      capabilities: descriptors,
+      policies: descriptors.map((descriptor2) => ({ id: descriptor2.id, policy: "agent" }))
+    })
+  };
+};
+
+// server/runtime.ts
+import { compileClientProject, installClientSdk } from "@ragents/host/plugin-support/actor-programs/client-compiler.js";
+import { compileAppBackend, installServerSdk, prepareAppProject, prepareAppWorkspace, projectSourceFiles, readAppPackage, typecheckServerProject } from "@ragents/host/plugin-support/actor-programs/app-project.js";
+import { syncWorkspaceOwnership } from "@ragents/host/plugin-support/workspace-ownership.js";
+import { runManagedProcess, sandboxedLaunch } from "@ragents/workspace-executor";
+
+// server/controls-template.ts
+var controlsTemplate = {
+  id: "controls",
+  title: "UI-Controls ausprobieren",
+  description: "Lokale Demo mit Formular, Tabelle, Dateien, Aufgaben, Ablaufdiagramm, SVG-Verbindungen, Nachrichten, Dokument und Diff ohne Funktionsaufrufe.",
+  ragents: {
+    title: "UI-Controls ausprobieren",
+    description: "Eine lokale Demo der vorhandenen Mini-App-Controls. Werte und Dateien bleiben in dieser Ansicht.",
+    views: [{ id: "main", client: "src/client.tsx" }]
+  },
+  files: {
+    "src/client.tsx": `import React from "react";
+import { createRoot } from "react-dom/client";
+import * as UI from "@ragents/client/ui";
+
+type FormValues = Parameters<typeof UI.Form>[0]["values"];
+type Row = { id: string; name: string; count: number };
+const rows: Row[] = [
+  { id: "analysis", name: "Analyse", count: 12 },
+  { id: "review", name: "Review", count: 4 },
+  { id: "notes", name: "Dokumentation", count: 8 },
+];
+
+const App = () => {
+  const [values, setValues] = React.useState<FormValues>({ title: "Ergebnisse pr\xFCfen", notes: "", count: 3, mode: "review", approved: false });
+  const [selected, setSelected] = React.useState<string[]>([]);
+  const [files, setFiles] = React.useState<File[]>([]);
+  const [result, setResult] = React.useState("Noch keine Formularwerte \xFCbernommen.");
+  const [messages, setMessages] = React.useState<Parameters<typeof UI.MessageList>[0]["messages"]>([
+    { key: "editorial", sender: "Redaktion", text: "Der Hinweis soll **kurz und verst\xE4ndlich** bleiben." },
+    { key: "review", sender: "Textpr\xFCfung", text: "\xD6ffnungszeiten und Reparaturhinweis bleiben erhalten." },
+  ]);
+  const [done, setDone] = React.useState(false);
+  return <UI.AppLayout title="UI-Controls ausprobieren" description="Lokale Demo: keine Agenten, Uploads oder Serveraktionen. Werte und Dateiauswahl bleiben nur in dieser Ansicht und werden beim Neuladen zur\xFCckgesetzt.">
+    <UI.Stack gap="large">
+      <UI.Form title="Formular" fields={[
+        { id: "title", label: "Auftrag", type: "text", placeholder: "Was soll bearbeitet werden?", required: true },
+        { id: "notes", label: "Hinweise", type: "textarea", rows: 3, placeholder: "Was soll bei der Bearbeitung ber\xFCcksichtigt werden?", hint: "Mehrzeiliger Text bleibt im Formular ausgerichtet." },
+        { id: "count", label: "Anzahl", type: "number", placeholder: "Anzahl der Ergebnisse", hint: "1 bis 10 Ergebnisse.", required: true, min: 1, max: 10 },
+        { id: "mode", label: "Modus", type: "select", options: [{ value: "review", label: "Pr\xFCfen" }, { value: "draft", label: "Entwerfen" }] },
+        { id: "approved", label: "Auswahl best\xE4tigt", type: "checkbox", required: true },
+      ]} values={values} onChange={setValues} onSubmit={async (next) => { setResult(JSON.stringify(next, null, 2)); }} submitLabel="Werte lokal anzeigen" />
+      <UI.Stack gap="small">
+        <UI.DataTable<Row> title="Datentabelle" rows={rows} rowKey={(row) => row.id} filterable
+          selectedKeys={selected} onSelectionChange={setSelected}
+          columns={[{ id: "name", label: "Arbeit", value: (row) => row.name, sortable: true }, { id: "count", label: "Ergebnisse", value: (row) => row.count, sortable: true }]}
+          actions={[{ id: "select", label: "Ausw\xE4hlen", onClick: (row) => { setSelected([row.id]); } }]} />
+        <p aria-live="polite">{selected.length} Zeilen ausgew\xE4hlt</p>
+      </UI.Stack>
+      <UI.FilePicker label="Lokale Dateiauswahl" files={files} onChange={setFiles} maxFiles={5} maxBytes={10 * 1024 * 1024} />
+      <UI.Stack gap="small">
+        <UI.TaskProgress title="Beispielaufgaben" tasks={[
+          { id: "read", label: "Unterlagen lesen", status: "done" },
+          { id: "review", label: "Ergebnisse pr\xFCfen", status: done ? "done" : "pending", description: "Lokaler Beispielstatus, kein laufender Actor." },
+        ]} />
+        <UI.Stack direction="row"><UI.Button onClick={() => setDone((current) => !current)}>Beispielstatus umschalten</UI.Button></UI.Stack>
+      </UI.Stack>
+      <UI.Stack gap="small">
+        <h2>Ablaufdiagramm</h2>
+        <p>Das Diagramm erh\xE4lt seinen Zustand aus denselben Daten wie die Aufgabenliste.</p>
+        <UI.FlowDiagram label={done ? "Eingang, Pr\xFCfung fertig, Ergebnis bereit" : "Eingang, Pr\xFCfung l\xE4uft, Ergebnis ausstehend"}
+          nodes={[
+            { id: "input", label: "Eingang", detail: "Unterlagen liegen vor", status: "done", kind: "service" },
+            { id: "check", label: "Pr\xFCfung", detail: done ? "Pr\xFCfung abgeschlossen" : "Unterlagen werden gepr\xFCft", status: done ? "done" : "active", kind: "agent" },
+            { id: "result", label: "Ergebnis", detail: done ? "Ergebnis bereit" : "Wartet auf die Pr\xFCfung", status: done ? "done" : "pending", kind: "actor" },
+          ]}
+          edges={[{ source: "input", target: "check" }, { source: "check", target: "result" }]} />
+      </UI.Stack>
+      <UI.Stack gap="small">
+        <h2>SVG-Verbindungen</h2>
+        <p>SvgEdge zeichnet die Kanten. Knoten, Beschriftungen und Positionen stehen im Code dieser Ansicht.</p>
+        <svg viewBox="0 0 360 160" role="img" aria-label={done ? "Eingang fertig, Pr\xFCfung abgeschlossen, Ergebnis bereit" : "Eingang fertig, Pr\xFCfung l\xE4uft, Ergebnis offen"}
+          className="block h-auto w-full text-[13px]">
+          <UI.SvgEdge d="M112 42 L144 42" tone={done ? "success" : "warning"} active={!done} />
+          <UI.SvgEdge d="M252 42 C320 42 320 118 252 118" arrow={done ? "end" : "none"} tone={done ? "success" : "neutral"} lineStyle={done ? "solid" : "dashed"} />
+          <UI.SvgEdge d="M144 118 C64 118 64 96 64 72" arrow="both" tone="accent" />
+          {[{ x: 8, y: 12, label: "Eingang", status: "Fertig" },
+            { x: 148, y: 12, label: "Pr\xFCfung", status: done ? "Fertig" : "L\xE4uft" },
+            { x: 148, y: 88, label: "Ergebnis", status: done ? "Bereit" : "Offen" }].map((node) => <g key={node.label}>
+              <rect x={node.x} y={node.y} width="104" height="56" rx="8" className="fill-background stroke-border-strong" />
+              <text x={node.x + 52} y={node.y + 23} textAnchor="middle" className="fill-foreground font-semibold">{node.label}</text>
+              <text x={node.x + 52} y={node.y + 42} textAnchor="middle" className="fill-muted-foreground text-[11px]">{node.status}</text>
+            </g>)}
+        </svg>
+      </UI.Stack>
+      <UI.Stack gap="small">
+        <UI.MessageList messages={messages} label="Lokale Redaktionsnotizen" />
+        <UI.Stack direction="row"><UI.Button onClick={() => setMessages((current) => [...current, {
+          key: "note-" + current.length, sender: current.length % 2 ? "Textpr\xFCfung" : "Redaktion",
+          text: "Lokale Beispielnotiz " + (current.length - 1) + ": Diese Nachricht wurde gerade erg\xE4nzt.",
+        }])}>Lokale Nachricht erg\xE4nzen</UI.Button></UI.Stack>
+      </UI.Stack>
+      <UI.DocumentViewer title="Lokales Formularergebnis" format="text" content={result} />
+      <UI.DiffViewer title="Beispiel\xE4nderung" patch={"--- a/result.txt\\n+++ b/result.txt\\n@@ -1 +1 @@\\n-Status: offen\\n+Status: gepr\xFCft"} />
+    </UI.Stack>
+  </UI.AppLayout>;
+};
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+createRoot(root).render(<App />);
+`
+  }
+};
+
+// server/templates.ts
+var blank = {
+  id: "blank",
+  title: "Leere Mini-App",
+  description: "Eine reine React-View am vorhandenen Actor ohne zus\xE4tzliche Serverfunktion.",
+  ragents: {
+    title: "Meine View",
+    description: "Eine kleine Bedienoberfl\xE4che des vorhandenen Actors.",
+    views: [{ id: "main", client: "src/client.tsx" }]
+  },
+  files: {
+    "src/client.tsx": `import { createRoot } from "react-dom/client";
+import * as UI from "@ragents/client/ui";
+
+const App = () => (
+  <UI.AppLayout title="Meine View">
+    <UI.Stack><p>Bereit f\xFCr deine Inhalte.</p></UI.Stack>
+  </UI.AppLayout>
+);
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+createRoot(root).render(<App />);
+`
+  }
+};
+var chat = {
+  id: "chat",
+  title: "Actor-Chat",
+  description: "Wiederverwendbarer Chat mit Verlauf und optionaler Eingabe an den Actor dieser View.",
+  ragents: {
+    title: "Actor-Chat",
+    description: "Zeigt das Gespr\xE4ch mit einem Actor und sendet ihm Benutzereingaben.",
+    views: [{ id: "main", client: "src/client.tsx" }]
+  },
+  files: {
+    "src/client.tsx": `import { createRoot } from "react-dom/client";
+import * as UI from "@ragents/client/ui";
+import { context } from "@ragents/client";
+
+const App = () => (
+  <UI.Chat actor={"@" + context.actor.handle} className="h-full" showInput placeholder="Nachricht an den Actor" />
+);
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+createRoot(root).render(<App />);
+`
+  }
+};
+var textAnalysis = {
+  id: "text-analysis",
+  title: "Textanalyse",
+  description: "Ein TypeScript-Actor analysiert Texte mit eigener Funktion, Zustand und React-View.",
+  ragents: {
+    title: "Textanalyse",
+    description: "Z\xE4hlt Zeichen, W\xF6rter und Zeilen und merkt sich die Zahl der Analysen.",
+    backend: "src/server.ts",
+    views: [{ id: "main", client: "src/client.tsx" }]
+  },
+  files: {
+    "src/client.tsx": `import React from "react";
+import { createRoot } from "react-dom/client";
+import { context, useAppState } from "@ragents/client";
+import * as UI from "@ragents/client/ui";
+
+type FormValues = Parameters<typeof UI.Form>[0]["values"];
+
+const App = () => {
+  const state = useAppState();
+  const [values, setValues] = React.useState<FormValues>({ text: "" });
+  const [result, setResult] = React.useState("Bereit");
+
+  const analyse = async (next: FormValues): Promise<void> => {
+    const answer = await context.capabilities.call("analyse", { text: String(next.text ?? "") });
+    setResult([
+      \`Zeichen: \${answer.characters}\`,
+      \`W\xF6rter: \${answer.words}\`,
+      \`Zeilen: \${answer.lines}\`,
+    ].join("\\n"));
+  };
+
+  return (
+    <UI.AppLayout title="Textanalyse" description={<>Analysen: {state.analyses ?? 0}</>}>
+      <UI.Grid>
+        <UI.Form fields={[
+          { id: "text", label: "Text", type: "textarea", rows: 6, placeholder: "Text eingeben" },
+        ]} values={values} onChange={setValues} onSubmit={analyse} submitLabel="Analysieren" />
+        <UI.Stack><pre aria-live="polite" className="min-h-[90px] overflow-auto rounded-md border border-border bg-muted p-2.5 font-mono whitespace-pre-wrap">{result}</pre></UI.Stack>
+      </UI.Grid>
+    </UI.AppLayout>
+  );
+};
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+createRoot(root).render(<App />);
+`,
+    "src/contract.ts": `import { Type } from "typebox";
+
+export const contract = {
+  state: Type.Object({ analyses: Type.Optional(Type.Integer({"minimum": 0})) }, {"additionalProperties": false}),
+  functions: {
+    analyse: {
+      label: "Text analysieren",
+      description: "Z\xE4hlt W\xF6rter, Zeichen und Zeilen ohne externe Wirkung.",
+      tool: { name: "analyse_text" },
+      input: Type.Object({ text: Type.String({"description": "Der zu analysierende Text."}) }, {"additionalProperties": false}),
+      output: Type.Object({ text: Type.String(), characters: Type.Integer({"minimum": 0}), words: Type.Integer({"minimum": 0}), lines: Type.Integer({"minimum": 0}), analyses: Type.Integer({"minimum": 1}) }, {"additionalProperties": false}),
+      capabilities: [],
+    },
+  },
+} as const;
+`,
+    "src/server.ts": `import { defineActor } from "@ragents/server";
+import { contract } from "./contract.ts";
+
+export default defineActor(contract, {
+  functions: {
+    analyse: async (input, context) => {
+      const text = input.text.trim();
+      const state = context.state.read();
+      const analyses = (state.analyses ?? 0) + 1;
+      context.state.replace({ analyses });
+
+      return {
+        text,
+        characters: text.length,
+        words: text ? text.split(/\\s+/).length : 0,
+        lines: text ? text.split(/\\r?\\n/).length : 0,
+        analyses,
+      };
+    },
+  },
+});
+`,
+    "tests/program.test.ts": `import assert from "node:assert/strict";
+import test from "node:test";
+import type { Static } from "typebox";
+import { createTestContext } from "@ragents/server/testing";
+import { contract } from "../src/contract.ts";
+import program from "../src/server.ts";
+
+test("z\xE4hlt W\xF6rter, Zeilen und weitere Analysen", async () => {
+  const context = createTestContext<Static<typeof contract.state>>({ state: {} });
+  assert.deepEqual(await program.functions.analyse({"text": "  Hallo Welt\\nNeue Zeile  "}, context), {"text": "Hallo Welt\\nNeue Zeile", "characters": 21, "words": 4, "lines": 2, "analyses": 1});
+  assert.deepEqual(await program.functions.analyse({"text": ""}, context), {"text": "", "characters": 0, "words": 0, "lines": 0, "analyses": 2});
+  assert.deepEqual(context.state.read(), {"analyses": 2});
+});
+`
+  }
+};
+var headlessCounter = {
+  id: "headless-counter",
+  title: "Z\xE4hler ohne Oberfl\xE4che",
+  description: "Ein TypeScript-Actor z\xE4hlt Eingaben in seinem Zustand und bietet dieselbe Arbeit als Funktion an.",
+  ragents: {
+    title: "Z\xE4hler",
+    description: "Sammelt eingehende Texte ohne Modellaufrufe oder Oberfl\xE4che.",
+    backend: "src/server.ts"
+  },
+  files: {
+    "src/contract.ts": `import { Type } from "typebox";
+
+const state = Type.Object({
+  texts: Type.Optional(Type.Array(Type.String())),
+  count: Type.Optional(Type.Integer({ minimum: 0 })),
+}, { additionalProperties: false });
+
+export const contract = {
+  state,
+  functions: {
+    record: {
+      label: "Text z\xE4hlen",
+      input: Type.Object({ text: Type.String() }, { additionalProperties: false }),
+      output: Type.Object({ count: Type.Integer(), texts: Type.Array(Type.String()) }, { additionalProperties: false }),
+      tool: { name: "record_text" },
+    },
+    inspect: {
+      label: "Z\xE4hler lesen",
+      input: Type.Object({}, { additionalProperties: false }),
+      output: state,
+      tool: { name: "read_counter" },
+    },
+  },
+  input: { capabilities: [] },
+} as const;
+`,
+    "src/server.ts": `import { defineActor } from "@ragents/server";
+import type { Static } from "typebox";
+import { contract } from "./contract.ts";
+
+const record = (state: Static<typeof contract.state>, text: string) => {
+  const texts = [...(state.texts ?? []), text];
+  return { texts, count: texts.length };
+};
+
+export default defineActor(contract, {
+  functions: {
+    record: (input, context) => {
+      const result = record(context.state.read(), input.text);
+      context.state.replace(result);
+      return result;
+    },
+    inspect: (_input, context) => context.state.read(),
+  },
+  onInput: (input, context) => {
+    context.state.replace(record(context.state.read(), input.content));
+  },
+});
+`,
+    "tests/program.test.ts": `import assert from "node:assert/strict";
+import test from "node:test";
+import type { Static } from "typebox";
+import { createTestContext } from "@ragents/server/testing";
+import { contract } from "../src/contract.ts";
+import program from "../src/server.ts";
+
+test("Eingaben und Funktionen teilen denselben Z\xE4hler", async () => {
+  const context = createTestContext<Static<typeof contract.state>>({ state: {} });
+  for (const content of ["eins", "zwei", "drei"]) {
+    await program.onInput!({ id: content, content, artifactIds: [], sourceEventIds: [], subscriptionId: null, event: null }, context);
+  }
+  assert.deepEqual(await program.functions.inspect({}, context), { texts: ["eins", "zwei", "drei"], count: 3 });
+  assert.deepEqual(await program.functions.record({ text: "vier" }, context), { texts: ["eins", "zwei", "drei", "vier"], count: 4 });
+  assert.deepEqual(context.state.read(), { texts: ["eins", "zwei", "drei", "vier"], count: 4 });
+});
+`
+  }
+};
+var sharedList = {
+  id: "shared-list",
+  title: "Gemeinsame Liste eines Actors",
+  description: "Ein Actor besitzt eine Funktion und eine React-View f\xFCr denselben Listenstand.",
+  ragents: {
+    title: "Gemeinsame Liste",
+    description: "Sammelt Texte aus der App und aus einem Agenten-Werkzeug in einer gemeinsamen Liste.",
+    backend: "src/server.ts",
+    views: [{ id: "main", client: "src/client.tsx" }]
+  },
+  files: {
+    "src/client.tsx": `import React from "react";
+import { createRoot } from "react-dom/client";
+import { context, useAppState } from "@ragents/client";
+import * as UI from "@ragents/client/ui";
+
+type FormValues = Parameters<typeof UI.Form>[0]["values"];
+
+const App = () => {
+  const state = useAppState();
+  const [values, setValues] = React.useState<FormValues>({ text: "" });
+  const [status, setStatus] = React.useState("Bereit");
+  const entries = state.entries ?? [];
+
+  const append = async (next: FormValues): Promise<void> => {
+    const answer = await context.capabilities.call("append", { text: String(next.text ?? "") });
+    setValues({ text: "" });
+    setStatus(\`Hinzugef\xFCgt: \${answer.text}\`);
+  };
+
+  return (
+    <UI.AppLayout title="Gemeinsame Liste" description={<>{entries.length} {entries.length === 1 ? "Eintrag" : "Eintr\xE4ge"}</>}>
+      <UI.Grid>
+        <UI.Form fields={[
+          { id: "text", label: "Neuer Eintrag", type: "textarea", placeholder: "Text eingeben" },
+        ]} values={values} onChange={setValues} onSubmit={append} submitLabel="Hinzuf\xFCgen" />
+        <UI.Stack>
+          <p className="text-muted-foreground" role="status">{status}</p>
+          <ul className="border-t border-border">
+            {entries.map((entry, index) => <li className="min-h-[31px] border-b border-border-soft py-1.5 [overflow-wrap:anywhere]" key={index}>{entry}</li>)}
+          </ul>
+        </UI.Stack>
+      </UI.Grid>
+    </UI.AppLayout>
+  );
+};
+
+const root = document.getElementById("root");
+if (!root) throw new Error("Das Wurzelelement #root fehlt.");
+createRoot(root).render(<App />);
+`,
+    "src/contract.ts": `import { Type } from "typebox";
+
+export const contract = {
+  state: Type.Object({ entries: Type.Optional(Type.Array(Type.String())) }, {"additionalProperties": false}),
+  functions: {
+    append: {
+      label: "Eintrag hinzuf\xFCgen",
+      description: "H\xE4ngt den eingegebenen Text an die gemeinsame Liste an.",
+      input: Type.Object({ text: Type.String({"description": "Der Text f\xFCr den neuen Listeneintrag."}) }, {"additionalProperties": false}),
+      output: Type.Object({ text: Type.String(), entries: Type.Array(Type.String()) }, {"additionalProperties": false}),
+      capabilities: [],
+      tool: { name: "append_to_list", card: true },
+    },
+  },
+} as const;
+`,
+    "src/server.ts": `import { defineActor } from "@ragents/server";
+import { contract } from "./contract.ts";
+
+export default defineActor(contract, {
+  functions: {
+    append: async (input, context) => {
+      const text = input.text.trim();
+      const state = context.state.read();
+      const entries = [...(state.entries ?? []), text];
+      context.state.replace({ entries });
+      return { text, entries };
+    },
+  },
+});
+`,
+    "tests/program.test.ts": `import assert from "node:assert/strict";
+import test from "node:test";
+import type { Static } from "typebox";
+import { createTestContext } from "@ragents/server/testing";
+import { contract } from "../src/contract.ts";
+import program from "../src/server.ts";
+
+test("erg\xE4nzt Eintr\xE4ge ohne vorhandene Eintr\xE4ge zu verlieren", async () => {
+  const context = createTestContext<Static<typeof contract.state>>({ state: {} });
+  assert.deepEqual(await program.functions.append({"text": "  Erster Eintrag  "}, context), {"text": "Erster Eintrag", "entries": ["Erster Eintrag"]});
+  assert.deepEqual(await program.functions.append({"text": "Zweiter Eintrag"}, context), {"text": "Zweiter Eintrag", "entries": ["Erster Eintrag", "Zweiter Eintrag"]});
+  assert.deepEqual(context.state.read(), {"entries": ["Erster Eintrag", "Zweiter Eintrag"]});
+});
+`
+  }
+};
+var runModuleTemplates = [blank, chat, controlsTemplate, textAnalysis, headlessCounter, sharedList];
+var templateFiles = (template, name2) => ({
+  "package.json": `${JSON.stringify({ name: name2, private: true, type: "module", ragents: template.ragents }, null, 2)}
+`,
+  ...template.files
+});
+var templateById = (id) => {
+  const template = runModuleTemplates.find((candidate) => candidate.id === id);
+  if (!template) throw new Error(`Unbekannte Actor-Programm-Vorlage ${id}. G\xFCltig: ${runModuleTemplates.map((entry) => entry.id).join(", ")}.`);
+  return template;
+};
+
+// server/test-report.ts
+import { realpath } from "node:fs/promises";
+var reporterSource = `
+import { inspect } from "node:util";
+const shown = (value) => inspect(value, { depth: 4, breakLength: Infinity, maxArrayLength: 20, maxStringLength: 200 }).slice(0, 300);
+export default async function* (source) {
+  for await (const { type, data } of source) {
+    if (type === "test:pass" && data.details?.type !== "suite") yield JSON.stringify({ kind: "pass" }) + "\\n";
+    if (type === "test:fail" && data.details?.type !== "suite" && data.details?.error?.failureType !== "subtestsFailed") {
+      const error = data.details.error;
+      const cause = error.cause instanceof Error ? error.cause : error;
+      const assertion = cause.code === "ERR_ASSERTION";
+      yield JSON.stringify({ kind: "fail", name: data.name, file: data.file ?? null, line: data.line ?? null, column: data.column ?? null,
+        message: String(cause.message), generated: cause.generatedMessage === true, stack: String(cause.stack ?? ""),
+        ...(assertion ? { expected: shown(cause.expected), actual: shown(cause.actual) } : {}) }) + "\\n";
+    }
+    if (type === "test:stderr") yield JSON.stringify({ kind: "stderr", file: data.file ?? null, message: String(data.message) }) + "\\n";
+  }
+}
+`;
+var testReporterArgument = `--test-reporter=data:text/javascript,${encodeURIComponent(reporterSource)}`;
+var maxDetailed = 10;
+var frameLine = /^\s+at /;
+var errorLines = (lines) => {
+  const meaningful = lines.map((line) => line.trimEnd()).filter((line) => line.trim() !== "" && !frameLine.test(line) && !/^Node\.js v\d/.test(line) && !/^\s*\^+$/.test(line));
+  const named = meaningful.filter((line) => /^[A-Za-z]*Error\b/.test(line));
+  return (named.length > 0 ? named : meaningful.slice(-5)).slice(0, 5);
+};
+var createTestReport = async (directory) => {
+  const roots = [.../* @__PURE__ */ new Set([directory, await realpath(directory)])].sort((left, right) => right.length - left.length);
+  const relative = (text) => roots.reduce((result, root) => result.replaceAll(`file://${root}/`, "").replaceAll(`${root}/`, ""), text);
+  const failures = [];
+  const stderrByFile = /* @__PURE__ */ new Map();
+  const unparsed = [];
+  let passed = 0;
+  let failed2 = 0;
+  let pending = "";
+  const record = (line) => {
+    if (line.trim() === "") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      unparsed.push(line);
+      return;
+    }
+    if (parsed.kind === "pass") passed += 1;
+    if (parsed.kind === "fail") {
+      failed2 += 1;
+      if (failures.length < maxDetailed) failures.push(parsed);
+    }
+    if (parsed.kind === "stderr") {
+      const lines = stderrByFile.get(parsed.file ?? "") ?? [];
+      stderrByFile.set(parsed.file ?? "", [...lines, ...parsed.message.split("\n")].slice(-50));
+    }
+  };
+  const placeOf = (failure) => {
+    const frame = failure.stack.split("\n").filter((line) => frameLine.test(line)).map(relative).map((line) => /\(?([^\s()]+:\d+:\d+)\)?\s*$/.exec(line)?.[1]).find((place) => place !== void 0 && !place.startsWith("/") && !place.startsWith("node:") && !place.includes("node_modules/"));
+    const declared = failure.file === null ? failure.name : `${relative(failure.file)}${failure.line === null ? "" : `:${failure.line}:${failure.column ?? 1}`}`;
+    return frame ?? declared;
+  };
+  const describe = (failure) => {
+    const fileOutput = failure.message === "test failed" && failure.file !== null ? stderrByFile.get(failure.file) ?? stderrByFile.get(relative(failure.file)) : void 0;
+    const message = fileOutput ? errorLines(fileOutput).join("; ") : failure.generated ? failure.message.split("\n")[0].replace(/:$/, "") : failure.message.trim().slice(0, 500);
+    const values = failure.expected === void 0 || failure.expected === failure.actual ? "" : ` - erwartet ${failure.expected}, tats\xE4chlich ${failure.actual}`;
+    return `- ${failure.name} (${placeOf(failure)}): ${relative(message)}${relative(values)}`;
+  };
+  return {
+    stdout: (chunk) => {
+      const lines = (pending + chunk).split("\n");
+      pending = lines.pop() ?? "";
+      lines.forEach(record);
+    },
+    report: (name2, outcome) => {
+      record(pending);
+      pending = "";
+      const summary = outcome.timedOut ? `Tests f\xFCr ${name2} nach Zeit\xFCberschreitung abgebrochen: ${passed} bestanden, ${failed2} fehlgeschlagen.` : `Tests f\xFCr ${name2} fehlgeschlagen: ${passed} bestanden, ${failed2} fehlgeschlagen.`;
+      const details = failures.map(describe);
+      const more = failed2 > failures.length ? [`... und ${failed2 - failures.length} weitere`] : [];
+      const withoutResult = failed2 === 0 ? [`Der Testlauf endete${outcome.code === null ? "" : ` mit Code ${outcome.code}`} ohne fehlgeschlagenen Test:`, ...errorLines([...unparsed, ...outcome.stderr.split("\n")]).map(relative)] : [];
+      return [summary, ...details, ...more, ...withoutResult].join("\n");
+    }
+  };
+};
+
+// server/runtime.ts
+import { FRAME_BODY_CLASS, FRAME_DOCUMENT_CLASS, FRAME_ROOT_CLASS } from "@ragents/host/plugin-support/actor-programs/client-runtime.js";
+import { buildTailwind } from "@ragents/host/plugin-support/actor-programs/tailwind.js";
+var NAME = /^[a-z][a-z0-9-]{0,63}$/;
+var errorText = (error) => error instanceof Error ? error.message : String(error);
+var maxShownComplaints = 10;
+var maxComplaintLength = 240;
+var checkFailure = (title, lines, fallback) => {
+  const all = [...new Set(lines.map((line) => line.trim()).filter((line) => line !== ""))];
+  if (all.length === 0)
+    return new Error(fallback);
+  const shown = all.slice(0, maxShownComplaints).map((line) => line.length > maxComplaintLength ? `${line.slice(0, maxComplaintLength - 3)}...` : line);
+  const omitted = all.length - shown.length;
+  return Object.assign(new Error([
+    `${title}: ${all.length} Fehler.`,
+    ...shown,
+    ...omitted > 0 ? [`... und ${omitted} weitere; alle mit actor_program_diagnostics.`] : []
+  ].join("\n")), { lines: all });
+};
+var actorDescriptionOf = (text) => {
+  const line = (text ?? "").replace(/\s+/g, " ").trim();
+  return line.length <= actorDescriptionMaxLength ? line || void 0 : `${line.slice(0, actorDescriptionMaxLength - 3).trimEnd()}...`;
+};
+var exposed = defineToolAvailability({ availability: "conditional", availabilityDetail: "Ver\xF6ffentlichte Funktion eines aktiven Actors im Run." }, () => true);
+var objectSchema = { type: "object", additionalProperties: true };
+var checked = (schema, value, label) => {
+  const result = jsonValue(value, label);
+  if (!Value.Check(schema, result))
+    throw new Error(`${label}: ${schemaComplaints(schema, result)}`);
+  return result;
+};
+var safePath = (name2) => {
+  if (!name2 || path.isAbsolute(name2) || name2.includes("\\") || name2.includes("\0") || name2.split("/").some((part) => !part || part === "." || part === ".."))
+    throw new Error(`Ung\xFCltiger Paketpfad ${name2}.`);
+  return name2;
+};
+var inside = async (directory, relative) => {
+  const root = await realpath2(directory);
+  const file = await realpath2(path.join(root, safePath(relative)));
+  if (!file.startsWith(`${root}${path.sep}`))
+    throw new Error(`Paketpfad ${relative} liegt au\xDFerhalb des Pakets.`);
+  const stat = await lstat(file);
+  if (!stat.isFile() || stat.size > 2e6)
+    throw new Error(`Ung\xFCltige oder zu gro\xDFe Paketdatei ${relative}.`);
+  return readFile(file, "utf8");
+};
+var occupied = (file) => {
+  try {
+    lstatSync(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+};
+var packageExists = (name2) => new Error(`Das Paket ${name2} existiert bereits.`);
+var commitPackage = (staged, directory, name2) => {
+  if (occupied(directory))
+    throw packageExists(name2);
+  try {
+    renameSync(staged, directory);
+  } catch (error) {
+    if (["EEXIST", "ENOTEMPTY", "ENOTDIR"].includes(error.code ?? ""))
+      throw packageExists(name2);
+    throw error;
+  }
+};
+var descriptor = (tool) => ({ id: tool.name, label: tool.label, description: tool.description, schema: tool.schema, resultSchema: tool.resultSchema });
+var ActorProgramRuntime = class {
+  #options;
+  #queues = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Map();
+  #installing = /* @__PURE__ */ new Set();
+  #creating = /* @__PURE__ */ new Set();
+  #staged = /* @__PURE__ */ new Set();
+  #removing = /* @__PURE__ */ new Set();
+  #knownRuns = /* @__PURE__ */ new Set();
+  #epochs = /* @__PURE__ */ new Map();
+  #stopping = /* @__PURE__ */ new Set();
+  #shuttingDown = false;
+  constructor(options) {
+    this.#options = options;
+  }
+  runtime() {
+    return this.#options.runtime();
+  }
+  view(runId) {
+    return this.runtime().view(runId);
+  }
+  ownerId(runId) {
+    return this.runtime().state(runId).ownerId;
+  }
+  operatorContext(runId, label = "operation") {
+    return { actorId: this.ownerId(runId), commandId: `actor-program:${label}:${randomUUID()}` };
+  }
+  programsOf(view) {
+    return view.pluginStates.flatMap((entry) => {
+      if (entry.pluginId !== ACTOR_PROGRAMS_STATE_ID || entry.scope.kind !== "actor")
+        return [];
+      const state = entry.state;
+      const actorId = entry.scope.actorId;
+      const actor = view.actors.find((candidate) => candidate.id === actorId);
+      return state.program && actor && actor.kind !== "human" && actor.lifecycle.kind !== "stopped" ? [state.program] : [];
+    });
+  }
+  programs(runId) {
+    return this.runtime().listRuns().some((run) => run.id === runId) ? this.programsOf(this.view(runId)) : [];
+  }
+  actor(runId, actorId) {
+    const actor = this.view(runId).actors.find((candidate) => candidate.id === actorId);
+    if (!actor || actor.kind === "human" || actor.lifecycle.kind === "stopped")
+      throw new Error("Der Actor ist nicht aktiv.");
+    if (this.#removing.has(`${runId}\0${actorId}`))
+      throw new Error("Das Actor-Paket wird entfernt.");
+    return actor;
+  }
+  resolveActor(runId, callerId, reference) {
+    const actors = this.view(runId).actors;
+    const found = reference === "self" ? actors.find((candidate) => candidate.id === callerId) : actorByHandle(actors, reference);
+    if (!found)
+      throw new Error(`Actor ${reference} ist unbekannt.`);
+    return this.actor(runId, found.id);
+  }
+  data(runId, actorId) {
+    const view = this.view(runId);
+    const entry = view.pluginStates.find((item) => item.pluginId === ACTOR_STATE_ID && item.scope.kind === "actor" && item.scope.actorId === actorId);
+    const revision = this.runtime().events(runId).filter((event) => (event.type === "plugin.state-replaced" || event.type === "plugin.state-patched") && event.payload.pluginId === ACTOR_STATE_ID && event.payload.scope.kind === "actor" && event.payload.scope.actorId === actorId).at(-1)?.sequence ?? 0;
+    return { version: 1, revision, values: entry?.state ?? {} };
+  }
+  #writeProgram(context, runId, actorId, program) {
+    this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_PROGRAMS_STATE_ID, scope: { kind: "actor", actorId }, state: jsonValue({ version: 1, program }, "Actor-Programm") });
+  }
+  #script(runId) {
+    return this.view(runId).pluginStates.find((entry) => entry.pluginId === ACTOR_SCRIPT_STATE_ID && entry.scope.kind === "run")?.state;
+  }
+  async #writeSources(directory, files) {
+    for (const source of files) {
+      const file = path.join(directory, safePath(source.path));
+      if (source.path.split("/").includes("node_modules"))
+        throw new Error("Paketquellen d\xFCrfen keine Abh\xE4ngigkeiten \xFCberschreiben.");
+      await mkdir(path.dirname(file), { recursive: true });
+      await writeFile(file, source.content, { flag: "wx" });
+    }
+  }
+  async #refresh(runId, program, signal) {
+    const script = this.#script(runId);
+    const files = script ? this.#options.scriptSources(script.entryId, program.name) : void 0;
+    if (files) {
+      const directory = path.join(await this.workspaceDirectory(runId), program.name);
+      for (const entry of await readdir(directory))
+        if (entry !== "node_modules")
+          await rm(path.join(directory, entry), { recursive: true, force: true });
+      await this.#writeSources(directory, files);
+    }
+    try {
+      await this.#activate(this.operatorContext(runId, "refresh"), runId, program.name, false, signal);
+    } catch (error) {
+      throw new Error(`Der Capability-Vertrag von ${program.name} hat sich ge\xE4ndert und die Neuaktivierung scheiterte: ${errorText(error)}`);
+    }
+  }
+  async #bound(runId, actorId, revision, signal, contractOf, descriptorsFor) {
+    const current = () => {
+      const program2 = this.programs(runId).find((entry) => entry.actorId === actorId);
+      if (!program2)
+        throw new Error("Der Actor besitzt kein aktives Programm.");
+      return program2;
+    };
+    const bind = (program2) => {
+      const contract = contractOf(program2);
+      const descriptors = descriptorsFor(contract.capabilityIds);
+      return { program: program2, contract, descriptors, drifted: runCapabilityContractHash2(descriptors) !== contract.capabilityContractHash };
+    };
+    const program = current();
+    if (revision !== void 0 && program.revision !== revision)
+      throw new Error("Das Actor-Paket wurde ersetzt.");
+    const bound = bind(program);
+    if (!bound.drifted)
+      return bound;
+    await this.#refresh(runId, program, signal);
+    const refreshed = bind(current());
+    if (refreshed.drifted)
+      throw new Error(`Der Capability-Vertrag von ${program.name} weicht auch nach der Neuaktivierung ab.`);
+    return refreshed;
+  }
+  async workspaceDirectory(runId) {
+    this.#knownRuns.add(runId);
+    return prepareAppWorkspace(path.join(this.#options.directoryFor(runId), "actor-workspace"));
+  }
+  templates() {
+    return runModuleTemplates.map(({ id, title, description }) => ({ id, title, description }));
+  }
+  async #create(runId, name2, build) {
+    this.#assertName(name2);
+    const actors = await this.workspaceDirectory(runId);
+    const directory = path.join(actors, name2);
+    const key = `${runId}\0${name2}`;
+    if (this.#creating.has(key))
+      throw new Error(`Das Paket ${name2} wird gerade angelegt.`);
+    if (occupied(directory))
+      throw packageExists(name2);
+    this.#creating.add(key);
+    const staging = path.join(path.dirname(actors), ".staging");
+    const staged = path.join(staging, `${name2}-${randomUUID()}`);
+    this.#staged.add(staged);
+    try {
+      await mkdir(staging, { recursive: true });
+      for (const entry of await readdir(staging))
+        if (!this.#staged.has(path.join(staging, entry)))
+          await rm(path.join(staging, entry), { recursive: true, force: true });
+      await mkdir(staged);
+      const built = await build(staged);
+      commitPackage(staged, directory, name2);
+      return { directory, built };
+    } finally {
+      this.#creating.delete(key);
+      this.#staged.delete(staged);
+      await rm(staged, { recursive: true, force: true });
+    }
+  }
+  async scaffold(runId, name2, templateId) {
+    const sources = Object.entries(templateFiles(templateById(templateId), name2)).map(([file, content]) => ({ path: file, content }));
+    const { built: files } = await this.#create(runId, name2, async (directory) => {
+      await this.#writeSources(directory, sources);
+      await prepareAppProject(directory);
+      const pkg = await readAppPackage(directory);
+      const backend = pkg.backend ? await compileAppBackend({ directory, backend: pkg.backend, runId, executor: this.runtime().nativeTypeScriptExecutor }) : void 0;
+      await installClientSdk(directory, { stateSchema: backend?.contract.state ?? objectSchema, actions: Object.entries(backend?.contract.functions ?? {}).map(([id, fn]) => ({ id, inputSchema: fn.input, resultSchema: fn.output })) });
+      return (await projectSourceFiles(directory)).map((file) => file.path);
+    });
+    return { name: name2, directory: `@actors/${name2}`, files };
+  }
+  async importPackage(context, runId, name2, files, signal, scriptEntryId) {
+    const { directory } = await this.#create(runId, name2, (staged) => this.#writeSources(staged, files));
+    try {
+      if (scriptEntryId)
+        this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_SCRIPT_STATE_ID, scope: { kind: "run" }, state: { version: 1, entryId: scriptEntryId } });
+      await this.activate(context, runId, name2, signal);
+      const program = this.programs(runId).find((entry) => entry.name === name2);
+      return { name: name2, actorId: program.actorId, actorHandle: program.actorHandle, views: program.views.length };
+    } catch (error) {
+      await rm(directory, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async check(runId, name2, callerId, signal, reference) {
+    this.#assertName(name2);
+    const directory = path.join(await this.workspaceDirectory(runId), name2);
+    if ((await lstat(directory)).isSymbolicLink())
+      throw new Error("Actor-Pakete d\xFCrfen keine Symlinks sein.");
+    await prepareAppProject(directory);
+    const pkg = await readAppPackage(directory);
+    const previous = this.programs(runId).find((program) => program.name === name2);
+    const owner = reference ? this.resolveActor(runId, callerId, reference) : previous ? this.actor(runId, previous.actorId) : !pkg.backend ? this.actor(runId, callerId) : void 0;
+    if (previous && owner?.id !== previous.actorId)
+      throw new Error("Ein aktiviertes Paket kann nicht zu einem anderen Actor wechseln.");
+    const caller = this.view(runId).actors.find((candidate) => candidate.id === callerId);
+    if (!caller)
+      throw new Error("Aufrufender Actor fehlt.");
+    const provisional = owner ?? {
+      id: "pending",
+      handle: name2,
+      displayName: pkg.title,
+      kind: "script",
+      grants: caller.grants.filter((grant) => grant.delegable),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: callerId,
+      description: actorDescriptionOf(pkg.description) ?? null,
+      execution: { driver: { kind: "script", config: {} }, workspacePath: null, turnTimeoutMs: null },
+      lifecycle: { kind: "idle", since: (/* @__PURE__ */ new Date()).toISOString() },
+      usage: emptyUsage(),
+      toolNames: null,
+      openedToolNames: []
+    };
+    const available2 = (await this.#options.agentToolsFor(runId, provisional.id, owner ? void 0 : provisional)).map(descriptor);
+    for (const operation of this.#options.operations.list())
+      if (operation.operator !== "unavailable" && !available2.some((entry) => entry.id === operation.id))
+        available2.push(operation);
+    await installServerSdk(directory, available2);
+    const backend = pkg.backend ? await compileAppBackend({ directory, backend: pkg.backend, runId, executor: this.runtime().nativeTypeScriptExecutor, signal }) : void 0;
+    const contract = backend?.contract ?? { state: objectSchema, functions: {} };
+    if (contract.input && owner?.kind === "agent")
+      throw new Error("Ein LLM-Actor verarbeitet Eingaben mit seinem Agententreiber; onInput ist nur f\xFCr TypeScript-Actors erlaubt.");
+    if (contract.state.type !== "object")
+      throw new Error("Actor-Zustand muss ein Object-Schema sein.");
+    const state = owner ? this.data(runId, owner.id).values : {};
+    checked(contract.state, state, "Actor-Zustand");
+    const actorId = owner?.id ?? "pending";
+    const actorHandle = owner?.handle ?? name2;
+    const functions = Object.entries(contract.functions).map(([id, fn]) => {
+      if (!/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(id))
+        throw new Error(`Ung\xFCltiger Funktionsname ${id}.`);
+      if (fn.tool && !/^[a-z][a-z0-9_]{0,63}$/.test(fn.tool.name))
+        throw new Error(`Ung\xFCltiger Werkzeugname ${fn.tool.name}.`);
+      const capabilities = fn.capabilities ?? [];
+      const selected2 = capabilities.map((name3) => {
+        const entry = available2.find((item) => item.id === name3);
+        if (!entry)
+          throw new Error(`Capability ${name3} ist nicht verf\xFCgbar.`);
+        return entry;
+      });
+      return {
+        id,
+        label: fn.label,
+        description: fn.description ?? fn.label,
+        inputSchema: fn.input,
+        resultSchema: fn.output,
+        capabilityIds: capabilities,
+        capabilityContractHash: runCapabilityContractHash2(selected2),
+        confirmation: fn.confirmation ?? null,
+        ...fn.tool ? { tool: { name: fn.tool.name, targets: fn.tool.targets ? fn.tool.targets.map((target) => target === "self" ? actorId : this.resolveActor(runId, callerId, target).id) : null, card: fn.tool.card ?? true } } : {}
+      };
+    });
+    const inputCapabilities = contract.input?.capabilities ?? [];
+    const inputDescriptors = inputCapabilities.map((id) => {
+      const found = available2.find((entry) => entry.id === id);
+      if (!found)
+        throw new Error(`Eingabe-Capability ${id} ist nicht verf\xFCgbar.`);
+      return found;
+    });
+    await installClientSdk(directory, { stateSchema: contract.state, actions: functions.map((fn) => ({ id: fn.id, inputSchema: fn.inputSchema, resultSchema: fn.resultSchema })) });
+    const hasServerFiles = pkg.backend || (await projectSourceFiles(directory)).some((file) => /^tests\/.*\.tsx?$/.test(file.path));
+    const serverErrors = hasServerFiles ? typecheckServerProject(directory, pkg.backend) : [];
+    if (serverErrors.length)
+      throw checkFailure(`Typpr\xFCfung von ${name2}`, serverErrors, `Die Typpr\xFCfung von ${name2} schlug ohne Meldung fehl.`);
+    const clients = [];
+    const views = [];
+    for (const view of pkg.views ?? []) {
+      const client = await compileClientProject({ directory, entryPoint: view.client, stateSchema: contract.state, actions: functions.map((fn) => ({ id: fn.id, inputSchema: fn.inputSchema, resultSchema: fn.resultSchema })) });
+      if (!client.valid)
+        throw checkFailure(
+          `Client-Build von ${view.client}`,
+          client.diagnostics.filter((item) => item.category === "error").map((item) => `${item.fileName ?? view.client}${item.start ? `:${item.start.line}:${item.start.column}` : ""} ${item.message.replace(/\s*\n\s*/g, " ")}`),
+          `Der Client-Build von ${view.client} schlug ohne Meldung fehl.`
+        );
+      const styles = view.styles ? await inside(directory, view.styles) : "";
+      if (/@import\b|url\s*\(\s*["']?\s*(?:https?:|\/\/)/i.test(styles))
+        throw new Error("Ansichts-CSS darf keine externen Ressourcen laden.");
+      const clientFile = `view-${view.id}.mjs`;
+      clients.push({ file: clientFile, javaScript: client.javaScript });
+      views.push({
+        id: `${name2}--${view.id}`,
+        key: view.id,
+        title: view.title ?? pkg.title,
+        visible: previous?.views.find((item) => item.key === view.id)?.visible ?? true,
+        placements: [{ kind: "canvas", anchorActorId: actorId }],
+        html: `<!doctype html><html class="${FRAME_DOCUMENT_CLASS}"><head><meta charset="utf-8"></head><body class="${FRAME_BODY_CLASS}"><div id="root" class="${FRAME_ROOT_CLASS}"></div></body></html>`,
+        styles,
+        clientFile
+      });
+    }
+    const viewSources = [...new Set((pkg.views ?? []).map((view) => path.dirname(path.resolve(directory, view.client))))];
+    const frameStyles = viewSources.length > 0 ? await buildTailwind(viewSources) : "";
+    const files = await projectSourceFiles(directory);
+    const revision = canonicalHash({ files, backend: backend?.javaScript ?? null, clients });
+    const definition = {
+      name: name2,
+      title: pkg.title,
+      description: pkg.description ?? "",
+      actorId,
+      actorHandle,
+      revision,
+      installedBy: previous?.installedBy ?? callerId,
+      directory: path.join(this.#options.directoryFor(runId), "actor-builds", name2, revision),
+      sourceDirectory: directory,
+      ...backend ? { backendFile: "server.mjs" } : {},
+      stateSchema: contract.state,
+      stylesFile: "frame.css",
+      functions,
+      views,
+      ...contract.input ? { input: { capabilityIds: inputCapabilities, capabilityContractHash: runCapabilityContractHash2(inputDescriptors) } } : {}
+    };
+    return { directory, files, definition, clients, frameStyles, createActor: !owner, ...backend ? { backendJavaScript: backend.javaScript } : {} };
+  }
+  activate(context, runId, name2, signal, reference) {
+    return this.#activate(context, runId, name2, true, signal, reference);
+  }
+  async #activate(context, runId, name2, idle, signal, reference) {
+    const key = `${runId}\0${name2}`;
+    if (this.#installing.has(key))
+      throw new Error(`Paket ${name2} wird bereits aktiviert.`);
+    const epoch = this.invocationPermit(runId);
+    this.#installing.add(key);
+    const original = this.programs(runId).find((item) => item.name === name2);
+    let compiled;
+    let published = false;
+    try {
+      compiled = await this.check(runId, name2, context.actorId, signal, reference);
+      const definition = compiled.definition;
+      const tests = compiled.files.filter((file) => /^tests\/.*\.test\.tsx?$/.test(file.path));
+      if (tests.length) {
+        const processContext = await this.#options.serverProcessContextFor(runId);
+        const report = await createTestReport(compiled.directory);
+        let stderr = "";
+        const launch = await sandboxedLaunch(processContext, { command: process.execPath, args: ["--import", "tsx", "--test", testReporterArgument, ...tests.map((file) => file.path)] });
+        const result = await runManagedProcess({
+          command: launch.command,
+          args: [...launch.args],
+          cwd: compiled.directory,
+          env: processContext.env,
+          uid: processContext.uid,
+          gid: processContext.gid,
+          label: `Tests ${name2}`,
+          signal,
+          timeoutMs: 6e4,
+          onStdout: (chunk) => report.stdout(chunk.toString()),
+          onStderr: (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-12e3);
+          }
+        });
+        if (result.code !== 0 || result.timedOut)
+          throw new Error(report.report(name2, { code: result.code, timedOut: result.timedOut, stderr }));
+      }
+      if (canonicalHash(compiled.files) !== canonicalHash(await projectSourceFiles(compiled.directory)))
+        throw new Error("Paketdateien wurden w\xE4hrend der Pr\xFCfung ge\xE4ndert; erneut aktivieren.");
+      if (epoch !== this.invocationPermit(runId))
+        throw new Error("Der Run wurde w\xE4hrend der Aktivierung gestoppt.");
+      if (this.programs(runId).find((item) => item.name === name2)?.revision !== original?.revision)
+        throw new Error("Das Paket wurde zwischenzeitlich ge\xE4ndert.");
+      if (idle)
+        this.#assertIdle(runId, definition.actorId);
+      const names = /* @__PURE__ */ new Set([...agentTools.map((tool) => tool.name), ...this.#options.reservedToolNames(), ...this.programs(runId).filter((program) => program.name !== name2).flatMap((program) => program.functions.flatMap((fn) => fn.tool ? [fn.tool.name] : []))]);
+      for (const fn of definition.functions)
+        if (fn.tool) {
+          if (names.has(fn.tool.name))
+            throw new Error(`Werkzeugname ${fn.tool.name} ist bereits vergeben.`);
+          names.add(fn.tool.name);
+        }
+      const occupied2 = this.programs(runId).find((program) => program.actorId === definition.actorId && program.name !== name2);
+      if (occupied2)
+        throw new Error(`Actor @${definition.actorHandle} besitzt bereits das Paket ${occupied2.name}. Erg\xE4nze darin Funktionen oder Ansichten.`);
+      await mkdir(definition.directory, { recursive: true });
+      for (const source of compiled.files) {
+        const file = path.join(definition.directory, safePath(source.path));
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, source.content);
+      }
+      await prepareAppProject(definition.directory);
+      if (compiled.backendJavaScript !== void 0)
+        await writeFile(path.join(definition.directory, "server.mjs"), compiled.backendJavaScript);
+      for (const client of compiled.clients)
+        await writeFile(path.join(definition.directory, client.file), client.javaScript);
+      await writeFile(path.join(definition.directory, definition.stylesFile), compiled.frameStyles);
+      await writeFile(path.join(definition.directory, "sources.json"), JSON.stringify(compiled.files));
+      await syncWorkspaceOwnership(definition.directory, await this.#options.serverProcessContextFor(runId));
+      signal?.throwIfAborted();
+      if (epoch !== this.invocationPermit(runId))
+        throw new Error("Der Run wurde w\xE4hrend der Aktivierung gestoppt.");
+      if (this.programs(runId).find((item) => item.name === name2)?.revision !== original?.revision)
+        throw new Error("Das Paket wurde zwischenzeitlich ge\xE4ndert.");
+      if (!compiled.createActor) {
+        this.actor(runId, definition.actorId);
+        if (idle)
+          this.#assertIdle(runId, definition.actorId);
+        checked(definition.stateSchema, this.data(runId, definition.actorId).values, "Actor-Zustand");
+        if (this.programs(runId).some((item) => item.actorId === definition.actorId && item.name !== name2))
+          throw new Error("Der Actor besitzt inzwischen ein anderes Paket.");
+      }
+      const currentNames = /* @__PURE__ */ new Set([...agentTools.map((tool) => tool.name), ...this.#options.reservedToolNames(), ...this.programs(runId).filter((program) => program.name !== name2).flatMap((program) => program.functions.flatMap((fn) => fn.tool ? [fn.tool.name] : []))]);
+      for (const fn of definition.functions)
+        if (fn.tool) {
+          if (currentNames.has(fn.tool.name))
+            throw new Error(`Werkzeugname ${fn.tool.name} ist inzwischen vergeben.`);
+          currentNames.add(fn.tool.name);
+        }
+      jsonValue({ version: 1, program: definition }, "Actor-Programm");
+      if (compiled.createActor) {
+        const actors = this.view(runId).actors;
+        const caller = actors.find((actor2) => actor2.id === context.actorId);
+        const holder = actors.find((actor2) => actor2.handle === name2);
+        if (holder?.kind === "script" && holder.lifecycle.kind === "stopped") {
+          checked(definition.stateSchema, this.data(runId, holder.id).values, "Actor-Zustand");
+          this.runtime().restartActor(context, runId, holder.id, "Actor-Paket erneut aktiviert");
+        } else if (holder)
+          throw new Error(`Handle @${name2} geh\xF6rt bereits dem ${holder.kind !== "human" && holder.lifecycle.kind === "stopped" ? "gestoppten" : "aktiven"} Actor ${holder.displayName}; nur ein gestoppter TypeScript-Actor wird beim Aktivieren neu gestartet. W\xE4hle einen anderen Paketnamen.`);
+        else
+          this.runtime().createScriptActor(context, runId, { handle: name2, displayName: definition.title, description: actorDescriptionOf(definition.description), grants: caller.grants.filter((grant) => grant.delegable), toolNames: null });
+        const actor = this.resolveActor(runId, context.actorId, `@${name2}`);
+        definition.actorId = actor.id;
+        definition.actorHandle = actor.handle;
+        for (const view of definition.views)
+          for (const placement of view.placements)
+            placement.anchorActorId = actor.id;
+        for (const fn of definition.functions)
+          if (fn.tool?.targets)
+            fn.tool.targets = fn.tool.targets.map((target) => target === "pending" ? actor.id : target);
+      }
+      signal?.throwIfAborted();
+      this.#writeProgram(context, runId, definition.actorId, definition);
+      published = true;
+      if (original && original.revision !== definition.revision)
+        await this.runtime().nativeTypeScriptExecutor.stopInstance(runId, this.#instance(original));
+      return { name: name2, actor: `@${definition.actorHandle}`, views: definition.views.length, active: true };
+    } finally {
+      this.#installing.delete(key);
+      if (!published && compiled && compiled.definition.revision !== original?.revision)
+        await rm(compiled.definition.directory, { recursive: true, force: true });
+    }
+  }
+  list(runId) {
+    return this.programs(runId).map((program) => ({ name: program.name, actor: `@${program.actorHandle}`, functions: program.functions.map((fn) => fn.id), views: program.views.map((view) => ({ name: view.key, title: view.title, visible: view.visible })) }));
+  }
+  async remove(context, runId, name2) {
+    const program = this.#program(runId, name2);
+    this.#assertIdle(runId, program.actorId);
+    if (this.#installing.has(`${runId}\0${name2}`))
+      throw new Error("Das Paket wird gerade aktiviert.");
+    const actor = this.actor(runId, program.actorId);
+    const key = `${runId}\0${program.actorId}`;
+    this.#removing.add(key);
+    try {
+      await this.stopActor(runId, program.actorId);
+      this.#writeProgram(context, runId, program.actorId, null);
+      if (actor.kind === "script")
+        this.runtime().stopActor(context, runId, program.actorId, "Actor-Paket entfernt");
+      await rm(program.directory, { recursive: true, force: true });
+    } finally {
+      this.#removing.delete(key);
+    }
+    return { removed: name2 };
+  }
+  setVisibility(context, runId, reference, visible) {
+    const { program, view } = resolveActorView(this.programs(runId), reference);
+    this.#writeProgram(context, runId, program.actorId, { ...program, views: program.views.map((item) => item.id === view.id ? { ...item, visible } : item) });
+    return { view: `${program.name}/${view.key}`, visible };
+  }
+  apps(runId) {
+    return this.programs(runId).flatMap((program) => program.views.map((view) => ({
+      id: view.id,
+      actorId: program.actorId,
+      actorHandle: program.actorHandle,
+      title: view.title,
+      description: program.description,
+      revision: program.revision,
+      actions: program.functions.map(({ id, label, description, confirmation }) => ({ id, label, description, confirmation })),
+      placements: view.placements,
+      visible: view.visible,
+      state: this.data(runId, program.actorId),
+      invocations: this.#invocations(runId).invocations.filter((invocation) => invocation.actorId === program.actorId && invocation.revision === program.revision)
+    })));
+  }
+  runLocalTools(runId) {
+    if (!this.runtime().listRuns().some((run) => run.id === runId))
+      return [];
+    const view = this.view(runId);
+    return this.programs(runId).flatMap((program) => program.functions.flatMap((fn) => fn.tool ? [{
+      moduleId: program.name,
+      name: fn.tool.name,
+      description: fn.description,
+      card: fn.tool.card,
+      actorId: program.actorId,
+      actorHandle: program.actorHandle,
+      functionId: fn.id,
+      revision: program.revision,
+      sourceHash: program.revision,
+      installedBy: program.installedBy,
+      parameters: Object.entries(fn.inputSchema.properties ?? {}).map(([name2, schema]) => ({ name: name2, type: ["string", "number", "integer", "boolean"].includes(schema.type ?? "") ? schema.type ?? "json" : "json", description: schema.description ?? name2, required: (fn.inputSchema.required ?? []).includes(name2) })),
+      targets: (fn.tool.targets ?? view.actors.filter((actor) => actor.kind !== "human" && actor.lifecycle.kind !== "stopped").map((actor) => actor.id)).map((actorId) => ({ actorId, handle: view.actors.find((actor) => actor.id === actorId)?.handle ?? null }))
+    }] : []));
+  }
+  async moduleSource(runId, reference) {
+    const program = this.#program(runId, reference);
+    return { files: JSON.parse(await readFile(path.join(program.directory, "sources.json"), "utf8")) };
+  }
+  frame(runId, viewId, revision) {
+    const program = this.#program(runId, viewId);
+    const view = program.views.find((item) => item.id === viewId);
+    if (!view || program.revision !== revision)
+      throw new Error("Die Ansicht wurde ersetzt oder entfernt.");
+    if (!program.stylesFile)
+      throw new Error("Das Programm stammt aus einer \xE4lteren Aktivierung ohne Stylesheet-Datei. Bitte erneut aktivieren.");
+    const frameStyles = readFileSync(path.join(program.directory, program.stylesFile), "utf8");
+    return { ...view, styles: `${frameStyles}
+${view.styles}`, platformVersion: 2, clientJavaScript: readFileSync(path.join(program.directory, view.clientFile), "utf8") };
+  }
+  installedTools(context) {
+    return this.programsOf(context.view).flatMap((program) => program.functions.flatMap((fn) => !fn.tool || fn.tool.targets && !fn.tool.targets.includes(context.actorId) ? [] : [defineRunFunction({
+      name: fn.tool.name,
+      label: fn.label,
+      description: fn.description,
+      schema: fn.inputSchema,
+      resultSchema: fn.resultSchema,
+      available: exposed,
+      executionMode: "sequential",
+      run: async (scope, id, input) => {
+        const descriptorsFor = (capabilityIds) => agentCapabilityBinding(context.actor, scope.availableFunctions(), capabilityIds, /* @__PURE__ */ new Set()).descriptors;
+        return this.#executeFunction(context.runId, program, fn, input, { id, kind: "tool", principal: { id: context.actorId, kind: context.actor.kind === "script" ? "script" : "agent" }, descriptorsFor, call: (name2, value, index) => scope.invokeFunction(`${id}:capability:${index}`, name2, value) }, scope.signal ?? new AbortController().signal);
+      }
+    })]));
+  }
+  async #serial(runId, actorId, signal, execute) {
+    const permit = this.invocationPermit(runId);
+    const key = `${runId}\0${actorId}`;
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    const operation = previous.then(() => {
+      signal.throwIfAborted();
+      if (permit !== this.invocationPermit(runId))
+        throw new Error("Der Run wurde vor dem Funktionsstart gestoppt.");
+      this.actor(runId, actorId);
+      return execute();
+    });
+    const queued = operation.then(() => void 0, () => void 0);
+    this.#queues.set(key, queued);
+    try {
+      return await operation;
+    } finally {
+      if (this.#queues.get(key) === queued)
+        this.#queues.delete(key);
+    }
+  }
+  async #backend(runId, program, input, binding, descriptors, signal) {
+    if (!program.backendFile)
+      throw new Error("Der Actor besitzt kein TypeScript-Backend.");
+    const current = this.#program(runId, program.name);
+    if (current.revision !== program.revision)
+      throw new Error("Das Actor-Paket wurde ersetzt.");
+    const logs = [];
+    let calls = 0;
+    const initial = this.data(runId, program.actorId);
+    const result = await this.runtime().nativeTypeScriptExecutor.execute({
+      program: { entry: program.backendFile, files: [{ fileName: program.backendFile, text: await readFile(path.join(program.directory, program.backendFile), "utf8") }], exportName: "handle" },
+      instanceId: this.#instance(program),
+      cwd: program.directory,
+      input,
+      state: initial.values,
+      std: { now: (/* @__PURE__ */ new Date()).toISOString(), idPrefix: binding.id },
+      context: { runId, actor: { id: program.actorId, handle: program.actorHandle }, invocationId: binding.id, invocationKind: binding.kind, principal: binding.principal, capabilities: descriptors }
+    }, { signal, log: (value) => {
+      if (logs.length < 100)
+        logs.push((typeof value === "string" ? value : JSON.stringify(value)).slice(0, 2e3));
+    }, call: async (name2, value) => {
+      const capability = descriptors.find((entry) => entry.id === name2);
+      if (!capability)
+        throw new Error(`Capability ${name2} ist nicht deklariert.`);
+      if (++calls > 64)
+        throw new Error("Ein Aufruf darf h\xF6chstens 64 Capabilities ausf\xFChren.");
+      if (program.functions.some((fn) => fn.tool?.name === name2))
+        throw new Error("Eine Actor-Funktion darf sich nicht \xFCber ein Werkzeug selbst aufrufen; verwende eine gemeinsame TypeScript-Funktion.");
+      checked(capability.schema, value, `Eingabe ${name2}`);
+      const output = await binding.call(name2, value, calls);
+      return checked(capability.resultSchema, output, `Ergebnis ${name2}`);
+    } });
+    signal.throwIfAborted();
+    this.actor(runId, program.actorId);
+    const state = checked(program.stateSchema, result.state, "Actor-Zustand");
+    return { result: result.result, logs, state, initial };
+  }
+  #commitState(runId, actorId, state, initial) {
+    if (canonicalHash(state) === canonicalHash(initial.values))
+      return;
+    if (this.data(runId, actorId).revision !== initial.revision)
+      throw new Error("Der Actor-Zustand wurde w\xE4hrend des Aufrufs ge\xE4ndert. Erneut aufrufen.");
+    this.runtime().replaceActorState(this.operatorContext(runId), runId, actorId, state);
+  }
+  #executeFunction(runId, bound, declared, input, binding, signal) {
+    const functionOf = (program) => {
+      const fn = program.functions.find((entry) => entry.id === declared.id);
+      if (!fn)
+        throw new Error("Die Funktion ist nicht deklariert.");
+      return fn;
+    };
+    return this.#serial(runId, bound.actorId, signal, async () => {
+      const { program, contract: fn, descriptors } = await this.#bound(runId, bound.actorId, bound.revision, signal, functionOf, binding.descriptorsFor);
+      const value = checked(fn.inputSchema, input, `Eingabe ${fn.id}`);
+      const result = await this.#backend(runId, program, { kind: "function", functionId: fn.id, input: value }, binding, descriptors, signal);
+      const output = checked(fn.resultSchema, result.result, `Ergebnis ${fn.id}`);
+      this.#commitState(runId, program.actorId, result.state, result.initial);
+      binding.output?.push(...result.logs);
+      return output;
+    });
+  }
+  async runInput(request, signal) {
+    this.#knownRuns.add(request.runId);
+    try {
+      const inputOf = (program) => {
+        if (!program.input)
+          throw new Error("Dieser TypeScript-Actor besitzt keinen onInput-Handler.");
+        return program.input;
+      };
+      const descriptorsFor = (capabilityIds) => agentCapabilityBinding(this.actor(request.runId, request.agentId), request.tools, capabilityIds, /* @__PURE__ */ new Set()).descriptors;
+      await this.#serial(request.runId, request.agentId, signal, async () => {
+        const { program, descriptors } = await this.#bound(request.runId, request.agentId, void 0, signal, inputOf, descriptorsFor);
+        const binding = { id: request.turnId, kind: "input", principal: { id: request.agentId, kind: "script" }, descriptorsFor, call: (name2, input, index) => request.invoke(`${request.turnId}:capability:${index}`, name2, input) };
+        const result = await this.#backend(request.runId, program, { kind: "input", input: scriptInputOf(request.input) }, binding, descriptors, signal);
+        this.#commitState(request.runId, request.agentId, result.state, result.initial);
+        for (const text of result.logs)
+          request.emit({ kind: "runtime", text });
+      });
+      return { failure: null, usage: emptyUsage() };
+    } catch (error) {
+      return { failure: errorText(error), usage: emptyUsage() };
+    }
+  }
+  invocationPermit(runId) {
+    if (this.#shuttingDown || this.#stopping.has(runId))
+      throw new Error("Der Run wird gestoppt.");
+    return this.#epochs.get(runId) ?? 0;
+  }
+  startInvocation(runId, viewId, revision, functionId, requestId, input, permit = this.invocationPermit(runId)) {
+    const program = this.#program(runId, viewId);
+    if (!program.views.some((view) => view.id === viewId))
+      throw new Error("Die Ansicht ist unbekannt.");
+    return this.#start(runId, program, viewId, revision, functionId, requestId, input, permit);
+  }
+  startFunctionInvocation(runId, actorHandle, revision, functionId, requestId, input, permit = this.invocationPermit(runId)) {
+    const program = this.programs(runId).find((entry) => entry.actorHandle === handleKey(actorHandle));
+    if (!program)
+      throw new Error("Der Actor ver\xF6ffentlicht kein Programm.");
+    return this.#start(runId, program, program.name, revision, functionId, requestId, input, permit);
+  }
+  #start(runId, program, viewId, revision, functionId, requestId, input, permit) {
+    this.#knownRuns.add(runId);
+    if (permit !== this.invocationPermit(runId))
+      throw new Error("Der Run wurde inzwischen gestoppt.");
+    if (program.revision !== revision)
+      throw new Error("Das Actor-Paket wurde ersetzt. Ansicht aktualisieren.");
+    const fn = program.functions.find((entry) => entry.id === functionId);
+    if (!fn)
+      throw new Error("Die Funktion ist nicht deklariert.");
+    const state = this.#invocations(runId);
+    const prior = state.invocations.find((entry) => entry.requestId === requestId);
+    if (prior) {
+      if (prior.actorId !== program.actorId || prior.actionId !== functionId || prior.revision !== revision || canonicalHash(prior.input) !== canonicalHash(input))
+        throw new Error("Die Request-ID wurde bereits f\xFCr einen anderen Aufruf verwendet.");
+      return prior;
+    }
+    if (!requestId || requestId.length > 200 || state.requestIds.includes(requestId))
+      throw new Error("Ung\xFCltige oder bereits verarbeitete Request-ID.");
+    if (state.requestIds.length >= 1e4)
+      throw new Error("Der Run hat seine Aufrufgrenze erreicht.");
+    if ([...this.#active.values()].filter((entry) => entry.runId === runId).length >= 8)
+      throw new Error("Es laufen bereits acht Actor-Funktionen.");
+    checked(fn.inputSchema, input, "Funktionseingabe");
+    const invocation = { id: randomUUID(), requestId, actorId: program.actorId, actorHandle: program.actorHandle, appId: viewId, revision, actionId: functionId, input, output: [], createdAt: (/* @__PURE__ */ new Date()).toISOString(), status: "queued" };
+    this.#replaceInvocation(runId, invocation, true);
+    const controller = new AbortController();
+    const completed = Promise.resolve().then(async () => {
+      const started = { ...invocation, status: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      this.#replaceInvocation(runId, started);
+      try {
+        if (fn.confirmation && !await this.#confirm(runId, invocation, fn.confirmation, controller.signal))
+          throw new Error("Die Funktion wurde nicht best\xE4tigt.");
+        const descriptorsFor = (capabilityIds) => operatorCapabilityBinding(this.ownerId(runId), this.#options.operations.list(), capabilityIds).descriptors;
+        const output = [];
+        const result = await this.#executeFunction(runId, program, fn, input, { output, id: invocation.id, kind: "app-action", principal: { id: this.ownerId(runId), kind: "operator" }, descriptorsFor, call: async (name2, value, index) => {
+          const operation = this.#options.operations.operation(name2);
+          const id = `${invocation.id}:capability:${index}`;
+          const confirmation = operation.operator === "confirm" ? await this.#confirm(runId, invocation, `${operation.label} ausf\xFChren?`, controller.signal, value) : true;
+          if (!confirmation)
+            throw new Error("Die Aktion wurde nicht best\xE4tigt.");
+          return this.#options.operations.invoke(name2, { runId, invocationId: id, principal: { kind: "operator", actorId: this.ownerId(runId) }, signal: controller.signal, ...operation.operator === "confirm" ? { operatorConfirmation: { operationId: name2, invocationId: id, inputHash: canonicalHash(value) } } : {} }, value);
+        } }, controller.signal);
+        this.#replaceInvocation(runId, { ...started, status: "succeeded", result, output, finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      } catch (error) {
+        this.#replaceInvocation(runId, { ...started, status: controller.signal.aborted ? "cancelled" : "failed", error: errorText(error).slice(0, 8e3), finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+    }).finally(() => this.#active.delete(invocation.id));
+    this.#active.set(invocation.id, { runId, actorId: program.actorId, controller, completed });
+    return invocation;
+  }
+  invocation(runId, reference, id) {
+    const invocation = this.#invocations(runId).invocations.find((entry) => entry.id === id && (entry.appId === reference || entry.actorHandle === reference));
+    if (!invocation)
+      throw new Error("Der Funktionsaufruf ist unbekannt.");
+    return invocation;
+  }
+  #invocations(runId) {
+    return this.view(runId).pluginStates.find((entry) => entry.pluginId === ACTOR_INVOCATIONS_STATE_ID && entry.scope.kind === "run")?.state ?? { version: 1, invocations: [], requestIds: [] };
+  }
+  #replaceInvocation(runId, invocation, remember = false) {
+    const current = this.#invocations(runId);
+    const entries = [...current.invocations.filter((entry) => entry.id !== invocation.id), invocation];
+    const active = entries.filter((entry) => entry.status === "queued" || entry.status === "running");
+    const finished = entries.filter((entry) => entry.status !== "queued" && entry.status !== "running").slice(-20);
+    const state = { version: 1, invocations: [...active, ...finished], requestIds: remember ? [...current.requestIds, invocation.requestId] : current.requestIds };
+    while (jsonBytes(state) > MAX_INVOCATIONS_STATE_BYTES && finished.length) {
+      finished.shift();
+      state.invocations = [...active, ...finished];
+    }
+    assertJsonValue2(state, "Actor-Aufrufe");
+    this.runtime().replacePluginState(this.operatorContext(runId), runId, { pluginId: ACTOR_INVOCATIONS_STATE_ID, scope: { kind: "run" }, state });
+  }
+  async #confirm(runId, invocation, question, signal, input = invocation.input) {
+    const answer = await this.#options.askService().ask({ runId, agentId: this.ownerId(runId), turnId: null, commandId: `actor-confirm:${randomUUID()}` }, { question: `${question}
+Eingabe: ${JSON.stringify(input).slice(0, 500)}`, options: ["Ausf\xFChren", "Abbrechen"], multi: false, description: `Funktion ${invocation.actionId} von @${invocation.actorHandle}`, parameters: { source: ACTOR_PROGRAMS_STATE_ID, invocationId: invocation.id } }, signal);
+    return answer === "Ausf\xFChren";
+  }
+  #program(runId, reference) {
+    const program = this.programs(runId).find((entry) => entry.name === reference || entry.views.some((view) => view.id === reference));
+    if (!program)
+      throw new Error(`Actor-Paket ${reference} ist nicht aktiv.`);
+    return program;
+  }
+  #instance(program) {
+    return `actor:${program.actorId}:${program.revision}`;
+  }
+  #assertName(name2) {
+    if (!NAME.test(name2))
+      throw new Error("Paketnamen beginnen mit einem Kleinbuchstaben und enthalten h\xF6chstens 64 Kleinbuchstaben, Ziffern oder Bindestriche.");
+  }
+  #assertIdle(runId, actorId) {
+    if (this.#queues.has(`${runId}\0${actorId}`) || [...this.#active.values()].some((entry) => entry.runId === runId && entry.actorId === actorId))
+      throw new Error("Der Actor hat noch laufende Funktionen oder Eingaben.");
+  }
+  async stopActor(runId, actorId) {
+    const active = [...this.#active.values()].filter((entry) => entry.runId === runId && entry.actorId === actorId);
+    active.forEach((entry) => entry.controller.abort(new Error("Actor gestoppt.")));
+    const state = this.view(runId).pluginStates.find((entry) => entry.pluginId === ACTOR_PROGRAMS_STATE_ID && entry.scope.kind === "actor" && entry.scope.actorId === actorId)?.state;
+    if (state?.program)
+      await this.runtime().nativeTypeScriptExecutor.stopInstance(runId, this.#instance(state.program));
+    await Promise.allSettled(active.map((entry) => entry.completed));
+  }
+  async stopRun(runId) {
+    this.#epochs.set(runId, (this.#epochs.get(runId) ?? 0) + 1);
+    this.#stopping.add(runId);
+    try {
+      const active = [...this.#active.values()].filter((entry) => entry.runId === runId);
+      active.forEach((entry) => entry.controller.abort(new Error("Run gestoppt.")));
+      await this.runtime().nativeTypeScriptExecutor.stopRun(runId);
+      await Promise.allSettled([...active.map((entry) => entry.completed), ...[...this.#queues].filter(([key]) => key.startsWith(`${runId}\0`)).map(([, queue]) => queue)]);
+    } finally {
+      this.#stopping.delete(runId);
+    }
+  }
+  waitForRunSettlement(runId) {
+    return Promise.allSettled([...this.#active.values()].filter((entry) => entry.runId === runId).map((entry) => entry.completed).concat([...this.#queues].filter(([key]) => key.startsWith(`${runId}\0`)).map(([, queue]) => queue))).then(() => void 0);
+  }
+  async prepareSession(runId) {
+    this.#knownRuns.add(runId);
+    if (!this.runtime().listRuns().some((run) => run.id === runId))
+      return;
+    for (const invocation of this.#invocations(runId).invocations)
+      if (invocation.status === "queued" || invocation.status === "running")
+        this.#replaceInvocation(runId, { ...invocation, status: "cancelled", error: "Der Server wurde w\xE4hrend des Aufrufs beendet.", finishedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  async stopSession(runId, _signal) {
+    await this.stopRun(runId);
+  }
+  async disposeRun(runId) {
+    await this.stopRun(runId);
+  }
+  async deleteSession(runId) {
+    await this.stopRun(runId);
+    await rm(this.#options.directoryFor(runId), { recursive: true, force: true });
+  }
+  async shutdown() {
+    this.#shuttingDown = true;
+    await Promise.allSettled([...this.#knownRuns].map((runId) => this.stopRun(runId)));
+  }
+};
+
+// server/tool-contributor.ts
+import { Type } from "typebox";
+import { defineRunFunction as defineRunFunction2, defineToolAvailability as defineToolAvailability2, holdsUsable } from "@ragents/engine";
+import { toolDescriptorFrom } from "@ragents/host/plugin-support/agent-tool.js";
+var metadata = [
+  { name: "actor_program_create", label: "Create Actor Program", description: "Create a private TypeScript package with fixed libraries.", longDescription: "Edit files under @actors/name using workspace tools." },
+  { name: "actor_program_activate", label: "Activate Actor Program", description: "Typecheck, build and test a package, then activate its functions and optional views.", longDescription: "actor self or @handle attaches to an existing actor; omitted creates a TypeScript actor for a backend, or attaches static views to self." },
+  { name: "actor_program_list", label: "List Actor Programs", description: "List active actor packages, functions and views." },
+  { name: "actor_program_remove", label: "Remove Actor Program", description: "Detach functions and views and stop the backend.", longDescription: "A TypeScript actor is stopped; an LLM actor retains its agent behavior." },
+  { name: "actor_view_set_visibility", label: "Show or hide Actor View", description: "Set surface visibility by package-name/view-key or @handle/view-key.", longDescription: "Use names you chose; the server resolves the view ID. A unique view title also works." },
+  { name: "actor_program_diagnostics", label: "Actor Program Diagnostics", description: "Read the last project diagnostics.", longDescription: "Changed errors are automatically supplied before the next model request." }
+];
+var actorProgramManagementToolNames = metadata.map((entry) => entry.name);
+var actorProgramToolsAvailable = defineToolAvailability2({ availability: "conditional", availabilityDetail: "F\xFCr ausf\xFChrbare Actors mit agent.spawn und plugin.state.write." }, (actor) => actor.kind !== "human" && holdsUsable(actor, "agent.spawn") && holdsUsable(actor, "plugin.state.write"));
+var name = Type.String({ pattern: "^[a-z][a-z0-9-]{0,63}$" });
+var managementTools = (runtime, diagnostics) => [
+  defineRunFunction2({ ...metadata[0], schema: Type.Object({ name, template: Type.Union(runtime.templates().map((entry) => Type.Literal(entry.id, { description: entry.description }))) }, { additionalProperties: false }), resultSchema: Type.Object({ name: Type.String(), directory: Type.String(), files: Type.Array(Type.String()) }, { additionalProperties: false }), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, _id, input) => runtime.scaffold(scope.caller.runId, input.name, input.template) }),
+  defineRunFunction2({ ...metadata[1], schema: Type.Object({ name, actor: Type.Optional(Type.String()) }, { additionalProperties: false }), resultSchema: Type.Object({ name: Type.String(), actor: Type.String(), views: Type.Number(), active: Type.Literal(true) }, { additionalProperties: false }), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, id, input) => runtime.activate(scope.context(id), scope.caller.runId, input.name, scope.signal, input.actor) }),
+  defineRunFunction2({ ...metadata[2], schema: Type.Object({}, { additionalProperties: false }), resultSchema: Type.Array(Type.Object({ name: Type.String(), actor: Type.String(), functions: Type.Array(Type.String()), views: Type.Array(Type.Object({ name: Type.String(), title: Type.String(), visible: Type.Boolean() })) })), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope) => runtime.list(scope.caller.runId) }),
+  defineRunFunction2({ ...metadata[3], schema: Type.Object({ name }, { additionalProperties: false }), resultSchema: Type.Object({ removed: Type.String() }, { additionalProperties: false }), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, id, input) => runtime.remove(scope.context(id), scope.caller.runId, input.name) }),
+  defineRunFunction2({ ...metadata[4], schema: Type.Object({ view: Type.String({ minLength: 1, description: "package-name/view-key or @handle/view-key of an activated view, without the surface entity prefix app:. No generated IDs needed." }), visible: Type.Boolean() }, { additionalProperties: false }), resultSchema: Type.Object({ view: Type.String(), visible: Type.Boolean() }, { additionalProperties: false }), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, id, input) => runtime.setVisibility(scope.context(id), scope.caller.runId, input.view, input.visible) }),
+  defineRunFunction2({ ...metadata[5], schema: Type.Object({ name: Type.Optional(name) }, { additionalProperties: false }), resultSchema: Type.String(), available: actorProgramToolsAvailable, executionMode: "sequential", run: (scope, _id, input) => diagnostics.latest(scope.caller.runId, scope.caller.actorId, input.name) })
+];
+var createActorProgramToolContributors = (runtime, diagnostics) => [
+  { name: "ragents.actor-programs.management", descriptors: metadata.map((item) => toolDescriptorFrom(item, actorProgramToolsAvailable)), tools: () => managementTools(runtime, diagnostics) },
+  { name: "ragents.actor-programs.functions", descriptors: [], dynamic: true, tools: (context) => runtime.installedTools(context) }
+];
+
+// server/controls-tool.ts
+import { Type as Type2 } from "typebox";
+import { defineRunFunction as defineRunFunction3, defineToolAvailability as defineToolAvailability3 } from "@ragents/engine";
+import { toolDescriptorFrom as toolDescriptorFrom2 } from "@ragents/host/plugin-support/agent-tool.js";
+import { readClientUiComponentNames, readClientUiComponentContracts } from "@ragents/host/plugin-support/actor-programs/client-contracts.js";
+
+// server/prompts.ts
+import { pluginAsset } from "@ragents/host/plugin-support/plugin-folder.js";
+import { boundToTools, handlebarsPrompt } from "@ragents/host/plugin-support/prompt.js";
+var buildingTools = [
+  "actor_program_create",
+  "actor_program_activate",
+  "actor_program_diagnostics",
+  "actor_program_list",
+  "actor_program_remove",
+  "actor_view_set_visibility"
+];
+var actorProgramGuide = handlebarsPrompt(
+  "ragents.actor-programs.prompt",
+  750,
+  pluginAsset("ragents.actor-programs", "prompt.hbs")
+);
+var actorProgramSummary = boundToTools(
+  { ...handlebarsPrompt("ragents.actor-programs.summary", 749, pluginAsset("ragents.actor-programs", "summary.hbs")), delivery: "initial" },
+  "actor_program_controls",
+  ...buildingTools
+);
+
+// server/controls-tool.ts
+var available = defineToolAvailability3({ availability: "always", availabilityDetail: "Typisierte UI-Referenz des installierten Actor-Programm-Plugins." }, () => true);
+var metadata2 = {
+  name: "actor_program_controls",
+  label: "Actor-Programm-Anleitung und Controls nachschlagen",
+  description: "Read Mini-App control contracts or the actor-program authoring guide.",
+  longDescription: "With topic: guide, explain the TypeScript package workflow through actor_program_activate. Otherwise list control names, or select one component (for example Form) for only its TypeScript props and supporting types. Import controls from @ragents/client/ui and use these exact props."
+};
+var describeClientControls = (component) => {
+  const components = readClientUiComponentNames();
+  if (component === void 0) return { components };
+  if (!components.includes(component)) throw new Error(`Unbekanntes Control ${component}. G\xFCltig: ${components.join(", ")}`);
+  return { files: readClientUiComponentContracts(component) };
+};
+var createControlsToolContributor = () => ({
+  name: "ragents.actor-programs.controls",
+  descriptors: [toolDescriptorFrom2(metadata2, available)],
+  tools: () => [defineRunFunction3({
+    ...metadata2,
+    available,
+    schema: Type2.Object({
+      topic: Type2.Optional(Type2.Union([Type2.Literal("controls"), Type2.Literal("guide")], { description: "Default controls: query component names or types. Guide: read the short package workflow without component." })),
+      component: Type2.Optional(Type2.String({ minLength: 1, description: "Optional control name from the catalog, without UI. prefix. Only valid when topic is controls or omitted." }))
+    }, { additionalProperties: false }),
+    resultSchema: Type2.Union([
+      Type2.Object({ guide: Type2.String() }, { additionalProperties: false }),
+      Type2.Object({ components: Type2.Array(Type2.String()) }, { additionalProperties: false }),
+      Type2.Object({ files: Type2.Record(Type2.String(), Type2.String()) }, { additionalProperties: false })
+    ]),
+    run: async (_scope, _call, input) => {
+      if (input.topic === "guide") {
+        if (input.component !== void 0) throw new Error("component ist nur bei topic: controls oder ohne topic erlaubt; f\xFCr topic: guide lasse component weg.");
+        return { guide: await actorProgramGuide.render({}) };
+      }
+      return describeClientControls(input.component);
+    }
+  })]
+});
+
+// server/index.ts
+import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import { actorProgramsToken } from "@ragents/host/plugin-support/actor-programs/service.js";
+
+// server/project-diagnostics.ts
+import { createHash } from "node:crypto";
+import { readdir as readdir2 } from "node:fs/promises";
+import path2 from "node:path";
+import { projectSourceFiles as projectSourceFiles2 } from "@ragents/host/plugin-support/actor-programs/app-project.js";
+var entryType = "ragents.actor-programs.project-diagnostics";
+var maxDeltaLines = 8;
+var maxLineLength = 240;
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var fingerprintOf = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+var errorLines2 = (error) => {
+  const complete = error instanceof Error ? error.lines : void 0;
+  if (Array.isArray(complete) && complete.every((line) => typeof line === "string")) return [...new Set(complete)];
+  const lines = messageOf(error).split("\n").map((line) => line.trim()).filter(Boolean);
+  const issues = lines.filter((line) => !/^(Build failed with \d+ errors?:|.*(?:Typprüfung|Typecheck|Diagnostik).*:)$/i.test(line));
+  return [...new Set(issues.length ? issues : lines)];
+};
+var allErrors = (snapshot) => Object.entries(snapshot.programs).sort(([left], [right]) => left.localeCompare(right)).flatMap(([programName, program]) => program.errors.map((error) => `${programName}: ${error}`));
+var isSnapshot = (value) => {
+  if (value === null || typeof value !== "object") return false;
+  const snapshot = value;
+  return snapshot.version === 1 && snapshot.programs !== null && typeof snapshot.programs === "object" && Object.values(snapshot.programs).every((program) => program && typeof program.fingerprint === "string" && Array.isArray(program.errors) && program.errors.every((error) => typeof error === "string"));
+};
+var createProjectDiagnostics = (options) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  const remember = (runId, actorId, snapshot) => {
+    const agents = snapshots.get(runId) ?? /* @__PURE__ */ new Map();
+    agents.set(actorId, snapshot);
+    snapshots.set(runId, agents);
+  };
+  const contribution = {
+    id: entryType,
+    beforeModelCall: async ({ runId, agentId }, call) => {
+      if (options.applies?.(runId, agentId) === false) return void 0;
+      call.signal?.throwIfAborted();
+      const previous = isSnapshot(call.kept) ? call.kept : { version: 1, programs: {} };
+      const next = { version: 1, programs: {} };
+      let changed = false;
+      try {
+        const directory = await options.workspaceFor(runId);
+        const entries = await readdir2(directory, { withFileTypes: true }).catch((error) => {
+          if (error.code === "ENOENT") return [];
+          throw error;
+        });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+          if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+          call.signal?.throwIfAborted();
+          let fingerprint;
+          let errors = [];
+          try {
+            if (entry.isSymbolicLink()) throw new Error("Actor-Projekte d\xFCrfen keine Symlinks sein.");
+            fingerprint = fingerprintOf(await projectSourceFiles2(path2.join(directory, entry.name)));
+          } catch (error) {
+            errors = errorLines2(error);
+            fingerprint = fingerprintOf({ errors });
+          }
+          const prior = previous.programs[entry.name];
+          if (prior?.fingerprint === fingerprint) {
+            next.programs[entry.name] = prior;
+            continue;
+          }
+          changed = true;
+          if (errors.length === 0) {
+            try {
+              await options.check(runId, entry.name, agentId, call.signal);
+            } catch (error) {
+              call.signal?.throwIfAborted();
+              errors = errorLines2(error);
+            }
+          }
+          next.programs[entry.name] = { fingerprint, errors };
+        }
+      } catch (error) {
+        call.signal?.throwIfAborted();
+        const errors = errorLines2(error);
+        Object.assign(next.programs, previous.programs);
+        next.programs["(Workspace)"] = { fingerprint: fingerprintOf({ errors }), errors };
+      }
+      if (JSON.stringify(Object.keys(previous.programs).sort()) !== JSON.stringify(Object.keys(next.programs).sort())) changed = true;
+      if (JSON.stringify(previous) !== JSON.stringify(next)) changed = true;
+      call.signal?.throwIfAborted();
+      remember(runId, agentId, next);
+      if (!changed) return void 0;
+      call.keep(next);
+      const before = new Set(allErrors(previous));
+      const after = new Set(allErrors(next));
+      const added = [...after].filter((error) => !before.has(error));
+      const resolved = [...before].filter((error) => !after.has(error));
+      const changes = [...added.map((error) => `Neu: ${error}`), ...resolved.map((error) => `Behoben: ${error}`)];
+      const lines = changes.slice(0, maxDeltaLines).map((line) => line.length > maxLineLength ? `${line.slice(0, maxLineLength - 3)}...` : line);
+      const omitted = changes.length - lines.length;
+      return [
+        `Actor-Programm-Projektpr\xFCfung (TypeScript und Build): ${after.size} Fehler in ${Object.keys(next.programs).length} Projekten; ${added.length} neu, ${resolved.length} behoben.`,
+        ...lines,
+        ...omitted > 0 ? [`${omitted} weitere \xC4nderungen. Vollst\xE4ndiger letzter Stand: actor_program_diagnostics.`] : []
+      ].join("\n");
+    }
+  };
+  return {
+    contribution,
+    latest(runId, actorId, programName) {
+      const snapshot = snapshots.get(runId)?.get(actorId);
+      if (!snapshot) return "Noch kein Actor-Programm-Projektstand f\xFCr diesen Agenten gepr\xFCft.";
+      const programs = Object.entries(snapshot.programs).filter(([id]) => programName === void 0 || id === programName);
+      if (programs.length === 0) return programName ? `Kein gepr\xFCfter Projektstand f\xFCr ${programName}.` : "Keine Actor-Programm-Projekte vorhanden.";
+      return programs.sort(([left], [right]) => left.localeCompare(right)).map(([id, program]) => [`${id}: ${program.errors.length} Fehler`, ...program.errors].join("\n")).join("\n\n");
+    },
+    forget(runId) {
+      snapshots.delete(runId);
+    }
+  };
+};
+
+// server/index.ts
+var actorProgramsPlugin = (pluginHost) => ({
+  manifest: { id: "ragents.actor-programs" },
+  register: (host) => {
+    const runtime = new ActorProgramRuntime({
+      runtime: host.service(runtimeProviderToken2),
+      agentToolsFor: agentToolsFrom(pluginHost),
+      askService: () => host.service(askServiceToken),
+      reservedToolNames: () => pluginHost.tools.describe().map((entry) => entry.name),
+      serverProcessContextFor: (runId) => host.service(sandboxServicesToken).serverProcessContextFor(runId),
+      operations: { operation: (id) => host.operation(id), invoke: (id, context, input) => host.invokeOperation(id, context, input), list: () => pluginHost.operations.describe() },
+      directoryFor: (runId) => host.storage.session(runId, "programs"),
+      scriptSources: (entryId, name2) => {
+        const script = pluginHost.startEntries.scriptPackage(entryId);
+        return !script ? void 0 : script.handle === name2 ? script.files : script.programs.find((program) => program.name === name2)?.files;
+      }
+    });
+    host.provide(actorProgramsToken, runtime);
+    const diagnostics = createProjectDiagnostics({
+      workspaceFor: (runId) => runtime.workspaceDirectory(runId),
+      check: (runId, name2, actorId, signal) => runtime.check(runId, name2, actorId, signal),
+      applies: (runId, actorId) => {
+        const view = host.service(runtimeProviderToken2)().view(runId);
+        const actor = view.actors.find((candidate) => candidate.id === actorId);
+        return !!actor && actor.kind !== "human" && actorProgramToolsAvailable(actor, view) && (actor.toolNames === null || actor.toolNames.some((name2) => actorProgramManagementToolNames.includes(name2)));
+      }
+    });
+    host.agentRuntime(diagnostics.contribution);
+    host.clientConfig({ routePrefix: miniAppsApiPrefix });
+    host.methods(...createActorProgramMethods({ ensureSession: host.service(runGuardToken), runtime }));
+    host.http(...createMiniAppFrameRoutes({ ensureSession: host.service(runGuardToken), runtime }));
+    host.lifecycle({
+      id: "ragents.actor-programs.lifecycle",
+      initialize: () => host.service(sandboxServicesToken).registerWorkspaceRoot({ id: "ragents.actor-programs", alias: "@actors", environmentVariable: "RAGENTS_ACTORS_DIR", directoryFor: (runId) => runtime.workspaceDirectory(runId), ownershipDirectoryFor: async (runId) => path3.dirname(await runtime.workspaceDirectory(runId)) }),
+      prepareSession: ({ runId }) => runtime.prepareSession(runId),
+      stopSession: ({ runId, signal }) => runtime.stopSession(runId, signal),
+      deleteSession: async ({ runId }) => {
+        diagnostics.forget(runId);
+        await runtime.deleteSession(runId);
+      },
+      shutdown: () => runtime.shutdown()
+    });
+    host.prompts(actorProgramSummary);
+    host.functions(createControlsToolContributor(), ...createActorProgramToolContributors(runtime, diagnostics));
+  }
+});
+var plugin = { requires: ["ragents.orchestration", "ragents.ask"], create: actorProgramsPlugin };
+export {
+  plugin
+};
+//# sourceMappingURL=index.js.map