Interne werking van de Plugin-architectuur

​

Laadpipeline

1. kandidaat-Plugin-roots ontdekken
2. native of compatibele bundelmanifests en package-metadata lezen
3. onveilige kandidaten weigeren
4. Plugin-configuratie normaliseren (plugins.enabled, allow, deny, entries, slots, load.paths)
5. enablement voor elke kandidaat bepalen
6. ingeschakelde native modules laden: gebouwde gebundelde modules gebruiken een native loader; lokale TypeScript-broncode van derden gebruikt de noodfallback Jiti
7. native register(api)-hooks aanroepen en registraties verzamelen in het Plugin-register
8. het register beschikbaar maken voor commando’s/runtime-oppervlakken

​

Manifest-first-gedrag

• de Plugin te identificeren
• gedeclareerde kanalen/Skills/configuratieschema’s of bundelcapabilities te ontdekken
• plugins.entries.<id>.config te valideren
• Control UI-labels/placeholders aan te vullen
• installatie-/catalogusmetadata te tonen
• goedkope activerings- en setupdescriptoren te behouden zonder Plugin-runtime te laden

• CLI-laden beperkt zich tot Plugins die eigenaar zijn van het gevraagde primaire commando
• kanaalsetup/Plugin-resolutie beperkt zich tot Plugins die eigenaar zijn van de gevraagde kanaal-id
• expliciete provider-setup/runtime-resolutie beperkt zich tot Plugins die eigenaar zijn van de gevraagde provider-id
• Gateway-opstartplanning gebruikt activation.onStartup voor expliciete opstartimports en opstart-opt-outs; Plugins zonder opstartmetadata laden alleen via nauwere activeringstriggers

​

Plugin-cachegrens

• PluginLoaderCacheState en compatibele actieve runtime-registers
• jiti-/modulecaches en public-surface loader-caches die worden gebruikt om te voorkomen dat hetzelfde runtime-oppervlak herhaaldelijk wordt geïmporteerd
• bestandssysteemcaches voor geïnstalleerde Plugin-artifacts
• kortlevende per-call maps voor padnormalisatie of duplicate resolution

• ontdekkingsresultaten
• directe manifestregisters
• manifestregisters die zijn gereconstrueerd uit de geïnstalleerde Plugin-index
• provider-eigenaarlookup, modelonderdrukking, providerpolicy of public-artifact metadata
• elk ander manifest-afgeleid antwoord waarbij een gewijzigd manifest, geïnstalleerde index of laadpad zichtbaar moet zijn bij de volgende metadatalezing

​

Registermodel

• Plugin-records (identiteit, bron, herkomst, status, diagnostiek)
• tools
• legacy hooks en getypeerde hooks
• kanalen
• providers
• Gateway-RPC-handlers
• HTTP-routes
• CLI-registrars
• achtergrondservices
• Plugin-owned commando’s

• Plugin-module -> registerregistratie
• core-runtime -> registerconsumptie

​

Conversation binding callbacks

export default {
  id: "my-plugin",
  register(api) {
    api.onConversationBindingResolved(async (event) => {
      if (event.status === "approved") {
        // A binding now exists for this plugin + conversation.
        console.log(event.binding?.conversationId);
        return;
      }

      // The request was denied; clear any local pending state.
      console.log(event.request.conversation.conversationId);
    });
  },
};

• status: "approved" of "denied"
• decision: "allow-once", "allow-always" of "deny"
• binding: de opgeloste binding voor goedgekeurde requests
• request: de oorspronkelijke request-samenvatting, detach-hint, sender-id en gespreksmetadata

​

Provider-runtime-hooks

• Manifestmetadata voor goedkope lookup voor runtime: setup.providers[].envVars, verouderde compatibiliteit providerAuthEnvVars, providerAuthAliases, providerAuthChoices en channelEnvVars.
• Config-time hooks: catalog (legacy discovery) plus applyConfigDefaults.
• Runtime-hooks: meer dan 40 optionele hooks voor auth, modelresolutie, stream-wrapping, thinking levels, replaypolicy en usage-eindpunten. Zie de volledige lijst onder Hookvolgorde en gebruik.

​

Hookvolgorde en gebruik

​

Providervoorbeeld

