Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Rozszerzalność

Rozszerzalność ekosystemu i zabezpieczenia kompilatora

1. Uniwersalny interfejs WebAssembly (Wasm)

Aby zapewnić symetrię architektoniczną w całym ekosystemie, Aggrega stosuje ustandaryzowany kontrakt wykonania, który obowiązuje jednakowo każde gniazdo Wasm w potoku kompilatora.

Interfejs YAML do wywoływania dowolnej wtyczki opiera się na dwóch celowo wybranych słowach kluczowych: function i with.

  • function: Aggrega osadza środowisko uruchomieniowe Wasm (zestaw narzędzi Extism działający na silniku Wazero), wykonując Wasm bezpośrednio w pamięci, więc nie jest uruchamiany żaden proces systemu operacyjnego. function wskazuje eksport wywoływany przez host w Go: jawnie wyeksportowaną funkcję modułu Wasm.
  • with: własne dane wejściowe wtyczki, oddzielone od values programisty i od parameters, które wypełnia encja Release. Słowo kluczowe podąża za konwencją GitHub Actions (with:); gdy wtyczka deklaruje JSON Schema dla swoich danych wejściowych, host waliduje je względem niego przed wykonaniem.

Typy Wasm Plugins: Ten uniwersalny interfejs function i with obsługuje każde programowalne gniazdo w kompilatorze:

Typ PluginGdzie działaPrzeznaczenieOczekiwany wynik
Provider (provider)Renderowanie (generowanie)Przekształca końcową reprezentację IR z pamięci w fizyczne pliki tekstowe dla formatu docelowego (Helm, Terraform, Compose).Tablica plików w postaci tekstowej.
Krok potoku FeatureRecipe (pipeline-step)Potok wtyczek encji Recipe lub FeatureRecipeSekwencyjne kroki, które pobierają sekrety lub wstrzykują kontenery sidecar do bazowych drzew AST.Poprawki RFC 6902 patches względem kluczowanego zbioru dokumentów oraz side_effects (emisja nowego dokumentu lub pliku), diagnostics i outputs, które może odczytać późniejszy krok. Dane wejściowe kroku zawierają ten kluczowany zbiór dokumentów i wyrenderowane wejście with kroku.
Governance (governance)Przed rozwijaniem adnotacji, budowa topologii, analiza statyczna lub etap renderowaniaPełni role nadzoru w potoku budowania. Przed rozwijaniem adnotacji wstrzykuje adnotacje do rozwiązanych komponentów, a podczas budowy topologii automatycznie oznacza węzły etykietami zgodności lub środowiskowymi (operator włącza każdą z tych ról). Podczas analizy statycznej lub na etapie renderowania działa jako głośne zabezpieczenie (Loud Guardrail): ocenia krawędzie grafu, ścieżki i etykiety — lub wyrenderowane artefakty — względem granic bezpieczeństwa. To, co może emitować, określa rola, przy której jest podpięta, a nie jej rodzaj.Przed rozwijaniem adnotacji — wstrzyknięcia adnotacji. Podczas budowy topologii — tablica poprawek JSONPatch kierowanych na metadata.labels. Podczas analizy statycznej lub na etapie renderowania — werdykty o istotności halt, warn lub info (polityka Rego zbiera je pod deny, warn i audit); halt zatrzymuje budowanie.
Linter (linter)Poza głównym przebiegiemOpcjonalne kontrole FinOps lub higieny (np. szacowanie kosztów chmury na podstawie .infra) oraz dyscyplina w momencie publikacji.Ciągi ostrzeżeń lub krytyczne zatrzymania.
Rozszerzenie CLI (cli)Czas wykonania (aggrega <command>)Gotowe do podłączenia polecenie najwyższego poziomu dostarczane przez podpisaną wtyczkę działającą w piaskownicy, bez żadnego kodu Go dla poszczególnych poleceń w hoście.Strumieniowane standardowe wyjście i wyjście błędów oraz kod wyjścia gościa.
Parser (parser)Na żądanie, wszędzie tam, gdzie odczytywany jest obcy formatPrzekształca obcy tekst źródłowy (HCL, TOML, YAML, JSON, JSON z komentarzami) w kanoniczne drzewo JSON.tree oraz diagnostics i opcjonalne źródłowe spans.
Importer (importer)Na żądanie, poza jakimkolwiek budowaniem (aggrega import, edytor i narzędzie import asystenta)Przekształca obce źródło infrastruktury lub definicji agentów (Langflow, Flowise, n8n, konfiguracja MCP, aplikacja Compose, aplikacja Dify, zadeklarowani agenci projektu CrewAI, konfiguracja aplikacji LangGraph, konfiguracje agentów aplikacji Google ADK, deklaratywny agent Agent Framework) w robocze pliki autorskie Aggrega, ogłaszając obsługiwane formaty jako możliwości import:<format>.Robocze encje Aggregate / Component / Release lub odwołania do ponownie wykorzystywanych encji Components z katalogu, stojące za nimi decyzje mapowania, diagnostyka oraz pliki szkieletowe do zapisania.

Środowisko hosta: piaskownica odmawiająca uprawnień. Aggrega osadza host Wasm jako zestaw narzędzi Extism działający na silniku Wazero; plik binarny hosta pozostaje czystym Go bez zależności od natywnego łańcucha narzędzi, dzięki czemu aggrega bezproblemowo kompiluje się skrośnie. Każde gniazdo działa za zaporą czystości AOT: host odmawia przyznania wtyczce jakiegokolwiek uprawnienia dostępu w czasie wykonania — bez sieci, systemu plików, zegara rzeczywistego, środowiska i standardowego wejścia/wyjścia — więc wywołanie, które by z niego korzystało, kończy się niepowodzeniem, a wtyczka importująca z interfejsu hosta, którego host nie udostępnia, jest odrzucana przy ładowaniu. Wtyczka, która nie może sięgnąć do sieci ani odczytać zegara, nie może złamać gwarancji kompilacji AOT, że te same dane wejściowe dają ten sam wynik. Środowiska uruchomieniowe języków, które potrzebują kilku nieszkodliwych importów startowych, działają z konfiguracją tych importów pozbawioną uprawnień: host ustala obserwowalny zegar, dostarcza prawdziwą entropię, odrzuca standardowe wejście/wyjście i nie przyznaje dostępu do systemu plików, argumentów ani środowiska — dzięki czemu wtyczka nie może sięgnąć do żadnego uprawnienia hosta, które różni się między budowaniami. Entropia celowo pozostaje prawdziwa, a nie ustalona: jej ustalenie ustabilizowałoby wewnętrzne ziarno funkcji skrótu i kolejność iteracji map w środowisku uruchomieniowym języka gościa, a tym samym ukryłoby wtyczkę, której własny wynik nie jest powtarzalny, zamiast pozwolić, by ujawniło się to jako różniący się wynik. Wtyczka, której wynik zależy od entropii, to problem determinizmu na poziomie autorskim, a ta konfiguracja ma go ujawniać, a nie maskować.

