@quilltap/qtap-plugin-gab-ai 1.1.0

package/CLAUDE.md

@@ -0,0 +1,46 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Package
+
+Published as `@quilltap/qtap-plugin-gab-ai` (public npm package).
+
+## Build Commands
+
+```bash
+npm run build    # Bundle TypeScript to index.js using esbuild
+npm run clean    # Remove built index.js
+```
+
+## Architecture
+
+This is a Quilltap LLM provider plugin that integrates Gab AI's API. The plugin uses an OpenAI-compatible API pattern.
+
+### Key Files
+
+- **index.ts** - Plugin entry point exporting the `LLMProviderPlugin` interface with metadata, config, capabilities, and factory methods
+- **provider.ts** - `GabAIProvider` class extending `OpenAICompatibleProvider` from `@quilltap/plugin-utils` with Gab-specific config (base URL: `https://gab.ai/v1`)
+- **types.ts** - Re-exports types from `@quilltap/plugin-types`
+- **manifest.json** - Plugin metadata including compatibility requirements (Quilltap >=1.7.0, Node >=18.0.0)
+- **icon.tsx** - React component for the provider icon
+
+### Build System
+
+esbuild bundles the plugin to CommonJS format. External packages (`@quilltap/plugin-types`, `@quilltap/plugin-utils`, React, Next.js, zod) are provided at runtime by the main Quilltap app and should not be bundled.
+
+### Plugin Interface
+
+The plugin exports:
+- `metadata` - Provider name, display name, colors, abbreviation
+- `config` - API key requirements
+- `capabilities` - Supports chat only (no image generation, embeddings, or web search)
+- `attachmentSupport` - Text-only, no file attachments
+- `createProvider()` - Factory for GabAIProvider instances
+- `getAvailableModels()` - Fetches models from Gab AI API
+- `validateApiKey()` - Validates API credentials
+- `formatTools()` / `parseToolCalls()` - OpenAI-format tool handling
+
+### Dependencies
+
+Runtime dependencies (`@quilltap/plugin-utils`, React, Next.js, zod) are provided by the Quilltap host application. The OpenAI SDK is provided transitively via `@quilltap/plugin-utils`.

package/README.md

@@ -0,0 +1,136 @@
+# Gab AI Provider Plugin for Quilltap
+
+This plugin provides integration with Gab AI's API, enabling Quilltap to use Gab AI language models for chat completions.
+
+## Features
+
+- **Chat Completions**: Access to Gab AI language models for conversational AI
+- **Streaming**: Support for streaming responses for real-time chat
+- **Text-Only**: Text input and output (no file attachments)
+- **OpenAI-Compatible**: Uses OpenAI SDK with Gab AI's base URL
+
+## Installation
+
+The plugin is included with Quilltap. To ensure you have the latest version of the OpenAI SDK (used for API compatibility):
+
+```bash
+npm install openai@latest
+```
+
+## Configuration
+
+### API Key Setup
+
+1. Create a Gab AI account at https://api.gab.com
+2. Generate an API key from your account dashboard
+3. In Quilltap settings, add your API key under the Gab AI provider configuration
+
+### Required Permissions
+
+This plugin requires the following:
+- Network access to `api.gab.com`
+- A valid Gab AI API account with billing enabled
+
+## Supported Models
+
+The available models depend on your Gab AI account access. Use the "Fetch Available Models" feature in Quilltap to see your accessible models.
+
+### Chat Completion Models
+
+Gab AI provides various language models optimized for different use cases:
+- Standard models for general-purpose chat
+- Specialized models for specific domains
+
+**Note**: The exact available models and their capabilities depend on your Gab AI account access and may change over time. Use the "Fetch Available Models" feature in Quilltap to see your current accessible models.
+
+## File Attachment Support
+
+The plugin does not support file attachments. All interactions are text-only.
+
+### Supported MIME Types
+
+None - text only
+
+## Parameters
+
+### Chat Completion Parameters
+
+- **model**: The model to use (varies by account access)
+- **temperature**: Randomness of responses (0-2, default: 0.7)
+- **maxTokens**: Maximum response length (default: 1000)
+- **topP**: Diversity parameter (0-1, default: 1)
+- **stop**: Stop sequences to end generation
+
+## Logging
+
+The plugin includes comprehensive debug logging for all operations:
+
+- API calls and responses
+- Stream processing
+- Model fetching
+- API key validation
+- Error handling
+
+Set `LOG_LEVEL=debug` to see detailed operation logs.
+
+## Error Handling
+
+The plugin provides detailed error messages for:
+- Invalid API keys
+- Model availability errors
+- API errors and rate limiting
+- Network connectivity issues
+
+## Examples
+
+### Basic Chat
+
+```typescript
+const response = await provider.sendMessage({
+  messages: [
+    { role: 'user', content: 'Hello, how are you?' }
+  ],
+  model: 'gab-01',
+}, apiKey);
+```
+
+### Streaming
+
+```typescript
+for await (const chunk of provider.streamMessage({
+  messages: [{ role: 'user', content: 'Tell me a story' }],
+  model: 'gab-01',
+}, apiKey)) {
+  console.log(chunk.content);
+}
+```
+
+## Troubleshooting
+
+### Invalid API Key
+
+- Verify the key is correct from your Gab AI account dashboard
+- Ensure the key has not expired
+- Check that billing is enabled on your Gab AI account
+
+### No Models Available
+
+- Ensure your API key has access to the models
+- Check that your account is not in a restricted region
+- Verify your billing information is valid
+
+### Slow Responses
+
+- Check Gab AI status page
+- Verify network connection
+- Check rate limiting (429 errors)
+
+## Support
+
+For issues with the plugin, refer to:
+- Quilltap GitHub: https://github.com/foundry-9/F9-Quilltap
+- Gab AI Documentation: https://api.gab.com/docs
+
+## License
+
+MIT License - See LICENSE file for details