api.registerProvider({
  id: "example-proxy",
  label: "Example Proxy",
  auth: [],
  catalog: {
    order: "simple",
    run: async (ctx) => {
      const apiKey = ctx.resolveProviderApiKey("example-proxy").apiKey;
      if (!apiKey) {
        return null;
      }
      return {
        provider: {
          baseUrl: "https://proxy.example.com/v1",
          apiKey,
          api: "openai-completions",
          models: [{ id: "auto", name: "Auto" }],
        },
      };
    },
  },
  resolveDynamicModel: (ctx) => ({
    id: ctx.modelId,
    name: ctx.modelId,
    provider: "example-proxy",
    api: "openai-completions",
    baseUrl: "https://proxy.example.com/v1",
    reasoning: false,
    input: ["text"],
    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
    contextWindow: 128000,
    maxTokens: 8192,
  }),
  prepareRuntimeAuth: async (ctx) => {
    const exchanged = await exchangeToken(ctx.apiKey);
    return {
      apiKey: exchanged.token,
      baseUrl: exchanged.baseUrl,
      expiresAt: exchanged.expiresAt,
    };
  },
  resolveUsageAuth: async (ctx) => {
    const auth = await ctx.resolveOAuthToken();
    return auth ? { token: auth.token } : null;
  },
  fetchUsageSnapshot: async (ctx) => {
    return await fetchExampleProxyUsage(ctx.token, ctx.timeoutMs, ctx.fetchFn);
  },
});

​

Ingebouwde voorbeelden

​

Runtimehelpers

const clip = await api.runtime.tts.textToSpeech({
  text: "Hello from OpenClaw",
  cfg: api.config,
});

const result = await api.runtime.tts.textToSpeechTelephony({
  text: "Hello from OpenClaw",
  cfg: api.config,
});

const voices = await api.runtime.tts.listVoices({
  provider: "elevenlabs",
  cfg: api.config,
});

• textToSpeech retourneert de normale core-TTS-outputpayload voor bestands-/spraaknotitieoppervlakken.
• Gebruikt core-messages.tts-configuratie en providerselectie.
• Retourneert PCM-audiobuffer + samplerate. Plugins moeten resamplen/coderen voor providers.
• listVoices is optioneel per provider. Gebruik het voor voice-pickers of setupflows die eigendom zijn van de vendor.
• Stemlijsten kunnen rijkere metadata bevatten, zoals locale, gender en persoonlijkheidstags voor providerbewuste pickers.
• OpenAI en ElevenLabs ondersteunen vandaag telefonie. Microsoft niet.

api.registerSpeechProvider({
  id: "acme-speech",
  label: "Acme Speech",
  isConfigured: ({ config }) => Boolean(config.messages?.tts),
  synthesize: async (req) => {
    return {
      audioBuffer: Buffer.from([]),
      outputFormat: "mp3",
      fileExtension: ".mp3",
      voiceCompatible: false,
    };
  },
});

• Houd TTS-beleid, terugval en antwoordbezorging in core.
• Gebruik spraakproviders voor synthese gedrag dat eigendom is van de vendor.
• Legacy Microsoft-edge-input wordt genormaliseerd naar de provider-id microsoft.
• Het voorkeursmodel voor eigenaarschap is bedrijfsgericht: één vendor-Plugin kan eigenaar zijn van tekst-, spraak-, beeld- en toekomstige mediaproviders naarmate OpenClaw die capability-contracten toevoegt.

api.registerMediaUnderstandingProvider({
  id: "google",
  capabilities: ["image", "audio", "video"],
  describeImage: async (req) => ({ text: "..." }),
  transcribeAudio: async (req) => ({ text: "..." }),
  describeVideo: async (req) => ({ text: "..." }),
});

• Houd orchestratie, terugval, configuratie en kanaalbedrading in core.
• Houd vendorgedrag in de provider-Plugin.
• Additieve uitbreiding moet getypt blijven: nieuwe optionele methoden, nieuwe optionele resultaatvelden, nieuwe optionele capabilities.
• Videogeneratie volgt al hetzelfde patroon:
  • core is eigenaar van het capability-contract en de runtimehelper
  • vendor-Plugins registreren api.registerVideoGenerationProvider(...)
  • feature-/kanaal-Plugins gebruiken api.runtime.videoGeneration.*

const image = await api.runtime.mediaUnderstanding.describeImageFile({
  filePath: "/tmp/inbound-photo.jpg",
  cfg: api.config,
  agentDir: "/tmp/agent",
});

const video = await api.runtime.mediaUnderstanding.describeVideoFile({
  filePath: "/tmp/inbound-video.mp4",
  cfg: api.config,
});

