Aspectos internos de la arquitectura de Plugin

​

Canalización de carga

1. descubre raíces candidatas de plugins
2. lee manifiestos de bundles nativos o compatibles y metadatos de paquete
3. rechaza candidatos no seguros
4. normaliza la configuración de plugins (plugins.enabled, allow, deny, entries, slots, load.paths)
5. decide la habilitación de cada candidato
6. carga módulos nativos habilitados: los módulos bundled compilados usan un cargador nativo; el código fuente TypeScript local de terceros usa el fallback de emergencia de Jiti
7. llama a los hooks nativos register(api) y recopila los registros en el registro de plugins
8. expone el registro a comandos/superficies de tiempo de ejecución

• su entrada resuelta escapa de la raíz del plugin
• su ruta (o su directorio raíz) permite escritura mundial
• para plugins no bundled, la propiedad de la ruta no coincide con el uid actual (o root)

​

Comportamiento con prioridad del manifiesto

• identificar el plugin
• descubrir canales/skills/esquema de configuración declarados o capacidades del bundle
• validar plugins.entries.<id>.config
• aumentar etiquetas/placeholders de Control UI
• mostrar metadatos de instalación/catálogo
• preservar descriptores económicos de activación y configuración sin cargar el runtime del plugin

• la carga de CLI se limita a plugins que poseen el comando primario solicitado
• la resolución de configuración/plugin de canal se limita a plugins que poseen el id de canal solicitado
• la resolución explícita de configuración/runtime de proveedor se limita a plugins que poseen el id de proveedor solicitado
• la planificación de inicio del Gateway usa activation.onStartup para importaciones explícitas de inicio; los plugins sin metadatos de inicio cargan solo mediante disparadores de activación más específicos

​

Límite de caché de plugins

• PluginLoaderCacheState y registros compatibles de runtime activo
• cachés de jiti/módulos y cachés de cargador de superficie pública usadas para evitar importar repetidamente la misma superficie de runtime
• cachés de sistema de archivos para artefactos de plugins instalados
• mapas por llamada de vida corta para normalización de rutas o resolución de duplicados

• resultados de descubrimiento
• registros directos de manifiestos
• registros de manifiestos reconstruidos desde el índice de plugins instalados
• búsqueda de propietario de proveedor, supresión de modelos, política de proveedores o metadatos de artefactos públicos
• cualquier otra respuesta derivada del manifiesto donde un manifiesto cambiado, índice instalado o ruta de carga deba ser visible en la siguiente lectura de metadatos

​

Modelo de registro

• módulo de plugin -> registro en el registro
• runtime del core -> consumo del registro

​

Callbacks de vinculación de conversaciones

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" o "denied"
• decision: "allow-once", "allow-always" o "deny"
• binding: la vinculación resuelta para solicitudes aprobadas
• request: el resumen de la solicitud original, la pista de desvinculación, el id del remitente y metadatos de la conversación

​

Hooks de runtime de proveedores

• Metadatos del manifiesto para búsqueda económica previa al runtime: setup.providers[].envVars, compatibilidad obsoleta providerAuthEnvVars, providerAuthAliases, providerAuthChoices y channelEnvVars.
• Hooks en tiempo de configuración: catalog (discovery heredado) más applyConfigDefaults.
• Hooks de runtime: más de 40 hooks opcionales que cubren autenticación, resolución de modelos, envoltura de streams, niveles de thinking, política de replay y endpoints de uso. Consulta Orden y uso de hooks.

​

Orden y uso de hooks

​

Ejemplo de proveedor

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);
  },
});

​

Ejemplos integrados

​

Helpers de tiempo de ejecución

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 devuelve la carga de salida normal de TTS del núcleo para superficies de archivo/nota de voz.
• Usa la configuración central messages.tts y la selección de proveedor.
• Devuelve búfer de audio PCM + frecuencia de muestreo. Los Plugins deben remuestrear/codificar para proveedores.
• listVoices es opcional por proveedor. Úsalo para selectores de voz propiedad del proveedor o flujos de configuración.
• Las listas de voces pueden incluir metadatos más ricos, como configuración regional, género y etiquetas de personalidad para selectores conscientes del proveedor.
• OpenAI y ElevenLabs admiten telefonía hoy. Microsoft no.

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,
    };
  },
});

