Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Erweiterbarkeit

Erweiterbarkeit des Ökosystems und Leitplanken des Compilers

1. Die universelle WebAssembly-(Wasm-)Schnittstelle

Um architektonische Symmetrie im gesamten Ökosystem sicherzustellen, verwendet Aggrega einen standardisierten Ausführungsvertrag, der einheitlich für jeden Wasm-Socket in der Compiler-Pipeline gilt.

Die YAML-Schnittstelle zum Aufrufen jedes Plugins stützt sich auf zwei bewusst gewählte Schlüsselwörter: function und with.

  • function: Aggrega bettet eine Wasm-Laufzeit ein (das Extism-Toolkit auf der Wazero-Engine) und führt Wasm direkt im Speicher aus, sodass kein Betriebssystemprozess gestartet wird. function benennt den Export, den der Go-Host aufruft: eine explizit exportierte Funktion des Wasm-Moduls.
  • with: die eigenen Eingaben des Plugins, getrennt von den values des Entwicklers und von den parameters, die ein Release erfüllt. Das Schlüsselwort folgt der Konvention von GitHub Actions (with:); wo ein Plugin ein JSON Schema für seine Eingaben deklariert, validiert der Host sie vor der Ausführung dagegen.

Die Typen von Wasm-Plugins: Diese universelle Schnittstelle aus function und with unterstützt jeden programmierbaren Socket im Compiler:

Plugin-TypWo es läuftZweckErwartete Ausgabe
Provider (provider)Rendering (Generierung)Übersetzt die endgültige In-Memory-IR in physische, als Zeichenketten serialisierte Dateien für ein Zielformat (Helm, Terraform, Compose).Ein Array von als Zeichenketten serialisierten Dateien.
FeatureRecipe-Pipeline-Schritt (pipeline-step)Die Plugin-Pipeline eines Recipe oder FeatureRecipeSequenzielle Schritte, die Secrets abrufen oder Sidecars in Basis-ASTs injizieren.RFC-6902-patches gegen die nach Schlüsseln geordnete Dokumentmenge, dazu side_effects (ein neues Dokument oder eine neue Datei ausgeben), diagnostics und outputs, die ein späterer Schritt lesen kann. Die Schritteingabe enthält diese nach Schlüsseln geordnete Dokumentmenge und die gerenderte with-Eingabe des Schritts.
Governance (governance)Vor der Annotationsexpansion, Topologieaufbau, statische Analyse oder Render-PhaseErfüllt die Governance-Rollen der Build-Pipeline. Vor der Annotationsexpansion fügt es Annotationen in aufgelöste Komponenten ein, und beim Topologieaufbau versieht es Knoten automatisch mit Compliance- oder Umgebungs-Labels (ein Betreiber aktiviert eines ausdrücklich für die eine oder die andere Rolle). Bei der statischen Analyse oder in der Render-Phase agiert es als Loud Guardrail: Es bewertet Graphkanten, Pfade und Labels — oder die gerenderten Artefakte — gegen Sicherheitsgrenzen. Die Rolle, an die es angebunden ist, nicht sein Typ, legt fest, was es ausgeben darf.Vor der Annotationsexpansion Annotationsinjektionen. Beim Topologieaufbau ein Array von JSONPatches, die auf metadata.labels zielen. Bei der statischen Analyse oder in der Render-Phase Urteile mit Schweregrad halt, warn oder info (eine Rego-Policy sammelt sie unter deny, warn und audit); ein halt bricht den Build ab.
Linter (linter)Außerhalb des BuildsOptionale FinOps- oder Hygiene-Prüfungen (z. B. Cloud-Kostenschätzung aus .infra) und Disziplin zum Veröffentlichungszeitpunkt.Warnungstexte oder fatale Abbrüche.
CLI-Erweiterung (cli)Laufzeit (aggrega <command>)Ein einsteckbarer Befehl der obersten Ebene, beigesteuert von einem signierten, in einer Sandbox laufenden Plugin, ohne befehlsspezifischen Go-Code im Host.Gestreamte Standardausgabe und Standardfehlerausgabe sowie der Exit-Code des Gasts.
Parser (parser)Bei Bedarf, überall dort, wo ein fremdes Format gelesen wirdWandelt fremden Quelltext (HCL, TOML, YAML, JSON, JSON mit Kommentaren) in einen kanonischen JSON-Baum um.tree plus diagnostics und optionale Quell-spans.
Importer (importer)Bei Bedarf, außerhalb jedes Builds (aggrega import, der Editor und das import-Werkzeug des Assistenten)Wandelt eine fremde Infrastruktur- oder Agentendefinitionsquelle (Langflow, Flowise, n8n, eine MCP-Konfiguration, eine Compose-Anwendung, eine Dify-Anwendung, die deklarierten Agenten eines CrewAI-Projekts, die Konfiguration einer LangGraph-Anwendung, die Agentenkonfigurationen einer Google-ADK-Anwendung, einen deklarativen Agenten von Agent Framework) in Entwürfe von Aggrega-Authoring-Dateien um und gibt die Formate, die es verarbeitet, als import:<format>-Capabilities an.Entwürfe von Aggregate- / Component- / Release-Entitäten oder Referenzen auf die Katalog-Components, die er wiederverwendet, die zugrunde liegenden Mapping-Entscheidungen, Diagnosen und die zu schreibenden Scaffold-Dateien.

Die Host-Laufzeit: eine Sandbox, die Capabilities verweigert. Aggrega bettet den Wasm-Host als das Extism-Toolkit auf der Wazero-Engine ein; die Host-Binärdatei bleibt reines Go ohne Abhängigkeit von einer nativen Toolchain, sodass sich aggrega problemlos cross-kompilieren lässt. Jeder Socket läuft hinter einer AOT-Reinheits-Firewall: Der Host weigert sich, einem Plugin irgendeine Capability für Laufzeitzugriff zu gewähren — kein Netzwerk, kein Dateisystem, keine Systemuhr, keine Umgebung, keine Standard-E/A —, sodass ein Aufruf, der eine davon nutzen würde, fehlschlägt, und ein Plugin, das aus einer Host-Oberfläche importiert, die der Host nicht bereitstellt, beim Laden abgelehnt wird. Ein Plugin, das weder das Netzwerk erreichen noch die Uhr lesen kann, kann die Ahead-of-Time-Garantie des Compilers nicht brechen, dass dieselbe Eingabe dieselbe Ausgabe erzeugt. Sprachlaufzeiten, die einige harmlose Start-Importe benötigen, laufen gegen eine Konfiguration dieser Importe, die Capabilities verweigert: Der Host fixiert die beobachtbare Uhr, liefert echte Entropie, verwirft die Standard-E/A und gewährt keinen Zugriff auf Dateisystem, Argumente oder Umgebung — sodass ein Plugin keine Host-Capability erreichen kann, die zwischen Builds variiert. Die Entropie wird bewusst echt gelassen statt fixiert: Ihre Fixierung würde den internen Hash-Seed und die Map-Iterationsreihenfolge der Sprachlaufzeit eines Gasts stabilisieren und so ein Plugin verbergen, dessen eigene Ausgabe nicht reproduzierbar ist, statt dies als abweichende Ausgabe sichtbar werden zu lassen. Ein Plugin, dessen Ergebnis von Entropie abhängt, hat ein Determinismusproblem auf Authoring-Ebene, und diese Konfiguration ist darauf ausgelegt, es aufzudecken statt es zu verschleiern.