const extraction = await api.runtime.mediaUnderstanding.extractStructuredWithModel({
  provider: "codex",
  model: "gpt-5.5",
  input: [
    {
      type: "image",
      buffer: receiptImageBuffer,
      fileName: "receipt.png",
      mime: "image/png",
    },
    { type: "text", text: "Use the printed fields as the source of truth." },
  ],
  instructions: "Return entities and searchable tags.",
  schemaName: "example.evidence",
  jsonSchema: {
    type: "object",
    properties: {
      entities: { type: "array", items: { type: "string" } },
      tags: { type: "array", items: { type: "string" } },
    },
  },
  cfg: api.config,
});

const { text } = await api.runtime.mediaUnderstanding.transcribeAudioFile({
  filePath: "/tmp/inbound-audio.ogg",
  cfg: api.config,
  // Optional when MIME cannot be inferred reliably:
  mime: "audio/ogg",
});

• api.runtime.mediaUnderstanding.* is het aanbevolen gedeelde oppervlak voor begrip van beeld/audio/video.
• extractStructuredWithModel(...) is de Plugin-gerichte seam voor begrensde provider-owned image-first extractie. Neem ten minste één beeldinput op; tekstinputs zijn aanvullende context. product-Plugins zijn eigenaar van hun routes en schema’s, terwijl OpenClaw eigenaar is van de provider-/runtimegrens.
• Gebruikt core media-understanding-audioconfiguratie (tools.media.audio) en provider-terugvalvolgorde.
• Retourneert { text: undefined } wanneer er geen transcriptie-output wordt geproduceerd (bijvoorbeeld overgeslagen/niet-ondersteunde input).
• api.runtime.stt.transcribeAudioFile(...) blijft als compatibiliteitsalias bestaan.

const result = await api.runtime.subagent.run({
  sessionKey: "agent:main:subagent:search-helper",
  message: "Expand this query into focused follow-up searches.",
  provider: "openai",
  model: "gpt-4.1-mini",
  deliver: false,
});

• provider en model zijn optionele overrides per run, geen persistente sessiewijzigingen.
• OpenClaw respecteert die override-velden alleen voor vertrouwde aanroepers.
• Voor terugvalruns die eigendom zijn van Plugins moeten operators zich aanmelden met plugins.entries.<id>.subagent.allowModelOverride: true.
• Gebruik plugins.entries.<id>.subagent.allowedModels om vertrouwde Plugins te beperken tot specifieke canonieke provider/model-doelen, of "*" om elk doel expliciet toe te staan.
• Subagent-runs van niet-vertrouwde Plugins werken nog steeds, maar override-verzoeken worden geweigerd in plaats van stilzwijgend terug te vallen.
• Door Plugins gemaakte subagent-sessies worden getagd met de id van de makende Plugin. Terugval api.runtime.subagent.deleteSession(...) mag alleen die sessies in eigendom verwijderen; willekeurige sessieverwijdering vereist nog steeds een admin-scoped Gateway-request.

const providers = api.runtime.webSearch.listProviders({
  config: api.config,
});

const result = await api.runtime.webSearch.search({
  config: api.config,
  args: {
    query: "OpenClaw plugin runtime helpers",
    count: 5,
  },
});

• Houd providerselectie, credentialresolutie en gedeelde requestsemantiek in core.
• Gebruik webzoekproviders voor vendorspecifieke zoektransporten.
• api.runtime.webSearch.* is het aanbevolen gedeelde oppervlak voor feature-/kanaal-Plugins die zoekgedrag nodig hebben zonder afhankelijk te zijn van de agent-toolwrapper.

​

api.runtime.imageGeneration

const result = await api.runtime.imageGeneration.generate({
  config: api.config,
  args: { prompt: "A friendly lobster mascot", size: "1024x1024" },
});

const providers = api.runtime.imageGeneration.listProviders({
  config: api.config,
});

• generate(...): genereer een afbeelding met de geconfigureerde keten van afbeeldinggeneratieproviders.
• listProviders(...): lijst beschikbare afbeeldinggeneratieproviders en hun capabilities.

​

Gateway-HTTP-routes

api.registerHttpRoute({
  path: "/acme/webhook",
  auth: "plugin",
  match: "exact",
  handler: async (_req, res) => {
    res.statusCode = 200;
    res.end("ok");
    return true;
  },
});

