Create a plugin registration helper with options pre-configured

declare function createPluginRegistrar(options: PluginOptions): (plugin: CorePlugin) => PluginRegistrationResult;

Check if a schema is Zod-like

declare function isZodSchema(schema: unknown): schema is ZodSchemaLike;

Register multiple plugins at once

declare function registerPlugins(plugins: CorePlugin[], options?: PluginOptions): PluginRegistrationResult[];

Plugin Registry - manages core plugins

declare class PluginRegistry

```ts
import { pluginRegistry, docxtemplaterPlugin } from '@eigenpal/docx-editor/core-plugins';

// Register plugins
pluginRegistry.register(docxtemplaterPlugin);

// Get all MCP tools for MCP server
const tools = pluginRegistry.getMcpTools();

// Get command handler for executor
const handler = pluginRegistry.getCommandHandler('insertTemplateVariable');
```

Result of command execution

interface CommandResult

Core plugin interface - headless, works in Node.js

Plugins can: - Register command handlers that DocumentAgent dispatches to - Declare MCP tools that the MCP server exposes to AI clients - Have optional initialization logic - Declare dependencies on other plugins

interface CorePlugin

JSON Schema definition (subset)

interface JsonSchema

A loaded document in the session

interface LoadedDocument

MCP session state

Maintains state across tool calls within a session.

interface McpSession

MCP tool annotations

interface McpToolAnnotations

Context passed to MCP tool handlers

interface McpToolContext

MCP tool definition

Describes a tool that can be called by AI clients through the MCP server.

interface McpToolDefinition

MCP tool example

interface McpToolExample

MCP tool result

interface McpToolResult

Extended command type for plugins

Plugins can define custom command types beyond the built-in AgentCommand types.

interface PluginCommand

Plugin configuration options

interface PluginOptions

Result of plugin registration

interface PluginRegistrationResult

Zod-like schema interface for compatibility

interface ZodSchemaLike

Command handler function type

Receives a document and a command, returns a modified document. Must be pure/immutable - always return a new document.

type CommandHandler = (doc: Document, command: PluginCommand) => Document;

Extract command type from a union

type ExtractCommand<T extends AgentCommand, Type extends string> = T extends {
    type: Type;
} ? T : never;

MCP tool content types

type McpToolContent = {
    type: 'text';
    text: string;
} | {
    type: 'image';
    data: string;
    mimeType: string;
} | {
    type: 'resource';
    uri: string;
    mimeType?: string;
    text?: string;
};

MCP tool handler function

type McpToolHandler = (input: unknown, context: McpToolContext) => Promise<McpToolResult> | McpToolResult;

Plugin lifecycle events

type PluginEvent = {
    type: 'registered';
    plugin: CorePlugin;
} | {
    type: 'unregistered';
    pluginId: string;
} | {
    type: 'error';
    pluginId: string;
    error: Error;
};

Plugin event listener

type PluginEventListener = (event: PluginEvent) => void;

Create a typed command handler

type TypedCommandHandler<T extends PluginCommand> = (doc: Document, command: T) => Document;

Docxtemplater plugin for template variable functionality.

Dependency validation is handled lazily by `processTemplate` at call time, so no eager `initialize()` is needed.

docxtemplaterPlugin: CorePlugin

Global plugin registry instance

Use this for registering plugins and accessing their capabilities.

pluginRegistry: PluginRegistry