Gegen den Host entwickeln: das PDK. Plugin-Autoren schreiben die Wasm-Speicher-ABI nicht von Hand. Aggrega liefert ein Plugin Development Kit in drei Sprachen — Go, Rust und TypeScript —, schlanke Wrapper, die die typisierte Ein- und Ausgabe jedes Sockets bereitstellen, sodass der Autor gewöhnliche Funktionen schreibt. Die obige Schnittstelle function / with ist das, womit ein Aggregate oder ein FeatureRecipe ein Plugin aufruft; das PDK ist das, gegen das ein Plugin-Autor entwickelt.

Wo jeder Socket läuft. Jeder Socket läuft über denselben Host: der Publishing-Linter unter aggrega lint; die Governance-Rollen, die Render-Provider und die Pipeline-Schritte von Recipe und FeatureRecipe während aggrega build; Parser überall dort, wo ein Fremdformat gelesen wird; Importer unter aggrega import; und CLI-Plugins als Befehle der obersten Ebene. Siehe Status der Sprache für den Bereitschaftsstand pro Socket.

Welche Plugins gepinnt werden und welche Ihre Umgebung wählt. Aggrega teilt Plugins danach ein, ob sie die Ausgabe ändern, die Sie ausliefern. Ausgabeprägende Plugins — die Render-Provider, die in einer Transformationsrolle angebundenen Governance-Plugins (label-transform, annotation-transform) und die Pipeline-Schritte von FeatureRecipe und Recipe — werden beim aggrega pull im Release-Lockfile gepinnt und bei aggrega build und aggrega serve allein aus diesem Lockfile byte-identisch reproduziert. Zwei Arten werden nicht gepinnt, weil ein Build jede davon jedes Mal von derselben Stelle liest: ein Render-Provider, der aus der Compiler-Binärdatei heraus bereitgestellt wird, und ein Provider oder Pipeline-Schritt, dessen Plugin-Entität in einem Ihrer eigenen Katalogverzeichnisse verfasst ist. Um zu ändern, welches ausgabeprägende Plugin angewendet wird, pullen Sie erneut; eine Änderung Ihrer Workspace-Konfiguration nach einem Pull verändert die Ausgabe eines Builds erst beim nächsten Pull. Gate-Plugins — Richtlinie und Lint — beurteilen einen Build, ohne seine Bytes zu ändern, daher werden sie beim Pull zwischengespeichert (damit ein Build sie auch offline ausführen kann; eines, das die Compiler-Binärdatei mitführt, oder eines, das in Ihrem eigenen Katalogverzeichnis verfasst ist, wird stattdessen von dort gelesen), aber nicht gepinnt: Welches Gate läuft, wählt Ihre Umgebung zur Build-Zeit, sodass eine Aufteilung in tolerante Entwicklung / strenge CI eine gewöhnliche Konfigurationsentscheidung statt eines erneuten Pulls ist, und ein Wechsel der Gates ändert nie die Ausgabe, die ein erfolgreicher Build erzeugt. Plugins, die nur auf Authoring-Eingaben wirken, etwa Importer und CLI-Erweiterungen, prägen keine Build-Ausgabe und sind weder gepinnt noch Teil der zwischengespeicherten Menge des Builds.

2. FeatureRecipe-Plugin-Pipelines

FeatureRecipes binden abstrakte betriebliche Absichten (etwa das Anbinden eines Sicherheits-Proxys oder das Injizieren eines Sidecars) an versionierte WebAssembly-(Wasm)-Plugin-Pipelines. Ops deklariert, was ein Feature an einem konkreten Provider-Ziel benötigt; der Compiler führt die deklarierte Pipeline auf dem flachen IR-Graphen aus.

Diese Bindung hat drei Konsequenzen für das Ökosystem:

  • Entkoppelte Weiterentwicklung. Das Infrastrukturvokabular wächst über externe Wasm-Plugins, ohne dass eine neue Kernversion des Aggrega-Compilers erforderlich ist. Neue Provider, neue Sidecars und neue Sicherheitsintegrationen werden als unabhängige Wasm-Binärdateien gegen die stabile Wasm-ABI ausgeliefert.
  • Semantische Versionierung. FeatureRecipes referenzieren Wasm-Plugins per Version — exakt (:1.0.0) oder als Caret-Bereich (:^1.0.0, die höchste damit kompatible Version). Mit dem Caret-Bereich legt Ops eine Hauptversion fest und übernimmt deren Minor- und Patch-Versionen, sobald die Lockfile mit aggrega pull --upgrade neu aufgelöst wird.
  • Auslagern von Komplexität. Herstellerspezifische CRD-Generierung oder komplexes Rendering (herstellerspezifische Policy-Objekte, provider-native Routing-Ressourcen) liegt in reinen Wasm-Plugins, die auf dem flachen IR-Graphen arbeiten, statt sich durch Schemadeklarationen oder Template-Logik innerhalb von Komponentendefinitionen zu ziehen.

Verkettung von Pipelines — Trennung der Zuständigkeiten über Plugins hinweg. Eine FeatureRecipe-Pipeline kann mehrere Wasm-Plugins nacheinander verketten, wobei jedes vom Compiler denselben IR-Knotenkontext erhält. Das Standardmuster teilt die Verantwortung so auf, dass ein einzelnes Plugin nicht zugleich die semantische Absicht einer Funktionalität und den physischen Mechanismus zum Abfangen des Datenverkehrs einer bestimmten Zielumgebung trägt.

Eine kanonische Kette aus zwei Plugins sieht so aus:

  • Ein Konfigurations-Plugin, das die semantischen Regeln der Funktionalität ausgibt (Sicherheits-Policy-Regeln, Audit-Muster, Rate-Limit-Schwellenwerte). Es versteht die Absicht der Funktionalität; es versteht nicht die Infrastruktur der Zielumgebung zum Abfangen des Datenverkehrs.
  • Ein Routing-Plugin, das die physische Mesh-Konfiguration ausgibt, die diese Regeln transportiert (Gateway-CRDs, Sidecar-Injection-Patches, Firewall-Regeln). Es versteht die Infrastruktur der Zielumgebung; es versteht nicht die semantische Absicht der Funktionalität.

Beide Plugins erhalten nacheinander denselben IR-Knotenkontext vom Compiler und lassen sich daher sauber kombinieren, ohne direkt aneinander gekoppelt zu sein. Der Compiler orchestriert die Pipeline; die Plugins tragen das Domänenwissen.

3. Abfangen von Datenverkehr: Das Ziel HTTPRoute

Das Erweiterbarkeitsmodell von Aggrega zielt auf den HTTPRoute-Standard der Kubernetes Gateway API als providerübergreifendes Artefakt für das Abfangen von Datenverkehr auf Mesh-Ebene. Die Standardbibliothek gibt HTTPRoute-Objekte über das Feature core/http-route aus, dessen helm-FeatureRecipe eine Route pro angebundener Komponente rendert; Zielumgebungen, die die Gateway API verarbeiten, übersetzen HTTPRoute in ihre nativen Infrastrukturen.

