@agent-native/core 0.76.5 → 0.76.6

package/corpus/core/docs/content/locales/de-DE/local-file-mode.md

@@ -0,0 +1,433 @@
+---
+title: "Lokaler Dateimodus"
+description: "Führen Sie agentennative Apps mit lokalen Markdown-, MDX- und anderen Repo-Dateien als Quelle der Wahrheit aus – einschließlich MDX-Dokumenten im Obsidian-Stil mit benutzerdefinierten Komponenten."
+---
+
+# Lokaler Dateimodus
+
+Im lokalen Dateimodus kann eine agentennative App ihre normale UI- und Aktionsoberfläche anhängen
+direkt zu Dateien in einem Repository oder Arbeitsbereich. Die App fühlt sich immer noch wie eine gehostete App an
+Produkt, aber seine Listenansichten, Editor- und Agent-Tools lesen und schreiben lokale Dateien
+anstelle von SQL-gestützten App-Datensätzen.
+
+Die erste Implementierung befindet sich in der Inhaltsvorlage: Die linke Seitenleiste ist
+wird aus lokalen `.md`- und `.mdx`-Dateien gefüllt. Wenn Sie eine Seite auswählen, wird der Standard geöffnet
+Inhaltseditor und Speichern schreibt zurück in die ausgewählte Datei. Dieselben Dateien können
+kann auch von Codex, Claude Code, dem Agent-Native-Sidebar-Agenten oder einem normalen bearbeitet werden
+Herausgeber.
+
+Was den Inhalt angeht, fühlt sich das Produkt dadurch wie Open-Source-Obsidian für MDX an:
+Ihre Dokumente bleiben als Dateien bestehen, während die App einen visuellen Editor, Agent actions, hinzufügt
+gemeinsame Kopien und umfangreiche interaktive MDX-Komponenten.
+
+Verwenden Sie den lokalen Dateimodus, wenn Sie einen Repo-First-Workflow wünschen:
+
+- ein Dokumenten-Repo mit `docs/*.mdx`
+- ein Blog mit `blog/*.mdx`
+- Ressourcen wie Positionierung, Nachrichten oder Teamnotizen in `resources/*.md`
+- eine persönliche Wissensdatenbank im Obsidian-Stil mit einem umfangreicheren MDX-Editor
+- Dokumente, die interaktive benutzerdefinierte MDX-Blöcke benötigen, die aus lokalem React-Code generiert werden
+- App-Artefakte, die für Programmierer leicht zu prüfen und zu patchen sein sollten
+
+Verwenden Sie den Datenbankmodus, wenn Sie die gehostete kollaborative App-Erfahrung wünschen:
+Mehrbenutzerfreigabe, SQL-gestützte Berechtigungen, Kommentare, Versionsverlauf und
+Produktionshosting ohne Zugriff auf das lokale Dateisystem.
+
+## Das mentale Modell
+
+Es gibt zwei Source-of-Truth-Modi:
+
+| Modus              | Quelle der Wahrheit                             | Am besten für                                                                              |
+| ------------------ | ----------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| Datenbankmodus     | SQL Zeilen bis Drizzle                          | Gehostete Apps, Zusammenarbeit, Freigabe, Kommentare, Versionsverlauf                      |
+| Lokaler Dateimodus | Repo-Dateien deklariert von `agent-native.json` | Lokale/Entwickler-Workflows, Git-Überprüfung, Coding-Agent-Änderungen, dateinativer Inhalt |
+
+UI und Agent actions sollten in beiden Modi die gleiche Form behalten. Ein Inhalt
+Editor bearbeitet weiterhin Dokumente; Der Unterschied besteht darin, ob diese Dokumente aufgelöst werden
+in SQL Zeilen oder lokale Dateien.
+
+```an-diagram title="Same actions, two sources of truth" summary="The UI and agent call identical actions in both modes. The action layer decides whether each call resolves to SQL rows or repo files."
+{
+  "html": "<div class=\"diagram-mode\"><div class=\"diagram-col entry\"><div class=\"diagram-node\">Content UI</div><div class=\"diagram-node\">Agent + actions<br><small class=\"diagram-muted\">list/get/update-document</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-row resolve\"><div class=\"diagram-panel\" data-rough><span class=\"diagram-pill accent\">Database mode</span><small class=\"diagram-muted\">SQL rows via Drizzle</small><small class=\"diagram-muted\">hosted · sharing · comments · history</small></div><div class=\"diagram-panel\" data-rough><span class=\"diagram-pill ok\">Local File Mode</span><small class=\"diagram-muted\">repo files via agent-native.json</small><small class=\"diagram-muted\">Git review · coding-agent edits</small></div></div></div>",
+  "css": ".diagram-mode{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-mode .diagram-col{display:flex;flex-direction:column;gap:10px}.diagram-mode .diagram-arrow{font-size:22px;line-height:1}.diagram-mode .resolve{display:flex;gap:12px;flex-wrap:wrap}.diagram-mode .diagram-panel{display:flex;flex-direction:column;gap:4px;padding:12px 14px}"
+}
+```
+
+## Beispiel-Repo
+
+Ein Inhaltsarbeitsbereich kann so klein sein:
+
+```an-file-tree title="A Content workspace repo"
+{
+  "entries": [
+    { "path": "agent-native.json", "note": "declares which folders are content roots and their kinds" },
+    { "path": "docs/", "note": "content root — shows in the sidebar as pages" },
+    { "path": "docs/getting-started.mdx" },
+    { "path": "docs/guides/custom-components.mdx" },
+    { "path": "blog/", "note": "content root" },
+    { "path": "blog/launch-post.mdx" },
+    { "path": "resources/", "note": "content root" },
+    { "path": "resources/messaging/positioning.md" },
+    { "path": "components/", "note": "NOT a content root — preview component library MDX can import" },
+    { "path": "components/FrameworkTabs.tsx" },
+    { "path": "components/Callout.tsx" },
+    { "path": "extensions/", "note": "NOT a content root — local extension library (sandboxed widgets)" },
+    { "path": "extensions/doc-status/extension.json" },
+    { "path": "extensions/doc-status/index.html" }
+  ]
+}
+```
+
+Im lokalen Dateimodus zeigt die Inhaltsseitenleiste `docs/`, `blog/` und
+`resources/` Bäume als Seiten. Wenn Sie `docs/getting-started.mdx` auswählen, wird das geöffnet
+Datei im Standard-Inhaltseditor; Bearbeitung im UI schreibt zurück nach
+`docs/getting-started.mdx`.
+
+`components/` ist kein Inhaltsstammverzeichnis. Es handelt sich um eine Vorschau-Komponentenbibliothek, die MDX
+Dateien können importiert oder referenziert werden. Der Editor kann einfache lokale MDX-Komponenten rendern
+ohne dass Sie die gesamte Content-App klonen oder forken müssen.
+
+`extensions/` ist ebenfalls kein Inhaltsstammverzeichnis. Es handelt sich um eine lokale Erweiterungsbibliothek:
+kleine Sandbox-Widgets, die in App-Slots gerendert werden können, während ihre Quelle drin bleibt
+das Repo.
+
+## Inhalt in ein Repo installieren
+
+Installieren Sie für vorhandene Dokumente, Blogs oder MDX-Arbeitsbereiche die lokalen Inhaltsdateien
+Fähigkeit:
+
+```bash
+npx @agent-native/core@latest skills add content --mode local-files --scope project
+```
+
+Dadurch wird der `content`-Skill in die Agent-Skill-Ordner des Repositorys kopiert und geschrieben
+oder aktualisiert `agent-native.json` mit den Inhaltsstandards:
+
+- `mode: "local-files"` auf Arbeitsbereichsebene
+- `apps.content.mode: "local-files"`
+- Inhaltsstämme für `docs/`, `blog/`, `content/` und `resources/`
+- `components/` für lokale MDX-Komponenten
+- `extensions/` für lokale Erweiterungs-Widgets
+
+Der installierte Skill weist Programmieragenten an, Content actions zu verwenden
+(`list-documents`, `get-document`, `edit-document`, `update-document`,
+`share-local-file-document` und Komponentendatei actions) bei einer lokalen Content-App
+oder Agent Native Desktop Bridge macht sie verfügbar. Wenn keine Bridge läuft, wird der Skill
+greift auf sichere direkte Repo-Bearbeitungen zurück und behält dabei Frontmatter, Importe, JSX,
+und unbekanntes MDX.
+
+## Konfiguration
+
+Fügen Sie `agent-native.json` zum Repository oder Arbeitsbereichsstamm hinzu:
+
+```json
+{
+  "version": 1,
+  "apps": {
+    "content": {
+      "mode": "local-files",
+      "roots": [
+        {
+          "name": "Docs",
+          "path": "docs",
+          "kind": "docs",
+          "extensions": [".md", ".mdx"]
+        },
+        {
+          "name": "Blog",
+          "path": "blog",
+          "kind": "blog",
+          "extensions": [".md", ".mdx"]
+        },
+        {
+          "name": "Resources",
+          "path": "resources",
+          "kind": "resources",
+          "extensions": [".md", ".mdx"]
+        }
+      ],
+      "components": "components",
+      "extensions": "extensions",
+      "hide": ["**/_*.md", "**/_*.mdx"]
+    }
+  }
+}
+```
+
+Sie können lokale Dateien auch mit `AGENT_NATIVE_MODE=local-files` oder
+`AGENT_NATIVE_DATA_MODE=local-files`; Das Manifest wird bevorzugt, weil es
+dokumentiert den Ordnervertrag im Repo selbst.
+
+## Inhaltsdateiformat
+
+Der Inhalt lautet Markdown und MDX. Frontmatter enthält Seitenmetadaten und der Text ist
+das bearbeitbare Dokument:
+
+```mdx
+---
+title: "Getting Started"
+icon: "sparkles"
+isFavorite: true
+updatedAt: "2026-06-12T20:00:00.000Z"
+---
+
+# Getting Started
+
+Use <FrameworkTabs value="react" /> to show framework-specific code.
+```
+
+Der Titel stammt von `title` frontmatter, sofern vorhanden, andernfalls von
+Dateiname. Der Editor behält die MDX-Quelle bei, die er noch nicht visuell bearbeiten kann, also
+Codierungsagenten und normale Texteditoren bleiben sichere Fluchtwege.
+
+## Benutzerdefinierte MDX-Komponenten
+
+Inhalte können eine Vorschau lokaler Komponenten aus dem konfigurierten `components`-Ordner anzeigen.
+Dies ist für MDX-Komponenten im Dokumentstil wie Registerkarten, Beschriftungen und Pakete gedacht.
+Installieren Sie Snippets oder Framework-spezifische Codeblöcke.
+
+Fügen Sie beispielsweise eine interaktive Komponente neben Ihrem Inhalt hinzu:
+
+```tsx
+// components/ImpactCounter.tsx
+import { useState } from "react";
+
+export function ImpactCounter({
+  label = "points",
+  accent = "blue",
+  featured = false,
+}: {
+  label?: string;
+  accent?: "blue" | "green" | "purple";
+  featured?: boolean;
+}) {
+  const [count, setCount] = useState(3);
+  const accentClass =
+    accent === "green"
+      ? "border-green-300 bg-green-50"
+      : accent === "purple"
+        ? "border-purple-300 bg-purple-50"
+        : "border-blue-300 bg-blue-50";
+
+  return (
+    <div className={`rounded-md border p-4 ${accentClass}`}>
+      <div className="text-sm text-muted-foreground">Launch impact</div>
+      <div className="mt-1 text-3xl font-semibold">
+        {count} {label}
+      </div>
+      {featured ? <div className="mt-1 text-sm">Featured metric</div> : null}
+      <button
+        type="button"
+        className="mt-3 rounded border px-3 py-1 text-sm"
+        onClick={() => setCount((value) => value + 1)}
+      >
+        Add point
+      </button>
+    </div>
+  );
+}
+
+export const ImpactCounterInputs = {
+  label: {
+    type: "string",
+    label: "Metric label",
+    default: "points",
+  },
+  accent: {
+    type: "select",
+    label: "Accent",
+    options: ["blue", "green", "purple"],
+    default: "blue",
+  },
+  featured: {
+    type: "boolean",
+    label: "Featured",
+    default: false,
+  },
+};
+```
+
+Dann verwenden Sie es aus einer beliebigen lokalen MDX-Datei:
+
+```mdx
+---
+title: "Launch Notes"
+---
+
+# Launch Notes
+
+<ImpactCounter label="wins" />
+```
+
+Der Content-Entwicklungsserver erkennt PascalCase-benannte Exporte und PascalCase-Standardwerte
+Exporte aus `.tsx`-, `.jsx`-, `.ts`- und `.js`-Dateien unter `components/`. Diese
+Komponenten werden im Editor gerendert und im Slash-Menü darunter angezeigt
+**Lokale Komponenten**. Durch das Einfügen eines Schrägstrichs wird ein minimales Tag erstellt, z. B.
+`<ImpactCounter />`; Fügen Sie bei Bedarf Requisiten zur MDX-Quelle hinzu.
+
+Die Komponentenausführung ist absichtlich eine lokale Dev/Desktop-Bridge-Funktion, nicht
+einfacher Zugriff auf gehostete Browserordner. Wenn Sie `content.agent-native.com` öffnen,
+Wählen Sie **Lokale Dateien** und einen Ordner in Chrome, den die App lesen und schreiben kann
+die Dateien `.md` und `.mdx` über den Browser-Dateisystemzugriff auf API, aber
+Chrome stellt keinen absoluten Ordnerpfad für die Kompilierung durch Vite bereit
+`components/*.tsx`. Um benutzerdefinierte React-Komponenten in der Vorschau anzuzeigen und im laufenden Betrieb neu zu laden, führen Sie
+Inhalte lokal oder verwenden Sie Agent Native Desktop, damit die vertrauenswürdige lokale Bridge dies tun kann
+registrieren Sie den ausgewählten Arbeitsbereich beim lokalen Content-Entwicklungsserver. In diesem Modus
+Änderungen an vorhandenen Komponentendateien, Hot-Reload über Vite und Hinzufügen von oder
+Durch das Entfernen von Komponentendateien werden die Komponentenregistrierung und das Slash-Menü neu geladen.
+
+Agenten können auch mit diesen registrierten Komponentendateien arbeiten. Verwenden
+`list-local-component-files`, um dann die registrierte Arbeitsbereichs-ID zu finden
+`write-local-component-file` zum Erstellen oder Aktualisieren von `.tsx`, `.jsx`, `.ts` oder
+`.js`-Dateien im Ordner `components/` des Arbeitsbereichs. Die MDX-Dateien bleiben die
+Quelle der Wahrheit für die Komponentenverwendung; Die Komponentendateien bleiben normale Repo
+Quelldateien mit Git überprüft.
+
+Wenn eine Komponente Eingabemetadaten exportiert, wählen Sie die Komponente im Editor aus
+zeigt eine Schaltfläche zum Bearbeiten in der oberen rechten Ecke der Komponente an. Unterstützte Eingabetypen
+sind `string`, `textarea`, `number`, `boolean` und `select`. Das Formular schreibt
+wechselt zurück zum MDX-Tag, sodass lokale Dateien die Quelle der Wahrheit bleiben. Die
+Metadaten können als `ComponentNameInputs`, `ComponentNameConfig.inputs`,
+`Component.inputs` oder `agentNative.inputs`.
+
+Einfache Komponenten-Tags mit Literal-Requisiten können inline in der Vorschau angezeigt werden:
+
+```mdx
+<FrameworkTabs value="react" />
+
+<Callout type="warning">This setting affects production deploys.</Callout>
+```
+
+Komplexe JSX-Ausdrücke bleiben in der Quelle erhalten. Wenn der Editor dies nicht sicher tun kann
+Sehen Sie sich noch eine Vorschau einer Komponenten-Requisite an, es wird ein Warnungsplatzhalter angezeigt und nicht
+Daten werden stillschweigend gelöscht.
+
+## Lokale Dateien teilen
+
+Lokale Dateien werden nicht direkt freigegeben, da andere Benutzer einen Pfad darauf nicht lesen können
+Ihre Maschine. Mit der Schaltfläche „Teilen“ in der Symbolleiste „Inhalt“ wird ein
+datenbankgestützte Kopie der ausgewählten Datei, navigiert zu dieser Kopie und öffnet die
+normales Freigabe-Popover. Die ursprüngliche lokale Datei verbleibt unter „Lokale Dateien“. die
+Datenbankkopie erscheint unter „Freigegebene Kopien“ im lokalen Dateimodus und verwendet die
+Standardmodell für die gemeinsame Nutzung von Dokumenten.
+
+## Lokale Erweiterungen
+
+Der lokale Dateimodus kann auch Repo-gestützte Erweiterungen aus der konfigurierten Datei laden
+`extensions`-Ordner. Jede Erweiterung ist ein Verzeichnis mit einem `extension.json`
+Manifest und eine HTML-Eintragsdatei:
+
+```text
+extensions/
+  doc-status/
+    extension.json
+    index.html
+```
+
+```json
+{
+  "id": "doc-status",
+  "name": "Doc Status",
+  "description": "Shows metadata for the selected Content file.",
+  "entry": "index.html",
+  "slots": ["content.sidebar.bottom"],
+  "permissions": {
+    "appActions": ["list-documents"],
+    "extensionData": true
+  }
+}
+```
+
+`index.html` ist das gleiche Alpine/Tailwind-Erweiterungskörperformat, das von Normal verwendet wird
+datenbankgestützte Erweiterungen. Wenn die Content-App eine lokale Erweiterung erkennt,
+deklariert `content.sidebar.bottom` und rendert diese Erweiterung am Ende von
+die Inhaltsseitenleiste. Der Host übergibt `window.slotContext` mit dem ausgewählten
+Dokument-ID, Titel, Quellmetadaten und ob sich der Inhalt im lokalen Dateimodus befindet.
+
+Lokale Erweiterungen werden von der App in der Vorschau angezeigt, aber als Dateien bearbeitet. Die Erweiterungen
+Liste zeigt sie mit einem Lokaldatei-Logo an und der Ganzseitenbetrachter verweist darauf
+die Eintragsdatei. Von SQL unterstützte Erweiterung actions wie Aktualisieren, Löschen, Teilen und
+Verlauf gilt nicht; Verwenden Sie Ihren Editor, Codex-, Claude-Code oder den Git-Verlauf für
+Quellenänderungen.
+
+Für v1 sind lokale Erweiterungen absichtlich konservativ:
+
+- Sie können `extensionData` für ihren eigenen kleinen Laufzeitstatus verwenden
+- Sie können nur die in `extension.json` aufgeführten `appAction`s aufrufen
+- rohe SQL-Helfer und externe `extensionFetch` sind deaktiviert
+- Slot-Ziele werden in `extension.json` deklariert und nicht über SQL installiert
+
+Dadurch erhalten lokale Arbeitsbereiche eine Obsidian-ähnliche Plugin-Oberfläche, ohne dass eine
+Beliebige Repo-Dateien erben alle Funktionen einer datenbankgestützten Erweiterung.
+
+## Wie Apps es nutzen
+
+Der lokale Dateimodus wird durch die lokalen Artefakt-Helfer des Frameworks implementiert.
+Eine App deklariert Roots für die Artefakttypen, die sie besitzt, und liest und schreibt dann
+über dieselbe Aktionsoberfläche, die UI und Agent bereits verwenden.
+
+Für Inhalte bedeutet das:
+
+- `list-documents` listet konfigurierte `.md`- und `.mdx`-Dateien auf.
+- `get-document` liest eine ausgewählte lokale Datei.
+- `update-document` schreibt die ausgewählte lokale Datei.
+- `create-document` erstellt eine neue lokale `.mdx`-Datei im ausgewählten Ordner.
+- `delete-document` löscht die lokale Datei.
+- Die Suche erfolgt über die konfigurierten lokalen Dateien.
+
+Das Verschieben, Umbenennen und Neuanordnen lokaler Dateiseiten aus dem Inhalt UI ist nicht möglich
+wird noch unterstützt. Führen Sie diese Vorgänge im Arbeitsbereich oder mit einem Codierungsagenten aus. die
+Die Inhaltsseitenleiste spiegelt den resultierenden Dateibaum wider.
+
+Dadurch bleibt der Agentenvertrag einfach: Der Agent kann weiterhin Inhalte actions verwenden,
+und diese actions entscheiden, ob das Ziel SQL-backed oder file-backed ist.
+
+Andere Apps können im Laufe der Zeit dasselbe Muster annehmen. Eine Slides-App kann Karten erstellen
+`slides/*.mdx` zu Decks, eine Pläne-App kann `plans/*` zu Plandokumenten zuordnen und ein
+Dashboards-App kann `dashboards/*.mdx` Dashboards zuordnen. Diese App-spezifischen
+Ordner sind Konventionen, die über demselben lokalen Artefaktvertrag liegen.
+
+## Lokale Dateien vs. Export/Import
+
+Inhalt hat zwei verschiedene Datei-Workflows:
+
+| Workflow                     | Was passiert                                                                                                                                                                                  |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/local-files` Export/Import | Der Datenbankmodus bleibt die Quelle der Wahrheit. Dateien sind eine explizite Synchronisierungsoberfläche, die Sie exportieren, bearbeiten, in der Vorschau anzeigen und importieren können. |
+| Lokaler Dateimodus           | Dateien sind die Quelle der Wahrheit. Die Inhaltsseitenleiste und der Editor arbeiten direkt mit lokalen Dateien.                                                                             |
+
+Verwenden Sie Export/Import, wenn Sie gelegentlich Dateien in einem gehosteten Arbeitsbereich überprüfen möchten.
+Verwenden Sie den lokalen Dateimodus, wenn das Repo selbst der Arbeitsbereich ist.
+
+## Geschichte und Zusammenarbeit
+
+Der lokale Dateimodus basiert auf dem dateinativen Verlauf:
+
+- übertragen Sie wichtige Änderungen an Git
+- Pull-Anfragen zur Überprüfung verwenden
+- Lassen Sie Codierungsagenten dieselben Dateien direkt bearbeiten
+- Verwenden Sie normale Dateiunterschiede, um Änderungen zu verstehen
+
+Der Datenbankmodus eignet sich weiterhin besser für gehostete Kollaborationsfunktionen wie
+Freigabe, Kommentare, SQL-gestützter Versionsverlauf und Live-Mehrbenutzerbearbeitung.
+
+Die Anbietersynchronisierung kann über beide Modi gelegt werden. Beispielsweise kann ein Dokumenten-Repository
+Fügen Sie actions hinzu, die Inhalte von einem CMS in lokale MDX-Dateien ziehen oder ausgewählte Dateien per Push übertragen
+lokale Dateien zurück zu diesem CMS.
+
+## Produktionssicherheit
+
+Der lokale Dateimodus gewährt der App actions direkten Schreibzugriff auf den konfigurierten Arbeitsbereich
+Dateien. Dies eignet sich für die lokale Entwicklung und vertrauenswürdige Single-Tenant-Dateien
+Brücken, aber es ist nicht das Standard-Produktionssicherheitsmodell.
+
+Bei `NODE_ENV=production` verweigert das Framework den `local-files`-Modus, es sei denn, Sie
+set:
+
+```bash
+AGENT_NATIVE_ALLOW_LOCAL_FILES_IN_PRODUCTION=true
+```
+
+Legen Sie dies nur für eine vertrauenswürdige Einzelmandantenbereitstellung fest, die jeder verwenden kann
+Die App darf die konfigurierten Dateien lesen und schreiben. Für normales Hosting:
+Mehrbenutzer-Apps, verwenden Sie den Datenbankmodus und SQL-gestützte Freigabe.

package/corpus/core/docs/content/locales/de-DE/mcp-apps.md

@@ -0,0 +1,147 @@
+---
+title: "MCP Apps"
+description: "Erstellen und betten Sie interaktive MCP-Apps UIs in Claude, ChatGPT und anderen kompatiblen Hosts ein – unter Verwendung echter App-Routen, der Embed Bridge und der Host Bridge API."
+---
+
+# MCP Apps
+
+**Diese Seite: Inline-UIs in Claude/ChatGPT.** Erstellen von MCP-App-Ressourcen und der Einbettungsbrücke, die eine echte App-Route im Chat eines kompatiblen Hosts rendert. Diese Seite ist auch die einzige Startseite für die **Client-Support-Matrix** ([below](#client-support)).
+
+| Wenn Sie möchten...                                                                                    | Lesen                                    |
+| ------------------------------------------------------------------------------------------------------ | ---------------------------------------- |
+| Verbinden Sie einen externen Agenten/Host mit Ihrer App                                                | [External Agents](/docs/external-agents) |
+| Geben Sie Ihrem Agent mehr Tools (nutzen Sie andere MCP-Server)                                        | [MCP Clients](/docs/mcp-clients)         |
+| Erstellen Sie Inline-UIs, die in Claude/ChatGPT rendern                                                | **Diese Seite** – MCP Apps               |
+| MCP-Serverreferenz auf niedrigerer Ebene (Authentifizierung, Tools, benutzerdefinierte Bereitstellung) | [MCP Protocol](/docs/mcp-protocol)       |
+
+MCP Apps sind die offizielle `io.modelcontextprotocol/ui`-Erweiterung, mit der kompatible Hosts – Claude, Claude Desktop, ChatGPT, VS Code GitHub Copilot, Goose, Postman, MCPJam und Cursor – interaktive UIs inline im Chat rendern können. In agentennativen Apps ist jede MCP-App eine **echte React-Route** und kein separates einfaches HTML-Widget.
+
+Im eigenen Chat einer Agent-Native-App bevorzugen Sie [native chat renderers](/docs/native-chat-ui) für Erstanbieter-Widgets wie Tabellen, Diagramme, eingegebene Ergebnisse und Genehmigungsangebote. Verwenden Sie MCP-Apps für externe/hostübergreifende Inline-UI in Claude, ChatGPT, Copilot, Cursor und anderen kompatiblen Hosts mit der Aktion `link` als universellem Deep-Link-Fallback.
+
+## Erstellung: optionale MCP Apps UI {#mcp-apps}
+
+Für Hosts, die die MCP Apps-Erweiterung unterstützen, kann eine Aktion auch eine Inline-UI-Ressource mit `mcpApp` ankündigen. Hierbei handelt es sich um eine progressive Verbesserung für Abläufe, bei denen der externe Agent dem Benutzer eine interaktive Oberfläche statt nur Text zur Verfügung stellen soll – zum Beispiel die Überprüfung eines E-Mail-Entwurfs, die Bearbeitung einer Kalendereinladung oder die Auswahl zwischen generierten Dashboard-Varianten.
+
+Verwenden Sie die echte React-App mit `embedRoute()` oder `embedApp()`, wann immer der Benutzer UI benötigt. Das mentale Modell ist einfach: Das `link`-Ziel der Aktion ist auch das MCP-App-Einbettungsziel. Stellen Sie den Vorgang als normale Aktion/Tool bereit, geben Sie einen fokussierten Deep Link mit `link` zurück und fügen Sie `mcpApp.resource = embedApp(...)` hinzu, damit fähige Hosts dieselbe Route inline laden, anstatt einen neuen Tab zu öffnen. Wenn beide auf derselben Route erstellt werden sollen, bevorzugen Sie `embedRoute({ title, openLabel, path })`: Es handelt sich um den Convenience-Wrapper, der passende `link`- und `mcpApp`-Felder aus einem Aufruf zurückgibt, während `embedApp(...)` die untergeordnete Ressource ist, die Sie `mcpApp.resource` direkt zuweisen.
+
+Das bedeutet, dass vollständige App-Einbettungen alles tun können, was die Route nach dem Öffnen tun kann: einen E-Mail-Entwurf überprüfen oder bearbeiten, einen gefilterten Posteingang/eine gefilterte Suche anzeigen, ein Kalenderereignis oder einen Ereignisentwurf öffnen, eine Erweiterungsseite laden, ein vollständiges Analyse-Dashboard oder eine gespeicherte Analyse überprüfen, eine Präsentation im Folieneditor fortsetzen oder ein Designprojekt/-editor öffnen. Ziehen Sie URL/Deep-Link-Parameter und die vorhandene `/_agent-native/open`-Navigations-/App-Statusbrücke der Erfindung eines zweiten Statusprotokolls für MCP-Apps vor.
+
+In seltenen Fällen ist das richtige Ziel eine fokussierte App-Route, die eine gemeinsam genutzte React-Komponente anstelle der gesamten App-Shell rendert. Die `/chart`-Route von Analytics ist das Vorbild: Sie nimmt eine kompakte `SqlPanel`-Nutzlast im URL und rendert dieselbe Diagrammkomponente, die das Dashboard verwendet. Dies ist immer noch eine App-Einbettung, keine einfache HTML MCP-App. Stellen Sie es über eine normale Aktion / `open_app({ path, embed: true })` bereit oder rufen Sie es auf, halten Sie URL deterministisch und lassen Sie `embedApp()` diese Route inline rendern.
+
+Schreiben Sie keine einmaligen einfachen HTML MCP-Apps für das Produkt UI von Hand. Wenn die Aktion eine benutzerdefinierte Oberfläche benötigt, fügen Sie zuerst eine echte App-Route/-Komponente hinzu oder verwenden Sie sie erneut und betten Sie diese Route ein.
+
+```an-diagram title="MCP App embed round-trip" summary="The action's link target is also the embed target. Capable hosts load the same signed app route inline; everyone else falls back to the deep link."
+{
+  "html": "<div class=\"diagram-embed\"><div class=\"diagram-card\" data-rough><strong>Action</strong><small class=\"diagram-muted\">`link` target = MCP App embed target</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\" data-rough><strong>embedApp()</strong><span class=\"diagram-pill accent\">create_embed_session</span><small class=\"diagram-muted\">mints short-lived embed session</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\" data-rough><strong>/_agent-native/embed/start</strong><small class=\"diagram-muted\">exchanges one-time SQL ticket</small></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-card\" data-rough><strong>Signed app route</strong><span class=\"diagram-pill ok\">real React route</span><small class=\"diagram-muted\">short-lived browser session</small></div><div class=\"diagram-fallback\"><span class=\"diagram-pill warn\">no MCP Apps support</span><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&darr;</div><div class=\"diagram-box\" data-rough>&quot;Open in … &rarr;&quot; deep link</div></div></div>",
+"css": ".diagram-embed{display:flex;align-items:center;gap:12px;flex-wrap:wrap}.diagram-embed .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px;min-width:140px}.diagram-embed .diagram-arrow{font-size:22px;line-height:1}.diagram-embed .diagram-fallback{display:flex;flex-direction:column;align-items:center;gap:6px;margin-inline-start:8px}"
+}
+
+```
+
+```ts
+import { embedApp } from "@agent-native/core";
+
+export default defineAction({
+  // ...description, schema, run, link...
+  mcpApp: {
+    resource: embedApp({
+      title: "Review draft",
+      description: "Open the generated draft in the real Mail compose UI.",
+      iframeTitle: "Agent-Native Mail",
+      openLabel: "Open in Mail",
+    }),
+  },
+});
+```
+
+```an-annotated-code title="The mcpApp resource config"
+{
+  "filename": "actions/review-draft.ts",
+  "language": "ts",
+  "code": "import { embedApp } from \"@agent-native/core\";\n\nexport default defineAction({\n  // ...description, schema, run, link...\n  mcpApp: {\n    resource: embedApp({\n      title: \"Review draft\",\n      description: \"Open the generated draft in the real Mail compose UI.\",\n      iframeTitle: \"Agent-Native Mail\",\n      openLabel: \"Open in Mail\",\n    }),\n  },\n});",
+  "annotations": [
+    { "lines": "6", "label": "Progressive enhancement", "note": "`mcpApp.resource` advertises an inline UI for hosts that support the MCP Apps extension. Keep the action's `link` builder too — CLI-only and older hosts ignore the UI metadata and still need the deep link." },
+    { "lines": "7", "label": "Embed = the link target", "note": "`embedApp()` uses the action's `link` as its launch target: it calls `create_embed_session`, exchanges a one-time SQL ticket at `/_agent-native/embed/start`, and navigates the MCP App frame to the same signed app route." },
+    { "lines": "11", "label": "Universal fallback label", "note": "`openLabel` is the visible `\"Open in … →\"` text used as the deep-link escape hatch when a host does not render the inline iframe." }
+  ]
+}
+```
+
+Der MCP-Server kündigt die Erweiterung `io.modelcontextprotocol/ui` an, fügt `_meta.ui.resourceUri` plus `_meta["ui/resourceUri"]` zu `tools/list` hinzu und gibt außerdem ChatGPT Apps SDK-Kompatibilitätsmetadaten aus (`openai/outputTemplate`, Widget CSP/description/accessibility). Es macht HTML über `resources/list`, `resources/templates/list` und `resources/read` unter Verwendung von MIME `text/html;profile=mcp-app` verfügbar. Der stdio-Proxy leitet diese Ressourcenhandler von der Live-App weiter, sodass Desktop- und CLI-Clients dieselben Ressourcen sehen wie HTTP-Clients.
+
+Behalten Sie den vorhandenen `link`-Builder bei, auch wenn Sie `mcpApp` hinzufügen. Nur CLI-Clients, ältere Hosts und alle Hosts, die MCP-Apps nicht rendern, ignorieren die UI-Metadaten und benötigen weiterhin den `"Open in … →"`-Link. `embedApp()` verwendet diesen Link als Startziel, ruft den Nur-App-Helper `create_embed_session` auf, tauscht ein einmaliges SQL-Ticket bei `/_agent-native/embed/start` aus und navigiert den MCP-App-Frame mit einer kurzlebigen Browsersitzung und einem Bearer-Fallback für Abrufe desselben Ursprungs zur Zielroute. `open_app({ app, path, embed: true })` ist die allgemeine Notausstiegsmöglichkeit für Routen wie vollständige Dashboards, gefilterte Posteingänge, Kalenderentwurfsansichten, Analysen und Erweiterungsseiten und sollte großzügig verwendet werden, wenn die vollständige App die übersichtlichste Überprüfungs-/Bearbeitungsoberfläche darstellt.
+
+`embedApp()` schließt den MCP-Anforderungsursprung in die Ressource CSP ein, sodass der Launcher die signierte Erstanbieter-App-Route abrufen und bei expliziter Anforderung ein Frame erstellen kann. Dispatch fügt seiner `open_app`-Ressource die genauen Ursprünge für die gewährten Apps hinzu, sodass ein einzelner Dispatch-Connector Mail, Kalender, Folien und den Rest einbinden kann, ohne jeden HTTPS-Ursprung zuzulassen. Übergeben Sie nur zusätzliche Frame- oder Ressourcendomänen für eine benutzerdefinierte MCP-App, die tatsächlich einen Drittanbieter-Player einbettet oder Drittanbieter-Assets lädt.
+
+Innerhalb dieser `embedApp()`-Routen ist `sendToAgentChat()` einbettungsfähig. Automatisch übermittelte Eingabeaufforderungen werden als `ui/update-model-context` plus `ui/message` an den MCP-Host weitergeleitet, sodass eine Schaltfläche in der eingebetteten App die Claude/ChatGPT-Konversation absichtlich vom ausgewählten App-Status aus fortsetzen kann. Verborgener Kontext wird als Modellkontext gesendet; Der sichtbare Benutzerzug bleibt nur die Eingabeaufforderung der App, wodurch eine gruselige Zustimmung des Hosts zu internen Dateipfaden für den App-Status vermieden wird. `submit: false` bleibt lokales Vorabfüll-/Überprüfungsverhalten.
+
+## Erstklassige MCP App Bridge {#mcp-app-bridge}
+
+MCP App-Einbettungen sind Routeneinbettungen, keine separaten Miniprodukte. `embedApp()` startet vom `link`-Ziel der Aktion, erstellt eine kurzlebige Einbettungssitzung und startet die signierte App-Route. Standard-MCP-Apps-Hosts können im MCP-App-Frame selbst navigieren, wenn der Host die Route direkt hydrieren kann.
+
+```an-diagram title="Two host bridge paths, one signed route" summary="Claude transplants the hydrated route and uses the direct ui/_bridge; ChatGPT gets a controlled iframe via window.openai and relays host actions over postMessage. Both point at the same signed app route."
+{
+  "html": "<div class=\"diagram-bridge\"><div class=\"diagram-col\"><div class=\"diagram-card\" data-rough><strong>Claude web</strong><span class=\"diagram-pill accent\">single-frame transplant</span><small class=\"diagram-muted\">hydrates signed app HTML in Claude's iframe, then direct`ui/_` host bridge</small></div><div class=\"diagram-card\" data-rough><strong>ChatGPT web</strong><span class=\"diagram-pill accent\">controlled route iframe</span><small class=\"diagram-muted\">`window.openai`host APIs ·`agentNative.mcpHost.*` postMessage relay</small></div></div><div class=\"diagram-arrow diagram-muted\" aria-hidden=\"true\">&rarr;</div><div class=\"diagram-box\" data-rough>Same signed app route<br><small class=\"diagram-muted\">normal route + React components</small></div></div>",
+"css": ".diagram-bridge{display:flex;align-items:center;gap:14px;flex-wrap:wrap}.diagram-bridge .diagram-col{display:flex;flex-direction:column;gap:12px}.diagram-bridge .diagram-card{display:flex;flex-direction:column;gap:6px;padding:14px 16px;max-width:300px}.diagram-bridge .diagram-arrow{font-size:22px;line-height:1}.diagram-bridge .diagram-box{padding:16px 18px;text-align:center}"
+}
+
+```
+
+Claude Web verwendet einen Single-Frame-Transplantationspfad: Das Ressourcendokument ruft die signierte App HTML ab und hydratisiert sie im MCP-App-Iframe von Claude, da Claude App-eigene untergeordnete Iframes oder externe Frame-Navigation nicht zuverlässig zulässt. Das ChatGPT-Web erhält einen kontrollierten Routen-Iframe, da die Apps-Brücke uns stabile `window.openai`-Host-APIs und eine begrenzte Höhenkontrolle bietet. Alle Pfade verweisen auf dieselbe signierte App-Route und rendern die normale Route und die React-Komponenten. Entwerfen Sie eingebettete Routen, sodass ein Neuladen mit demselben signierten URL dieselbe Ansicht wiederherstellt.
+
+Für die gleiche App `open_app({ embed: true })` prägt das Framework das Embed-Start-Ticket während des ursprünglichen Tool-Aufrufs und speichert den signierten Start URL in versteckten Tool-Metadaten. Benutzerdefinierter actions kann `embedStartUrl` für denselben schnellen Pfad zurückgeben; Die MCP-Schicht entfernt das Ticket tragende URL aus dem modellsichtbaren `structuredContent` und den normalen Open-Link-Metadaten. Wenn kein Einbettungsstart URL vorhanden ist, greift die Ressource auf den Nur-App-Helper `create_embed_session` zurück. Dadurch bleiben Produktionshosts, die iframe-initiierte Toolaufrufe einschränken, auf der direkten Route, ohne dass einmalige App-Sitzungs-URLs in das Transkript gelangen. Wenn ein Benutzer einen alten Chat erneut öffnet, nachdem ein einmaliges Startticket abgelaufen ist, gibt die Startroute eine kleine Aktualisierungsseite zurück und postet `agentNative.embedSessionExpired` im Wrapper; `embedApp()` beseitigt den veralteten Start URL und prägt ein neues Ticket über `create_embed_session`, wenn noch die ursprüngliche App-Route vorhanden ist.
+
+ChatGPT erhält einen dedizierten Kompatibilitätspfad über `window.openai`: Das Startdokument liest `toolInput`, `toolOutput` und `toolResponseMetadata` direkt und ruft dann `create_embed_session` über `window.openai.callTool(...)` auf. Standard-MCP-Apps-Hosts verwenden die `ui/*` JSON-RPC-Brücke. Direkt hydrierte Routen können `ui/update-model-context`, `ui/message`, `ui/open-link` und `ui/request-display-mode` über die Host-Bridge-Helfer aufrufen. Die transplantierte Route von Claude verwendet nach der Hydratation dieselbe direkte `ui/*`-Wirtsbrücke. Wenn der ChatGPT- oder explizite Diagnose-Iframe-Pfad verwendet wird, leitet der Wrapper denselben Host actions über `agentNative.mcpHost.*`-PostMessage-Anfragen weiter. Halten Sie die Ergebnisform für beide Pfade identisch: Geben Sie einen fokussierten `link` und einen prägnanten strukturierten Inhalt zurück.
+
+Stellen Sie den Standard-`_meta.ui.domain` nicht auf eine App URL ein. MCP Apps behandelt dieses Feld als hostspezifisch: Claude validiert Sandbox-Domänen im `{hash}.claudemcpcontent.com`-Stil, während ChatGPT seine eigenen `openai/widgetDomain`-Metadaten verwendet. Lassen Sie `ui.domain` weg, es sei denn, Sie geben absichtlich einen hostspezifischen Wert aus; Der Host wählt einen Standard-Sandbox-Ursprung.
+
+Erweiterungsseiten behalten ihre Sandbox in MCP-Chat-Einbettungen, ohne einen zweiten Routen-Iframe zu navigieren. Bei normaler App-Nutzung wird `/_agent-native/extensions/:id/render` als untergeordneter Sandbox-Iframe gerendert. Im MCP-Chat-Bridge-Modus rendert das Framework dasselbe Erweiterungsdokument wie das Sandbox-`srcDoc` innerhalb des Routen-Iframes und vermeidet so Ausfälle des Hosts `frame-ancestors`/`X-Frame-Options`, während `sandbox="allow-scripts allow-forms"` erhalten bleibt.
+
+Die Ressourcen-Shell besitzt die äußere Hostgröße. `embedApp({ height })` ist standardmäßig auf `560px` eingestellt, klemmt die Schale auf `320-900px` und reserviert `44px` für die kleine Symbolleiste, sodass das Routenansichtsfenster `height - 44px` ist. Halten Sie eingebettete App-Routen intern scrollbar und lassen Sie den Launcher die begrenzte intrinsische Höhe und nicht die gesamte Dokumenthöhe melden; Andernfalls kann die automatische Größenänderung des Hosts eine normale App-Seite in ein sehr großes Chat-Artefakt verwandeln. Eine geänderte Shell wirkt sich nur auf neue MCP-App-Ressourcen und neue Tool-Aufrufe aus. Alte ChatGPT/Claude-Konversationsrahmen können das vorherige Ressourcenverhalten beibehalten. Überprüfen Sie daher die Größe mit einem neuen Inline-Rendering, bevor Sie über eine Korrektur entscheiden.
+
+### Einbettungsmodi {#embed-modes}
+
+Claude verwendet standardmäßig den Single-Frame-Transplantationspfad. Sie können es auch auf anderen Hosts mit `embedMode: "transplant"` oder `frame: "transplant"` erzwingen, wenn Sie das Ladeverhalten von Hostmodulen debuggen. Sie können den verschachtelten Diagnose-Iframe mit `embedMode: "iframe"`, `renderMode: "iframe"`, `nested: true` oder `frame: "iframe"` erzwingen. Wenn der Iframe blockiert ist, ersetzt `embedApp()` ihn durch einen Open-App-Fallback: Der Benutzer kann es inline erneut versuchen, eine frisch erstellte Einbettungssitzung über den Host öffnen oder die sichtbare Route URL verwenden. Halten Sie das `link`-Ziel der Aktion für sich genommen nützlich, da es immer noch die universelle Notluke ist.
+
+Wenn Sie Claude über ngrok testen, verwenden Sie einen Produktions-Build (`npx @agent-native/core@latest build`, dann `npx @agent-native/core@latest start`) oder eine bereitgestellte Vorschau/Produktion URL. Der Single-Frame-Transplantationspfad von Claude funktioniert mit Produktions-Asset-Chunks; Rohe Vite-Entwicklungsmodule wie `/app/root.tsx` können durch App-Authentifizierung geschützt werden und dynamische Importe vom Claude-Ressourcesursprung scheitern lassen.
+
+## Hostbrücke API {#host-bridge}
+
+Die Host-Bridge ist bewusst klein:
+
+| Modus                  | Nachrichtentyp                        | Verwenden Sie es für                                            |
+| ---------------------- | ------------------------------------- | --------------------------------------------------------------- |
+| direkte Host-Route     | `ui/update-model-context`             | Versteckter Kontext für das Hostmodell                          |
+| direkte Host-Route     | `ui/message`                          | Veröffentlichen Sie eine sichtbare Benutzerübergabe an den Host |
+| direkte Host-Route     | `ui/open-link`                        | Öffnen Sie eine externe oder App URL über den Host              |
+| direkte Host-Route     | `ui/request-display-mode`             | Anfrage `inline`, `fullscreen` oder `pip`                       |
+| Claude-Transplantation | `ui/*`                                | Gleiche direkte Wirtsbrücke nach der Hydratation                |
+| ChatGPT / Iframe-Route | `agentNative.mcpHostContext`          | Theme, Gebietsschema, Hostplattform, Dimensionen                |
+| ChatGPT / Iframe-Route | `agentNative.embeddedAppReady`        | Bestätigen Sie, dass der Routen-Iframe geladen wurde            |
+| ChatGPT / Iframe-Route | `agentNative.mcpHost.*` / `.response` | Wrapper-Relay für Host-Anfragen                                 |
+
+Eingebettete Routen können `updateMcpAppModelContext()`, `openMcpAppHostLink()`, `requestMcpAppDisplayMode()`, `getMcpAppHostContext()` und `useMcpAppHostContext()` von `@agent-native/core/client` verwenden. `sendToAgentChat()` verwendet denselben Pfad wie vollständige App-Einbettungen für automatisch übermittelte Eingabeaufforderungen.
+
+Anzeigemodus ist Best-Effort. Der In-App-`McpAppRenderer` meldet derzeit einen Inline-Webhost-Kontext und einen Nur-Inline-Anzeigemodus; Externe Hosts berücksichtigen möglicherweise größere Anzeigeanforderungen, ignorieren sie oder antworten mit einem Fehler im nicht unterstützten Modus. Halten Sie die Inline-Route immer nutzbar.
+
+## Client-Unterstützung und Caching {#client-support}
+
+Die aktuelle offizielle Kundenliste von MCP Apps umfasst Claude, Claude Desktop, VS Code GitHub Copilot, Goose, Postman, MCPJam, ChatGPT und Cursor; Die Host-Unterstützung variiert immer noch je nach Plan, Release-Kanal und Client-Version. Überprüfen Sie daher [MCP extension support matrix](https://modelcontextprotocol.io/extensions/client-matrix). Benutzerdefinierte ChatGPT-Apps von MCP sind über den Entwicklermodus für Business- und Enterprise/Edu-Arbeitsbereiche im ChatGPT-Web verfügbar. siehe OpenAIs [developer mode and MCP apps](https://help.openai.com/en/articles/12584461-developer-mode-and-full-mcp-apps-in-chatgpt-beta)-Hinweise.
+
+Claude Code, Codex und andere CLI/Code-Editor-Clients erhalten weiterhin dieselben Ressourcen und Metadaten, wenn sie MCP-Apps unterstützen, behandeln sie jedoch als Link-Out-Hosts, es sei denn, Sie haben das Inline-Iframe-Rendering in genau dieser Oberfläche überprüft. Der Deep Link bleibt der zuverlässige Fallback, wenn ein Host beschließt, einen Iframe nicht zu rendern. In der Praxis sollte jede agentennative App mit beidem erstellt werden: MCP Apps für die Inline-Überprüfung/-Bearbeitung in fähigen Hosts und `link` für universelles Roundtripping zurück zur vollständigen App.
+
+Claude und ChatGPT können Tool- und Ressourcenmetadaten für einen vorhandenen benutzerdefinierten Connector zwischenspeichern. Nachdem Sie die Metadaten der MCP-App geändert haben, überprüfen Sie dies mit einem neuen Tool-Aufruf. Wenn der Host immer noch den alten Deskriptor verwendet, schließen Sie den Claude-Anschluss erneut an oder scannen/überprüfen Sie den ChatGPT-Anschluss erneut, damit der Katalog aktualisiert wird. Wenn Claude nach einer Bereitstellung eine Warnung darüber protokolliert, dass `_meta.ui.csp` oder `_meta.ui.permissions` im Tool-Deskriptor vorhanden sind, verwendet dieser Connector veraltete Metadaten: Löschen Sie den Claude-Connector, verbinden Sie ihn erneut und starten Sie einen neuen Chat.
+
+## Testen {#testing}
+
+Testen Sie MCP-Apps mit den leichten Geräten rund um `embedApp()` und `McpAppRenderer`; Sie decken CSP, Hostkontext, App-Start und Bridge-Nachrichtenverhalten ab, ohne dass ein echter externer Host erforderlich ist. Lösen Sie bei der Validierung des ChatGPT- oder Claude-Webs nach Shell-Änderungen einen neuen Tool-Aufruf aus und messen Sie den sichtbaren Iframe. Zuvor gerenderte Frames in derselben Konversation zeigen möglicherweise immer noch die zwischengespeicherte Höhe oder das Startverhalten.
+
+## Verwandt {#related}
+
+- [External Agents](/docs/external-agents) – Verbindung von Claude, ChatGPT, Codex und Cursor mit gehosteten Apps; MCP Apps-Kompatibilitätsmatrix; Katalogebenen; Deep-Links.
+- [MCP Protocol](/docs/mcp-protocol) – der automatisch gemountete MCP-Server, Authentifizierung, Tools und `ask-agent`.
+- [Actions](/docs/actions) – `defineAction`, der `link`-Builder, `publicAgent`.
+
+```
+
+```