• Mantén la política de TTS, la alternativa y la entrega de respuestas en el núcleo.
• Usa proveedores de voz para comportamiento de síntesis propiedad del proveedor.
• La entrada heredada de Microsoft edge se normaliza al id de proveedor microsoft.
• El modelo de propiedad preferido está orientado a empresas: un Plugin de proveedor puede poseer proveedores de texto, voz, imagen y futuros medios a medida que OpenClaw agrega esos contratos de capacidad.

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

• Mantén la orquestación, la alternativa, la configuración y el cableado de canales en el núcleo.
• Mantén el comportamiento del proveedor en el Plugin proveedor.
• La expansión aditiva debe seguir tipada: nuevos métodos opcionales, nuevos campos de resultado opcionales, nuevas capacidades opcionales.
• La generación de video ya sigue el mismo patrón:
  • el núcleo posee el contrato de capacidad y el helper de tiempo de ejecución
  • los Plugins de proveedores registran api.registerVideoGenerationProvider(...)
  • los Plugins de funcionalidad/canal consumen 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.* es la superficie compartida preferida para comprensión de imagen/audio/video.
• extractStructuredWithModel(...) es la superficie orientada a Plugins para extracción acotada propiedad del proveedor y centrada en imágenes. Incluye al menos una entrada de imagen; las entradas de texto son contexto suplementario. Los Plugins de producto poseen sus rutas y esquemas, mientras OpenClaw posee el límite de proveedor/tiempo de ejecución.
• Usa la configuración central de audio de comprensión de medios (tools.media.audio) y el orden de alternativas de proveedor.
• Devuelve { text: undefined } cuando no se produce salida de transcripción (por ejemplo, entrada omitida/no admitida).
• api.runtime.stt.transcribeAudioFile(...) permanece como alias de compatibilidad.

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 y model son anulaciones opcionales por ejecución, no cambios de sesión persistentes.
• OpenClaw solo respeta esos campos de anulación para llamadores de confianza.
• Para ejecuciones alternativas propiedad de Plugins, los operadores deben optar por ellas con plugins.entries.<id>.subagent.allowModelOverride: true.
• Usa plugins.entries.<id>.subagent.allowedModels para restringir Plugins de confianza a destinos canónicos provider/model específicos, o "*" para permitir explícitamente cualquier destino.
• Las ejecuciones de subagente de Plugins no confiables siguen funcionando, pero las solicitudes de anulación se rechazan en lugar de recurrir silenciosamente a la alternativa.
• Las sesiones de subagente creadas por Plugins se etiquetan con el id del Plugin creador. La alternativa api.runtime.subagent.deleteSession(...) puede eliminar solo esas sesiones propias; la eliminación arbitraria de sesiones aún requiere una solicitud de Gateway con alcance de administrador.

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,
  },
});

• Mantén la selección de proveedor, la resolución de credenciales y la semántica de solicitudes compartida en el núcleo.
• Usa proveedores de búsqueda web para transportes de búsqueda específicos del proveedor.
• api.runtime.webSearch.* es la superficie compartida preferida para Plugins de funcionalidad/canal que necesitan comportamiento de búsqueda sin depender del envoltorio de herramienta del agente.

​

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(...): genera una imagen usando la cadena de proveedores de generación de imágenes configurada.
• listProviders(...): enumera los proveedores de generación de imágenes disponibles y sus capacidades.

​

Rutas HTTP de Gateway

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

• path: ruta bajo el servidor HTTP del gateway.
• auth: obligatorio, "gateway" o "plugin". Usa "gateway" para requerir la autenticación normal del gateway, o "plugin" para la autenticación/verificación de webhook gestionada por el plugin.
• match: opcional. "exact" (predeterminado) o "prefix".
• handleUpgrade: manejador opcional para solicitudes de actualización WebSocket en la misma ruta.
• replaceExisting: opcional. Permite que el mismo plugin reemplace su propio registro de ruta existente.
• handler: devuelve true cuando la ruta haya gestionado la solicitud.