package/esbuild.config.mjs

@@ -0,0 +1,109 @@
+/**
+ * esbuild configuration for qtap-plugin-anthropic
+ *
+ * Bundles the plugin with its SDK dependency into a single CommonJS file.
+ * External packages (react, zod, etc.) are provided by the main app at runtime.
+ */
+
+import * as esbuild from 'esbuild';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Find the project root (3 levels up from plugin directory)
+const projectRoot = resolve(__dirname, '..', '..', '..');
+
+// Packages that should NOT be bundled - they're provided by the main app at runtime
+const EXTERNAL_PACKAGES = [
+  // Quilltap packages (provided by main app)
+  '@quilltap/plugin-types',
+  '@quilltap/plugin-utils',
+  // React (provided by main app)
+  'react',
+  'react-dom',
+  'react/jsx-runtime',
+  'react/jsx-dev-runtime',
+  // Next.js (provided by main app)
+  'next',
+  'next-auth',
+  // Other main app dependencies
+  'zod',
+  // Node.js built-ins
+  'fs',
+  'path',
+  'crypto',
+  'http',
+  'https',
+  'url',
+  'util',
+  'stream',
+  'events',
+  'buffer',
+  'querystring',
+  'os',
+  'child_process',
+  'node:fs',
+  'node:path',
+  'node:crypto',
+  'node:http',
+  'node:https',
+  'node:url',
+  'node:util',
+  'node:stream',
+  'node:events',
+  'node:buffer',
+  'node:querystring',
+  'node:os',
+  'node:child_process',
+  'node:module',
+];
+
+async function build() {
+  try {
+    const result = await esbuild.build({
+      entryPoints: [resolve(__dirname, 'index.ts')],
+      bundle: true,
+      platform: 'node',
+      target: 'node18',
+      format: 'cjs',
+      outfile: resolve(__dirname, 'index.js'),
+
+      // Resolve @/ imports to project root
+      alias: {
+        '@': projectRoot,
+      },
+
+      // Don't bundle these - they're available at runtime from the main app
+      external: EXTERNAL_PACKAGES,
+
+      // Source maps for debugging (optional, can remove for smaller builds)
+      sourcemap: false,
+
+      // Minification (optional, disable for debugging)
+      minify: false,
+
+      // Tree shaking
+      treeShaking: true,
+
+      // Log level
+      logLevel: 'info',
+    });
+
+    if (result.errors.length > 0) {
+      console.error('Build failed with errors:', result.errors);
+      process.exit(1);
+    }
+
+    console.log('Build completed successfully!');
+
+    if (result.warnings.length > 0) {
+      console.warn('Warnings:', result.warnings);
+    }
+  } catch (error) {
+    console.error('Build failed:', error);
+    process.exit(1);
+  }
+}
+
+build();

