Assistants d'exécution des plugins

Référence de l’objet api.runtime injecté dans chaque plugin lors de l’enregistrement. Utilisez ces assistants au lieu d’importer directement les éléments internes de l’hôte.

Plugins de channel

Guide pas à pas qui utilise ces assistants dans le contexte des plugins de channel.

Plugins de provider

Guide pas à pas qui utilise ces assistants dans le contexte des plugins de provider.

register(api) {
  const runtime = api.runtime;
}

Chargement et écriture de la configuration

Privilégiez la configuration qui a déjà été transmise au chemin d’appel actif, par exemple api.config lors de l’enregistrement ou un argument cfg sur les rappels channel/provider. Cela permet à un instantané du processus de circuler dans le travail au lieu de réanalyser la configuration sur les chemins critiques.

Utilisez api.runtime.config.current() uniquement lorsqu’un gestionnaire de longue durée a besoin de l’instantané actuel du processus et qu’aucune configuration n’a été transmise à cette fonction. La valeur retournée est en lecture seule ; clonez-la ou utilisez un assistant de mutation avant de la modifier.

Les usines d’outils reçoivent ctx.runtimeConfig ainsi que ctx.getRuntimeConfig(). Utilisez le getter dans le rappel execute d’un outil de longue durée lorsque la configuration peut changer après la création de la définition de l’outil.

Persistez les modifications avec api.runtime.config.mutateConfigFile(...) ou api.runtime.config.replaceConfigFile(...). Chaque écriture doit choisir une politique afterWrite explicite :

• afterWrite: { mode: "auto" } laisse le planificateur de rechargement de la passerelle décider.
• afterWrite: { mode: "restart", reason: "..." } force un redémarrage propre lorsque l’enregistreur sait que le rechargement à chaud n’est pas sûr.
• afterWrite: { mode: "none", reason: "..." } supprime le rechargement/redémarrage automatique uniquement lorsque l’appelant gère la suite.

Les assistants de mutation renvoient afterWrite ainsi qu’un résumé typé followUp afin que les appelants puissent enregistrer ou tester s’ils ont demandé un redémarrage. La passerelle (gateway) conserve toujours la maîtrise du moment où ce redémarrage a réellement lieu.

api.runtime.config.loadConfig() et api.runtime.config.writeConfigFile(...) sont des assistants de compatibilité obsolètes sous runtime-config-load-write. Ils avertissent une fois lors de l’exécution et restent disponibles pour les anciens plugins externes pendant la fenêtre de migration. Les plugins groupés ne doivent pas les utiliser ; les gardes de la limite de configuration échouent si le code du plugin les appelle ou importe ces assistants depuis les sous-chemins du SDK de plugin.

Pour les importations directes du SDK, utilisez les sous-chemins de configuration ciblés au lieu du tonneau (barrel) de compatabilité large openclaw/plugin-sdk/config-runtime : config-contracts pour les types, plugin-config-runtime pour les assertions de configuration déjà chargées et la recherche des entrées de plugin, runtime-config-snapshot pour les instantanés du processus actuel, et config-mutation pour les écritures. Les tests de plugins groupés doivent simuler (mock) directement ces sous-chemins ciblés au lieu de simuler le tonneau de compatibilité large.

Le code d’exécution interne OpenClaw suit la même direction : charger la configuration une fois à la frontière du CLI, de la passerelle ou du processus, puis transmettre cette valeur. Les écritures de mutation réussies rafraîchissent l’instantané d’exécution du processus et avancent sa révision interne ; les caches longue durée doivent se baser sur la clé de cache détenue par l’exécution au lieu de sérialiser la configuration localement. Les modules d’exécution longue durée disposent d’un scanner de tolérance zéro pour les appels ambiants loadConfig() ; utilisez un cfg transmis, une context.getRuntimeConfig() de requête, ou getRuntimeConfig() à une frontière de processus explicite.

Les chemins d’exécution des providers et des canaux doivent utiliser l’instantané de configuration d’exécution active, et non un instantané de fichier renvoyé pour la lecture ou l’édition de la configuration. Les instantanés de fichiers préservent les valeurs sources telles que les marqueurs SecretRef pour l’interface utilisateur et les écritures ; les rappels de provider ont besoin de la vue d’exécution résolue. Lorsqu’un assistant peut être appelé avec soit l’instantané source actif soit l’instantané d’exécution actif, passez par selectApplicableRuntimeConfig() avant de lire les identifiants.

