@quilltap/plugin-utils 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to @quilltap/plugin-utils will be documented in this file.
 
+## [1.2.0] - 2025-12-31
+
+### Added
+
+- **Roleplay Template Plugin Utilities**
+  - `createRoleplayTemplatePlugin()` - Create roleplay template plugins with full control
+  - `createSingleTemplatePlugin()` - Simplified helper for single-template plugins
+  - `validateTemplateConfig()` - Validate individual template configurations
+  - `validateRoleplayTemplatePlugin()` - Validate complete roleplay template plugins
+  - `CreateRoleplayTemplatePluginOptions` - Options interface for full control
+  - `CreateSingleTemplatePluginOptions` - Simplified options for single templates
+
+- **New Export Path**
+  - `@quilltap/plugin-utils/roleplay-templates` - Direct import path for roleplay template utilities
+
+## [1.1.0] - 2025-12-30
+
+### Added
+
+- **OpenAI-Compatible Provider Base Class**
+  - `OpenAICompatibleProvider` - Reusable base class for OpenAI-compatible LLM providers
+  - `OpenAICompatibleProviderConfig` - Configuration interface for customizing providers
+  - Supports streaming and non-streaming chat completions
+  - Configurable API key requirements (`requireApiKey` option)
+  - Customizable provider name for logging (`providerName` option)
+  - Customizable attachment error messages (`attachmentErrorMessage` option)
+  - Includes API key validation and model listing
+  - Uses the plugin logger bridge for consistent logging
+  - Peer dependency on `openai` package (optional, only needed if using this provider)
+
+- **New Export Path**
+  - `@quilltap/plugin-utils/providers` - Direct import path for provider base classes
+
 ## [1.0.0] - 2025-12-30
 
 ### Added

package/README.md

@@ -110,6 +110,101 @@ When running standalone:
 | `createConsoleLogger(prefix, minLevel?)` | Create a standalone console logger |
 | `createNoopLogger()` | Create a no-op logger |
 
+### OpenAI-Compatible Provider Base Class
+
+Create custom LLM providers for OpenAI-compatible APIs with minimal code:
+
+```typescript
+import { OpenAICompatibleProvider } from '@quilltap/plugin-utils';
+
+// Create a provider for any OpenAI-compatible API
+export class MyLLMProvider extends OpenAICompatibleProvider {
+  constructor() {
+    super({
+      baseUrl: 'https://api.my-llm-service.com/v1',
+      providerName: 'MyLLM',
+      requireApiKey: true,
+      attachmentErrorMessage: 'MyLLM does not support file attachments',
+    });
+  }
+}
+```
+
+This gives you a complete `LLMProvider` implementation with:
+- Streaming and non-streaming chat completions
+- API key validation
+- Model listing
+- Proper error handling and logging
+
+**Configuration Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseUrl` | `string` | (required) | API endpoint URL with version path |
+| `providerName` | `string` | `'OpenAICompatible'` | Name used in log messages |
+| `requireApiKey` | `boolean` | `false` | Whether API key is mandatory |
+| `attachmentErrorMessage` | `string` | (default message) | Error shown for attachment failures |
+
+**Note:** Requires `openai` as a peer dependency:
+```bash
+npm install openai
+```
+
+### Roleplay Template Plugin Utilities
+
+Create roleplay template plugins with built-in validation and logging:
+
+```typescript
+import { createSingleTemplatePlugin } from '@quilltap/plugin-utils';
+
+// Simple single-template plugin
+export const plugin = createSingleTemplatePlugin({
+  templateId: 'my-rp-format',
+  displayName: 'My RP Format',
+  description: 'A custom roleplay formatting style',
+  systemPrompt: `[FORMATTING INSTRUCTIONS]
+1. DIALOGUE: Use quotation marks
+2. ACTIONS: Use asterisks *like this*
+3. THOUGHTS: Use angle brackets <like this>`,
+  tags: ['custom', 'roleplay'],
+  enableLogging: true,
+});
+```
+
+For plugins providing multiple templates:
+
+```typescript
+import { createRoleplayTemplatePlugin } from '@quilltap/plugin-utils';
+
+export const plugin = createRoleplayTemplatePlugin({
+  metadata: {
+    templateId: 'rp-format-pack',
+    displayName: 'RP Format Pack',
+    description: 'A collection of roleplay formats',
+  },
+  templates: [
+    {
+      name: 'Screenplay',
+      description: 'Screenplay-style formatting',
+      systemPrompt: '...',
+    },
+    {
+      name: 'Novel',
+      description: 'Novel-style prose',
+      systemPrompt: '...',
+    },
+  ],
+  enableLogging: true,
+});
+```
+
+| Function | Description |
+|----------|-------------|
+| `createRoleplayTemplatePlugin(options)` | Create a plugin with full control over metadata and templates |
+| `createSingleTemplatePlugin(options)` | Simplified helper for plugins with a single template |
+| `validateTemplateConfig(template)` | Validate an individual template configuration |
+| `validateRoleplayTemplatePlugin(plugin)` | Validate a complete roleplay template plugin |
+
 ## Example: Complete Plugin Provider
 
 ```typescript