4. Plugin-Autonomie: Auflösung von Labels

Wenn Wasm-Plugins physische Ressourcen aus dem IR-Graphen erzeugen, müssen SREs einen laufenden Kubernetes-Pod oder eine Cloud-Ressource bis zur semantischen Absicht des Entwicklers im Aggregate zurückverfolgen können. Das Erweiterbarkeitsmodell von Aggrega legt diese Übersetzung vollständig in die Hand des Autors des Wasm-Plugins.

Der Compiler übergibt das vollständige labels-Dictionary des IR-Graphen ohne Interpretation an die Wasm-Sandbox. Der Plugin-Autor — Platform Ops — entscheidet von dort aus über die Zuordnungslogik: alle Labels unverändert weitergeben, nach bestimmten Domänenpräfixen filtern (*.aggrega.ai/*) oder Graph-Labels direkt auf native Tagging-Schemata des Providers abbilden (ein IR-Label in AWS-tags, Kubernetes-annotations oder einen cloudspezifischen Metadatenmechanismus übersetzen). Der Compiler schränkt nicht ein, wie die erzeugten Artefakte getaggt werden.

Diese Autonomie hält domänenspezifische Intelligenz — welche Labels für die Observability wichtig sind, welche auf native Tagging-Konventionen abgebildet werden, welche plattformintern sind — innerhalb der Wasm-Plugin-Schicht, wo sich das Ökosystem unabhängig vom Veröffentlichungsrhythmus des Go-Compilers weiterentwickelt.

5. CLI-Erweiterungen: Laufzeitbefehle

Die oben beschriebenen Sockets laufen innerhalb eines Builds — der Compiler ruft sie auf, während er ein Aggregate parst, mutiert, validiert und rendert. Der CLI-Erweiterungs-Socket ist grundlegend anders: Er läuft im Terminal, außerhalb jedes Builds, wenn ein Operator aggrega <command> eingibt. Auf diese Weise wächst die Befehlsoberfläche von aggrega selbst ohne neue Kernversion.

Was eine CLI-Erweiterung ist. Eine CLI-Erweiterung ist ein direkt einsetzbarer aggrega <command>, den ein signiertes, in einer Sandbox ausgeführtes Wasm-Plugin beisteuert. Sie folgt demselben Drop-in-Ansatz mit der Logik im Gast wie der Rendering-Socket: Die Domänenlogik liegt vollständig im Gast, und der Go-Host steuert keinen befehlsspezifischen Code bei. Für einen neuen Befehl der obersten Ebene braucht es nur drei Dinge — eine .wasm-Binärdatei, eine Plugin-Entität, die pluginType: cli deklariert (siehe Plugin), und ein explizites aggrega plugin add cli. Der Host erkennt den Befehl aus der Selbstbeschreibung des installierten Plugins; kein Befehl ist in die Binärdatei kompiliert.

Warum ein Laufzeit-Socket kann, was ein Build-Socket nicht kann. Da die Sockets zur Kompilierzeit während eines Builds laufen, bleiben sie ohne Capabilities und deterministisch: Aggrega ist ein Ahead-of-Time-Compiler, und dieselbe Eingabe muss immer dieselbe Ausgabe erzeugen (siehe Architektonische Invarianten). Ein Render- oder Policy-Plugin kann daher weder das Netzwerk erreichen noch die Uhr lesen noch auf das Terminal streamen — alles, was zwischen Läufen variiert, würde diese Garantie brechen. Eine CLI-Erweiterung läuft nach dieser Grenze und außerhalb davon, gesteuert von einem Menschen an einer Eingabeaufforderung statt von der deterministischen Pipeline. Genau deshalb darf ein CLI-Plugin während der Ausführung Standardausgabe und Standardfehler streamen und einen Prozess-Exit-Code zurückgeben: Es gibt kein Build-Artefakt, dessen byteweise Stabilität diese Effekte gefährden könnten.

Installieren, ausführen und entdecken. aggrega plugin add cli <query> durchsucht die konfigurierte Registry nach einem passenden cli-Plugin, prüft es gegen die Vertrauensrichtlinie der Registry und installiert es als Befehl der obersten Ebene — wobei zuerst die deklarierten Capabilities des Plugins ausgegeben werden, sodass der Operator genau bestätigt, was der Befehl tun darf, bevor er installiert wird. Nach der Installation führt aggrega <command> ihn wie jeden integrierten Befehl aus. Ein CLI-Plugin deklariert seine Befehle und deren Flags in seiner describe()-Selbstbeschreibung, und der Host stellt die Flags jedes Befehls in aggrega help <command> genauso dar wie bei einem integrierten Befehl, sodass ein Operator die --flags eines installierten Befehls auf dieselbe Weise entdeckt. Um installierbare Befehle und Kataloginhalte zu finden, durchsucht aggrega search den lokalen Index der konfigurierten Registrys — --kind plugin --plugin-type cli schränkt die Ergebnisse auf installierbare CLI-Plugins ein, und eine ungefilterte Suche umfasst Katalogentitäten; aggrega plugin list zeigt, was bereits installiert ist. Die befehlsspezifischen Flags und Ausgabeformen sind auf diesen Referenzseiten beschrieben.

Das Capability-Modell. Eine CLI-Erweiterung startet mit einer festen Grundausstattung, die jeder Befehl ohne Deklaration und ohne Rückfrage erhält:

Basis-CapabilityGewährt
Befehlszeilenargumente (Eingabe)Immer
Gestreamte Standardausgabe und StandardfehlerImmer
Prozess-Exit-Code (Ausgabe)Immer

Alles, was über die Grundausstattung hinausgeht, ist standardmäßig deaktiviert. Ein Plugin, das mehr benötigt, deklariert jede zusätzliche Capability explizit, und der Host gewährt sie erst, nachdem er sie bei der Installation zur Bestätigung durch den Operator angezeigt hat. Eine über die Grundausstattung hinaus hinzugefügte Capability-Klasse — Zugriff auf Umgebung, Dateisystem oder Netzwerk, interaktive Eingabe — wird hinter derselben Schranke aus Deklaration und Bestätigung gewährt, sodass ein Befehl nie stillschweigend eine Reichweite erlangen kann, die der Operator nicht genehmigt hat.

Integrierte Befehle haben immer Vorrang. Ein installiertes Plugin kann niemals einen integrierten Befehl verdecken. Ein Schutz reservierter Namen, gestützt auf eine Denylist, schützt die integrierten Befehle und eine Reihe von Namen, die für integrierte Befehle reserviert sind, und eine Kollision wird bei der Installation abgelehnt, statt das Kernverhalten überschreiben zu dürfen. Die Befehlsoberfläche, auf die sich ein Operator verlässt, bleibt stabil, unabhängig davon, was darauf installiert wird.

6. Parser-Plugins: Lesen fremder Formate

Der Compiler muss regelmäßig Text lesen, der in einem Format geschrieben ist, das er nicht selbst erzeugt hat — ein Terraform-Modul in HCL, eine Konfigurationsdatei in TOML, eine Manifestdatei in YAML oder JSON. Der Parser-Socket liefert diese Lesefähigkeit, ohne dem Compiler-Kern ein bestimmtes Format beizubringen. Ein Parser ist ein zustandsloses Plugin, das einen fremden Quelltext in einen strukturierten JSON-Baum umwandelt: Übergeben Sie ihm die Bytes einer HCL-Datei, und er gibt denselben Inhalt als JSON-Objekt zurück, das der Rest der Pipeline bereits zu durchlaufen weiß. Jeder Teil des Compilers, der ein Format lesen muss, das er nicht nativ parst, fordert einen geparsten Baum an und arbeitet damit weiter.

Ein Format ist eine Capability, keine Compiler-Funktion. Ein Parser kündigt die Formate, die er verarbeitet, als Capabilities an — parse:hcl, parse:toml und so weiter —, und der Host löst einen Parser anhand des angeforderten Formats auf, führt ihn aus und gibt den Baum zurück. Dies ist dasselbe Drop-in-Modell mit angekündigten Capabilities, dem die Render-Provider und CLI-Plugins folgen: Der Compiler-Kern enthält keine eingebaute Liste von Formaten, daher bedeutet das Hinzufügen eines Formats, ein neues Parser-Plugin auszuliefern, niemals eine neue Kernversion. Parser für HCL, TOML, YAML, JSON und JSON mit Kommentaren werden als Grundausstattung in der Binärdatei mitgeliefert; ein Unternehmen, das ein weiteres Format benötigt, liefert ein Parser-Plugin aus, das es ankündigt.

Die Formatauswahl ist deklarativ und wird nie geraten. Der Host untersucht nie den Inhalt einer Datei, um zu entscheiden, was sie ist. Er wählt ein Format anhand deklarierter Signale in einer festen Rangfolge. Ein Render-Provider kann das Format jeder Datei deklarieren, die er ausgibt, und der Host bevorzugt dieses vom Erzeuger deklarierte Format uneingeschränkt — der Provider, der die Bytes geschrieben hat, ist maßgeblich dafür, wie sie zu lesen sind. Für eine Datei, die der Erzeuger nicht gekennzeichnet hat, dient eine feste Zuordnung von Dateiendungen als Rückfall — .tf wählt HCL, .toml wählt TOML, .yaml wählt YAML, .json wählt JSON. Die Auswahl anhand eines deklarierten Formats oder einer festen Endung hält das Parsen deterministisch und nachvollziehbar: Dieselbe Eingabe wird immer an denselben Parser geleitet, und ein Operator kann ablesen, welcher Parser laufen wird, ohne die Bytes in der Datei zu kennen. Inhaltserkennung würde die Wahl von der Nutzlast abhängig machen, und Aggrega tut das nicht.

Ein Parser ist rein syntaktisch. Die Ausgabe ist ein JSON-Baum plus Diagnosen und optional die Quellpositionen, aus denen jeder Knoten stammt. Ein Parser trägt keine Aggrega-Bedeutung — er gibt wieder, was der Text strukturell aussagt, nichts darüber, was er als Component, Recipe oder andere Entität bedeutet. Einen geparsten Baum in Aggrega-Entitäten umzuwandeln ist ein separates Anliegen, das an anderer Stelle liegt; die einzige Aufgabe des Parsers ist die getreue Übersetzung von Syntax in JSON. Die Leserichtung ist im selben Sinne eine Einbahnstraße: Ein Parser liest ein Format in einen Baum ein, er schreibt kein Format zurück.

Ein Konsument: Policy über Terraform-HCL. Eine Policy der Render-Phase, die das von einem Build erzeugte Terraform untersuchen muss, lernt HCL nicht selbst. Der Host parst das HCL-Artefakt über den Parser-Socket und übergibt dem Policy-Plugin den JSON-Baum, den es bereits liest, sodass die Policy über strukturierte Daten in der Form urteilt, die jeder andere Socket erhält. Neue Leser fremder Formate setzen sich auf dieselbe Weise zusammen — den Host nach dem Baum fragen, dann in JSON arbeiten —, sodass die Fähigkeit des Compilers, ein Format zu verstehen, durch das Hinzufügen von Parser-Plugins wächst statt durch das Wachsen des Kerns.

7. Importer-Plugins: Entwürfe von Authoring-Dateien aus fremden Quellen

Ein Team beginnt selten bei null. Seine Agentenarchitektur existiert oft bereits anderswo — ein Langflow- oder Flowise-Flow, ein n8n-Workflow, eine Dify-Anwendung, die MCP-Server, mit denen ein Client konfiguriert ist, eine Compose-Anwendung, die Agenten, die die Konfiguration eines Frameworks deklariert. Der Importer-Socket macht aus dieser fremden Quelle einen fliegenden Start für das Aggrega-Authoring: Er liest die Quelle und erzeugt erste Entwürfe von Aggregate- und Component-Entitäten sowie aus einer MCP-Konfiguration, einer Compose-Anwendung oder der deklarierten Konfiguration eines Frameworks einen Release-Entwurf, den ein Autor prüft und fertigstellt, sodass ein Team das, was es bereits hat, nach Aggrega mitnimmt, statt es von Hand neu zu schreiben. Ein Importer bildet Bedeutung ab — er liest, was ein Quellknoten ist, und schlägt die Aggrega-Entität vor, die dafür steht, oder belässt ihn in dem Flow, den die entworfene Plattform trägt; der Compiler leitet die ausgegebenen Entitäten undurchsichtig weiter, genau wie er agnostisch gegenüber dem bleibt, was ein Plugin erzeugt.

Ein Format ist eine Capability, keine Compiler-Funktion. Ein Importer kündigt die Formate, die er verarbeitet, als Capabilities an — import:langflow, import:flowise, import:n8n, import:mcp, import:compose, import:dify, import:crewai, import:langgraph, import:google-adk, import:agent-framework und so weiter —, und der Host löst einen Importer anhand des angeforderten Formats auf, führt ihn aus und nimmt die von ihm entworfenen Entitäten entgegen. Dies ist dasselbe Drop-in-Modell mit angekündigten Capabilities, dem der Parser-Socket mit parse:<format> folgt: Der Compiler-Kern enthält keine eingebaute Liste importierbarer Formate, daher bedeutet die Unterstützung eines neuen Formats, ein Importer-Plugin auszuliefern, das es ankündigt, niemals eine neue Kernversion.

Ein Importer liest über den Parser-Socket; er parst nicht erneut. Ein Importer benötigt die strukturierte Form seiner Quelle, implementiert aber das Lesen eines Formats, das das Ökosystem bereits parst, nicht neu. Wenn er den Baum braucht, bittet er den Host, den passenden Parser auszuführen — denjenigen, den der Katalog des Workspace für die Syntax der Quelle bereitstellt, oder, wo der Katalog keinen bereitstellt, denjenigen, den der Compiler selbst mitbringt —, über dieselbe vom Host vermittelte Parse-Capability, die der Rest der Pipeline nutzt, und arbeitet mit dem zurückgegebenen JSON-Baum. Das Lesen (Syntax zu Baum) bleibt Aufgabe des Parsers; das Abbilden (Baum zu Aggrega-Entitäten) ist Aufgabe des Importers. Die beiden Sockets lassen sich kombinieren, ohne einander zu duplizieren: Ein Importer ergänzt die Abbildungsintelligenz für eine Quelle und stützt sich für die Bytes auf den vorhandenen Parser.

Ein Format wird anhand dessen erkannt, was sein Importer deklariert, und nie geraten. Ein Import kann sein Quellformat direkt benennen. Wo er das nicht tut, wird das Format anhand von Signaturen erkannt, die jeder Importer in seiner Selbstbeschreibung deklariert und die seine Plugin-Entität festhält: die Syntax, in der eine Quelle gelesen wird, die Dateinamen, für die eine Signatur gilt, und die Pfade, die der geparste Baum enthalten muss oder nicht enthalten darf. Der Host kennt kein eigenes Format. Er parst die Quelle über den Parser, den der Katalog des Workspace für jede in einer Signatur genannte Syntax bereitstellt — oder den des Compilers, wo der Katalog keinen bereitstellt —, wertet die deklarierten Prädikate über dem zurückgegebenen Baum aus und liest die Quelle als das Format des einen Importers, dessen Signatur passt. Deklarierte Signaturen nehmen den Platz ein, den beim Parser-Socket eine feste Zuordnung von Dateiendungen innehat, denn die Formate, die ein Import liest, können sich eine Endung teilen — ein Langflow-Export, ein Flowise-Export und ein n8n-Workflow sind allesamt JSON-Dateien. Eine Quelle, auf die keine Signatur passt, wird abgelehnt, wobei nach dem Format gefragt wird und die von den Importern angekündigten Formate genannt werden — oder, bei einem Verzeichnis, nach einer seiner Dateien für sich allein oder nach einem Format gefragt wird, dessen Importer Dateimuster deklariert, wobei nur diese genannt werden; eine Quelle, auf die Signaturen mehrerer Formate passen, wird abgelehnt, wobei diese genannt werden. Die Erkennung liest nichts außer der Quelle und erreicht kein Netzwerk, sodass das Erkennen eines neuen Formats eine Deklaration ist, die der neue Importer mitliefert, niemals eine Änderung am Host. Die Regeln für das Schreiben einer Signatur stehen unter Der Importer-Socket.

Ein Verzeichnis wird über die Dateien gelesen, die sein Importer deklariert. Eine Quelle ist eine Datei oder ein Verzeichnis. Eine Datei wird dem Importer vollständig übergeben. Ein Verzeichnis wird in benannte Quellen eingelesen — genau die Dateien darin, die die Dateimuster der Signaturen des Importers auswählen, jede benannt nach ihrem Pfad innerhalb des Verzeichnisses, in sortierter Reihenfolge —, und keine andere Datei des Verzeichnisses wird geöffnet; ein Link, der das Lesen aus dem Verzeichnis herausführen würde, wird abgelehnt, bevor irgendetwas gelesen wird. Ein Importer, der keine Dateimuster deklariert, liest eine einzelne Datei und lehnt ein Verzeichnis ab, und auch ein Verzeichnis, das keine Datei enthält, die die Muster eines Importers auswählen, wird abgelehnt. Die Langflow-, Flowise-, n8n-, Dify- und Agent-Framework-Importer des Compilers deklarieren keine, daher liest jeder eine einzelne exportierte Flow-, Workflow- oder Anwendungsdatei oder einen einzelnen deklarativen Agenten; sein MCP-Importer deklariert die Dateinamen der MCP-Client-Konfigurationen, die er liest, sodass das Verzeichnis eines Projekts über die darin enthaltenen Konfigurationen gelesen wird; sein Compose-Importer deklariert die Dateinamen, die Compose standardmäßig liest, sodass das Verzeichnis eines Projekts über seine Compose-Datei und die Override-Datei gelesen wird, die Compose darüberlegt; und sein CrewAI-Importer deklariert die Dateinamen, unter denen ein CrewAI-Projekt seine Agenten und Tasks deklariert, sodass das Verzeichnis eines Projekts über diese Deklarationen gelesen und sein Programm nie gelesen wird; und sein LangGraph-Importer deklariert langgraph.json, sodass das Verzeichnis einer Anwendung allein über ihre Konfiguration gelesen wird, ihr Code und ihre Umgebungsdateien nie gelesen werden und eine Umgebungsdatei, die die Konfiguration nennt, den Importer nur dort erreicht, wo with.sources seiner Anbindung sie ihm übergibt, und dann nur für die Namen der Variablen; und sein Google-ADK-Importer deklariert root_agent.yaml, sodass das Verzeichnis einer Anwendung allein über die Konfiguration ihres Root-Agenten gelesen wird, die Konfigurationen, die ihre Sub-Agenten nennen, den Importer nur dort erreichen, wo with.sources seiner Anbindung sie ihm übergibt, und weder ihr Code noch ihre Umgebungsdatei jemals gelesen wird.

Die Abbildung ist deterministisch, mit Konfidenzwerten versehen und wird an Ihrem eigenen Katalog gemessen. Der Host übergibt dem Importer eine Sicht auf die Components, die der eigene Katalog des Workspace enthält — den Katalog, aus dem der Importer ausgewählt wurde — die Katalogordner des Workspace oder, wo er keine nennt, den Katalog-Snapshot, den seine Standard-Registry veröffentlicht —, die Components eines Unternehmenskatalogs genauso wie die der Standardbibliothek. Die Sicht enthält Name, Version und Labels jeder Component, die Schlüsselnamen, die ihre values und provides deklarieren, und die Selektoren ihrer Sockets, aber nie einen Wert, einen Standardwert oder ein Geheimnis; über diesen Snapshot hinaus wird nichts dafür abgerufen, und ihre Reihenfolge ist fest, sodass ein Katalog genau eine Sicht ergibt. Ein Importer, der auf dem Importer-Paket des Go-PDK aufbaut — darunter die eigenen Langflow-, Flowise-, n8n- und Compose-Importer des Compilers —, bewertet jeden Knoten der Quelle gegen diese Components und nichts anderes, mit einem deterministischen Konfidenzmodell ohne KI-Modell, und hält die Entscheidung — die abgewogenen Kandidaten, die zugewiesene Übereinstimmungsstufe und die getroffene Wahl — als prüfbare Hinweise fest, die ein Autor lesen und überarbeiten kann. Eine Component, die der Katalog hinzugewinnt, ist beim nächsten Import ein Kandidat, ohne dass ein Importer neu gebaut wird. Standardmäßig gibt es nur Hinweise: Der Import schlägt vor, und der Autor entscheidet. Eine Übereinstimmung mit hoher Konfidenz kann als Referenz auf eine vorhandene Katalogkomponente statt als frisch entworfener Inhalt geschrieben werden, aber nur, wenn der Operator dies ausdrücklich aktiviert — stets als expliziter, umkehrbarer Vorschlag, über den der Autor entscheidet, niemals als stillschweigende Umschreibung. Da die Bewertung ohne Modell und ohne Laufzeitabfrage auskommt, erzeugt dieselbe Quelle, gegen denselben Katalog bewertet, immer dieselben Hinweise.

Ein Flow wird als die Plattform entworfen, die ihn ausführt. Ein Langflow-Flow, ein Flowise-Chatflow und ein n8n-Workflow laufen auf einer Plattform, und standardmäßig entwirft ein Import diese Plattform statt der Knoten des Flows: eine Instanz der Plattform-Component der Standardbibliothek — core/ai-agent/langflow, core/ai-agent/flowise oder core/ai-agent/n8n —, die den Flow so, wie er exportiert wurde, in ihrem Wert flow_definition trägt, den die Plattform beim Deployment lädt. Jeder Teil des Flows, den ein Socket der Plattform aufnimmt — bei den Plattformen der Standardbibliothek ein Modell, ein MCP-Server oder ein anderes über HTTP erreichtes Tool sowie ein Vektorspeicher —, wird zu einer eigenen Component, referenziert oder entworfen, wie die Abbildung entscheidet, und wird unter uses der Plattform mit diesem Socket verbunden. So ist jeder Aufruf, den der Flow an ein Modell, ein Tool oder einen Speicher richtet, eine Verbindung, die das Aggregate deklariert: Ein Governance-Plugin, das den Graphen beurteilt, sieht sie wie jede andere Kante, und die Egress-Allowlist der Standardbibliothek, die die Einstellung attach_egress_allowlist an die Plattform anbindet, lässt die Plattform sich nur mit dem verbinden, was ihre Verbindungen erreichen, mit ihren eigenen Pods und dem DNS des Clusters. Wo das Format es zulässt, schreibt der Entwurf in den getragenen Flow, was den Flow jeden Teil über seine Verbindung erreichen lässt. Jeder andere Knoten — ein Agent, eine Chain, ein Trigger — bleibt im getragenen Flow und wird zu keiner Component, wobei seine Entscheidung die Kandidaten festhält, gegen die er abgewogen wurde. Eine Dify-Anwendung wird auf dieselbe Weise entworfen, in der Form, die eine ganze Installation annimmt: ein Eintrag der Dify-Installation, die die Standardbibliothek zusammenstellt, core/dify, der die Anwendung in seinem Parameter app_definition trägt, wobei die Installation ihre eigenen Verbindungen herstellt. Die Einstellung layout der Anbindung des Importers wählt den Entwurf: platform, der Standard, oder nodes, das jeden Knoten der Quelle als eigene Component entwirft, jede Kante des Flows als uses-Verbindung, und keinen Flow trägt. Die Plattform, die den Flow trägt legt dar, welche Knoten zu Teilen werden und wo jeder angebunden wird.

Ein Code-First-Framework wird über seine deklarierte Konfiguration gelesen, nie über sein Programm. CrewAI, LangGraph, Google ADK und Agent Framework halten das Verhalten einer Anwendung in ihrem Programm und deklarieren ihre Agenten, Graphen und Modelle in einer Konfiguration daneben. Ihre Importer lesen nur diese Deklarationen — die Agenten- und Task-Dateien eines CrewAI-Projekts, die langgraph.json einer LangGraph-Anwendung, die Agentenkonfigurationen einer Google-ADK-Anwendung, einen deklarativen Agent-Framework-Agenten — und entwerfen den Agenten der Standardbibliothek für das Framework um ein Programm herum, das sie nie öffnen, verbunden mit dem, was die Deklarationen nennen: dem Modell, das ein Agent anfordert, wo der model-Socket des Agenten es annimmt, und dem Datenspeicher, in dem ein LangGraph-Checkpointer den Zustand hält. Einen MCP-Server, den ein Agent-Framework-Agent nennt, erreicht der Anbieter des Modells als gehostetes Tool, daher nennt der Entwurf ihn in Kommentaren und verbindet nichts mit ihm. Das Programm läuft in dem Image, das das Release nennt. Was nur das Programm aussagt — die Logik eines Tasks, ein Tool, das sein Code definiert, ein Agent, den sein Code erstellt —, wird in den Kommentaren und Entscheidungen des Entwurfs genannt und wird zu keiner Component; es in Authoring-Dateien zu überführen ist Aufgabe des Autors, von Hand oder mit einem KI-Assistenten, der im Auftrag des Autors über aggrega mcp schreibt, die Referenz liest und Entitäten erzeugt und validiert.

Was eine Quelle darüber aussagt, wie ihre Teile laufen, landet in einem Release-Entwurf. Betriebliche Eingaben bereitzustellen ist Sache des Release, daher entwerfen die MCP-, Compose-, CrewAI-, LangGraph-, Google-ADK- und Agent-Framework-Importer ein Release neben dem Aggregate, das dessen spec.aggregate benennt: Das Release trägt, was die Quelle aussagt — die Befehlszeile oder Adresse eines Servers, das Image und den Port eines generischen Servers, den Endpunkt eines Modells — und in Kommentaren über jedem Eintrag das, was die Quelle aussagt, aber kein Schlüssel der entworfenen Component aufnimmt, etwa die Volumes eines Dienstes oder die Umgebung einer Konfiguration. Was keine Quelle aussagt — das Image, das das Programm eines Frameworks ausführt, die Anmeldeinformation, die eine Verbindung vorlegt, metadata.environment und spec.manifest des Release —, wird in einem Kommentar an der Stelle genannt, an die es gehört, damit der Operator es bereitstellt, und der Build hält an und nennt, welche der Angaben Image, Umgebung und Manifestangabe noch nicht gesetzt ist. Ein Plattformentwurf schreibt kein Release: Der Kommentar über der Instanz der Plattform nennt, was das Release bereitstellt — die eigenen Eingaben der Plattform, etwa das Image, das sie ausführt, oder ihr Eigentümerkonto, die Adresse jedes angebundenen MCP-Servers und die Anmeldeinformation, die jede Verbindung vorlegt.

Ein Anmeldewert, den eine Quelle enthält, wird unverändert übernommen, sofern nicht seine Entfernung verlangt wird. Ein Importer ermittelt jeden Wert in seiner Quelle, der eine Anmeldeinformation tragen kann, jeweils einer Klasse zugeordnet: was das Format als Anmeldeinformation kennzeichnet, ein Element der Konfiguration eines MCP-Servers oder eine Eingabe, die das Format nicht als Anmeldeinformation kennzeichnet, die aber dennoch eine tragen kann, etwa die Header einer Anfrage. Standardmäßig wird keiner leer geschrieben: Jeder Wert, der etwas enthält, wird unverändert übernommen — in den Flow oder die Anwendung, die die Plattform trägt, oder in den Release-Entwurf — und in einer credential-carried-Warnung anhand seiner Position benannt — sein Knoten, Server, Dienst oder Agent und sein Feld —, nie anhand seines Werts, zusammen mit dem Einstellungswert, der ihn leer schreibt. Die Einstellung empty_credentials schaltet die Entfernung ein, jeweils eine Klasse: marked schreibt leer, was ein Format als Anmeldeinformation kennzeichnet, sowie jedes Element der Konfiguration eines MCP-Servers, und all zusätzlich die nicht als Anmeldeinformation gekennzeichneten Eingaben, wobei jeder leer geschriebene Wert mit credential-emptied gemeldet wird. Was der Entwurf schreibt, damit ein Flow seine Verbindung erreicht, ist Verdrahtung und wird unabhängig von der Einstellung geschrieben, und eine Verbindung im Entwurf trägt keine Anmeldeinformation: Das Release bindet diejenige an, die jede Verbindung vorlegt. Eine Datei, auf die eine Quelle nur verweist, etwa eine Umgebungsdatei, wird nur für die Namen ihrer Variablen gelesen, sofern sie überhaupt gelesen wird, und ein Knoten für Knoten erstellter Entwurf liest keinen Wert. Was außerhalb der Stellen liegt, die ein Importer ermittelt — der Code einer benutzerdefinierten Komponente, ein Prompt —, muss der Autor vor dem Teilen eines Entwurfs selbst prüfen, wie Anmeldewerte, die der Flow enthält darlegt.

Befehl, Editor und Assistent führen denselben Import aus. aggrega import <file or directory> führt einen Import im Terminal aus; der Editor führt denselben Vorgang über die Anfrage aggrega/import seiner Sitzung aus und ein KI-Assistent über das import-Tool von aggrega mcp. Alle drei wählen den Importer auf dieselbe Weise aus, unter den Importern, die der Katalog des Workspace enthält, und den Kern-Importern des Compilers: denjenigen, den eine plugins.importer-Anbindung nennt, sofern sie einen nennt, der das Format ankündigt, und andernfalls die höchste Version des einen Importers, der es ankündigt — Importer zweier Namen für ein Format, von denen keiner angebunden ist, brechen den Import ab und nennen beide, wie Welcher Importer eine Quelle in Entwürfe umwandelt darlegt. Alle drei melden die Abbildungsentscheidungen neben den Entwürfen. Der Befehl gibt auf Standardfehler eine Zeile pro abgebildetem Knoten aus und nennt die dafür gewählte Component oder den Entwurf, ob sie referenziert oder entworfen ist, die Übereinstimmungsstufe und, wo der Importer einen Kandidaten abgewogen hat, die Bewertung des besten Kandidaten; der Editor zeigt dieselben Zeilen, und das Ergebnis der Editor-Sitzung und die Antwort des Assistenten enthalten jede Entscheidung vollständig. So sieht ein Autor, wo der Import geraten hat, auf welcher Oberfläche er auch lief, ohne die Entwürfe zu öffnen. --format nennt das Quellformat explizit — zum Beispiel langflow, flowise, n8n, mcp, compose, dify, crewai, langgraph, google-adk oder agent-framework — anstelle der Erkennung. Der Befehl legt die Entitäten und alle vom Import erzeugten Gerüstdateien unterhalb des Workspace-Stammverzeichnisses ab oder unterhalb des Verzeichnisses, das --output-dir nennt; --dry-run tut alles, was der Befehl tut, außer zu schreiben, gibt die entworfenen Dateien als Inhalt zurück und nennt die Datei, für die jede bestimmt ist, sodass ein Autor das Gerüst prüfen kann, bevor er irgendetwas in den Arbeitsbaum übernimmt.

Die Kern-Importer. Die Kern-Importer, die der Compiler mitliefert, lesen diese Formate, je ein Importer pro Format:

  • Langflow — ein aus Langflow exportierter Flow, entworfen als die Langflow-Plattform der Standardbibliothek, die den Flow trägt, wobei jeder Teil davon, den ein Socket aufnimmt, mit diesem Socket verbunden wird.
  • Flowise — ein aus Flowise exportierter Chatflow oder Agentflow, entworfen als die Flowise-Plattform der Standardbibliothek, die ihn trägt, wobei jeder Teil davon, den ein Socket aufnimmt, mit diesem Socket verbunden wird.
  • n8n — ein aus n8n exportierter Workflow, entworfen als die n8n-Plattform der Standardbibliothek, die ihn trägt, wobei jeder Teil davon, den ein Socket aufnimmt, mit diesem Socket verbunden wird.
  • Dify — eine aus Dify exportierte Anwendung, entworfen als die Dify-Installation, die die Standardbibliothek zusammenstellt und die die Anwendung trägt, wobei die Modelle, Tools und Wissensdatenbanken, die sie nennt, als innerhalb von Dify konfiguriert gemeldet werden.
  • MCP — die Konfiguration eines MCP-Clients oder die Serverbeschreibung einer MCP-Registry, wobei jeder Server als Instanz des MCP-Tools der Standardbibliothek entworfen wird, mit einem Release, das die Befehlszeile, die Adresse oder das Image jedes Servers trägt.
  • Compose — ein Infrastrukturformat, wobei jeder Dienst einer Compose-Anwendung als die Katalog-Component entworfen wird, zu der sein Image passt — über eine Tabelle, die der Importer mitbringt und die bei seinem Bau aus den Compose-Recipes und -Components des Standardkatalogs erzeugt wird — oder als generischer Server, der sein Image ausführt, mit einem Release, das Image und Port jedes generischen Servers trägt und in Kommentaren die Ports, Volumes und die Umgebung, die jeder Dienst deklariert.
  • CrewAI — die Agenten, die ein CrewAI-Projekt in seinen Konfigurationsdateien deklariert, jeder entworfen als der CrewAI-Agent der Standardbibliothek, der seine Rolle, sein Ziel und seine Hintergrundgeschichte trägt und mit dem Modell verbunden ist, das er nennt, wobei die Tasks und Tools des Projekts als Teil seines Programms gemeldet werden und das Programm selbst nie gelesen wird, mit einem Release, das es dem Operator überlässt, das Image zu nennen, das es ausführt.
  • LangGraph — die Graphen, die die Konfiguration einer LangGraph-Anwendung deklariert, jeder entworfen als der LangGraph-Agent der Standardbibliothek, der den Importpfad seines Graphen trägt und mit dem Datenspeicher verbunden ist, in dem sein Checkpointer den Zustand hält, mit einem Release, das in einem Kommentar die Umgebung angibt, die die Konfiguration deklariert, wobei der Code der Graphen nie gelesen wird.
  • Google ADK — die Agentenbäume, die die Agentenkonfigurationen einer Google-ADK-Anwendung deklarieren, jeder entworfen als der ADK-Agent der Standardbibliothek, verbunden mit dem Modell, das er nennt, wo ADK die Anfragen dieses Modells an die Gemini API sendet, während ein auf anderem Weg erreichtes Modell — etwa über einen LiteLLM-Modellstring — in einem Kommentar genannt und seine Verbindung dem Autor überlassen wird, mit einem Release, das es dem Operator überlässt, das Image zu nennen, das die Anwendung ausführt, wobei der Code der Anwendung nie gelesen wird.
  • Agent Framework — ein deklarativer Agent-Framework-Agent, entworfen als der Agent-Framework-Agent der Standardbibliothek, verbunden mit dem OpenAI-Modell, das er nennt, wobei jeder MCP-Server, den er nennt, in Kommentaren festgehalten wird, da der Anbieter des Modells ihn als gehostetes Tool erreicht, mit einem Release, das den Endpunkt des Modells und, in einem Kommentar, die Adresse jedes Servers trägt, wobei der Code der Anwendung nie gelesen wird.

Es handelt sich um Importer-Plugins wie alle anderen — die formatspezifische Abbildungsintelligenz liegt in ihnen, nicht im Kern —, gebaut aus den Quellen des Compilers und mit jeder Compiler-Version in der Version dieser Veröffentlichung publiziert. Keiner ist in die Binärdatei kompiliert: Die Binärdatei trägt die Plugin-Entität jedes Importers und den Digest des einen Moduls, das sie akzeptiert, sodass jeder sein Format in jedem Workspace ohne Katalogeintrag bedient. Der erste Import, der einen benötigt, den die Maschine nicht besitzt, ruft ihn aus der Standard-Registry des Workspace ab, bindet ihn an diesen Digest, verifiziert ihn so, wie ein Pull ein abgerufenes Plugin verifiziert — seine Signatur gemäß der Vertrauensrichtlinie dieser Registry und die Host-Funktionen, die er nutzt —, und legt ihn im Inhaltscache des Workspace ab; jeder spätere Import liest ihn von dort, ohne dafür auf das Netzwerk zuzugreifen. Ein Import pinnt keinen Importer: Für ihn wird nichts weiter geschrieben — kein Lockfile-Eintrag und kein Datensatz vertrauenswürdiger Plugins —, kein Pull legt ihn in den Cache, und kein Build liest ihn. Ein Modul, das die Verifizierung nicht besteht, wird abgelehnt, und nichts wird behalten. Wo das Modul nicht abgerufen werden kann — der Workspace ist offline, seine Registry ist nicht erreichbar oder die Registry enthält es nicht —, bricht der Import ab und nennt den Importer, seine Version und das, was sein Modul auf die Maschine bringt. Die Wahl bleibt beim Workspace: Ein Importer, den sein Katalog unter einem anderen Namen für eines dieser Formate enthält, läuft dort, wo eine plugins.importer-Anbindung ihn nennt, und einer mit demselben Namen und derselben Version wie ein Kern-Importer läuft an dessen Stelle.

Einen Katalog anlegen und wachsen lassen

Ein Katalog muss nicht aus dem Nichts aufgebaut werden. Der größte Teil der Arbeit, Recipes und Erweiterungen für eine neue Umgebung bereitzustellen, besteht aus Scaffolding und Wiederverwendung, statt jedes Binary von Hand zu schreiben.

Eine fremde Quelle in Entwürfe von Authoring-Dateien importieren. aggrega import <file or directory> liest eine deklarative Quelle für Agentendefinitionen – einen Langflow- oder Flowise-Flow, einen n8n-Workflow oder die Konfiguration eines MCP-Clients bzw. die Serverbeschreibung einer MCP-Registry –, eine Compose-Anwendung, eine Dify-Anwendung, die Agenten, die ein CrewAI-Projekt deklariert, die Graphen, die die Konfiguration einer LangGraph-Anwendung deklariert, die Agenten, die die Agentenkonfigurationen einer Google-ADK-Anwendung deklarieren, oder einen deklarativen Agent-Framework-Agenten, und erzeugt erste Entwürfe von Aggregate- und Component-YAML sowie aus einer MCP-, Compose-, CrewAI-, LangGraph-, Google-ADK- oder Agent-Framework-Quelle einen Entwurf eines Release, den ein Autor prüft und fertigstellt, sodass ein Team das weiterführt, was es bereits hat, statt es von Hand neu zu schreiben. Für jeden Knoten eines Flows und jeden Dienst einer Compose-Anwendung bewertet es die Components des eigenen Katalogs des Workspace – den eines Unternehmenskatalogs ebenso wie den der Standardbibliothek – mit einem deterministischen Konfidenzmodell ohne Modell und hält die Entscheidung – die abgewogenen Kandidaten, die zugewiesene Stufe und die getroffene Wahl – als prüfbare Hinweise fest, die der Befehl, der Editor und der Assistent alle melden; eine Übereinstimmung mit hoher Konfidenz kann als Katalogreferenz geschrieben werden, wenn der Operator dies aktiviert, stets als expliziter, umkehrbarer Vorschlag, den der Autor freigibt, und nie als stille Umschreibung. Jede Component, die ein Katalog hinzugewinnt, ist ein Kandidat, den der nächste Import abwägt. Die formatspezifische Zuordnungslogik liegt in einer Importer-Erweiterung: Die Langflow-, Flowise-, n8n-, MCP-, Compose-, Dify-, CrewAI-, LangGraph-, Google-ADK- und Agent-Framework-Importer des Compilers bedienen diese Formate in jedem Workspace, beim ersten Gebrauch abgerufen und verifiziert, und ein Katalog fügt ein Format hinzu, indem er eine Importer-Erweiterung enthält, die es ausweist. Eine Verzeichnisquelle wird über die Dateimuster gelesen, die ihr Importer deklariert; die Langflow-, Flowise-, n8n-, Dify- und Agent-Framework-Importer deklarieren keine, und jeder liest eine exportierte Datei oder einen deklarativen Agenten, während der MCP-Importer die Client-Konfigurationen liest, die ein Verzeichnis enthält, der Compose-Importer dessen Compose-Dateien, zusammengeführt, wie Compose sie zusammenführt, der CrewAI-Importer die Deklarationen eines Projekts, nie dessen Programm, der LangGraph-Importer die Konfiguration einer Anwendung, nie deren Code oder eine Umgebungsdatei – deren Namen er nur liest, wo seine Anbindung ihm die Datei übergibt –, und der Google-ADK-Importer die Konfiguration des Root-Agenten einer Anwendung, nie deren Code oder deren Umgebungsdatei, wobei die Konfigurationen ihrer Sub-Agenten gelesen werden, wo seine Anbindung sie ihm übergibt – eine Konfiguration, die laut ADK experimentell ist und deren Agenten standardmäßig ein Gemini-Modell verwenden und Modelle anderer Anbieter namentlich über ADK-eigene Klassen oder über einen LiteLLM-Modellstring erreichen.

Die meiste Arbeit an Erweiterungen besteht aus Vorlagen, nicht aus kompiliertem Code. Ein großer Teil der Funktionen injiziert lediglich einen statischen Sidecar, eine Umgebungsvariable oder ein Label – ein einfacher JSONPatch ohne bedingte Logik. Eine einzige konfigurierbare Patcher-Erweiterung, einmal so geschrieben, dass sie eine deklarative JSONPatch-Vorlage als ihre with-Eingabe entgegennimmt, kann diesen häufigen Fall ohne ein eigenes kompiliertes Binary pro Funktion abdecken: Der Autor schreibt eine Vorlage, und für viele Ziele im CRD-Stil genügt bereits eine valuesMapping-Vorlage allein (die oft auf gemeinsame Fragmente in einem MappingLibrary-Eintrag verweist). Eigens geschriebene PDK-Erweiterungen sind für den tatsächlich bedingten Rest gedacht.

Auf etablierte Werkzeuge zurückgreifen. Beim Schreiben neuer Erweiterungslogik können Autoren die öffentlich dokumentierten Ausgabe-Formen etablierter Open-Source-Werkzeuge heranziehen – die Struktur der CRDs, Patches oder Vorlagen, die diese Werkzeuge bekanntermaßen erzeugen – als Referenz für die Zielform, die eine neue Erweiterung erzeugen muss, unter Beachtung der Lizenz jedes Projekts. Sidecar-Injection-Webhooks, Bibliotheken für höherstufige Konstrukte, CRD-Generatoren für Operatoren sowie Trait- oder Kompositionskataloge veröffentlichen alle Ausgabestrukturen, die eng dem entsprechen, was ein vergleichbares FeatureRecipe oder eine vergleichbare Erweiterung ausgeben muss. Ziel ist es, einem gut verstandenen Ausgabevertrag zu entsprechen, nicht die Implementierung eines Projekts zu kopieren.