Utilitaires d’exécution réutilisables

Utilisez les faits botLoopProtection de tour de canal pour les messages entrants créés par le bot. Le Core applique le garde de fenêtre glissante en mémoire partagée avant l’enregistrement de la session et l’expédition, sans lier la stratégie à un canal spécifique. Le garde suit les clés (scopeId, conversationId, participant pair), compte ensemble les deux directions d’une paire, applique un temps de recharge une fois le budget de la fenêtre dépassé, et nettoie les entrées inactives de manière opportuniste.

Les plugins de canal qui exposent ce comportement aux opérateurs devraient privilégier la forme partagée channels.defaults.botLoopProtection pour les budgets de base, puis ajouter par-dessus des redéfinitions spécifiques au canal/fournisseur. La configuration partagée utilise des secondes car elle est destinée à l’utilisateur :

type ChannelBotLoopProtectionConfig = {
  enabled?: boolean;
  maxEventsPerWindow?: number;
  windowSeconds?: number;
  cooldownSeconds?: number;
};

Passez les faits normalisés de paire de bots avec le tour résolu. Le Core résout les valeurs par défaut, la conversion des unités et la sémantique enabled :

return {
  channel: "example",
  routeSessionKey,
  storePath,
  ctxPayload,
  recordInboundSession,
  runDispatch,
  botLoopProtection: {
    scopeId: "account-1",
    conversationId: "channel-1",
    senderId: "bot-a",
    receiverId: "bot-b",
    config: channelConfig.botLoopProtection,
    defaultsConfig: runtimeConfig.channels?.defaults?.botLoopProtection,
    defaultEnabled: allowBotsMode !== "off",
  },
};

Utilisez openclaw/plugin-sdk/pair-loop-guard-runtime directement uniquement pour les boucles d’événements personnalisées deux parties qui ne passent pas par le noyau partagé de tour de canal.

Espaces de noms d’exécution

api.runtime.agent

Identité de l’agent, répertoires et gestion de session.

// Resolve the agent's working directory
const agentDir = api.runtime.agent.resolveAgentDir(cfg);

// Resolve agent workspace
const workspaceDir = api.runtime.agent.resolveAgentWorkspaceDir(cfg);

// Get agent identity
const identity = api.runtime.agent.resolveAgentIdentity(cfg);

// Get default thinking level
const thinking = api.runtime.agent.resolveThinkingDefault({
  cfg,
  provider,
  model,
});

// Validate a user-provided thinking level against the active provider profile
const policy = api.runtime.agent.resolveThinkingPolicy({ provider, model });
const level = api.runtime.agent.normalizeThinkingLevel("extra high");
if (level && policy.levels.some((entry) => entry.id === level)) {
  // pass level to an embedded run
}

// Get agent timeout
const timeoutMs = api.runtime.agent.resolveAgentTimeoutMs(cfg);

// Ensure workspace exists
await api.runtime.agent.ensureAgentWorkspace(cfg);

// Run an embedded agent turn
const agentDir = api.runtime.agent.resolveAgentDir(cfg);
const result = await api.runtime.agent.runEmbeddedAgent({
  sessionId: "my-plugin:task-1",
  runId: crypto.randomUUID(),
  sessionFile: path.join(agentDir, "sessions", "my-plugin-task-1.jsonl"),
  workspaceDir: api.runtime.agent.resolveAgentWorkspaceDir(cfg),
  prompt: "Summarize the latest changes",
  timeoutMs: api.runtime.agent.resolveAgentTimeoutMs(cfg),
});

runEmbeddedAgent(...) est l’assistant neutre pour démarrer un tour d’agent OpenClaw normal depuis le code du plugin. Il utilise la même résolution de provider/modèle et la même sélection de harnais d’agent que les réponses déclenchées par le canal.

runEmbeddedPiAgent(...) reste un alias de compatibilité.

resolveThinkingPolicy(...) renvoie les niveaux de réflexion pris en charge par le provider/modèle et la valeur par défaut facultative. Les plugins de provider possèdent le profil spécifique au modèle via leurs hooks de réflexion, les plugins d’outil doivent donc appeler cet assistant d’exécution plutôt que d’importer ou de dupliquer les listes de providers.