package/dist/index.d.mts

@@ -1,6 +1,8 @@
 export { AnthropicToolDefinition, GoogleToolDefinition, LogContext, LogLevel, OpenAIToolDefinition, PluginLogger, ToolCall, ToolCallRequest, ToolFormatOptions, ToolResult, UniversalTool, createConsoleLogger, createNoopLogger } from '@quilltap/plugin-types';
 export { ToolCallFormat, ToolConvertTarget, applyDescriptionLimit, convertFromAnthropicFormat, convertFromGoogleFormat, convertToAnthropicFormat, convertToGoogleFormat, convertToolTo, convertToolsTo, detectToolCallFormat, hasToolCalls, parseAnthropicToolCalls, parseGoogleToolCalls, parseOpenAIToolCalls, parseToolCalls } from './tools/index.mjs';
 export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFactory, createPluginLogger, getLogLevelFromEnv, hasCoreLogger } from './logging/index.mjs';
+export { OpenAICompatibleProvider, OpenAICompatibleProviderConfig } from './providers/index.mjs';
+export { CreateRoleplayTemplatePluginOptions, CreateSingleTemplatePluginOptions, createRoleplayTemplatePlugin, createSingleTemplatePlugin, validateRoleplayTemplatePlugin, validateTemplateConfig } from './roleplay-templates/index.mjs';
 
 /**
  * @quilltap/plugin-utils
@@ -22,6 +24,6 @@ export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFact
  * Version of the plugin-utils package.
  * Can be used at runtime to check compatibility.
  */
-declare const PLUGIN_UTILS_VERSION = "1.0.0";
+declare const PLUGIN_UTILS_VERSION = "1.2.0";
 
 export { PLUGIN_UTILS_VERSION };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { AnthropicToolDefinition, GoogleToolDefinition, LogContext, LogLevel, OpenAIToolDefinition, PluginLogger, ToolCall, ToolCallRequest, ToolFormatOptions, ToolResult, UniversalTool, createConsoleLogger, createNoopLogger } from '@quilltap/plugin-types';
 export { ToolCallFormat, ToolConvertTarget, applyDescriptionLimit, convertFromAnthropicFormat, convertFromGoogleFormat, convertToAnthropicFormat, convertToGoogleFormat, convertToolTo, convertToolsTo, detectToolCallFormat, hasToolCalls, parseAnthropicToolCalls, parseGoogleToolCalls, parseOpenAIToolCalls, parseToolCalls } from './tools/index.js';
 export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFactory, createPluginLogger, getLogLevelFromEnv, hasCoreLogger } from './logging/index.js';
+export { OpenAICompatibleProvider, OpenAICompatibleProviderConfig } from './providers/index.js';
+export { CreateRoleplayTemplatePluginOptions, CreateSingleTemplatePluginOptions, createRoleplayTemplatePlugin, createSingleTemplatePlugin, validateRoleplayTemplatePlugin, validateTemplateConfig } from './roleplay-templates/index.js';
 
 /**
  * @quilltap/plugin-utils
@@ -22,6 +24,6 @@ export { PluginLoggerWithChild, __clearCoreLoggerFactory, __injectCoreLoggerFact
  * Version of the plugin-utils package.
  * Can be used at runtime to check compatibility.
  */
