@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/permissions/manager.js

@@ -0,0 +1,269 @@
+import { getConfigSnapshot, isAutoApproveEnabled } from '../config/index.js';
+import { analyzePermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions/analysis';
+import { LayeredPolicyEvaluator } from '@pellux/goodvibes-sdk/platform/runtime/permissions/evaluator';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export function createPermissionConfigReader(configManager) {
+    return {
+        isAutoApproveEnabled: () => isAutoApproveEnabled(configManager),
+        getSnapshot: () => getConfigSnapshot(configManager),
+        getWorkingDirectory: () => configManager.getWorkingDirectory(),
+    };
+}
+/** Maps tool names to permission categories and config tool keys. */
+const TOOL_CATEGORIES = {
+    read: 'read',
+    find: 'read',
+    fetch: 'read',
+    analyze: 'read',
+    inspect: 'read',
+    state: 'read',
+    registry: 'read',
+    // write — new tool names
+    write: 'write',
+    edit: 'write',
+    // execute — new tool name
+    exec: 'execute',
+    // delegate — new tool names
+    agent: 'delegate',
+    delegate: 'delegate',
+    workflow: 'delegate',
+    mcp: 'delegate',
+};
+/** Maps tool names to their key in PermissionsToolConfig. */
+const TOOL_CONFIG_KEYS = {
+    read: 'read',
+    write: 'write',
+    edit: 'edit',
+    exec: 'exec',
+    find: 'find',
+    fetch: 'fetch',
+    analyze: 'analyze',
+    inspect: 'inspect',
+    agent: 'agent',
+    state: 'state',
+    workflow: 'workflow',
+    registry: 'registry',
+    delegate: 'delegate',
+    mcp: 'mcp',
+};
+/**
+ * PermissionManager - Controls tool execution approval.
+ *
+ * Approval logic (priority order):
+ *   1. --no-worries-just-vibes flag OR mode='allow-all' -> auto-approve everything
+ *   2. mode='custom' -> check per-tool config action ('allow'/'prompt'/'deny')
+ *   3. mode='prompt' (default) -> auto-approve reads, prompt for writes/execute/delegate
+ *   4. Session approval cache hit -> use cached decision
+ *   5. Ask the shell-owned permission controller and block until user responds
+ */
+export class PermissionManager {
+    sessionApprovals = new Map();
+    requestPermission;
+    configReader;
+    hookDispatcher;
+    policyRuntimeState;
+    constructor(requestPermission = async () => ({ approved: false, remember: false }), configReader, policyRuntimeState, hookDispatcher = null) {
+        this.requestPermission = requestPermission;
+        this.configReader = configReader;
+        this.policyRuntimeState = policyRuntimeState;
+        this.hookDispatcher = hookDispatcher;
+    }
+    /**
+     * check - Returns a Promise that resolves to true (approved) or false (denied).
+     * Blocks orchestrator until the user responds when a prompt is needed.
+     */
+    async check(toolName, args) {
+        const result = await this.checkDetailed(toolName, args);
+        return result.approved;
+    }
+    async checkDetailed(toolName, args) {
+        // 1. Auto-approve when --no-worries-just-vibes is active
+        const category = this.getCategory(toolName, args);
+        const analysis = analyzePermissionRequest(toolName, args, category);
+        const callId = crypto.randomUUID();
+        await this.fireHook('Pre:permission:request', 'Pre', 'permission', 'request', {
+            callId,
+            toolName,
+            category,
+            analysis,
+        });
+        this.policyRuntimeState.recordPermissionRequest({
+            callId,
+            tool: toolName,
+            category,
+            analysis,
+        });
+        if (this.configReader.isAutoApproveEnabled()) {
+            return this.emitAndReturn(callId, toolName, category, this.result(true, false, 'config_policy', 'config_allow', analysis));
+        }
+        const permsConfig = this.configReader.getSnapshot().permissions;
+        const mode = permsConfig?.mode ?? 'prompt';
+        // 2. allow-all mode: auto-approve everything
+        if (mode === 'allow-all') {
+            return this.emitAndReturn(callId, toolName, category, this.result(true, false, 'runtime_mode', 'mode_allow_all', analysis));
+        }
+        const evaluatorDecision = this.evaluateRuntimePolicy(toolName, args, mode);
+        const mappedDecision = this.mapEvaluatorDecision(evaluatorDecision, analysis);
+        if (mappedDecision) {
+            return this.emitAndReturn(callId, toolName, category, mappedDecision);
+        }
+        // 3. custom mode: check per-tool setting
+        if (mode === 'custom') {
+            if (TOOL_CONFIG_KEYS[toolName] !== undefined) {
+                const toolKey = TOOL_CONFIG_KEYS[toolName];
+                const action = permsConfig?.tools?.[toolKey] ?? 'prompt';
+                if (action === 'allow')
+                    return this.emitAndReturn(callId, toolName, category, this.result(true, false, 'config_policy', 'config_allow', analysis));
+                if (action === 'deny')
+                    return this.emitAndReturn(callId, toolName, category, this.result(false, false, 'config_policy', 'config_deny', analysis));
+                // action === 'prompt': fall through to cache + prompt
+            }
+            else {
+                // Unknown tool in custom mode: default to 'prompt' behavior
+                // Fall through to cache + prompt
+            }
+        }
+        else {
+            // 4. prompt mode: auto-approve read operations
+            if (category === 'read')
+                return this.emitAndReturn(callId, toolName, category, this.result(true, false, 'config_policy', 'config_allow', analysis));
+        }
+        // 5. Check session approval cache
+        const key = this.getApprovalKey(toolName, args);
+        if (this.sessionApprovals.has(key)) {
+            const approved = this.sessionApprovals.get(key);
+            return this.emitAndReturn(callId, toolName, category, this.result(approved, true, 'session_override', approved ? 'session_cached_allow' : 'session_cached_deny', analysis));
+        }
+        // 6. Prompt user via the shell-owned permission controller
+        let decision;
+        try {
+            decision = await this.requestPermission({
+                callId,
+                tool: toolName,
+                args,
+                category,
+                analysis,
+                workingDirectory: this.configReader.getWorkingDirectory() ?? undefined,
+            });
+        }
+        catch (error) {
+            void this.fireHook('Fail:permission:request', 'Fail', 'permission', 'request', {
+                callId,
+                toolName,
+                category,
+                analysis,
+                error: summarizeError(error),
+            });
+            throw error;
+        }
+        if (decision.remember) {
+            this.sessionApprovals.set(key, decision.approved);
+        }
+        return this.emitAndReturn(callId, toolName, category, this.result(decision.approved, Boolean(decision.remember), 'user_prompt', decision.approved ? 'user_approved' : 'user_denied', analysis));
+    }
+    /** Returns the permission category for a tool name. Unknown tools default to 'delegate'. */
+    getCategory(toolName, args = {}) {
+        if (toolName === 'inspect' && args.mode === 'scaffold' && args.dryRun === false) {
+            return 'write';
+        }
+        return TOOL_CATEGORIES[toolName] ?? 'delegate';
+    }
+    /**
+     * getApprovalKey - Stable key for session-level "always approve" decisions.
+     * Includes the most meaningful argument to distinguish different invocations.
+     */
+    getApprovalKey(toolName, args) {
+        if (typeof args['path'] === 'string') {
+            return `${toolName}:${args['path']}`;
+        }
+        if (typeof args['command'] === 'string') {
+            return `${toolName}:${args['command']}`;
+        }
+        // Generic fallback: key only on tool name ("always allow this tool")
+        return toolName;
+    }
+    result(approved, persisted, sourceLayer, reasonCode, analysis) {
+        return {
+            approved,
+            persisted,
+            sourceLayer,
+            reasonCode,
+            analysis,
+        };
+    }
+    evaluateRuntimePolicy(toolName, args, mode) {
+        const rules = this.policyRuntimeState.getRegistry().getCurrent()?.rules ?? [];
+        const evaluator = new LayeredPolicyEvaluator({
+            mode: mode === 'allow-all' ? 'allow-all' : mode === 'custom' ? 'custom' : 'default',
+            projectRoot: this.configReader.getWorkingDirectory() ?? undefined,
+            rules,
+            defaultEffect: 'deny',
+        });
+        return evaluator.evaluate(toolName, args);
+    }
+    mapEvaluatorDecision(decision, analysis) {
+        if (decision.allowed) {
+            if (decision.sourceLayer === 'policy') {
+                return this.result(true, false, 'managed_policy', 'managed_policy_allow', analysis);
+            }
+            if (decision.sourceLayer === 'safety') {
+                return this.result(false, false, 'safety_check', 'safety_guardrail', analysis);
+            }
+            if (decision.sourceLayer === 'mode') {
+                return this.result(true, false, 'runtime_mode', 'mode_allow_all', analysis);
+            }
+            if (decision.sourceLayer === 'default' && decision.classification === 'read') {
+                return this.result(true, false, 'config_policy', 'config_allow', analysis);
+            }
+            return null;
+        }
+        if (decision.sourceLayer === 'safety') {
+            return this.result(false, false, 'safety_check', 'safety_guardrail', analysis);
+        }
+        if (decision.sourceLayer === 'mode') {
+            return this.result(false, false, 'runtime_mode', 'mode_denied', analysis);
+        }
+        if (decision.sourceLayer === 'policy') {
+            return this.result(false, false, 'managed_policy', 'managed_policy_deny', analysis);
+        }
+        return null;
+    }
+    emitAndReturn(callId, toolName, category, result) {
+        this.policyRuntimeState.recordPermissionDecision({
+            callId,
+            tool: toolName,
+            category,
+            result,
+        });
+        void this.fireHook('Post:permission:decision', 'Post', 'permission', 'decision', {
+            callId,
+            toolName,
+            category,
+            approved: result.approved,
+            persisted: result.persisted,
+            sourceLayer: result.sourceLayer,
+            reasonCode: result.reasonCode,
+            riskLevel: result.analysis.riskLevel,
+            classification: result.analysis.classification,
+        });
+        return result;
+    }
+    async fireHook(path, phase, category, specific, payload) {
+        if (!this.hookDispatcher)
+            return;
+        try {
+            await this.hookDispatcher.fire({
+                path,
+                phase,
+                category,
+                specific,
+                sessionId: 'permissions',
+                timestamp: Date.now(),
+                payload,
+            });
+        }
+        catch {
+            // Permission hooks are best-effort observability surfaces.
+        }
+    }
+}

package/dist/_internal/platform/permissions/prompt.d.ts

@@ -0,0 +1,18 @@
+import type { PermissionCategory, PermissionRequestAnalysis } from '@pellux/goodvibes-sdk/platform/permissions/types';
+export interface PermissionPromptRequest {
+    callId: string;
+    tool: string;
+    args: Record<string, unknown>;
+    category: PermissionCategory;
+    analysis: PermissionRequestAnalysis;
+    workingDirectory?: string;
+}
+export interface PermissionPromptDecision {
+    approved: boolean;
+    remember?: boolean;
+}
+export type PermissionRequestHandler = (request: PermissionPromptRequest) => Promise<PermissionPromptDecision>;
+export interface PermissionRequest extends PermissionPromptRequest {
+    resolve: (approved: boolean, remember?: boolean) => void;
+}
+//# sourceMappingURL=prompt.d.ts.map

package/dist/_internal/platform/permissions/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/permissions/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,kDAAkD,CAAC;AAEtH,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,yBAAyB,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,OAAO,EAAE,uBAAuB,KAC7B,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAEvC,MAAM,WAAW,iBAAkB,SAAQ,uBAAuB;IAChE,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1D"}

package/dist/_internal/platform/permissions/prompt.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/platform/plugins/api.d.ts

@@ -0,0 +1,155 @@
+import type { CommandRegistry } from '../input/command-registry.js';
+import type { ModelDefinition, ProviderRegistry, TokenLimits, ModelTier } from '../providers/registry.js';
+import type { LLMProvider } from '../providers/interface.js';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import type { RuntimeEventBus, AnyRuntimeEvent, RuntimeEventPayload } from '../runtime/events/index.js';
+import type { GatewayMethodCatalog, GatewayMethodDescriptor, GatewayMethodHandler } from '../control-plane/index.js';
+import { type ChannelDeliveryStrategy, type ChannelPlugin } from '../channels/index.js';
+import type { ChannelDeliveryRouter, ChannelPluginRegistry } from '../channels/index.js';
+import type { MemoryEmbeddingProvider, MemoryEmbeddingProviderRegistry } from '../state/index.js';
+import type { VoiceProvider, VoiceProviderRegistry } from '@pellux/goodvibes-sdk/platform/voice/index';
+import type { MediaProvider, MediaProviderRegistry } from '../media/index.js';
+import type { WebSearchProvider, WebSearchProviderRegistry } from '../web-search/index.js';
+/**
+ * PluginProviderConfig — minimal config for registering a custom LLM provider
+ * via an OpenAI-compatible endpoint.
+ */
+export interface PluginProviderConfig {
+    /** Base URL for an OpenAI-compatible endpoint (e.g. "http://localhost:8080/v1"). */
+    baseURL: string;
+    /** API key. May be empty string for local/unauthenticated servers. */
+    apiKey?: string;
+    /** Model IDs this provider exposes. */
+    models: string[];
+    /** Optional display label shown in the model picker. */
+    displayName?: string;
+    /** Optional embedding model exposed by the endpoint. */
+    embeddingModel?: string;
+    /** Optional reasoning-format override for compatible endpoints. */
+    reasoningFormat?: 'mercury' | 'openrouter' | 'llamacpp' | 'none';
+    /** Optional context-window metadata for runtime-registered model picker entries. */
+    contextWindow?: number;
+    /** Optional runtime capability hints for the registered model entries. */
+    capabilities?: Partial<ModelDefinition['capabilities']>;
+    /** Optional reasoning effort options surfaced in the picker. */
+    reasoningEffort?: string[];
+    /** Optional provider tier surfaced in the picker. */
+    tier?: ModelTier;
+    /** Optional token limits surfaced in the picker. */
+    tokenLimits?: TokenLimits;
+    /** Optional auth env vars for provider posture. */
+    authEnvVars?: readonly string[];
+    /** Optional service names that expose service-owned OAuth. */
+    serviceNames?: readonly string[];
+    /** Optional subscription-provider identity used for stored OAuth posture. */
+    subscriptionProviderId?: string;
+    /** Optional catalog suppressions for runtime clients. */
+    suppressCatalogModels?: readonly string[];
+}
+export interface PluginRuntimeProviderModel {
+    readonly id: string;
+    readonly displayName?: string;
+    readonly description?: string;
+    readonly contextWindow?: number;
+    readonly selectable?: boolean;
+    readonly capabilities?: Partial<ModelDefinition['capabilities']>;
+    readonly reasoningEffort?: string[];
+    readonly tier?: ModelTier;
+    readonly tokenLimits?: TokenLimits;
+}
+export interface PluginProviderRegistration {
+    readonly provider: LLMProvider;
+    readonly models?: readonly PluginRuntimeProviderModel[];
+    readonly suppressCatalogModels?: readonly string[];
+    readonly replace?: boolean;
+}
+/**
+ * PluginToolSchema — JSON Schema for a tool parameter object.
+ */
+export type PluginToolSchema = Record<string, unknown>;
+/**
+ * PluginToolHandler — Called when the LLM invokes a plugin-registered tool.
+ */
+export type PluginToolHandler = (args: Record<string, unknown>) => Promise<{
+    success: boolean;
+    output?: string;
+    error?: string;
+}>;
+/**
+ * PluginCommandHandler — Called when a user runs a plugin-registered slash command.
+ */
+export type PluginCommandHandler = (args: string[]) => void | Promise<void>;
+/**
+ * PluginAPI — The constrained API surface exposed to plugins.
+ * Plugins receive an instance of this interface during init; they cannot
+ * access the wider application internals directly.
+ */
+export interface PluginAPI {
+    /** Register a custom slash command. */
+    registerCommand(name: string, description: string, handler: PluginCommandHandler): void;
+    /** Register a custom LLM provider (OpenAI-compatible endpoint). */
+    registerProvider(name: string, config: PluginProviderConfig): Promise<void>;
+    /** Register a fully custom runtime provider instance with optional model entries. */
+    registerProviderInstance(registration: PluginProviderRegistration): void;
+    /** Register a custom tool available to the LLM. */
+    registerTool(name: string, schema: PluginToolSchema, handler: PluginToolHandler): void;
+    /** Register a callable control-plane gateway method. */
+    registerGatewayMethod(descriptor: Omit<GatewayMethodDescriptor, 'source' | 'pluginId'> & Partial<Pick<GatewayMethodDescriptor, 'source' | 'pluginId'>>, handler: GatewayMethodHandler): void;
+    /** Register a channel plugin for a surface such as Slack, Discord, ntfy, or webhooks. */
+    registerChannelPlugin(plugin: ChannelPlugin): void;
+    /** Register an outbound channel delivery strategy. */
+    registerDeliveryStrategy(strategy: ChannelDeliveryStrategy, options?: {
+        readonly replace?: boolean;
+    }): void;
+    /** Register a memory embedding provider. Sync providers can power sqlite-vec indexing immediately. */
+    registerMemoryEmbeddingProvider(provider: MemoryEmbeddingProvider, options?: {
+        readonly replace?: boolean;
+        readonly makeDefault?: boolean;
+    }): void;
+    /** Register a TS-only voice provider for TTS, STT, or realtime session negotiation. */
+    registerVoiceProvider(provider: VoiceProvider, options?: {
+        readonly replace?: boolean;
+    }): void;
+    /** Register a TS-only media provider for analysis, transform, or generation. */
+    registerMediaProvider(provider: MediaProvider, options?: {
+        readonly replace?: boolean;
+    }): void;
+    /** Register a provider-backed web search adapter. */
+    registerWebSearchProvider(provider: WebSearchProvider, options?: {
+        readonly replace?: boolean;
+    }): void;
+    /** Subscribe to a typed runtime event. Returns an unsubscribe function. */
+    onEvent<K extends AnyRuntimeEvent['type']>(eventName: K, handler: (payload: RuntimeEventPayload<K>) => void): () => void;
+    /** Read a plugin-specific config value from the plugin's stored settings. */
+    getConfig(key: string): unknown;
+    /** Emit structured log output to the application logger. */
+    log(level: 'info' | 'warn' | 'error' | 'debug', message: string): void;
+}
+/**
+ * PluginAPIContext — Internal dependencies passed when creating a PluginAPI instance.
+ * Not exposed to plugins.
+ */
+export interface PluginAPIContext {
+    pluginName: string;
+    runtimeBus: RuntimeEventBus;
+    commandRegistry: CommandRegistry;
+    providerRegistry: ProviderRegistry;
+    toolRegistry: ToolRegistry;
+    gatewayMethods: GatewayMethodCatalog;
+    channelRegistry: ChannelPluginRegistry;
+    channelDeliveryRouter: ChannelDeliveryRouter;
+    memoryEmbeddingRegistry: MemoryEmbeddingProviderRegistry;
+    voiceProviderRegistry: VoiceProviderRegistry;
+    mediaProviderRegistry: MediaProviderRegistry;
+    webSearchProviderRegistry: WebSearchProviderRegistry;
+    /** Plugin-specific config key-value pairs from plugins.json state. */
+    pluginConfig: Record<string, unknown>;
+    /** Collect cleanup callbacks so the manager can teardown on disable/reload. */
+    cleanup: Array<() => void>;
+}
+/**
+ * createPluginAPI — Factory that creates a sandboxed PluginAPI for a single plugin.
+ * All registrations are tracked in `ctx.cleanup` so they can be undone on deactivation.
+ */
+export declare function createPluginAPI(ctx: PluginAPIContext): PluginAPI;
+//# sourceMappingURL=api.d.ts.map

package/dist/_internal/platform/plugins/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/plugins/api.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/plugins/api.js

@@ -0,0 +1,197 @@
+import {} from '../channels/index.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * createPluginAPI — Factory that creates a sandboxed PluginAPI for a single plugin.
+ * All registrations are tracked in `ctx.cleanup` so they can be undone on deactivation.
+ */
+export function createPluginAPI(ctx) {
+    return {
+        registerCommand(name, description, handler) {
+            // Namespace commands to avoid collisions: "plugin-<pluginName>-<name>"
+            const cmdName = `plugin-${ctx.pluginName}-${name}`;
+            const cmd = {
+                name: cmdName,
+                description: `[${ctx.pluginName}] ${description}`,
+                handler: async (args) => {
+                    try {
+                        await handler(args);
+                    }
+                    catch (err) {
+                        logger.error(`[plugin:${ctx.pluginName}] Command '${name}' threw: ${summarizeError(err)}`);
+                    }
+                },
+            };
+            ctx.commandRegistry.register(cmd);
+            ctx.cleanup.push(() => ctx.commandRegistry.unregister(cmdName));
+        },
+        async registerProvider(name, config) {
+            // Dynamically import to avoid circular dependency at module load time.
+            try {
+                const { OpenAICompatProvider } = await import('../providers/openai-compat.js');
+                try {
+                    const provider = new OpenAICompatProvider({
+                        name,
+                        baseURL: config.baseURL,
+                        apiKey: config.apiKey ?? '',
+                        defaultModel: config.models[0] ?? '',
+                        models: config.models,
+                        ...(config.embeddingModel ? { embeddingModel: config.embeddingModel } : {}),
+                        ...(config.reasoningFormat ? { reasoningFormat: config.reasoningFormat } : {}),
+                        ...(config.authEnvVars ? { authEnvVars: config.authEnvVars } : {}),
+                        ...(config.serviceNames ? { serviceNames: config.serviceNames } : {}),
+                        ...(config.subscriptionProviderId ? { subscriptionProviderId: config.subscriptionProviderId } : {}),
+                        ...(config.suppressCatalogModels ? { suppressedModels: config.suppressCatalogModels } : {}),
+                    });
+                    const unregister = ctx.providerRegistry.registerRuntimeProvider({
+                        provider,
+                        models: config.models.map((modelId) => ({
+                            id: modelId,
+                            provider: name,
+                            registryKey: `${name}:${modelId}`,
+                            displayName: config.displayName ?? modelId,
+                            description: `Plugin provider ${name}`,
+                            contextWindow: config.contextWindow ?? 8192,
+                            selectable: true,
+                            capabilities: {
+                                toolCalling: config.capabilities?.toolCalling ?? true,
+                                codeEditing: config.capabilities?.codeEditing ?? true,
+                                reasoning: config.capabilities?.reasoning ?? false,
+                                multimodal: config.capabilities?.multimodal ?? false,
+                            },
+                            ...(config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {}),
+                            ...(config.tier ? { tier: config.tier } : {}),
+                            ...(config.tokenLimits ? { tokenLimits: config.tokenLimits } : {}),
+                        })),
+                        suppressCatalogModels: config.suppressCatalogModels,
+                    });
+                    ctx.cleanup.push(unregister);
+                    logger.info(`[plugin:${ctx.pluginName}] Registered provider '${name}' with ${config.models.length} model(s)`);
+                }
+                catch (err) {
+                    logger.error(`[plugin:${ctx.pluginName}] registerProvider '${name}' failed: ${summarizeError(err)}`);
+                    throw err;
+                }
+            }
+            catch (err) {
+                logger.error(`[plugin:${ctx.pluginName}] Could not import OpenAICompatProvider: ${summarizeError(err)}`);
+                throw err;
+            }
+        },
+        registerProviderInstance(registration) {
+            const unregister = ctx.providerRegistry.registerRuntimeProvider({
+                provider: registration.provider,
+                models: (registration.models ?? []).map((model) => ({
+                    id: model.id,
+                    provider: registration.provider.name,
+                    registryKey: `${registration.provider.name}:${model.id}`,
+                    displayName: model.displayName ?? model.id,
+                    description: model.description ?? `Plugin provider ${registration.provider.name}`,
+                    contextWindow: model.contextWindow ?? 8192,
+                    selectable: model.selectable ?? true,
+                    capabilities: {
+                        toolCalling: model.capabilities?.toolCalling ?? true,
+                        codeEditing: model.capabilities?.codeEditing ?? true,
+                        reasoning: model.capabilities?.reasoning ?? false,
+                        multimodal: model.capabilities?.multimodal ?? false,
+                    },
+                    ...(model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}),
+                    ...(model.tier ? { tier: model.tier } : {}),
+                    ...(model.tokenLimits ? { tokenLimits: model.tokenLimits } : {}),
+                })),
+                suppressCatalogModels: registration.suppressCatalogModels,
+                replace: registration.replace,
+            });
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered provider instance '${registration.provider.name}'`);
+        },
+        registerTool(name, schema, handler) {
+            const toolName = `plugin_${ctx.pluginName}_${name}`;
+            if (ctx.toolRegistry.has(toolName)) {
+                logger.warn(`[plugin:${ctx.pluginName}] Tool '${toolName}' already registered — skipping`);
+                return;
+            }
+            const definition = {
+                name: toolName,
+                description: schema.description ?? `Plugin tool: ${name}`,
+                parameters: schema,
+            };
+            ctx.toolRegistry.register({
+                definition,
+                execute: async (args) => {
+                    try {
+                        return await handler(args);
+                    }
+                    catch (err) {
+                        return { success: false, error: summarizeError(err) };
+                    }
+                },
+            });
+            // ToolRegistry has no unregister method. Track for cleanup awareness.
+            ctx.cleanup.push(() => {
+                logger.warn(`[plugin:${ctx.pluginName}] Tool '${toolName}' cannot be unregistered on deactivate — it persists until process restart`);
+            });
+        },
+        registerGatewayMethod(descriptor, handler) {
+            const methodId = descriptor.id.startsWith(`plugin.${ctx.pluginName}.`)
+                ? descriptor.id
+                : `plugin.${ctx.pluginName}.${descriptor.id}`;
+            const unregister = ctx.gatewayMethods.register({
+                ...descriptor,
+                id: methodId,
+                source: 'plugin',
+                pluginId: ctx.pluginName,
+            }, handler);
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered gateway method '${methodId}'`);
+        },
+        registerChannelPlugin(plugin) {
+            const registry = ctx.channelRegistry;
+            registry.register(plugin);
+            ctx.cleanup.push(() => {
+                if (registry.get(plugin.id) === plugin)
+                    registry.unregister(plugin.id);
+            });
+            logger.info(`[plugin:${ctx.pluginName}] Registered channel plugin '${plugin.id}'`);
+        },
+        registerDeliveryStrategy(strategy, options = {}) {
+            const router = ctx.channelDeliveryRouter;
+            router.registerStrategy(strategy, options);
+            ctx.cleanup.push(() => {
+                router.unregisterStrategy(strategy.id);
+            });
+            logger.info(`[plugin:${ctx.pluginName}] Registered delivery strategy '${strategy.id}'`);
+        },
+        registerMemoryEmbeddingProvider(provider, options = {}) {
+            const unregister = ctx.memoryEmbeddingRegistry.register(provider, options);
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered memory embedding provider '${provider.id}'`);
+        },
+        registerVoiceProvider(provider, options = {}) {
+            const unregister = ctx.voiceProviderRegistry.register(provider, options);
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered voice provider '${provider.id}'`);
+        },
+        registerMediaProvider(provider, options = {}) {
+            const unregister = ctx.mediaProviderRegistry.register(provider, options);
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered media provider '${provider.id}'`);
+        },
+        registerWebSearchProvider(provider, options = {}) {
+            const unregister = ctx.webSearchProviderRegistry.register(provider, options);
+            ctx.cleanup.push(unregister);
+            logger.info(`[plugin:${ctx.pluginName}] Registered web search provider '${provider.id}'`);
+        },
+        onEvent(eventName, handler) {
+            const unsub = ctx.runtimeBus.on(eventName, (envelope) => handler(envelope.payload));
+            ctx.cleanup.push(unsub);
+            return unsub;
+        },
+        getConfig(key) {
+            return ctx.pluginConfig[key];
+        },
+        log(level, message) {
+            logger[level](`[plugin:${ctx.pluginName}] ${message}`);
+        },
+    };
+}