package/icon.tsx

@@ -0,0 +1,50 @@
+'use client';
+
+import React from 'react';
+
+interface IconProps {
+  className?: string;
+}
+
+/**
+ * Gab AI Icon Component
+ * Displays the Gab AI branding icon with customizable styling
+ *
+ * @param props Icon component properties
+ * @param props.className Optional CSS class name for styling
+ * @returns JSX Element representing the Gab AI icon
+ */
+export function GabAIIcon({ className = 'h-5 w-5' }: IconProps) {
+  return (
+    <svg
+      className={`text-green-600 ${className}`}
+      fill="currentColor"
+      viewBox="0 0 24 24"
+      xmlns="http://www.w3.org/2000/svg"
+      data-testid="gab-ai-icon"
+    >
+      {/* Gab AI logo - stylized circular design */}
+      <circle cx="12" cy="12" r="11" fill="none" stroke="currentColor" strokeWidth="2" />
+      <path
+        d="M12 2A10 10 0 1 1 2 12A10 10 0 0 1 12 2Z"
+        fill="currentColor"
+        opacity="0.1"
+      />
+      {/* Text label GAB */}
+      <text
+        x="50%"
+        y="50%"
+        textAnchor="middle"
+        dominantBaseline="middle"
+        fill="currentColor"
+        fontSize="9"
+        fontWeight="bold"
+        fontFamily="system-ui, -apple-system, sans-serif"
+      >
+        GAB
+      </text>
+    </svg>
+  );
+}
+
+export default GabAIIcon;

package/index.js