normalizeThinkingLevel(...) convertit le texte utilisateur tel que on, x-high ou extra high vers le niveau stocké canonique avant de le vérifier par rapport à la stratégie résolue.

Les assistants de magasin de session (Session store helpers) se trouvent sous api.runtime.agent.session :

const storePath = api.runtime.agent.session.resolveStorePath(cfg);
const store = api.runtime.agent.session.loadSessionStore(storePath);
await api.runtime.agent.session.updateSessionStore(storePath, (nextStore) => {
  // Patch one entry without replacing the whole file from stale state.
  nextStore[sessionKey] = { ...nextStore[sessionKey], thinkingLevel: "high" };
});
const filePath = api.runtime.agent.session.resolveSessionFilePath(cfg, sessionId);

Préférez updateSessionStore(...) ou updateSessionStoreEntry(...) pour les écritures d’exécution. Ils passent par le rédacteur de magasin de session détenu par Gateway, préservent les mises à jour simultanées et réutilisent le cache actif. saveSessionStore(...) reste disponible pour la compatibilité et les réécritures de type maintenance hors ligne.

api.runtime.agent.defaults

Constantes de modèle et de provider par défaut :

const model = api.runtime.agent.defaults.model; // e.g. "anthropic/claude-sonnet-4-6"
const provider = api.runtime.agent.defaults.provider; // e.g. "anthropic"

api.runtime.llm

Exécutez une complétion de texte hébergée sans importer les éléments internes du fournisseur ou dupliquer la préparation de l’URL de base d’authentification/de modèle OpenClaw.

const result = await api.runtime.llm.complete({
  messages: [{ role: "user", content: "Summarize this transcript." }],
  purpose: "my-plugin.summary",
  maxTokens: 512,
  temperature: 0.2,
});

L’assistant utilise le même chemin de préparation de complétion simple que celui du runtime intégré d’OpenClaw et de l’instantané de la configuration du runtime hébergé. Les moteurs de contexte reçoivent une capacité llm.complete liée à une session, de sorte que les appels au modèle utilisent l’agent de la session active et ne reviennent pas silencieusement à l’agent par défaut. Le résultat inclut l’attribution du fournisseur/modèle/agent ainsi que les jetons normalisés, le cache et l’utilisation des coûts estimés, le cas échéant.

Warning

Les substitutions de modèle nécessitent l’accord de l’opérateur via `plugins.entries.

.llm.allowModelOverride: truedans la configuration. Utilisezplugins.entries.

.llm.allowedModelspour restreindre les plugins de confiance à desprovider/modelcanoniques spécifiques. Les complétions inter-agents nécessitentplugins.entries.

.llm.allowAgentIdOverride: true`.

api.runtime.subagent

Lancez et gérez les exécutions de sous-agents en arrière-plan.

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

// Wait for completion
const result = await api.runtime.subagent.waitForRun({ runId, timeoutMs: 30000 });

// Read session messages
const { messages } = await api.runtime.subagent.getSessionMessages({
  sessionKey: "agent:main:subagent:search-helper",
  limit: 10,
});

// Delete a session
await api.runtime.subagent.deleteSession({
  sessionKey: "agent:main:subagent:search-helper",
});

Warning

Les substitutions de modèle (provider/model) nécessitent l’accord de l’opérateur via `plugins.entries.

.subagent.allowModelOverride: true` dans la configuration. Les plugins non fiables peuvent toujours exécuter des sous-agents, mais les demandes de substitution sont rejetées.

deleteSession(...) peut supprimer les sessions créées par le même plugin via api.runtime.subagent.run(...). La suppression de sessions d’utilisateur ou d’opérateur arbitraires nécessite toujours une requête Gateway avec une étendue d’administrateur.

api.runtime.nodes

Liste les nœuds connectés et appelle une commande d’hôte de nœud depuis le code de plugin chargé par Gateway ou depuis les commandes CLI du plugin. Utilisez ceci lorsqu’un plugin gère un travail local sur un appareil apparié, par exemple un navigateur ou un pont audio sur un autre Mac.