• path: routepad onder de Gateway HTTP-server.
• auth: vereist. Gebruik "gateway" om normale Gateway-authenticatie te vereisen, of "plugin" voor door plugins beheerde authenticatie/webhook-verificatie.
• match: optioneel. "exact" (standaard) of "prefix".
• replaceExisting: optioneel. Staat dezelfde plugin toe zijn eigen bestaande routeregistratie te vervangen.
• handler: retourneer true wanneer de route het verzoek heeft afgehandeld.

• api.registerHttpHandler(...) is verwijderd en veroorzaakt een plugin-laadfout. Gebruik in plaats daarvan api.registerHttpRoute(...).
• Pluginroutes moeten auth expliciet declareren.
• Exacte path + match-conflicten worden geweigerd tenzij replaceExisting: true, en de ene plugin kan de route van een andere plugin niet vervangen.
• Overlappende routes met verschillende auth-niveaus worden geweigerd. Houd exact/prefix-fallthroughketens alleen op hetzelfde authenticatieniveau.
• auth: "plugin"-routes ontvangen niet automatisch operator-runtime-scopes. Ze zijn bedoeld voor door plugins beheerde webhooks/handtekeningverificatie, niet voor geprivilegieerde Gateway-helperaanroepen.
• auth: "gateway"-routes worden uitgevoerd binnen een Gateway-request-runtime-scope, maar die scope is opzettelijk conservatief:
  • shared-secret bearer-authenticatie (gateway.auth.mode = "token" / "password") houdt runtime-scopes van pluginroutes vastgezet op operator.write, zelfs als de aanroeper x-openclaw-scopes verzendt
  • vertrouwde HTTP-modi met identiteit (bijvoorbeeld trusted-proxy of gateway.auth.mode = "none" op een private ingress) honoreren x-openclaw-scopes alleen wanneer de header expliciet aanwezig is
  • als x-openclaw-scopes ontbreekt bij die identiteit-dragende pluginrouteverzoeken, valt runtime-scope terug op operator.write
• Praktische regel: ga er niet van uit dat een Gateway-auth-pluginroute een impliciet adminoppervlak is. Als je route gedrag nodig heeft dat alleen voor admins is, vereis dan een authenticatiemodus met identiteit en documenteer het expliciete x-openclaw-scopes-headercontract.

​

Plugin SDK-importpaden

• index.js — entry voor gebundelde plugin
• api.js — barrel voor helpers/types
• runtime-api.js — barrel alleen voor runtime
• setup-entry.js — entry voor setup-plugin

​

Schema’s voor berichttools

• presentation voor semantische presentatieblokken (text, context, divider, buttons, select)
• delivery-pin voor verzoeken om vastgezette aflevering

​

Resolutie van kanaaldoelen

• messaging.inferTargetChatType({ to }) beslist of een genormaliseerd doel moet worden behandeld als direct, group of channel vóór directory-lookup.
• messaging.targetResolver.looksLikeId(raw, normalized) vertelt core of een invoer direct moet doorgaan naar id-achtige resolutie in plaats van directoryzoekopdracht.
• messaging.targetResolver.reservedLiterals vermeldt losse woorden die kanaal-/sessiereferenties zijn voor die provider. Resolutie behoudt geconfigureerde directoryvermeldingen voordat gereserveerde literals worden geweigerd, en faalt daarna gesloten bij een directory-mis.
• messaging.targetResolver.resolveTarget(...) is de pluginfallback wanneer core een definitieve provider-beheerde resolutie nodig heeft na normalisatie of na een directory-mis.
• messaging.resolveOutboundSessionRoute(...) beheert provider-specifieke sessie- routeconstructie zodra een doel is opgelost.

• Gebruik inferTargetChatType voor categoriebeslissingen die vóór het zoeken naar peers/groepen moeten plaatsvinden.
• Gebruik looksLikeId voor controles op “behandel dit als een expliciete/native doel-id”.
• Gebruik resolveTarget voor provider-specifieke normalisatiefallback, niet voor brede directoryzoekopdrachten.
• Houd provider-native ids zoals chat-id’s, thread-id’s, JID’s, handles en room- id’s binnen target-waarden of provider-specifieke parameters, niet in generieke SDK- velden.

​

Configuratie-ondersteunde directories

• door allowlists aangestuurde DM-peers
• geconfigureerde kanaal-/groepsmaps
• statische directoryfallbacks per account

• queryfiltering
• limiettoepassing
• deduplicatie-/normalisatiehelpers
• bouwen van ChannelDirectoryEntry[]

​

Providercatalogi

• { provider } voor één providervermelding
• { providers } voor meerdere providervermeldingen