@@ -0,0 +1,255 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  plugin: () => plugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// provider.ts
+var import_plugin_utils = require("@quilltap/plugin-utils");
+var GabAIProvider = class extends import_plugin_utils.OpenAICompatibleProvider {
+  constructor() {
+    super({
+      baseUrl: "https://gab.ai/v1",
+      providerName: "GabAI",
+      requireApiKey: true,
+      attachmentErrorMessage: "Gab AI does not support file attachments"
+    });
+  }
+};
+
+// icon.tsx
+var import_react = __toESM(require("react"));
+function GabAIIcon({ className = "h-5 w-5" }) {
+  return /* @__PURE__ */ import_react.default.createElement(
+    "svg",
+    {
+      className: `text-green-600 ${className}`,
+      fill: "currentColor",
+      viewBox: "0 0 24 24",
+      xmlns: "http://www.w3.org/2000/svg",
+      "data-testid": "gab-ai-icon"
+    },
+    /* @__PURE__ */ import_react.default.createElement("circle", { cx: "12", cy: "12", r: "11", fill: "none", stroke: "currentColor", strokeWidth: "2" }),
+    /* @__PURE__ */ import_react.default.createElement(
+      "path",
+      {
+        d: "M12 2A10 10 0 1 1 2 12A10 10 0 0 1 12 2Z",
+        fill: "currentColor",
+        opacity: "0.1"
+      }
+    ),
+    /* @__PURE__ */ import_react.default.createElement(
+      "text",
+      {
+        x: "50%",
+        y: "50%",
+        textAnchor: "middle",
+        dominantBaseline: "middle",
+        fill: "currentColor",
+        fontSize: "9",
+        fontWeight: "bold",
+        fontFamily: "system-ui, -apple-system, sans-serif"
+      },
+      "GAB"
+    )
+  );
+}
+
+// index.ts
+var import_plugin_utils2 = require("@quilltap/plugin-utils");
+var logger = (0, import_plugin_utils2.createPluginLogger)("GabAI");
+var metadata = {
+  providerName: "GAB_AI",
+  displayName: "Gab AI",
+  description: "Gab AI language models for chat completions",
+  colors: {
+    bg: "bg-green-100",
+    text: "text-green-800",
+    icon: "text-green-600"
+  },
+  abbreviation: "GAB"
+};
+var config = {
+  requiresApiKey: true,
+  requiresBaseUrl: false,
+  apiKeyLabel: "Gab AI API Key"
+};
+var capabilities = {
+  chat: true,
+  imageGeneration: false,
+  embeddings: false,
+  webSearch: false
+};
+var attachmentSupport = {
+  supportsAttachments: false,
+  supportedMimeTypes: [],
+  description: "No attachment support (text only)",
+  notes: "Gab AI does not currently support file attachments"
+};
+var plugin = {
+  metadata,
+  config,
+  capabilities,
+  attachmentSupport,
+  /**
+   * Factory method to create a Gab AI LLM provider instance
+   */
+  createProvider: (baseUrl) => {
+    logger.debug("Creating Gab AI provider instance", { context: "plugin.createProvider", baseUrl });
+    return new GabAIProvider();
+  },
+  /**
+   * Get list of available models from Gab AI API
+   * Requires a valid API key
+   */
+  getAvailableModels: async (apiKey, baseUrl) => {
+    logger.debug("Fetching available Gab AI models", { context: "plugin.getAvailableModels" });
+    try {
+      const provider = new GabAIProvider();
+      const models = await provider.getAvailableModels(apiKey);
+      logger.debug("Successfully fetched Gab AI models", { context: "plugin.getAvailableModels", count: models.length });
+      return models;
+    } catch (error) {
+      logger.error("Failed to fetch Gab AI models", { context: "plugin.getAvailableModels" }, error instanceof Error ? error : void 0);
+      return [];
+    }
+  },
+  /**
+   * Validate a Gab AI API key
+   */
+  validateApiKey: async (apiKey, baseUrl) => {
+    logger.debug("Validating Gab AI API key", { context: "plugin.validateApiKey" });
+    try {
+      const provider = new GabAIProvider();
+      const isValid = await provider.validateApiKey(apiKey);
+      logger.debug("Gab AI API key validation result", { context: "plugin.validateApiKey", isValid });
+      return isValid;
+    } catch (error) {
+      logger.error("Error validating Gab AI API key", { context: "plugin.validateApiKey" }, error instanceof Error ? error : void 0);
+      return false;
+    }
+  },
+  /**
+   * Get static model information
+   * Returns cached information about Gab AI models without needing API calls
+   */
+  getModelInfo: () => {
+    logger.debug("Getting Gab AI model information", { context: "plugin.getModelInfo" });
+    return [
+      {
+        id: "gab-01",
+        name: "Gab AI 01",
+        contextWindow: 128e3,
+        maxOutputTokens: 4096,
+        supportsImages: false,
+        supportsTools: false
+      }
+    ];
+  },
+  /**
+   * Render the Gab AI icon
+   */
+  renderIcon: (props) => {
+    logger.debug("Rendering Gab AI icon", { context: "plugin.renderIcon", className: props.className });
+    return GabAIIcon(props);
+  },
+  /**
+   * Format tools from OpenAI format to OpenAI format
+   * Gab AI uses OpenAI format (inherited from OpenAI-compatible)
+   *
+   * @param tools Array of tools in OpenAI format
+   * @returns Array of tools in OpenAI format
+   */
+  formatTools: (tools) => {
+    logger.debug("Formatting tools for Gab AI provider", {
+      context: "plugin.formatTools",
+      toolCount: tools.length
+    });
+    try {
+      const formattedTools = [];
+      for (const tool of tools) {
+        if (!("function" in tool)) {
+          logger.warn("Skipping tool with invalid format", {
+            context: "plugin.formatTools"
+          });
+          continue;
+        }
+        formattedTools.push(tool);
+      }
+      logger.debug("Successfully formatted tools", {
+        context: "plugin.formatTools",
+        count: formattedTools.length
+      });
+      return formattedTools;
+    } catch (error) {
+      logger.error(
+        "Error formatting tools for Gab AI",
+        { context: "plugin.formatTools" },
+        error instanceof Error ? error : void 0
+      );
+      return [];
+    }
+  },
+  /**
+   * Parse tool calls from Gab AI response format
+   * Extracts tool calls from Gab AI API responses (OpenAI format)
+   *
+   * @param response Gab AI API response object
+   * @returns Array of tool call requests
+   */
+  parseToolCalls: (response) => {
+    logger.debug("Parsing tool calls from Gab AI response", {
+      context: "plugin.parseToolCalls"
+    });
+    try {
+      const toolCalls = (0, import_plugin_utils2.parseOpenAIToolCalls)(response);
+      logger.debug("Successfully parsed tool calls", {
+        context: "plugin.parseToolCalls",
+        count: toolCalls.length
+      });
+      return toolCalls;
+    } catch (error) {
+      logger.error(
+        "Error parsing tool calls from Gab AI response",
+        { context: "plugin.parseToolCalls" },
+        error instanceof Error ? error : void 0
+      );
+      return [];
+    }
+  }
+};
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  plugin
+});