const { nodes } = await api.runtime.nodes.list({ connected: true });

const result = await api.runtime.nodes.invoke({
  nodeId: "mac-studio",
  command: "my-plugin.command",
  params: { action: "start" },
  timeoutMs: 30000,
});

À l’intérieur du Gateway, ce runtime est en cours de processus (in-process). Dans les commandes CLI du plugin, il appelle le Gateway configuré via RPC, donc des commandes telles que openclaw googlemeet recover-tab peuvent inspecter les nœuds appariés depuis le terminal. Les commandes de nœud passent toujours par l’appariement normal des nœuds du Gateway, les listes d’autorisation de commandes, les stratégies d’invocation de nœud de plugin et le traitement local des commandes de nœud.

Les plugins qui exposent des commandes d’hôte de nœud dangereuses doivent enregistrer une stratégie d’invocation de nœud avec api.registerNodeInvokePolicy(...). La stratégie s’exécute dans le Gateway après les vérifications de la liste d’autorisation des commandes et avant que la commande ne soit transmise au nœud, donc les appels directs node.invoke et les outils de plugin de niveau supérieur partagent le même chemin d’application.

api.runtime.tasks.managedFlows

Lie un runtime Task Flow à une clé de session OpenClaw existante ou à un contexte d’outil de confiance, puis créez et gérez des Task Flows sans passer de propriétaire à chaque appel.

Task Flow suit l’état du workflow durable en plusieurs étapes. Ce n’est pas un planificateur : utilisez Cron ou api.session.workflow.scheduleSessionTurn(...) pour les réveils futurs, puis utilisez managedFlows depuis le tour planifié lorsque ce travail nécessite un état de flux, des tâches enfants, des attentes ou une annulation.

const taskFlow = api.runtime.tasks.managedFlows.fromToolContext(ctx);

const created = taskFlow.createManaged({
  controllerId: "my-plugin/review-batch",
  goal: "Review new pull requests",
});

const child = taskFlow.runTask({
  flowId: created.flowId,
  runtime: "acp",
  childSessionKey: "agent:main:subagent:reviewer",
  task: "Review PR #123",
  status: "running",
  startedAt: Date.now(),
});

const waiting = taskFlow.setWaiting({
  flowId: created.flowId,
  expectedRevision: created.revision,
  currentStep: "await-human-reply",
  waitJson: { kind: "reply", channel: "telegram" },
});

Utilisez bindSession({ sessionKey, requesterOrigin }) lorsque vous disposez déjà d’une clé de session OpenClaw de confiance depuis votre propre couche de liaison. Ne liez pas à partir d’une saisie utilisateur brute.

api.runtime.tts

Synthèse vocale.

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

// Telephony-optimized TTS
const telephonyClip = await api.runtime.tts.textToSpeechTelephony({
  text: "Hello from OpenClaw",
  cfg: api.config,
});

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

Utilise la configuration centrale messages.tts et la sélection du provider. Renvoie le tampon audio PCM + le taux d’échantillonnage.

api.runtime.mediaUnderstanding

Analyse d’image, audio et vidéo.

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

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

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

// Generic file analysis
const result = await api.runtime.mediaUnderstanding.runFile({
  filePath: "/tmp/inbound-file.pdf",
  cfg: api.config,
});

// Structured image extraction through a specific provider/model.
// Include at least one image; text inputs are supplemental context.
const evidence = 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: "Prefer the printed total over handwritten notes." },
  ],
  instructions: "Extract vendor, total, and searchable tags.",
  schemaName: "receipt.evidence",
  jsonSchema: {
    type: "object",
    properties: {
      vendor: { type: "string" },
      total: { type: "number" },
      tags: { type: "array", items: { type: "string" } },
    },
    required: ["vendor", "total"],
  },
  cfg: api.config,
});

Renvoie { text: undefined } lorsqu’aucune sortie n’est produite (ex. : entrée ignorée).

Info

api.runtime.stt.transcribeAudioFile(...) reste un alias de compatibilité pour api.runtime.mediaUnderstanding.transcribeAudioFile(...).

api.runtime.imageGeneration

Génération d’images.

const result = await api.runtime.imageGeneration.generate({
  prompt: "A robot painting a sunset",
  cfg: api.config,
});

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

api.runtime.webSearch