• simple: gewone API-key- of env-gestuurde providers
• profile: providers die verschijnen wanneer authenticatieprofielen bestaan
• paired: providers die meerdere gerelateerde providervermeldingen synthetiseren
• late: laatste pass, na andere impliciete providers

• discovery werkt nog als legacy alias, maar geeft een deprecationwaarschuwing
• als zowel catalog als discovery zijn geregistreerd, gebruikt OpenClaw catalog
• augmentModelCatalog is verouderd; gebundelde providers moeten aanvullende rijen publiceren via registerModelCatalogProvider

​

Alleen-lezen kanaalinspectie

• resolveAccount(...) is het runtimepad. Het mag aannemen dat credentials volledig gematerialiseerd zijn en snel falen wanneer vereiste secrets ontbreken.
• Alleen-lezen commandopaden zoals openclaw status, openclaw status --all, openclaw channels status, openclaw channels resolve en doctor-/configuratie- reparatieflows zouden geen runtimecredentials hoeven te materialiseren alleen om configuratie te beschrijven.

• Retourneer alleen beschrijvende accountstatus.
• Behoud enabled en configured.
• Neem credentialbron-/statusvelden op wanneer relevant, zoals:
  • tokenSource, tokenStatus
  • botTokenSource, botTokenStatus
  • appTokenSource, appTokenStatus
  • signingSecretSource, signingSecretStatus
• Je hoeft geen ruwe tokenwaarden te retourneren alleen om alleen-lezen beschikbaarheid te rapporteren. tokenStatus: "available" retourneren (en het overeenkomende bron- veld) is genoeg voor statusachtige commando’s.
• Gebruik configured_unavailable wanneer een credential via SecretRef is geconfigureerd maar niet beschikbaar is in het huidige commandopad.

​

Pakketpacks

{
  "name": "my-pack",
  "openclaw": {
    "extensions": ["./src/safety.ts", "./src/tools.ts"],
    "setupEntry": "./src/setup-entry.ts"
  }
}

• kanaalregistratie zelf
• alle HTTP-routes die beschikbaar moeten zijn voordat de Gateway begint te luisteren
• alle Gateway-methoden, tools of services die tijdens datzelfde venster moeten bestaan

• singleAccountKeysToMove
• namedAccountPromotionKeys
• resolveSingleAccountPromotionTarget(...)

{
  "name": "@scope/my-channel",
  "openclaw": {
    "extensions": ["./index.ts"],
    "setupEntry": "./setup-entry.ts",
    "startup": {
      "deferConfiguredChannelFullLoadUntilAfterListen": true
    }
  }
}

​

Metadata van de kanaalcatalogus

{
  "name": "@openclaw/nextcloud-talk",
  "openclaw": {
    "extensions": ["./index.ts"],
    "channel": {
      "id": "nextcloud-talk",
      "label": "Nextcloud Talk",
      "selectionLabel": "Nextcloud Talk (self-hosted)",
      "docsPath": "/channels/nextcloud-talk",
      "docsLabel": "nextcloud-talk",
      "blurb": "Self-hosted chat via Nextcloud Talk webhook bots.",
      "order": 65,
      "aliases": ["nc-talk", "nc"]
    },
    "install": {
      "npmSpec": "@openclaw/nextcloud-talk",
      "localPath": "<bundled-plugin-local-path>",
      "defaultChoice": "npm"
    }
  }
}

• detailLabel: secundair label voor rijkere catalogus-/statusoppervlakken
• docsLabel: linktekst voor de docs-link overschrijven
• preferOver: plugin-/kanaal-id’s met lagere prioriteit die deze catalogusentry moet overtreffen
• selectionDocsPrefix, selectionDocsOmitLabel, selectionExtras: kopieerinstellingen voor selectieoppervlakken
• markdownCapable: markeert het kanaal als markdown-capable voor beslissingen over uitgaande opmaak
• exposure.configured: verberg het kanaal van oppervlakken met lijsten van geconfigureerde kanalen wanneer ingesteld op false
• exposure.setup: verberg het kanaal van interactieve setup-/configure-kiezers wanneer ingesteld op false
• exposure.docs: markeer het kanaal als intern/privé voor docs-navigatieoppervlakken
• showConfigured / showInSetup: verouderde aliassen die nog steeds worden geaccepteerd voor compatibiliteit; geef de voorkeur aan exposure
• quickstartAllowFrom: laat het kanaal deelnemen aan de standaard quickstart-allowFrom-flow
• forceAccountBinding: vereis expliciete accountbinding, zelfs wanneer er maar één account bestaat
• preferSessionLookupForAnnounceTarget: geef de voorkeur aan sessieopzoeking bij het resolven van aankondigingsdoelen