• api.registerHttpHandler(...) se eliminó y provocará un error de carga del plugin. Usa api.registerHttpRoute(...) en su lugar.
• Las rutas de Plugin deben declarar auth explícitamente.
• Los conflictos exactos de path + match se rechazan salvo que replaceExisting: true, y un plugin no puede reemplazar la ruta de otro plugin.
• Las rutas solapadas con distintos niveles de auth se rechazan. Mantén las cadenas de reserva exact/prefix solo en el mismo nivel de autenticación.
• Las rutas con auth: "plugin" no reciben ámbitos de ejecución de operador automáticamente. Son para webhooks/verificación de firmas gestionados por el plugin, no para llamadas privilegiadas a helpers del Gateway.
• Las rutas con auth: "gateway" se ejecutan dentro de un ámbito de ejecución de solicitud del Gateway. La superficie predeterminada (gatewayRuntimeScopeSurface: "write-default") es intencionadamente conservadora:
  • la autenticación bearer con secreto compartido (gateway.auth.mode = "token" / "password") y cualquier método de autenticación que no sea de proxy de confianza reciben un único ámbito operator.write, incluso si el llamador envía x-openclaw-scopes
  • los llamadores trusted-proxy sin una cabecera x-openclaw-scopes explícita también conservan la superficie heredada limitada a operator.write
  • los llamadores trusted-proxy que sí envían x-openclaw-scopes reciben los ámbitos declarados en su lugar
  • una ruta puede optar por gatewayRuntimeScopeSurface: "trusted-operator" para respetar siempre x-openclaw-scopes en modos de autenticación con identidad (recurriendo al conjunto completo de ámbitos predeterminados de la CLI cuando la cabecera no está presente)
• Regla práctica: no asumas que una ruta de plugin autenticada por gateway es una superficie de administración implícita. Si tu ruta necesita comportamiento exclusivo de administrador, opta por la superficie de ámbito trusted-operator, requiere un modo de autenticación con identidad y documenta el contrato explícito de la cabecera x-openclaw-scopes.

​

Rutas de importación del SDK de Plugin

• index.js — entrada de plugin incluido
• api.js — barrel de helpers/tipos
• runtime-api.js — barrel solo de runtime
• setup-entry.js — entrada de plugin de configuración

​

Esquemas de herramientas de mensajes

• presentation para bloques de presentación semántica (text, context, divider, buttons, select)
• delivery-pin para solicitudes de entrega fijada

​

Resolución de destinos de canal

• messaging.inferTargetChatType({ to }) decide si un destino normalizado debe tratarse como direct, group o channel antes de la búsqueda en el directorio.
• messaging.targetResolver.looksLikeId(raw, normalized) le indica a core si una entrada debe saltar directamente a una resolución tipo id en lugar de una búsqueda en el directorio.
• messaging.targetResolver.reservedLiterals enumera palabras simples que son referencias de canal/sesión para ese proveedor. La resolución preserva las entradas de directorio configuradas antes de rechazar literales reservados, y luego falla de forma cerrada ante una ausencia en el directorio.
• messaging.targetResolver.resolveTarget(...) es la reserva del plugin cuando core necesita una resolución final propiedad del proveedor después de la normalización o tras una ausencia en el directorio.
• messaging.resolveOutboundSessionRoute(...) es propietario de la construcción de rutas de sesión específica del proveedor una vez resuelto un destino.

• Usa inferTargetChatType para decisiones de categoría que deben ocurrir antes de buscar pares/grupos.
• Usa looksLikeId para comprobaciones de “tratar esto como un id de destino explícito/nativo”.
• Usa resolveTarget para la reserva de normalización específica del proveedor, no para búsquedas amplias en directorios.
• Mantén los ids nativos del proveedor, como ids de chat, ids de hilo, JIDs, handles e ids de sala, dentro de valores target o parámetros específicos del proveedor, no en campos genéricos del SDK.

​

Directorios respaldados por configuración

• pares de DM controlados por allowlist
• mapas configurados de canales/grupos
• reservas de directorio estático con ámbito de cuenta

• filtrado de consultas
• aplicación de límites
• helpers de deduplicación/normalización
• construcción de ChannelDirectoryEntry[]

​

Catálogos de proveedores

• { provider } para una entrada de proveedor
• { providers } para varias entradas de proveedor

• simple: proveedores simples basados en clave de API o entorno
• profile: proveedores que aparecen cuando existen perfiles de autenticación
• paired: proveedores que sintetizan varias entradas de proveedor relacionadas
• late: última pasada, después de otros proveedores implícitos

• discovery sigue funcionando como alias heredado, pero emite una advertencia de obsolescencia
• si se registran tanto catalog como discovery, OpenClaw usa catalog y emite una advertencia
• augmentModelCatalog está obsoleto; los proveedores incluidos deben publicar filas suplementarias mediante registerModelCatalogProvider

​

Inspección de canal de solo lectura

• resolveAccount(...) es la ruta de runtime. Puede asumir que las credenciales están completamente materializadas y puede fallar rápido cuando faltan secretos requeridos.
• Las rutas de comandos de solo lectura como openclaw status, openclaw status --all, openclaw channels status, openclaw channels resolve y los flujos de reparación de doctor/configuración no deberían necesitar materializar credenciales de runtime solo para describir la configuración.