Recherche Web.

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

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

api.runtime.media

Utilitaires médias de bas niveau.

const webMedia = await api.runtime.media.loadWebMedia(url);
const mime = await api.runtime.media.detectMime(buffer);
const kind = api.runtime.media.mediaKindFromMime("image/jpeg"); // "image"
const isVoice = api.runtime.media.isVoiceCompatibleAudio(filePath);
const metadata = await api.runtime.media.getImageMetadata(filePath);
const resized = await api.runtime.media.resizeToJpeg(buffer, { maxWidth: 800 });
const terminalQr = await api.runtime.media.renderQrTerminal("https://openclaw.ai");
const pngQr = await api.runtime.media.renderQrPngBase64("https://openclaw.ai", {
  scale: 6, // 1-12
  marginModules: 4, // 0-16
});
const pngQrDataUrl = await api.runtime.media.renderQrPngDataUrl("https://openclaw.ai");
const tmpRoot = resolvePreferredOpenClawTmpDir();
const pngQrFile = await api.runtime.media.writeQrPngTempFile("https://openclaw.ai", {
  tmpRoot,
  dirPrefix: "my-plugin-qr-",
  fileName: "qr.png",
});

api.runtime.config

Instantané de la configuration d’exécution actuelle et écritures de configuration transactionnelles. Privilégiez la configuration qui a déjà été transmise au chemin d’appel actif ; n’utilisez current() que lorsque le gestionnaire a besoin directement de l’instantané du processus.

const cfg = api.runtime.config.current();
await api.runtime.config.mutateConfigFile({
  afterWrite: { mode: "auto" },
  mutate(draft) {
    draft.plugins ??= {};
  },
});

mutateConfigFile(...) et replaceConfigFile(...) renvoient une valeur followUp, par exemple { mode: "restart", requiresRestart: true, reason }, qui enregistre l’intention de l’enregistreur sans retirer le contrôle de redémarrage à la passerelle.

api.runtime.system

Utilitaires au niveau système.

await api.runtime.system.enqueueSystemEvent(event);
api.runtime.system.requestHeartbeat({
  source: "other",
  intent: "event",
  reason: "plugin-event",
});
api.runtime.system.requestHeartbeatNow({ reason: "plugin-event" }); // Deprecated compatibility alias.
const output = await api.runtime.system.runCommandWithTimeout(cmd, args, opts);
const hint = api.runtime.system.formatNativeDependencyHint(pkg);

api.runtime.events

Abonnements aux événements.

api.runtime.events.onAgentEvent((event) => {
  /* ... */
});
api.runtime.events.onSessionTranscriptUpdate((update) => {
  /* ... */
});

api.runtime.logging

Journalisation.

const verbose = api.runtime.logging.shouldLogVerbose();
const childLogger = api.runtime.logging.getChildLogger({ plugin: "my-plugin" }, { level: "debug" });

api.runtime.modelAuth

Résolution de l’authentification du modèle et du provider.

const auth = await api.runtime.modelAuth.getApiKeyForModel({ model, cfg });
const providerAuth = await api.runtime.modelAuth.resolveApiKeyForProvider({
  provider: "openai",
  cfg,
});

api.runtime.state

Résolution du répertoire d’état et stockage à clé supporté par SQLite.

const stateDir = api.runtime.state.resolveStateDir(process.env);
const store = api.runtime.state.openKeyedStore

({ namespace: “my-feature”, maxEntries: 200, defaultTtlMs: 15 * 60_000, });