• ~/.openclaw/mpm/plugins.json
• ~/.openclaw/mpm/catalog.json
• ~/.openclaw/plugins/catalog.json

​

Context-engine-plugins

import { buildMemorySystemPromptAddition } from "openclaw/plugin-sdk/core";

export default function (api) {
  api.registerContextEngine("lossless-claw", (ctx) => ({
    info: { id: "lossless-claw", name: "Lossless Claw", ownsCompaction: true },
    async ingest() {
      return { ingested: true };
    },
    async assemble({ messages, availableTools, citationsMode }) {
      return {
        messages,
        estimatedTokens: 0,
        systemPromptAddition: buildMemorySystemPromptAddition({
          availableTools: availableTools ?? new Set(),
          citationsMode,
        }),
      };
    },
    async compact() {
      return { ok: true, compacted: false };
    },
  }));
}

import {
  buildMemorySystemPromptAddition,
  delegateCompactionToRuntime,
} from "openclaw/plugin-sdk/core";

export default function (api) {
  api.registerContextEngine("my-memory-engine", (ctx) => ({
    info: {
      id: "my-memory-engine",
      name: "My Memory Engine",
      ownsCompaction: false,
    },
    async ingest() {
      return { ingested: true };
    },
    async assemble({ messages, availableTools, citationsMode }) {
      return {
        messages,
        estimatedTokens: 0,
        systemPromptAddition: buildMemorySystemPromptAddition({
          availableTools: availableTools ?? new Set(),
          citationsMode,
        }),
      };
    },
    async compact(params) {
      return await delegateCompactionToRuntime(params);
    },
  }));
}

​

Een nieuwe capability toevoegen

1. definieer het core-contract Bepaal welk gedeeld gedrag core moet bezitten: beleid, fallback, config-merge, lifecycle, kanaalgerichte semantiek en vorm van runtime-helper.
2. voeg getypte pluginregistratie-/runtime-oppervlakken toe Breid OpenClawPluginApi en/of api.runtime uit met het kleinste nuttige getypte capability-oppervlak.
3. sluit core + kanaal-/featureconsumers aan Kanalen en feature-plugins moeten de nieuwe capability via core consumeren, niet door rechtstreeks een vendor-implementatie te importeren.
4. registreer vendor-implementaties Vendor-plugins registreren vervolgens hun backends tegen de capability.
5. voeg contractdekking toe Voeg tests toe zodat eigenaarschap en registratievorm in de loop van de tijd expliciet blijven.

​

Capability-checklist

• core-contracttypen in src/<capability>/types.ts
• core-runner/runtime-helper in src/<capability>/runtime.ts
• plugin-API-registratieoppervlak in src/plugins/types.ts
• pluginregistry-bedrading in src/plugins/registry.ts
• pluginruntime-exposure in src/plugins/runtime/* wanneer feature-/kanaalplugins het moeten consumeren
• capture-/testhelpers in src/test-utils/plugin-registration.ts
• eigenaarschaps-/contractassertions in src/plugins/contracts/registry.ts
• operator-/plugin-docs in docs/

​

Capability-template

// core contract
export type VideoGenerationProviderPlugin = {
  id: string;
  label: string;
  generateVideo: (req: VideoGenerationRequest) => Promise<VideoGenerationResult>;
};

// plugin API
api.registerVideoGenerationProvider({
  id: "openai",
  label: "OpenAI",
  async generateVideo(req) {
    return await generateOpenAiVideo(req);
  },
});

// shared runtime helper for feature/channel plugins
const clip = await api.runtime.videoGeneration.generate({
  prompt: "Show the robot walking through the lab.",
  cfg,
});

expect(findVideoGenerationProviderIdsForPlugin("openai")).toEqual(["openai"]);

• core is eigenaar van het capabilitycontract + orkestratie
• vendor-Plugins zijn eigenaar van vendor-implementaties
• feature-/kanaal-Plugins gebruiken runtime-helpers
• contracttests houden eigenaarschap expliciet

​

Gerelateerd

• Plugin-architectuur — openbaar capabilitymodel en vormen
• Plugin SDK-subpaden
• Plugin SDK-installatie
• Plugins bouwen