package/index.ts

@@ -0,0 +1,232 @@
+/**
+ * Gab AI Provider Plugin for Quilltap
+ * Main entry point that exports the plugin configuration
+ *
+ * This plugin provides:
+ * - Chat completion using Gab AI language models
+ * - Support for streaming responses
+ * - Text-only interactions (no file attachments)
+ *
+ * Implementation note: GabAIProvider extends OpenAICompatibleProvider,
+ * inheriting all the OpenAI-compatible logic with Gab-specific configuration.
+ */
+
+import type { LLMProviderPlugin } from './types';
+import { GabAIProvider } from './provider';
+import { GabAIIcon } from './icon';
+import {
+  createPluginLogger,
+  parseOpenAIToolCalls,
+  type OpenAIToolDefinition,
+  type ToolCallRequest,
+} from '@quilltap/plugin-utils';
+
+const logger = createPluginLogger('GabAI');
+
+/**
+ * Plugin metadata configuration
+ */
+const metadata = {
+  providerName: 'GAB_AI',
+  displayName: 'Gab AI',
+  description: 'Gab AI language models for chat completions',
+  colors: {
+    bg: 'bg-green-100',
+    text: 'text-green-800',
+    icon: 'text-green-600',
+  },
+  abbreviation: 'GAB',
+} as const;
+
+/**
+ * Configuration requirements
+ */
+const config = {
+  requiresApiKey: true,
+  requiresBaseUrl: false,
+  apiKeyLabel: 'Gab AI API Key',
+} as const;
+
+/**
+ * Supported capabilities
+ */
+const capabilities = {
+  chat: true,
+  imageGeneration: false,
+  embeddings: false,
+  webSearch: false,
+} as const;
+
+/**
+ * File attachment support
+ */
+const attachmentSupport = {
+  supportsAttachments: false as const,
+  supportedMimeTypes: [] as string[],
+  description: 'No attachment support (text only)',
+  notes: 'Gab AI does not currently support file attachments',
+};
+
+/**
+ * The Gab AI Provider Plugin
+ * Implements the LLMProviderPlugin interface for Quilltap
+ *
+ * Note: The underlying GabAIProvider extends OpenAICompatibleProvider,
+ * so all the core functionality is inherited from the openai-compatible plugin.
+ */
+export const plugin: LLMProviderPlugin = {
+  metadata,
+
+  config,
+
+  capabilities,
+
+  attachmentSupport,
+
+  /**
+   * Factory method to create a Gab AI LLM provider instance
+   */
+  createProvider: (baseUrl?: string) => {
+    logger.debug('Creating Gab AI provider instance', { context: 'plugin.createProvider', baseUrl });
+    return new GabAIProvider();
+  },
+
+  /**
+   * Get list of available models from Gab AI API
+   * Requires a valid API key
+   */
+  getAvailableModels: async (apiKey: string, baseUrl?: string) => {
+    logger.debug('Fetching available Gab AI models', { context: 'plugin.getAvailableModels' });
+    try {
+      const provider = new GabAIProvider();
+      const models = await provider.getAvailableModels(apiKey);
+      logger.debug('Successfully fetched Gab AI models', { context: 'plugin.getAvailableModels', count: models.length });
+      return models;
+    } catch (error) {
+      logger.error('Failed to fetch Gab AI models', { context: 'plugin.getAvailableModels' }, error instanceof Error ? error : undefined);
+      return [];
+    }
+  },
+
+  /**
+   * Validate a Gab AI API key
+   */
+  validateApiKey: async (apiKey: string, baseUrl?: string) => {
+    logger.debug('Validating Gab AI API key', { context: 'plugin.validateApiKey' });
+    try {
+      const provider = new GabAIProvider();
+      const isValid = await provider.validateApiKey(apiKey);
+      logger.debug('Gab AI API key validation result', { context: 'plugin.validateApiKey', isValid });
+      return isValid;
+    } catch (error) {
+      logger.error('Error validating Gab AI API key', { context: 'plugin.validateApiKey' }, error instanceof Error ? error : undefined);
+      return false;
+    }
+  },
+
+  /**
+   * Get static model information
+   * Returns cached information about Gab AI models without needing API calls
+   */
+  getModelInfo: () => {
+    logger.debug('Getting Gab AI model information', { context: 'plugin.getModelInfo' });
+    return [
+      {
+        id: 'gab-01',
+        name: 'Gab AI 01',
+        contextWindow: 128000,
+        maxOutputTokens: 4096,
+        supportsImages: false,
+        supportsTools: false,
+      },
+    ];
+  },
+
+  /**
+   * Render the Gab AI icon
+   */
+  renderIcon: (props) => {
+    logger.debug('Rendering Gab AI icon', { context: 'plugin.renderIcon', className: props.className });
+    return GabAIIcon(props);
+  },
+
+  /**
+   * Format tools from OpenAI format to OpenAI format
+   * Gab AI uses OpenAI format (inherited from OpenAI-compatible)
+   *
+   * @param tools Array of tools in OpenAI format
+   * @returns Array of tools in OpenAI format
+   */
+  formatTools: (
+    tools: (OpenAIToolDefinition | Record<string, unknown>)[],
+  ): OpenAIToolDefinition[] => {
+    logger.debug('Formatting tools for Gab AI provider', {
+      context: 'plugin.formatTools',
+      toolCount: tools.length,
+    });
+
+    try {
+      const formattedTools: OpenAIToolDefinition[] = [];
+
+      for (const tool of tools) {
+        // Validate tool has function property (OpenAI format)
+        if (!('function' in tool)) {
+          logger.warn('Skipping tool with invalid format', {
+            context: 'plugin.formatTools',
+          });
+          continue;
+        }
+
+        // Tools already in OpenAI format, pass through
+        formattedTools.push(tool as OpenAIToolDefinition);
+      }
+
+      logger.debug('Successfully formatted tools', {
+        context: 'plugin.formatTools',
+        count: formattedTools.length,
+      });
+
+      return formattedTools;
+    } catch (error) {
+      logger.error(
+        'Error formatting tools for Gab AI',
+        { context: 'plugin.formatTools' },
+        error instanceof Error ? error : undefined
+      );
+      return [];
+    }
+  },
+
+  /**
+   * Parse tool calls from Gab AI response format
+   * Extracts tool calls from Gab AI API responses (OpenAI format)
+   *
+   * @param response Gab AI API response object
+   * @returns Array of tool call requests
+   */
+  parseToolCalls: (response: any): ToolCallRequest[] => {
+    logger.debug('Parsing tool calls from Gab AI response', {
+      context: 'plugin.parseToolCalls',
+    });
+
+    try {
+      const toolCalls = parseOpenAIToolCalls(response);
+
+      logger.debug('Successfully parsed tool calls', {
+        context: 'plugin.parseToolCalls',
+        count: toolCalls.length,
+      });
+
+      return toolCalls;
+    } catch (error) {
+      logger.error(
+        'Error parsing tool calls from Gab AI response',
+        { context: 'plugin.parseToolCalls' },
+        error instanceof Error ? error : undefined
+      );
+      return [];
+    }
+  },
+};
+
+export default plugin;