await store.register("key-1", { value: "hello" });
const claimed = await store.registerIfAbsent("dedupe-key", { value: "first" });
const value = await store.lookup("key-1");
await store.consume("key-1");
await store.clear();
```

Les magasins à clé survivent aux redémarrages et sont isolés par l'ID du plugin lié au runtime. Utilisez `registerIfAbsent(...)` pour les revendications de déduplication atomique : il renvoie `true` lorsque la clé était manquante ou expirée et a été enregistrée, ou `false` lorsqu'une valeur active existe déjà sans écraser sa valeur, son heure de création ou son TTL. Limites : `maxEntries` par espace de noms, 1 000 lignes actives par plugin, valeurs JSON de moins de 64 Ko et expiration TTL facultative.

Warning

Plugins groupés uniquement dans cette version.

api.runtime.tools

Usines d’outils de mémoire et CLI.

const getTool = api.runtime.tools.createMemoryGetTool(/* ... */);
const searchTool = api.runtime.tools.createMemorySearchTool(/* ... */);
api.runtime.tools.registerMemoryCli(/* ... */);

api.runtime.channel

Helpers d’exécution spécifiques au channel (disponibles lorsqu’un plugin de channel est chargé).

api.runtime.channel.media est l’interface privilégiée pour les téléchargements et le stockage de médias de channel :

const saved = await api.runtime.channel.media.saveRemoteMedia({
  url,
  subdir: "inbound",
  maxBytes,
  filePathHint: fileName,
});

Utilisez saveRemoteMedia(...) lorsqu’une URL distante doit devenir un média OpenClaw. Utilisez saveResponseMedia(...) lorsque le plugin a déjà récupéré un Response avec une gestion de l’authentification, de la redirection ou de la liste d’autorisation propre au plugin. Utilisez readRemoteMediaBuffer(...) uniquement lorsque le plugin a besoin des octets bruts pour inspection, transformation, déchiffrement ou remise en ligne. fetchRemoteMedia(...) reste un alias de compatibilité obsolète pour readRemoteMediaBuffer(...).

api.runtime.channel.mentions est l’interface partagée de politique de mention entrante pour les plugins de channel groupés qui utilisent l’injection d’exécution :

const mentionMatch = api.runtime.channel.mentions.matchesMentionWithExplicit(text, {
  mentionRegexes,
  mentionPatterns,
});

const decision = api.runtime.channel.mentions.resolveInboundMentionDecision({
  facts: {
    canDetectMention: true,
    wasMentioned: mentionMatch.matched,
    implicitMentionKinds: api.runtime.channel.mentions.implicitMentionKindWhen(
      "reply_to_bot",
      isReplyToBot,
    ),
  },
  policy: {
    isGroup,
    requireMention,
    allowTextCommands,
    hasControlCommand,
    commandAuthorized,
  },
});

Helpers de mention disponibles :

• buildMentionRegexes
• matchesMentionPatterns
• matchesMentionWithExplicit
• implicitMentionKindWhen
• resolveInboundMentionDecision

api.runtime.channel.mentions n’expose pas intentionnellement les anciens helpers de compatibilité resolveMentionGating*. Privilégiez le chemin normalisé { facts, policy }.

Stockage des références d’exécution

Utilisez createPluginRuntimeStore pour stocker la référence d’exécution pour une utilisation en dehors du rappel register :

1. Créer le magasin

   import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
   import type { PluginRuntime } from "openclaw/plugin-sdk/runtime-store";
   
   const store = createPluginRuntimeStore

   ({ pluginId: “my-plugin”, errorMessage: “my-plugin runtime not initialized”, }); ```

2. Wire into the entry point

   export default defineChannelPluginEntry({
     id: "my-plugin",
     name: "My Plugin",
     description: "Example",
     plugin: myPlugin,
     setRuntime: store.setRuntime,
   });

3. Access from other files

   export function getRuntime() {
     return store.getRuntime(); // throws if not initialized
   }
   
   export function tryGetRuntime() {
     return store.tryGetRuntime(); // returns null if not initialized
   }

Note

Privilégiez

pluginId

pour l’identité du magasin d’exécution. Le formulaire de bas niveau

key

est destiné aux cas peu fréquents où un plugin a intentionnellement besoin de plus d’un emplacement d’exécution.

Autres champs de niveau supérieur api

Au-delà de api.runtime, l’objet API fournit également :

ID du plugin. Nom d'affichage du plugin. Instantané de la configuration actuelle (instantané d'exécution en mémoire actif, si disponible). Configuration spécifique au plugin provenant de `plugins.entries..config`. Enregistreur délimité (`debug`, `info`, `warn`, `error`). Mode de chargement actuel ; `"setup-runtime"` est la fenêtre de démarrage/configuration légère avant l'entrée complète. Résout un chemin relatif à la racine du plugin.

Connexes

• Internes du plugin — model de capacité et registre
• Points d’entrée du SDK — options definePluginEntry
• Aperçu du SDK — référence de sous-chemin