Pisanie pod host: PDK. Autorzy wtyczek nie piszą ręcznie ABI pamięci Wasm. Aggrega dostarcza Plugin Development Kit w trzech językach — Go, Rust i TypeScript — w postaci cienkich nakładek, które udostępniają typowane wejście i wyjście każdego gniazda, dzięki czemu autor pisze zwykłe funkcje. Opisany wyżej interfejs function / with służy encji Aggregate lub FeatureRecipe do wywołania wtyczki; PDK to to, względem czego autor wtyczki ją buduje.

Gdzie działa każde gniazdo. Każde gniazdo działa przez ten sam host: linter publikacji w ramach aggrega lint; role nadzoru, dostawcy renderowania oraz kroki potoków Recipe i FeatureRecipe podczas aggrega build; parsery wszędzie tam, gdzie odczytywany jest obcy format; importery w ramach aggrega import; a wtyczki CLI jako polecenia najwyższego poziomu. Gotowość poszczególnych gniazd opisano w Status języka.

Które wtyczki są przypięte, a które wybiera środowisko. Aggrega dzieli wtyczki według tego, czy zmieniają dostarczany wynik. Wtyczki kształtujące wynik — dostawcy renderowania, wtyczki nadzoru podpięte w roli transformacji (label-transform, annotation-transform) oraz kroki potoków FeatureRecipe i Recipe — są przypinane w pliku blokady wydania podczas aggrega pull i odtwarzane bajt w bajt przy aggrega build i aggrega serve wyłącznie na podstawie tego pliku blokady. Dwa rodzaje nie są przypinane, ponieważ kompilacja za każdym razem odczytuje je z tego samego miejsca: dostawca renderowania serwowany z wnętrza pliku binarnego kompilatora oraz dostawca lub krok potoku, którego encja Plugin jest zdefiniowana w jednym z własnych katalogów. Aby zmienić, która wtyczka kształtująca wynik ma zastosowanie, należy ponownie wykonać pull; zmiana konfiguracji obszaru roboczego po pull nie zmienia wyniku kompilacji aż do następnego pull. Wtyczki bramkujące — polityki i lint — oceniają kompilację bez zmieniania jej bajtów, więc są buforowane przy pull (aby kompilacja mogła je uruchomić offline; wtyczka dostarczana z plikiem binarnym kompilatora lub zdefiniowana we własnym katalogu jest odczytywana stamtąd), ale nie są przypinane: to, która bramka zostanie uruchomiona, wybiera środowisko w czasie kompilacji, więc podział na liberalne środowisko deweloperskie i rygorystyczne CI jest zwykłym wyborem konfiguracyjnym, a nie ponownym pull, a przełączanie bramek nigdy nie zmienia wyniku emitowanego przez kompilację zakończoną powodzeniem. Plugins działające wyłącznie na danych wejściowych autorskich, takie jak importery i rozszerzenia CLI, nie kształtują żadnego wyniku kompilacji i nie są ani przypinane, ani częścią buforowanego zestawu kompilacji.

2. Potoki Plugin w encjach FeatureRecipe

FeatureRecipes wiążą abstrakcyjne intencje operacyjne (takie jak dołączenie proxy bezpieczeństwa czy wstrzyknięcie sidecara) z wersjonowanymi potokami pluginów WebAssembly (Wasm). Zespół Ops deklaruje, czego encja Feature potrzebuje w konkretnym celu dostawcy; kompilator wykonuje zadeklarowany potok na płaskim grafie IR.

To powiązanie niesie trzy konsekwencje dla ekosystemu:

  • Niezależna ewolucja. Słownik infrastruktury rozrasta się dzięki zewnętrznym pluginom Wasm, bez potrzeby wydawania nowej wersji rdzenia kompilatora Aggrega. Nowi dostawcy, nowe sidecary i nowe integracje bezpieczeństwa są dostarczane jako niezależne binaria Wasm zgodne ze stabilnym ABI Wasm.
  • Wersjonowanie semantyczne. FeatureRecipes odwołują się do pluginów Wasm według wersji — dokładnej (:1.0.0) lub zakresu z daszkiem (:^1.0.0, najwyższa wersja z nią zgodna). Przy zakresie z daszkiem zespół Ops blokuje wersję główną, przyjmując jej wydania pomniejsze i poprawkowe za każdym razem, gdy plik blokady jest ponownie rozwiązywany przez aggrega pull --upgrade.
  • Przeniesienie złożoności. Generowanie CRD specyficznych dla dostawcy czy złożone renderowanie (obiekty polityk specyficzne dla dostawcy, natywne zasoby routingu dostawcy) odbywa się w czystych pluginach Wasm działających na płaskim grafie IR, zamiast przenikać przez deklaracje schematów lub logikę szablonów w definicjach komponentów.

Łączenie w potoki — rozdzielenie odpowiedzialności między pluginy. Potok FeatureRecipe może łączyć sekwencyjnie wiele pluginów Wasm, z których każdy otrzymuje od kompilatora ten sam kontekst węzła IR. Standardowy wzorzec dzieli odpowiedzialność tak, aby pojedynczy plugin nie niósł jednocześnie semantycznej intencji funkcji i fizycznego mechanizmu przechwytywania ruchu właściwego dla konkretnego środowiska docelowego.

Kanoniczny łańcuch dwóch pluginów wygląda następująco:

  • Plugin konfiguracyjny, który emituje reguły semantyczne funkcji (reguły polityki bezpieczeństwa, wzorce audytu, progi limitowania ruchu). Rozumie intencję funkcji; nie rozumie warstwy przechwytywania ruchu środowiska docelowego.
  • Plugin routingu, który emituje fizyczną konfigurację siatki przenoszącą te reguły (CRD bramy, łatki wstrzykiwania sidecarów, reguły zapory). Rozumie warstwę sieciową środowiska docelowego; nie rozumie semantycznej intencji funkcji.

Oba pluginy otrzymują od kompilatora kolejno ten sam kontekst węzła IR, dzięki czemu składają się czysto, bez bezpośredniego powiązania między sobą. Kompilator orkiestruje potok; pluginy niosą wiedzę dziedzinową.

3. Przechwytywanie ruchu: cel HTTPRoute