package/manifest.json

@@ -0,0 +1,56 @@
+{
+  "$schema": "../qtap-plugin-template/schemas/plugin-manifest.schema.json",
+  "name": "qtap-plugin-gab-ai",
+  "title": "Gab AI Provider",
+  "description": "Provides Gab AI language models for Quilltap",
+  "version": "1.0.0",
+  "author": {
+    "name": "Foundry-9 LLC",
+    "email": "charles.sebold@foundry-9.com",
+    "url": "https://foundry-9.com"
+  },
+  "license": "MIT",
+  "compatibility": {
+    "quilltapVersion": ">=1.7.0",
+    "nodeVersion": ">=18.0.0"
+  },
+  "capabilities": ["LLM_PROVIDER"],
+  "category": "PROVIDER",
+  "main": "index.js",
+  "typescript": true,
+  "frontend": "REACT",
+  "styling": "TAILWIND",
+  "enabledByDefault": true,
+  "status": "STABLE",
+  "keywords": ["gab", "gab-ai", "llm", "ai", "chat"],
+  "providerConfig": {
+    "providerName": "GAB_AI",
+    "displayName": "Gab AI",
+    "description": "Gab AI language models for chat completions",
+    "abbreviation": "GAB",
+    "colors": {
+      "bg": "bg-green-100",
+      "text": "text-green-800",
+      "icon": "text-green-600"
+    },
+    "requiresApiKey": true,
+    "requiresBaseUrl": false,
+    "apiKeyLabel": "Gab AI API Key",
+    "capabilities": {
+      "chat": true,
+      "imageGeneration": false,
+      "embeddings": false,
+      "webSearch": false
+    },
+    "attachmentSupport": {
+      "supported": false,
+      "mimeTypes": [],
+      "description": "No attachment support (text only)"
+    }
+  },
+  "permissions": {
+    "network": ["api.gab.com"],
+    "userData": false,
+    "database": false
+  }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@quilltap/qtap-plugin-gab-ai",
+  "version": "1.1.0",
+  "description": "Gab AI provider plugin for Quilltap",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "author": "Foundry-9 LLC",
+  "license": "MIT",
+  "scripts": {
+    "build": "node esbuild.config.mjs",
+    "clean": "rm -f index.js"
+  },
+  "dependencies": {
+    "@quilltap/plugin-utils": "^1.1.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/provider.ts

@@ -0,0 +1,31 @@
+/**
+ * Gab AI Provider Implementation for Quilltap Plugin
+ *
+ * Gab AI is OpenAI-compatible and provides language models via api.gab.com/v1
+ * This provider extends OpenAICompatibleProvider from @quilltap/plugin-utils
+ * with static configuration specific to the Gab AI service.
+ *
+ * Note: Gab AI does not currently support file attachments or image generation.
+ */
+
+import { OpenAICompatibleProvider } from '@quilltap/plugin-utils';
+
+/**
+ * Gab AI Provider - extends OpenAICompatibleProvider with Gab-specific configuration
+ *
+ * Configuration:
+ * - baseUrl: https://gab.ai/v1 (fixed)
+ * - API key: required
+ * - Attachments: not supported
+ * - Image generation: not supported
+ */
+export class GabAIProvider extends OpenAICompatibleProvider {
+  constructor() {
+    super({
+      baseUrl: 'https://gab.ai/v1',
+      providerName: 'GabAI',
+      requireApiKey: true,
+      attachmentErrorMessage: 'Gab AI does not support file attachments',
+    });
+  }
+}

package/types.ts

@@ -0,0 +1,22 @@
+/**
+ * Type exports for Gab AI Plugin
+ * Re-exports types from @quilltap/plugin-types for use within the plugin
+ */
+
+export type {
+  FileAttachment,
+  ImageGenParams,
+  GeneratedImage,
+  ImageGenResponse,
+  LLMMessage,
+  LLMParams,
+  LLMResponse,
+  StreamChunk,
+  LLMProvider,
+  LLMProviderPlugin,
+  ProviderMetadata,
+  ProviderConfigRequirements,
+  ProviderCapabilities,
+  AttachmentSupport,
+  ModelInfo,
+} from '@quilltap/plugin-types';