• Devuelve solo estado descriptivo de la cuenta.
• Preserva enabled y configured.
• Incluye campos de origen/estado de credenciales cuando sean relevantes, como:
  • tokenSource, tokenStatus
  • botTokenSource, botTokenStatus
  • appTokenSource, appTokenStatus
  • signingSecretSource, signingSecretStatus
• No necesitas devolver valores de token sin procesar solo para informar disponibilidad de solo lectura. Devolver tokenStatus: "available" (y el campo de origen correspondiente) es suficiente para comandos de estilo estado.
• Usa configured_unavailable cuando una credencial esté configurada mediante SecretRef pero no esté disponible en la ruta de comando actual.

​

Paquetes de paquetes

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

• el registro del canal en sí
• cualquier ruta HTTP que deba estar disponible antes de que el Gateway empiece a escuchar
• cualquier método, herramienta o servicio del Gateway que deba existir durante esa misma ventana

• singleAccountKeysToMove
• namedAccountPromotionKeys
• resolveSingleAccountPromotionTarget(...)

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

​

Metadatos del catálogo de canales

{
  "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: etiqueta secundaria para superficies de catálogo/estado más completas
• docsLabel: sobrescribir el texto del enlace para el enlace de la documentación
• preferOver: ids de plugin/canal de menor prioridad que esta entrada de catálogo debe superar
• selectionDocsPrefix, selectionDocsOmitLabel, selectionExtras: controles de texto de la superficie de selección
• markdownCapable: marca el canal como compatible con markdown para decisiones de formato saliente
• exposure.configured: oculta el canal de las superficies de listado de canales configurados cuando se establece en false
• exposure.setup: oculta el canal de los selectores interactivos de configuración cuando se establece en false
• exposure.docs: marca el canal como interno/privado para superficies de navegación de la documentación
• showConfigured / showInSetup: alias heredados que aún se aceptan por compatibilidad; prefiere exposure
• quickstartAllowFrom: hace que el canal opte por el flujo estándar de inicio rápido allowFrom
• forceAccountBinding: requiere vinculación explícita de cuenta incluso cuando solo existe una cuenta
• preferSessionLookupForAnnounceTarget: prefiere la búsqueda de sesión al resolver destinos de anuncio

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

​

Plugins de motor de contexto

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);
    },
  }));
}

​

Añadir una nueva capacidad

1. Define el contrato de core. Decide qué comportamiento compartido debe poseer core: política, fallback, fusión de configuración, ciclo de vida, semántica orientada a canales y forma de helper de runtime.
2. Añade superficies tipadas de registro/runtime de plugins. Extiende OpenClawPluginApi o api.runtime con la superficie de capacidad tipada útil más pequeña.
3. Conecta core + consumidores de canal/funcionalidad. Los canales y plugins de funcionalidad deben consumir la nueva capacidad a través de core, no importando directamente una implementación de proveedor.
4. Registra implementaciones de proveedor. Luego los plugins de proveedor registran sus backends contra la capacidad.
5. Añade cobertura de contrato. Añade pruebas para que la propiedad y la forma de registro permanezcan explícitas con el tiempo.

​

Checklist de capacidad

• tipos de contrato del núcleo en src/<capability>/types.ts
• helper de runner/runtime del núcleo en src/<capability>/runtime.ts
• superficie de registro de la API de plugins en src/plugins/types.ts
• cableado del registro de plugins en src/plugins/registry.ts
• exposición del runtime de plugins en src/plugins/runtime/* cuando los plugins de funciones/canales necesitan consumirla
• helpers de captura/prueba en src/test-utils/plugin-registration.ts
• aserciones de propiedad/contrato en src/plugins/contracts/registry.ts
• documentación de operador/plugin en docs/

​

Plantilla de capacidad

// 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(pluginManifest.contracts?.videoGenerationProviders).toEqual(["openai"]);

• el núcleo posee el contrato de capacidad + la orquestación
• los plugins de proveedores poseen las implementaciones de proveedores
• los plugins de funciones/canales consumen helpers de runtime
• las pruebas de contrato mantienen la propiedad explícita

​

Relacionado

• Arquitectura de plugins — modelo público de capacidades y formas
• Subrutas del Plugin SDK
• Configuración del Plugin SDK
• Creación de plugins