Model rozszerzalności Aggrega przyjmuje standard HTTPRoute z Kubernetes Gateway API jako międzydostawcowy artefakt do przechwytywania ruchu na poziomie siatki. Biblioteka standardowa emituje obiekty HTTPRoute przez encję Feature core/http-route, której encja FeatureRecipe dla helm renderuje jedną trasę na każdy dołączony komponent; środowiska docelowe obsługujące Gateway API tłumaczą HTTPRoute na swoje natywne warstwy sieciowe.

4. Autonomia Plugin: rozwiązywanie etykiet

Gdy pluginy Wasm generują zasoby fizyczne z grafu IR, zespoły SRE muszą móc prześledzić działający Pod Kubernetes lub zasób chmurowy aż do semantycznej intencji programisty w encji Aggregate. Model rozszerzalności Aggrega oddaje to tłumaczenie całkowicie pod kontrolę autora pluginu Wasm.

Kompilator przekazuje pełny słownik labels grafu IR do piaskownicy Wasm bez interpretacji. Autor pluginu — Platform Ops — decyduje o dalszej logice mapowania: przekazać wszystkie etykiety dosłownie, filtrować według określonych prefiksów domen (*.aggrega.ai/*) lub mapować etykiety grafu bezpośrednio na natywne schematy tagowania dostawcy (tłumacząc etykietę IR na tags w AWS, annotations w Kubernetes lub mechanizm metadanych specyficzny dla chmury). Kompilator nie narzuca żadnych ograniczeń co do sposobu tagowania wygenerowanych artefaktów.

Ta autonomia utrzymuje wiedzę dziedzinową — które etykiety mają znaczenie dla obserwowalności, które mapują się na natywne konwencje tagowania, które są wewnętrzne dla platformy — w warstwie pluginów Wasm, gdzie ekosystem rozwija się niezależnie od cyklu wydań kompilatora Go.

5. Rozszerzenia CLI: polecenia uruchomieniowe

Opisane wyżej gniazda działają wewnątrz kompilacji — kompilator wywołuje je podczas parsowania, modyfikowania, walidacji i renderowania encji Aggregate. Gniazdo rozszerzeń CLI różni się od nich zasadniczo: działa w terminalu, poza jakąkolwiek kompilacją, gdy operator wpisuje aggrega <command>. W ten sposób sam zestaw poleceń aggrega rozrasta się bez wydania rdzenia.

Czym jest rozszerzenie CLI. Rozszerzenie CLI to dołączane polecenie aggrega <command> dostarczane przez podpisaną, izolowaną w piaskownicy wtyczkę Wasm. Przyjmuje to samo podejście dołączanego modułu należącego do gościa co gniazdo renderowania: logika domenowa znajduje się w całości w gościu, a host w Go nie dokłada żadnego kodu dla poszczególnych poleceń. Dodanie nowego polecenia najwyższego poziomu wymaga tylko trzech rzeczy — pliku binarnego .wasm, jednej encji Plugin deklarującej pluginType: cli (zob. Plugin) oraz jawnego wywołania aggrega plugin add cli. Host wykrywa polecenie na podstawie samoopisu zainstalowanej wtyczki; żadne polecenie nie jest wkompilowane w plik binarny.

Dlaczego gniazdo uruchomieniowe może to, czego nie może gniazdo kompilacji. Ponieważ gniazda czasu kompilacji działają w trakcie kompilacji, pozostają pozbawione uprawnień i deterministyczne: Aggrega jest kompilatorem AOT (ahead-of-time), a te same dane wejściowe muszą zawsze dawać ten sam wynik (zob. Niezmienniki architektury). Wtyczka renderowania lub polityki nie może więc sięgać do sieci, odczytywać zegara ani pisać strumieniowo do terminala — wszystko, co zmienia się między uruchomieniami, złamałoby tę gwarancję. Rozszerzenie CLI działa po tej granicy i poza nią, sterowane przez człowieka przy wierszu poleceń, a nie przez deterministyczny potok. Właśnie dlatego wtyczka CLI może w trakcie działania strumieniowo wypisywać standardowe wyjście i standardowe wyjście błędów oraz zwracać kod wyjścia procesu: nie istnieje artefakt kompilacji, którego bajtowej stabilności te efekty mogłyby zagrozić.

Instalacja, uruchamianie i wykrywanie. aggrega plugin add cli <query> przeszukuje skonfigurowany rejestr w poszukiwaniu pasującej wtyczki cli, weryfikuje ją względem polityki zaufania rejestru i instaluje jako polecenie najwyższego poziomu — najpierw wypisując zadeklarowane uprawnienia wtyczki, aby operator potwierdził, co dokładnie polecenie może robić, zanim zostanie zainstalowane. Po instalacji aggrega <command> uruchamia je jak każde polecenie wbudowane. Wtyczka CLI deklaruje swoje polecenia i ich flagi w samoopisie describe(), a host wyświetla flagi każdego polecenia w aggrega help <command> dokładnie tak jak dla polecenia wbudowanego, więc operator poznaje --flags zainstalowanego polecenia w ten sam sposób. Aby znaleźć polecenia do zainstalowania i zawartość katalogu, aggrega search odpytuje lokalny indeks skonfigurowanych rejestrów — --kind plugin --plugin-type cli zawęża wyniki do wtyczek CLI do zainstalowania, a wyszukiwanie bez filtra obejmuje encje katalogu; aggrega plugin list pokazuje, co jest już zainstalowane. Flagi poszczególnych poleceń i kształty wyników opisano na tych stronach referencyjnych.

Model uprawnień. Rozszerzenie CLI zaczyna od stałego poziomu bazowego, który każde polecenie otrzymuje bez deklaracji i bez pytania:

Uprawnienie bazowePrzyznawane
Argumenty wiersza poleceń na wejściuZawsze
Strumieniowe standardowe wyjście i standardowe wyjście błędówZawsze
Kod wyjścia procesu na wyjściuZawsze

Wszystko ponad poziom bazowy jest domyślnie wyłączone. Wtyczka, która potrzebuje więcej, jawnie deklaruje każde dodatkowe uprawnienie, a host przyznaje je dopiero po pokazaniu go operatorowi do potwierdzenia podczas instalacji. Klasa uprawnień dodana ponad poziom bazowy — dostęp do środowiska, systemu plików lub sieci, interaktywne wejście — jest przyznawana za tą samą bramką deklaracji i potwierdzenia, więc polecenie nigdy nie może po cichu uzyskać zasięgu, którego operator nie zatwierdził.

Polecenia wbudowane zawsze mają pierwszeństwo. Zainstalowana wtyczka nigdy nie może przesłonić polecenia wbudowanego. Ochrona zarezerwowanych nazw oparta na liście zakazanych chroni polecenia wbudowane oraz zestaw nazw zarezerwowanych dla poleceń wbudowanych, a kolizja jest odrzucana przy instalacji, zamiast pozwolić na nadpisanie podstawowego działania. Zestaw poleceń, na którym polega operator, pozostaje stabilny niezależnie od tego, co zainstalowano na nim.

6. Parser Plugins: odczytywanie obcych formatów

Kompilator regularnie musi odczytywać tekst zapisany w formacie, którego nie jest autorem — moduł Terraform w HCL, plik konfiguracyjny w TOML, manifest w YAML lub JSON. Gniazdo parserów zapewnia tę zdolność odczytu bez uczenia rdzenia kompilatora jakiegokolwiek konkretnego formatu. Parser to bezstanowa wtyczka, która zamienia obcy tekst źródłowy w ustrukturyzowane drzewo JSON: po przekazaniu jej bajtów pliku HCL zwraca tę samą treść jako obiekt JSON, po którym reszta potoku już umie się poruszać. Każda część kompilatora, która musi odczytać format nieparsowany natywnie, prosi o sparsowane drzewo i dalej pracuje na nim.

Format jest uprawnieniem, a nie funkcją kompilatora. Parser ogłasza obsługiwane formaty jako uprawnienia — parse:hcl, parse:toml i tak dalej — a host wybiera parser według żądanego formatu, uruchamia go i zwraca drzewo. To ten sam model dołączanych modułów ogłaszających uprawnienia, który przyjmują dostawcy renderowania i wtyczki CLI: rdzeń kompilatora nie zawiera wbudowanej listy formatów, więc dodanie formatu oznacza dostarczenie nowej wtyczki parsera, nigdy wydanie rdzenia. Parsery HCL, TOML, YAML, JSON oraz JSON z komentarzami są dostarczane w pliku binarnym jako zestaw startowy; przedsiębiorstwo, które potrzebuje innego formatu, dostarcza wtyczkę parsera, która go ogłasza.

Wybór formatu jest deklaratywny, nigdy zgadywany. Host nigdy nie analizuje zawartości pliku, aby ustalić, czym on jest. Wybiera format na podstawie zadeklarowanych sygnałów w stałej kolejności pierwszeństwa. Dostawca renderowania może zadeklarować format każdego emitowanego pliku, a host bezwarunkowo preferuje ten format zadeklarowany przez producenta — dostawca, który zapisał bajty, jest autorytetem w kwestii ich odczytu. Dla pliku, którego producent nie oznaczył, rozwiązaniem zapasowym jest stała mapa rozszerzeń plików — .tf wybiera HCL, .toml wybiera TOML, .yaml wybiera YAML, .json wybiera JSON. Wybór według zadeklarowanego formatu lub stałego rozszerzenia sprawia, że parsowanie jest deterministyczne i czytelne: te same dane wejściowe zawsze trafiają do tego samego parsera, a operator może ustalić, który parser zostanie uruchomiony, bez znajomości bajtów w pliku. Rozpoznawanie po zawartości uzależniłoby wybór od ładunku, a Aggrega tego nie robi.

Parser jest czysto składniowy. Wynikiem jest drzewo JSON wraz z diagnostyką oraz opcjonalnie lokalizacjami w źródle, z których pochodzi każdy węzeł. Parser nie niesie żadnego znaczenia w Aggrega — opisuje, co tekst mówi strukturalnie, a nic o tym, co oznacza jako Component, Recipe czy jakakolwiek inna encja. Zamiana sparsowanego drzewa w encje Aggrega to osobna kwestia, obsługiwana gdzie indziej; jedynym zadaniem parsera jest wierne tłumaczenie składni na JSON. W tym samym duchu kierunek odczytu jest jednostronny: parser wczytuje format do drzewa, ale nie zapisuje formatu z powrotem.

Przykład konsumenta: polityka nad HCL Terraform. Polityka etapu renderowania, która musi zbadać kod Terraform tworzony przez kompilację, nie uczy się sama HCL. Host parsuje artefakt HCL przez gniazdo parserów i przekazuje wtyczce polityki drzewo JSON, które już umie czytać, więc polityka wnioskuje na ustrukturyzowanych danych w kształcie, jaki otrzymuje każde inne gniazdo. Nowe czytniki obcych formatów składają się w ten sam sposób — poproś host o drzewo, a następnie pracuj w JSON — więc zdolność kompilatora do rozumienia formatów rośnie przez dodawanie wtyczek parserów, a nie przez rozbudowę rdzenia.

7. Importer Plugins: tworzenie wstępnych plików autorskich z obcych źródeł

Zespół rzadko zaczyna od pustej strony. Jego architektura agentów często już istnieje gdzie indziej — jako przepływ Langflow lub Flowise, workflow n8n, aplikacja Dify, serwery MCP skonfigurowane w kliencie, aplikacja Compose czy agenci zadeklarowani w konfiguracji frameworka. Gniazdo importera zamienia takie obce źródło w gotowy punkt wyjścia do tworzenia w Aggrega: odczytuje źródło i generuje pierwsze wersje robocze encji Aggregate i Component, a z konfiguracji MCP, aplikacji Compose lub zadeklarowanej konfiguracji frameworka także roboczą encję Release, do przejrzenia i dokończenia przez autora, dzięki czemu zespół przenosi do Aggrega to, co już ma, zamiast tworzyć to ponownie ręcznie. Importer odwzorowuje znaczenie — odczytuje, czym jest węzeł źródła, i proponuje encję Aggrega, która go reprezentuje, albo pozostawia go w przepływie przenoszonym przez wygenerowaną platformę; kompilator przekazuje emitowane encje w sposób nieprzejrzysty, tak samo jak pozostaje agnostyczny wobec tego, co produkuje dowolna wtyczka.

Format jest zdolnością, a nie funkcją kompilatora. Importer ogłasza obsługiwane formaty jako zdolności — import:langflow, import:flowise, import:n8n, import:mcp, import:compose, import:dify, import:crewai, import:langgraph, import:google-adk, import:agent-framework i tak dalej — a host wybiera importer według żądanego formatu, uruchamia go i odbiera wygenerowane przez niego encje. To ten sam model wtyczek typu drop-in z ogłaszanymi zdolnościami, który gniazdo parsera stosuje z parse:<format>: rdzeń kompilatora nie zawiera wbudowanej listy importowalnych formatów, więc obsługa nowego formatu oznacza dostarczenie wtyczki importera, która go ogłasza, a nigdy nowego wydania rdzenia.

Importer czyta przez gniazdo parsera; nie parsuje ponownie. Importer potrzebuje ustrukturyzowanej postaci swojego źródła, ale nie implementuje ponownie odczytu formatu, który ekosystem już parsuje. Gdy potrzebuje drzewa, prosi host o uruchomienie odpowiedniego parsera — tego, który katalog obszaru roboczego udostępnia dla składni źródła, lub, gdy katalog nie udostępnia żadnego, tego, który zawiera sam kompilator — za pośrednictwem tej samej zdolności parsowania pośredniczonej przez host, z której korzysta reszta potoku, i pracuje na zwróconym drzewie JSON. Odczyt (składnia na drzewo) pozostaje zadaniem parsera; odwzorowanie (drzewo na encje Aggrega) należy do importera. Oba gniazda łączą się bez wzajemnego powielania: importer dodaje logikę odwzorowania dla źródła i opiera się na istniejącym parserze w kwestii bajtów.

Format jest rozpoznawany na podstawie deklaracji importera, nigdy zgadywany. Import może wprost wskazać format źródła. Jeśli tego nie robi, format jest rozpoznawany na podstawie sygnatur, które każdy importer deklaruje w swoim samoopisie i które zapisuje jego encja Plugin: składni, w której źródło jest odczytywane, nazw plików, do których sygnatura się odnosi, oraz ścieżek, które sparsowane drzewo musi lub nie może zawierać. Host nie zna żadnego formatu sam z siebie. Parsuje źródło parserem, który katalog obszaru roboczego udostępnia dla każdej składni wskazanej przez sygnaturę — lub własnym parserem kompilatora, gdy katalog nie udostępnia żadnego — ocenia zadeklarowane predykaty na zwróconym drzewie i odczytuje źródło jako format tego jedynego importera, którego sygnatura pasuje. Zadeklarowane sygnatury zastępują stałą mapę rozszerzeń plików używaną w gnieździe parsera, ponieważ formaty odczytywane przez import mogą mieć wspólne rozszerzenie — eksport Langflow, eksport Flowise i workflow n8n to wszystko pliki JSON. Źródło, do którego nie pasuje żadna sygnatura, jest odrzucane z prośbą o podanie formatu i z wymienieniem formatów ogłaszanych przez importery — lub, w przypadku folderu, z prośbą o podanie osobno jednego z jego plików albo formatu, którego importer deklaruje wzorce plików, i z wymienieniem tylko tych formatów; źródło, do którego pasują sygnatury więcej niż jednego formatu, jest odrzucane z wymienieniem tych formatów. Rozpoznawanie nie czyta niczego poza źródłem i nie sięga do sieci, więc rozpoznanie nowego formatu to deklaracja dostarczana przez nowy importer, a nigdy zmiana w hoście. Zasady pisania sygnatur opisano w sekcji Gniazdo importera.

Katalog jest odczytywany przez pliki, które deklaruje jego importer. Źródłem jest plik lub katalog. Plik jest przekazywany importerowi w całości. Katalog jest odczytywany jako nazwane źródła — dokładnie te jego pliki, które wybierają wzorce plików sygnatur importera, każdy nazwany swoją ścieżką wewnątrz katalogu, w kolejności posortowanej — i żaden inny plik katalogu nie jest otwierany; dowiązanie, które wyprowadziłoby odczyt poza katalog, jest odrzucane, zanim cokolwiek zostanie odczytane. Importer, który nie deklaruje wzorców plików, czyta jeden plik i odrzuca katalog; odrzucany jest również katalog, w którym nie ma pliku wybieranego przez wzorce importera. Importery Langflow, Flowise, n8n, Dify i Agent Framework kompilatora nie deklarują żadnych, więc każdy czyta jeden wyeksportowany plik przepływu, workflow lub aplikacji albo jednego agenta deklaratywnego; jego importer MCP deklaruje nazwy plików konfiguracji klientów MCP, które czyta, więc katalog projektu jest odczytywany przez zawarte w nim konfiguracje; jego importer Compose deklaruje nazwy plików, które Compose czyta domyślnie, więc katalog projektu jest odczytywany przez jego plik Compose i plik nadpisań, który Compose na niego nakłada; jego importer CrewAI deklaruje nazwy plików, w których projekt CrewAI deklaruje swoich agentów i zadania, więc katalog projektu jest odczytywany przez te deklaracje, a jego program nigdy nie jest czytany; jego importer LangGraph deklaruje langgraph.json, więc katalog aplikacji jest odczytywany wyłącznie przez jej konfigurację, a jej kod i pliki środowiskowe nigdy nie są czytane — plik środowiskowy wskazany w konfiguracji trafia do importera tylko wtedy, gdy przekaże go with.sources jego dołączenia, i to wyłącznie w zakresie nazw zmiennych; a jego importer Google ADK deklaruje root_agent.yaml, więc katalog aplikacji jest odczytywany wyłącznie przez konfigurację jej agenta głównego — konfiguracje wskazanych przez niego subagentów trafiają do importera tylko wtedy, gdy przekaże je with.sources jego dołączenia — i nigdy nie jest czytany ani jej kod, ani jej plik środowiskowy.

Odwzorowanie jest deterministyczne, oceniane pod kątem pewności i porównywane z własnym katalogiem. Host przekazuje importerowi widok Components zawartych we własnym katalogu obszaru roboczego — katalogu, z którego wybrano importer — w folderach katalogu obszaru roboczego lub, jeśli nie wskazuje on żadnego, w migawce katalogu publikowanej przez jego domyślny rejestr — Components katalogu firmowego tak samo jak biblioteki standardowej. Widok zawiera nazwę, wersję i etykiety każdej encji Component, nazwy kluczy deklarowanych w jej values i provides oraz selektory jej gniazd, a nigdy wartości, wartości domyślnej ani sekretu; poza tą migawką nic nie jest dla niego pobierane, a jego kolejność jest stała, więc jeden katalog daje jeden widok. Importer zbudowany na pakiecie importera z Go PDK — w tym własne importery Langflow, Flowise, n8n i Compose kompilatora — porównuje każdy węzeł źródła z tymi Components i niczym innym, przy użyciu deterministycznego modelu pewności bez modelu AI, i zapisuje decyzję — rozważonych kandydatów, przypisany poziom dopasowania i dokonany wybór — jako wskazówki do przejrzenia, które autor może przeczytać i poprawić. Encja Component dodana do katalogu jest kandydatem przy następnym imporcie, bez przebudowy importera. Domyślnie powstają tylko wskazówki: import proponuje, a autor decyduje. Dopasowanie o wysokiej pewności może zostać zapisane jako odwołanie do istniejącego komponentu katalogu zamiast świeżo wygenerowanej treści, ale tylko wtedy, gdy operator to włączy — zawsze jako jawna, odwracalna sugestia zatwierdzana przez autora, nigdy jako niejawne przepisanie. Ponieważ ocena nie korzysta z modelu ani z wyszukiwania w czasie działania, to samo źródło ocenione względem tego samego katalogu zawsze daje te same wskazówki.

Przepływ jest szkicowany jako platforma, która go uruchamia. Przepływ Langflow, chatflow Flowise i workflow n8n działają na platformie, więc domyślnie import szkicuje tę platformę, a nie węzły przepływu: jedną instancję platformowego Component z biblioteki standardowej — core/ai-agent/langflow, core/ai-agent/flowise lub core/ai-agent/n8n — która niesie przepływ w postaci wyeksportowanej w swojej wartości flow_definition, ładowanej przez platformę przy wdrożeniu. Każda część przepływu, którą przyjmuje gniazdo platformy — na platformach biblioteki standardowej model, serwer MCP lub inne narzędzie osiągane przez HTTP oraz magazyn wektorowy — staje się osobnym Component, wskazanym przez referencję lub naszkicowanym zgodnie z decyzją mapowania, i jest podłączana do tego gniazda w uses platformy. Każde wywołanie modelu, narzędzia lub magazynu przez przepływ jest więc połączeniem deklarowanym przez Aggregate: plugin nadzoru oceniający graf widzi je tak jak każdą inną krawędź, a lista dozwolonego ruchu wychodzącego z biblioteki standardowej, którą ustawienie attach_egress_allowlist dołącza do platformy, pozwala platformie łączyć się tylko z tym, do czego sięgają jej połączenia, z jej własnymi podami i z DNS klastra. Tam, gdzie format na to pozwala, szkic zapisuje w niesionym przepływie to, co sprawia, że przepływ sięga do każdej części przez jej połączenie. Każdy inny węzeł — agent, łańcuch, wyzwalacz — pozostaje w niesionym przepływie i nie staje się żadnym Component, a jego decyzja zapisuje kandydatów, z którymi był porównywany. Aplikacja Dify jest szkicowana w ten sam sposób, w formie całej instalacji: jako jeden wpis instalacji Dify składanej przez bibliotekę standardową, core/dify, niosący aplikację w swoim parametrze app_definition, przy czym instalacja sama łączy swoje połączenia. Ustawienie layout dołączenia importera wybiera szkic: platform, domyślne, lub nodes, które szkicuje każdy węzeł źródła jako osobny Component, każdą krawędź przepływu jako połączenie uses, i nie niesie żadnego przepływu. Platforma niosąca przepływ opisuje, które węzły stają się częściami i gdzie każdy jest podłączany.

Framework typu code-first jest odczytywany przez swoją zadeklarowaną konfigurację, nigdy przez program. CrewAI, LangGraph, Google ADK i Agent Framework trzymają zachowanie aplikacji w jej programie, a jej agentów, grafy i modele deklarują w konfiguracji obok niego. Ich importery odczytują tylko te deklaracje — pliki agentów i zadań projektu CrewAI, langgraph.json aplikacji LangGraph, konfiguracje agentów aplikacji Google ADK, deklaratywnego agenta Agent Framework — i szkicują agenta biblioteki standardowej dla danego frameworka wokół programu, którego nigdy nie otwierają, podłączonego do tego, co wskazują deklaracje: modelu, o który prosi agent, tam, gdzie gniazdo model agenta go przyjmuje, oraz magazynu danych, w którym checkpointer LangGraph przechowuje stan. Do serwera MCP wskazanego przez agenta Agent Framework sięga dostawca modelu, jako do narzędzia hostowanego, dlatego szkic wymienia go w komentarzach i niczego do niego nie podłącza. Program działa w obrazie wskazanym przez Release. To, co mówi tylko program — logika zadania, narzędzie zdefiniowane w kodzie, agent budowany przez kod — jest wymienione w komentarzach i decyzjach szkicu i nie staje się żadnym Component; przeniesienie tego do plików autorskich jest pracą autora, ręcznie lub z asystentem AI działającym w imieniu autora przez aggrega mcp, który czyta dokumentację referencyjną oraz tworzy szkielety encji i je waliduje.

To, co źródło mówi o sposobie działania swoich części, trafia do szkicu encji Release. Dane operacyjne dostarcza Release, dlatego importery MCP, Compose, CrewAI, LangGraph, Google ADK i Agent Framework szkicują Release obok encji Aggregate, wskazywanej przez jego spec.aggregate: Release niesie to, co podaje źródło — wiersz poleceń lub adres serwera, obraz i port serwera generycznego, endpoint modelu — a w komentarzach nad każdym wpisem to, co podaje źródło, a czego nie przyjmuje żaden klucz szkicowanego Component, np. wolumeny usługi lub środowisko konfiguracji. To, czego nie podaje żadne źródło — obraz uruchamiający program frameworka, poświadczenie przedstawiane przez połączenie, metadata.environment i spec.manifest encji Release — jest wymienione w komentarzu w odpowiednim miejscu, do uzupełnienia przez operatora, a budowanie zatrzymuje się, wskazując, który z elementów — obraz, środowisko, manifest — nadal nie jest ustawiony. Szkic platformy nie zapisuje encji Release: komentarz nad instancją platformy wymienia, co dostarcza Release — własne dane wejściowe platformy, np. uruchamiany przez nią obraz lub konto właściciela, adres każdego podłączonego serwera MCP oraz poświadczenie przedstawiane przez każde połączenie.

Wartość poświadczenia zawarta w źródle jest przenoszona bez zmian, chyba że zażąda się jej usunięcia. Importer lokalizuje w źródle każdą wartość, która może nieść poświadczenie, każdą należącą do jednej klasy: to, co format oznacza jako poświadczenie, element konfiguracji serwera MCP lub dane wejściowe, które format oznacza jako niebędące poświadczeniem, a które mimo to mogą je nieść, np. nagłówki żądania. Domyślnie żadna nie jest czyszczona: każda niepusta wartość jest przenoszona bez zmian — w przepływie lub aplikacji niesionej przez platformę albo w szkicu encji Release — i wymieniana w ostrzeżeniu credential-carried według miejsca, w którym się znajduje — węzła, serwera, usługi lub agenta oraz pola — nigdy według wartości, wraz z wartością ustawienia, która ją wyczyści. Ustawienie empty_credentials włącza usuwanie, po jednej klasie: marked czyści to, co format oznacza jako poświadczenie, oraz każdy element konfiguracji serwera MCP, a all dodatkowo dane wejściowe oznaczone jako niebędące poświadczeniem; każda wyczyszczona wartość jest zgłaszana przez credential-emptied. To, co szkic zapisuje, aby przepływ sięgał do swojego połączenia, jest okablowaniem i zapisywane jest niezależnie od ustawienia, a połączenie w szkicu nie niesie żadnego poświadczenia: Release dołącza to, które przedstawia każde połączenie. Plik, na który źródło jedynie wskazuje, np. plik środowiskowy, jest odczytywany wyłącznie pod kątem nazw zmiennych, o ile w ogóle jest odczytywany, a szkic tworzony węzeł po węźle nie odczytuje żadnej wartości. To, co leży poza miejscami lokalizowanymi przez importer — kod niestandardowego komponentu, prompt — autor powinien przejrzeć przed udostępnieniem szkicu, jak opisano w sekcji Wartości poświadczeń zawarte w przepływie.

Polecenie, edytor i asystent uruchamiają ten sam import. aggrega import <file or directory> uruchamia import z terminala; edytor wykonuje tę samą operację przez żądanie aggrega/import swojej sesji, a asystent AI przez narzędzie import serwera aggrega mcp. Wszystkie trzy wybierają importer w ten sam sposób, spośród importerów zawartych w katalogu obszaru roboczego i podstawowych importerów kompilatora: ten, który wskazuje dołączenie plugins.importer, o ile wskazuje importer deklarujący dany format, a w przeciwnym razie najwyższą wersję jedynego importera deklarującego ten format — importery o dwóch nazwach dla jednego formatu, z których żaden nie jest dołączony, zatrzymują import, który wymienia oba, jak opisano w sekcji Który importer zamienia źródło w szkice. Wszystkie trzy raportują decyzje mapowania obok szkiców. Polecenie wypisuje na standardowe wyjście błędów jeden wiersz na każdy zmapowany węzeł, wskazując wybrany dla niego Component lub szkic, to, czy jest on wskazany referencją, czy naszkicowany, poziom dopasowania oraz, jeśli importer rozważał kandydata, wynik najlepszego kandydata; edytor pokazuje te same wiersze, a wynik sesji edytora i odpowiedź asystenta zawierają każdą decyzję w pełnej postaci. Dzięki temu autor widzi, gdzie import zgadywał, niezależnie od tego, gdzie go uruchomiono, bez otwierania szkiców. --format jawnie wskazuje format źródła — np. langflow, flowise, n8n, mcp, compose, dify, crewai, langgraph, google-adk lub agent-framework — zamiast jego rozpoznawania. Polecenie zapisuje encje i wszelkie pliki szkieletowe wytworzone przez import w katalogu głównym obszaru roboczego lub w katalogu wskazanym przez --output-dir; --dry-run robi wszystko to, co polecenie, z wyjątkiem zapisu, zwracając naszkicowane pliki jako treść i podając plik, którego każdy dotyczy, dzięki czemu autor może przejrzeć szkielet przed zatwierdzeniem czegokolwiek w drzewie roboczym.

Podstawowe importery. Podstawowe importery dostarczane z kompilatorem odczytują następujące formaty, po jednym importerze na format:

  • Langflow — przepływ wyeksportowany z Langflow, naszkicowany jako platforma Langflow z biblioteki standardowej przenosząca ten przepływ; każda jego część, którą przyjmuje gniazdo, jest podłączona do tego gniazda.
  • Flowise — chatflow lub agentflow wyeksportowany z Flowise, naszkicowany jako platforma Flowise z biblioteki standardowej przenosząca go; każda jego część, którą przyjmuje gniazdo, jest podłączona do tego gniazda.
  • n8n — workflow wyeksportowany z n8n, naszkicowany jako platforma n8n z biblioteki standardowej przenosząca go; każda jego część, którą przyjmuje gniazdo, jest podłączona do tego gniazda.
  • Dify — aplikacja wyeksportowana z Dify, naszkicowana jako instalacja Dify składana przez bibliotekę standardową, przenosząca tę aplikację; modele, narzędzia i bazy wiedzy, które aplikacja wskazuje, są raportowane jako skonfigurowane wewnątrz Dify.
  • MCP — konfiguracja klienta MCP lub opis serwera z rejestru MCP; każdy serwer jest naszkicowany jako instancja narzędzia MCP z biblioteki standardowej, z encją Release przenoszącą wiersz poleceń, adres lub obraz każdego serwera.
  • Compose — format infrastruktury; każda usługa aplikacji Compose jest naszkicowana jako encja Component katalogu, do której pasuje jej obraz — na podstawie tabeli, którą zawiera importer, generowanej podczas jego budowania z encji Recipes i Components katalogu standardowego dla Compose — lub jako ogólny serwer uruchamiający jej obraz, z encją Release przenoszącą obraz i port każdego ogólnego serwera oraz, w komentarzach, porty, wolumeny i środowisko deklarowane przez każdą usługę.
  • CrewAI — agenci, których projekt CrewAI deklaruje w swoich plikach konfiguracyjnych; każdy jest naszkicowany jako agent CrewAI z biblioteki standardowej przenoszący swoją rolę, cel i historię oraz podłączony do wskazanego modelu; zadania i narzędzia projektu są raportowane jako należące do jego programu, sam program nigdy nie jest odczytywany, a encja Release pozostawia operatorowi wskazanie obrazu, który go uruchamia.
  • LangGraph — grafy deklarowane przez konfigurację aplikacji LangGraph; każdy jest naszkicowany jako agent LangGraph z biblioteki standardowej przenoszący ścieżkę importu swojego grafu i podłączony do magazynu danych, w którym jego checkpointer przechowuje stan, z encją Release podającą w komentarzu środowisko deklarowane przez konfigurację; kod grafów nigdy nie jest odczytywany.
  • Google ADK — drzewa agentów deklarowane przez konfiguracje agentów aplikacji Google ADK; każde jest naszkicowane jako agent ADK z biblioteki standardowej podłączony do wskazanego modelu tam, gdzie ADK wysyła żądania tego modelu do Gemini API, a model osiągany w jakikolwiek inny sposób — na przykład przez ciąg modelu LiteLLM — jest wymieniony w komentarzu, a jego połączenie pozostawione autorowi; z encją Release, która pozostawia operatorowi wskazanie obrazu uruchamiającego aplikację; kod aplikacji nigdy nie jest odczytywany.
  • Agent Framework — deklaratywny agent Agent Framework, naszkicowany jako agent Agent Framework z biblioteki standardowej podłączony do wskazanego modelu OpenAI, przy czym każdy wskazany przez niego serwer MCP jest zapisany w komentarzach, ponieważ dostawca modelu sięga do niego jako do narzędzia hostowanego, z encją Release przenoszącą punkt końcowy modelu oraz, w komentarzu, adres każdego serwera; kod aplikacji nigdy nie jest odczytywany.

Są to wtyczki importerów jak każde inne — logika mapowania specyficzna dla formatu znajduje się w nich, a nie w rdzeniu — budowane ze źródeł kompilatora i publikowane z każdym wydaniem kompilatora w wersji tego wydania. Żadna nie jest wkompilowana w plik binarny: plik binarny zawiera encję Plugin każdej z nich oraz skrót jedynego modułu, który akceptuje, dzięki czemu każda obsługuje swój format w każdym obszarze roboczym bez wpisu w katalogu. Pierwszy import, który potrzebuje importera nieobecnego na maszynie, pobiera go z domyślnego rejestru obszaru roboczego, wiąże go z tym skrótem, weryfikuje go tak, jak pull weryfikuje pobieraną wtyczkę — jej podpis zgodnie z polityką zaufania tego rejestru oraz używane przez nią funkcje hosta — i przechowuje go w pamięci podręcznej treści obszaru roboczego; każdy kolejny import odczytuje go stamtąd, nie łącząc się w tym celu z siecią. Import nie przypina żadnego importera: nie jest dla niego zapisywane nic innego — ani wpis w pliku blokady, ani zapis zaufanych wtyczek — żaden pull go nie buforuje i żadna kompilacja go nie odczytuje. Moduł, który nie przejdzie weryfikacji, jest odrzucany i nic nie jest przechowywane. Jeśli modułu nie można pobrać — obszar roboczy jest offline, rejestr jest nieosiągalny lub go nie zawiera — import zatrzymuje się, podając importer, jego wersję i to, co umieszcza jego moduł na maszynie. Wybór należy do obszaru roboczego: importer, który katalog zawiera pod inną nazwą dla jednego z tych formatów, działa tam, gdzie wskazuje go przyłączenie plugins.importer, a importer o tej samej nazwie i wersji co importer podstawowy działa zamiast niego.

Zasilanie i rozwijanie katalogu

Katalogu nie trzeba budować od zera. Większość pracy przy zasilaniu encji Recipes i pluginów dla nowego środowiska to generowanie szkieletów i ponowne użycie, a nie pisanie każdego pliku binarnego ręcznie.

Importowanie obcego źródła do roboczych plików autorskich. aggrega import <file or directory> odczytuje deklaratywne źródło definicji agentów — przepływ Langflow lub Flowise, przepływ pracy n8n albo konfigurację klienta MCP lub opis serwera z rejestru MCP — aplikację Compose, aplikację Dify, agentów deklarowanych przez projekt CrewAI, grafy deklarowane przez konfigurację aplikacji LangGraph, agentów deklarowanych przez konfiguracje agentów aplikacji Google ADK lub deklaratywnego agenta Agent Framework, i generuje pierwsze wersje robocze YAML Aggregate i Component, a ze źródła MCP, Compose, CrewAI, LangGraph, Google ADK lub Agent Framework również roboczą encję Release, którą autor przegląda i kończy, dzięki czemu zespół przenosi dalej to, co już ma, zamiast pisać to od nowa ręcznie. Dla każdego węzła przepływu i każdej usługi aplikacji Compose ocenia encje Components własnego katalogu obszaru roboczego — w równym stopniu katalogu firmowego, co biblioteki standardowej — za pomocą deterministycznego modelu ufności, niekorzystającego z modelu AI, i zapisuje decyzję — rozważonych kandydatów, przypisany poziom i dokonany wybór — jako wskazówki do przeglądu, które zgłaszają polecenie, edytor i asystent; dopasowanie o wysokiej ufności może zostać zapisane jako odwołanie do katalogu, gdy operator wyrazi na to zgodę, zawsze jako jawna, odwracalna sugestia zatwierdzana przez autora, a nie jako niejawne przepisanie. Każda encja Component, którą zyskuje katalog, staje się kandydatem rozważanym przy następnym imporcie. Logika mapowania specyficzna dla formatu znajduje się w pluginie importera: własne importery kompilatora Langflow, Flowise, n8n, MCP, Compose, Dify, CrewAI, LangGraph, Google ADK i Agent Framework obsługują te formaty w każdym obszarze roboczym, pobierane i weryfikowane przy pierwszym użyciu, a katalog dodaje format, przechowując plugin importera, który go deklaruje. Źródło będące katalogiem jest odczytywane według wzorców plików deklarowanych przez jego importer; importery Langflow, Flowise, n8n, Dify i Agent Framework nie deklarują żadnych i każdy odczytuje jeden wyeksportowany plik lub deklaratywnego agenta, natomiast importer MCP odczytuje konfiguracje klientów znajdujące się w katalogu, importer Compose jego pliki Compose, scalone tak, jak scala je Compose, importer CrewAI deklaracje projektu, nigdy jego programu, importer LangGraph konfigurację aplikacji, nigdy jej kodu ani pliku środowiskowego — którego nazwy odczytuje tylko wtedy, gdy jego podpięcie przekazuje mu ten plik — a importer Google ADK główną konfigurację agenta aplikacji, nigdy jej kodu ani pliku środowiskowego, przy czym konfiguracje jej podagentów są odczytywane, gdy podpięcie mu je przekazuje — konfigurację, którą ADK określa jako eksperymentalną, której agenci domyślnie używają modelu Gemini, a do modeli innych dostawców docierają po nazwie przez własne klasy ADK albo przez ciąg modelu LiteLLM.

Większość pracy nad pluginami to szablony, a nie skompilowany kod. Duża część funkcji jedynie wstrzykuje statyczny sidecar, zmienną środowiskową lub etykietę — zwykły JSONPatch bez logiki warunkowej. Jeden konfigurowalny plugin modyfikujący, napisany raz tak, by przyjmował deklaratywny szablon JSONPatch jako wejście with, może obsłużyć ten częsty przypadek bez osobnego skompilowanego pliku binarnego dla każdej funkcji: autor pisze szablon, a dla wielu celów w stylu CRD wystarcza sam szablon valuesMapping (często odwołujący się do współdzielonych fragmentów we wpisie MappingLibrary). Pluginy PDK pisane specjalnie służą rzeczywiście warunkowej reszcie.

Odwoływanie się do uznanych narzędzi. Pisząc nową logikę pluginu, autorzy mogą korzystać z publicznie udokumentowanych kształtów wyjścia uznanych narzędzi open source — struktury CRD, poprawek lub szablonów, które te narzędzia generują — jako wzorca docelowego kształtu, jaki musi wytworzyć nowy plugin, z poszanowaniem licencji każdego projektu. Webhooki wstrzykujące sidecary, biblioteki konstrukcji wyższego poziomu, generatory CRD operatorów oraz katalogi cech lub kompozycji publikują struktury wyjściowe, które ściśle odpowiadają temu, co musi wygenerować porównywalna encja FeatureRecipe lub plugin. Celem jest zgodność z dobrze zrozumiałym kontraktem wyjścia, a nie kopiowanie implementacji jakiegokolwiek projektu.