-declare const PLUGIN_UTILS_VERSION = "1.0.0";
+declare const PLUGIN_UTILS_VERSION = "1.2.0";
 
 export { PLUGIN_UTILS_VERSION };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,11 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  OpenAICompatibleProvider: () => OpenAICompatibleProvider,
   PLUGIN_UTILS_VERSION: () => PLUGIN_UTILS_VERSION,
   __clearCoreLoggerFactory: () => __clearCoreLoggerFactory,
   __injectCoreLoggerFactory: () => __injectCoreLoggerFactory,
@@ -33,6 +44,8 @@ __export(src_exports, {
   createConsoleLogger: () => import_plugin_types.createConsoleLogger,
   createNoopLogger: () => import_plugin_types.createNoopLogger,
   createPluginLogger: () => createPluginLogger,
+  createRoleplayTemplatePlugin: () => createRoleplayTemplatePlugin,
+  createSingleTemplatePlugin: () => createSingleTemplatePlugin,
   detectToolCallFormat: () => detectToolCallFormat,
   getLogLevelFromEnv: () => getLogLevelFromEnv,
   hasCoreLogger: () => hasCoreLogger,
@@ -40,7 +53,9 @@ __export(src_exports, {
   parseAnthropicToolCalls: () => parseAnthropicToolCalls,
   parseGoogleToolCalls: () => parseGoogleToolCalls,
   parseOpenAIToolCalls: () => parseOpenAIToolCalls,
-  parseToolCalls: () => parseToolCalls
+  parseToolCalls: () => parseToolCalls,
+  validateRoleplayTemplatePlugin: () => validateRoleplayTemplatePlugin,
+  validateTemplateConfig: () => validateTemplateConfig
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -331,10 +346,419 @@ function getLogLevelFromEnv() {
 // src/logging/index.ts
 var import_plugin_types = require("@quilltap/plugin-types");
 
+// src/providers/openai-compatible.ts
+var import_openai = __toESM(require("openai"));
+var OpenAICompatibleProvider = class {
+  /**
+   * Creates a new OpenAI-compatible provider instance.
+   *
+   * @param config - Configuration object or base URL string (for backward compatibility)
+   */
+  constructor(config) {
+    /** File attachments are not supported by default */
+    this.supportsFileAttachments = false;
+    /** No MIME types are supported for attachments */
+    this.supportedMimeTypes = [];
+    /** Image generation is not supported by default */
+    this.supportsImageGeneration = false;
+    /** Web search is not supported */
+    this.supportsWebSearch = false;
+    if (typeof config === "string") {
+      this.baseUrl = config;
+      this.providerName = "OpenAICompatible";
+      this.requireApiKey = false;
+      this.attachmentErrorMessage = "OpenAI-compatible provider file attachment support varies by implementation (not yet implemented)";
+    } else {
+      this.baseUrl = config.baseUrl;
+      this.providerName = config.providerName ?? "OpenAICompatible";
+      this.requireApiKey = config.requireApiKey ?? false;
+      this.attachmentErrorMessage = config.attachmentErrorMessage ?? "OpenAI-compatible provider file attachment support varies by implementation (not yet implemented)";
+    }
+    this.logger = createPluginLogger(`${this.providerName}Provider`);
+    this.logger.debug(`${this.providerName} provider instantiated`, {
+      context: `${this.providerName}Provider.constructor`,
+      baseUrl: this.baseUrl
+    });
+  }
+  /**
+   * Collects attachment failures for messages with attachments.
+   * Since attachments are not supported, all attachments are marked as failed.
+   *
+   * @param params - LLM parameters containing messages
+   * @returns Object with empty sent array and failed attachments
+   */
+  collectAttachmentFailures(params) {
+    const failed = [];
+    for (const msg of params.messages) {
+      if (msg.attachments) {
+        for (const attachment of msg.attachments) {
+          failed.push({
+            id: attachment.id,
+            error: this.attachmentErrorMessage
+          });
+        }
+      }
+    }
+    return { sent: [], failed };
+  }
+  /**
+   * Validates that an API key is provided when required.
+   * @throws Error if API key is required but not provided
+   */
+  validateApiKeyRequirement(apiKey) {
+    if (this.requireApiKey && !apiKey) {
+      throw new Error(`${this.providerName} provider requires an API key`);
+    }
+  }
+  /**
+   * Gets the effective API key to use for requests.
+   * Returns 'not-needed' for providers that don't require keys.
+   */
+  getEffectiveApiKey(apiKey) {
+    return this.requireApiKey ? apiKey : apiKey || "not-needed";
+  }
+  /**
+   * Sends a message and returns the complete response.
+   *
+   * @param params - LLM parameters including messages, model, and settings
+   * @param apiKey - API key for authentication
+   * @returns Complete LLM response with content and usage statistics
+   */
+  async sendMessage(params, apiKey) {
+    this.logger.debug(`${this.providerName} sendMessage called`, {
+      context: `${this.providerName}Provider.sendMessage`,
+      model: params.model,
+      baseUrl: this.baseUrl
+    });
+    this.validateApiKeyRequirement(apiKey);
+    const attachmentResults = this.collectAttachmentFailures(params);
+    const client = new import_openai.default({
+      apiKey: this.getEffectiveApiKey(apiKey),
+      baseURL: this.baseUrl
+    });
+    const messages = params.messages.filter((m) => m.role !== "tool").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    try {
+      const response = await client.chat.completions.create({
+        model: params.model,
+        messages,
+        temperature: params.temperature ?? 0.7,
+        max_tokens: params.maxTokens ?? 4096,
+        top_p: params.topP ?? 1,
+        stop: params.stop
+      });
+      const choice = response.choices[0];
+      this.logger.debug(`Received ${this.providerName} response`, {
+        context: `${this.providerName}Provider.sendMessage`,
+        finishReason: choice.finish_reason,
+        promptTokens: response.usage?.prompt_tokens,
+        completionTokens: response.usage?.completion_tokens
+      });
+      return {
+        content: choice.message.content ?? "",
+        finishReason: choice.finish_reason,
+        usage: {
+          promptTokens: response.usage?.prompt_tokens ?? 0,
+          completionTokens: response.usage?.completion_tokens ?? 0,
+          totalTokens: response.usage?.total_tokens ?? 0
+        },
+        raw: response,
+        attachmentResults
+      };
+    } catch (error) {
+      this.logger.error(
+        `${this.providerName} API error in sendMessage`,
+        { context: `${this.providerName}Provider.sendMessage`, baseUrl: this.baseUrl },
+        error instanceof Error ? error : void 0
+      );
+      throw error;
+    }
+  }
+  /**
+   * Sends a message and streams the response.
+   *
+   * @param params - LLM parameters including messages, model, and settings
+   * @param apiKey - API key for authentication
+   * @yields Stream chunks with content and final usage statistics
+   */
+  async *streamMessage(params, apiKey) {
+    this.logger.debug(`${this.providerName} streamMessage called`, {
+      context: `${this.providerName}Provider.streamMessage`,
+      model: params.model,
+      baseUrl: this.baseUrl
+    });
+    this.validateApiKeyRequirement(apiKey);
+    const attachmentResults = this.collectAttachmentFailures(params);
+    const client = new import_openai.default({
+      apiKey: this.getEffectiveApiKey(apiKey),
+      baseURL: this.baseUrl
+    });
+    const messages = params.messages.filter((m) => m.role !== "tool").map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    try {
+      const stream = await client.chat.completions.create({
+        model: params.model,
+        messages,
+        temperature: params.temperature ?? 0.7,
+        max_tokens: params.maxTokens ?? 4096,
+        top_p: params.topP ?? 1,
+        stream: true,
+        stream_options: { include_usage: true }
+      });
+      let chunkCount = 0;
+      for await (const chunk of stream) {
+        chunkCount++;
+        const content = chunk.choices[0]?.delta?.content;
+        const finishReason = chunk.choices[0]?.finish_reason;
+        const hasUsage = chunk.usage;
+        if (content && !(finishReason && hasUsage)) {
+          yield {
+            content,
+            done: false
+          };
+        }
+        if (finishReason && hasUsage) {
+          this.logger.debug("Stream completed", {
+            context: `${this.providerName}Provider.streamMessage`,
+            finishReason,
+            chunks: chunkCount,
+            promptTokens: chunk.usage?.prompt_tokens,
+            completionTokens: chunk.usage?.completion_tokens
+          });
+          yield {
+            content: "",
+            done: true,
+            usage: {
+              promptTokens: chunk.usage?.prompt_tokens ?? 0,
+              completionTokens: chunk.usage?.completion_tokens ?? 0,
+              totalTokens: chunk.usage?.total_tokens ?? 0
+            },
+            attachmentResults
+          };
+        }
+      }
+    } catch (error) {
+      this.logger.error(
+        `${this.providerName} API error in streamMessage`,
+        { context: `${this.providerName}Provider.streamMessage`, baseUrl: this.baseUrl },
+        error instanceof Error ? error : void 0
+      );
+      throw error;
+    }
+  }
+  /**
+   * Validates an API key by attempting to list models.
+   *
+   * @param apiKey - API key to validate
+   * @returns true if the API key is valid, false otherwise
+   */
+  async validateApiKey(apiKey) {
+    this.logger.debug(`Validating ${this.providerName} API connection`, {
+      context: `${this.providerName}Provider.validateApiKey`,
+      baseUrl: this.baseUrl
+    });
+    if (this.requireApiKey && !apiKey) {
+      return false;
+    }
+    try {
+      const client = new import_openai.default({
+        apiKey: this.getEffectiveApiKey(apiKey),
+        baseURL: this.baseUrl
+      });
+      await client.models.list();
+      this.logger.debug(`${this.providerName} API validation successful`, {
+        context: `${this.providerName}Provider.validateApiKey`
+      });
+      return true;
+    } catch (error) {
+      this.logger.error(
+        `${this.providerName} API validation failed`,
+        { context: `${this.providerName}Provider.validateApiKey`, baseUrl: this.baseUrl },
+        error instanceof Error ? error : void 0
+      );
+      return false;
+    }
+  }
+  /**
+   * Fetches available models from the API.
+   *
+   * @param apiKey - API key for authentication
+   * @returns Sorted array of model IDs, or empty array on failure
+   */
+  async getAvailableModels(apiKey) {
+    this.logger.debug(`Fetching ${this.providerName} models`, {
+      context: `${this.providerName}Provider.getAvailableModels`,
+      baseUrl: this.baseUrl
+    });
+    if (this.requireApiKey && !apiKey) {
+      this.logger.error(`${this.providerName} provider requires an API key to fetch models`, {
+        context: `${this.providerName}Provider.getAvailableModels`
+      });
+      return [];
+    }
+    try {
+      const client = new import_openai.default({
+        apiKey: this.getEffectiveApiKey(apiKey),
+        baseURL: this.baseUrl
+      });
+      const models = await client.models.list();
+      const modelList = models.data.map((m) => m.id).sort();
+      this.logger.debug(`Retrieved ${this.providerName} models`, {
+        context: `${this.providerName}Provider.getAvailableModels`,
+        modelCount: modelList.length
+      });
+      return modelList;
+    } catch (error) {
+      this.logger.error(
+        `Failed to fetch ${this.providerName} models`,
+        { context: `${this.providerName}Provider.getAvailableModels`, baseUrl: this.baseUrl },
+        error instanceof Error ? error : void 0
+      );
+      return [];
+    }
+  }
+  /**
+   * Image generation is not supported by default.
+   * @throws Error indicating image generation is not supported
+   */
+  async generateImage(_params, _apiKey) {
+    throw new Error(
+      `${this.providerName} image generation support varies by implementation (not yet implemented)`
+    );
+  }
+};
+
+// src/roleplay-templates/builder.ts
+function createRoleplayTemplatePlugin(options) {
+  const { metadata, templates, initialize, enableLogging = false } = options;
+  const templateArray = Array.isArray(templates) ? templates : [templates];
+  if (templateArray.length === 0) {
+    throw new Error("At least one template is required");
+  }
+  for (const template of templateArray) {
+    if (!template.name || template.name.trim() === "") {
+      throw new Error("Template name is required");
+    }
+    if (!template.systemPrompt || template.systemPrompt.trim() === "") {
+      throw new Error(`Template "${template.name}" requires a systemPrompt`);
+    }
+  }
+  const plugin = {
+    metadata: {
+      ...metadata,
+      // Ensure tags from templates are included in metadata if not already set
+      tags: metadata.tags ?? Array.from(
+        new Set(templateArray.flatMap((t) => t.tags ?? []))
+      )
+    },
+    templates: templateArray
+  };
+  if (initialize || enableLogging) {
+    plugin.initialize = async () => {
+      if (enableLogging) {
+        const logger = createPluginLogger(metadata.templateId);
+        logger.debug("Roleplay template plugin loaded", {
+          context: "init",
+          templateId: metadata.templateId,
+          displayName: metadata.displayName,
+          templateCount: templateArray.length,
+          templateNames: templateArray.map((t) => t.name)
+        });
+      }
+      if (initialize) {
+        await initialize();
+      }
+    };
+  }
+  return plugin;
+}
+function createSingleTemplatePlugin(options) {
+  const {
+    templateId,
+    displayName,
+    description,
+    systemPrompt,
+    author,
+    tags,
+    version,
+    initialize,
+    enableLogging
+  } = options;
+  return createRoleplayTemplatePlugin({
+    metadata: {
+      templateId,
+      displayName,
+      description,
+      author,
+      tags,
+      version
+    },
+    templates: {
+      name: displayName,
+      description,
+      systemPrompt,
+      tags
+    },
+    initialize,
+    enableLogging
+  });
+}
+function validateTemplateConfig(template) {
+  if (!template.name || template.name.trim() === "") {
+    throw new Error("Template name is required");
+  }
+  if (template.name.length > 100) {
+    throw new Error("Template name must be 100 characters or less");
+  }
+  if (!template.systemPrompt || template.systemPrompt.trim() === "") {
+    throw new Error("Template systemPrompt is required");
+  }
+  if (template.description && template.description.length > 500) {
+    throw new Error("Template description must be 500 characters or less");
+  }
+  if (template.tags) {
+    if (!Array.isArray(template.tags)) {
+      throw new Error("Template tags must be an array");
+    }
+    for (const tag of template.tags) {
+      if (typeof tag !== "string") {
+        throw new Error("All tags must be strings");
+      }
+    }
+  }
+  return true;
+}
+function validateRoleplayTemplatePlugin(plugin) {
+  if (!plugin.metadata) {
+    throw new Error("Plugin metadata is required");
+  }
+  if (!plugin.metadata.templateId || plugin.metadata.templateId.trim() === "") {
+    throw new Error("Plugin metadata.templateId is required");
+  }
+  if (!/^[a-z0-9-]+$/.test(plugin.metadata.templateId)) {
+    throw new Error("Plugin templateId must be lowercase alphanumeric with hyphens only");
+  }
+  if (!plugin.metadata.displayName || plugin.metadata.displayName.trim() === "") {
+    throw new Error("Plugin metadata.displayName is required");
+  }
+  if (!plugin.templates || !Array.isArray(plugin.templates) || plugin.templates.length === 0) {
+    throw new Error("Plugin must have at least one template");
+  }
+  for (const template of plugin.templates) {
+    validateTemplateConfig(template);
+  }
+  return true;
+}
+
 // src/index.ts
-var PLUGIN_UTILS_VERSION = "1.0.0";
+var PLUGIN_UTILS_VERSION = "1.2.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  OpenAICompatibleProvider,
   PLUGIN_UTILS_VERSION,
   __clearCoreLoggerFactory,
   __injectCoreLoggerFactory,
@@ -348,6 +772,8 @@ var PLUGIN_UTILS_VERSION = "1.0.0";
   createConsoleLogger,
   createNoopLogger,
   createPluginLogger,
+  createRoleplayTemplatePlugin,
+  createSingleTemplatePlugin,
   detectToolCallFormat,
   getLogLevelFromEnv,
   hasCoreLogger,
@@ -355,6 +781,8 @@ var PLUGIN_UTILS_VERSION = "1.0.0";
   parseAnthropicToolCalls,
   parseGoogleToolCalls,
   parseOpenAIToolCalls,
-  parseToolCalls
+  parseToolCalls,
+  validateRoleplayTemplatePlugin,
+  validateTemplateConfig
 });
 //# sourceMappingURL=index.js.map